diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
index 161d9cebd..8c931cfc0 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 7148b95b7..d29d5aaaf 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 386d728b6..bd35f03fb 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@v3
         with:
           context: .
+          file: Dockerfile
           push: false
           tags: ${{ env.IMAGE }}
           load: true
@@ -60,31 +61,42 @@ 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,
-            Mirror,
-            Pool,
-            SharedTables/MongoDB,
-            SharedTables/MariaDB,
-            SharedTables/MySQL,
-            SharedTables/Postgres,
-            SharedTables/SQLite,
-            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: Mirror
+            profiles: "--profile mariadb --profile mariadb-mirror --profile redis-mirror"
+          - adapter: Pool
+            profiles: "--profile mysql"
+          - 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: Schemaless/MongoDB
+            profiles: "--profile mongo"
 
     steps:
       - name: checkout
@@ -100,7 +112,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 46daf3d31..1d4d5f1ee 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 000000000..9a9a7aa47
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,117 @@
+# 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, Relationship, Relationships, TenantFilter, Transform, Read, Write, WriteContext, Interceptor, Decorator, PermissionFilter, MongoPermissionFilter, MongoTenantFilter, Tenancy
+  - `ORM/` -- EntityManager, EntityMapper, EntityMetadata, EntityState, IdentityMap, MetadataFactory, UnitOfWork, ColumnMapping, EmbeddableMapping, RelationshipMapping, plus `Mapping/` subdirectory (PHP attribute annotations: Entity, Column, Id, HasMany, HasOne, BelongsTo, Embedded, Permissions, Tenant, etc.)
+  - `Schema/` -- Introspector, SchemaDiff, SchemaChange, SchemaChangeType, 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 000000000..43c994c2d
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1 @@
+@AGENTS.md
diff --git a/Dockerfile b/Dockerfile
index a3392d45d..e6d3587cc 100755
--- a/Dockerfile
+++ b/Dockerfile
@@ -96,8 +96,6 @@ WORKDIR /usr/src/code
 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
@@ -110,14 +108,14 @@ COPY --from=redis /usr/local/lib/php/extensions/no-debug-non-zts-20240924/redis.
 COPY --from=pcov /usr/local/lib/php/extensions/no-debug-non-zts-20240924/pcov.so /usr/local/lib/php/extensions/no-debug-non-zts-20240924/
 COPY --from=xdebug /usr/local/lib/php/extensions/no-debug-non-zts-20240924/xdebug.so /usr/local/lib/php/extensions/no-debug-non-zts-20240924/
 
-COPY ./bin /usr/src/code/bin
-COPY ./src /usr/src/code/src
-COPY ./dev /usr/src/code/dev
+COPY bin /usr/src/code/bin
+COPY src /usr/src/code/src
+COPY dev /usr/src/code/dev
 
 # Add Debug Configs
 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 /usr/local/lib/php/extensions/no-debug-non-zts-20240924/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 309966b1d..7c5c5d178 100644
--- a/README.md
+++ b/README.md
@@ -633,22 +633,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 +755,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/tasks/index.php b/bin/tasks/index.php
index 256f23ce1..e52f599e3 100644
--- a/bin/tasks/index.php
+++ b/bin/tasks/index.php
@@ -61,8 +61,9 @@
             ],
         ];
 
-        if (!isset($dbAdapters[$adapter])) {
+        if (! isset($dbAdapters[$adapter])) {
             Console::error("Adapter '{$adapter}' not supported");
+
             return;
         }
 
diff --git a/bin/tasks/load.php b/bin/tasks/load.php
index 17206de1f..3fcceff11 100644
--- a/bin/tasks/load.php
+++ b/bin/tasks/load.php
@@ -25,7 +25,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 +34,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());
@@ -61,14 +59,13 @@
             $database->createIndex('articles', 'text', Database::INDEX_FULLTEXT, ['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 +100,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 +130,7 @@
                 ->withHost($cfg['host'])
                 ->withPort($cfg['port'])
                 ->withDbName($name)
-                //->withCharset('utf8mb4')
+                // ->withCharset('utf8mb4')
                 ->withUsername($cfg['user'])
                 ->withPassword($cfg['pass']),
             128
@@ -141,9 +139,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 +149,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,7 +172,7 @@ 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([
diff --git a/bin/tasks/migrate.php b/bin/tasks/migrate.php
new file mode 100644
index 000000000..a22dd37e2
--- /dev/null
+++ b/bin/tasks/migrate.php
@@ -0,0 +1,151 @@
+<?php
+
+/**
+ * @var CLI $cli
+ */
+global $cli;
+
+use Utopia\CLI\CLI;
+use Utopia\CLI\Console;
+use Utopia\Database\Migration\Migration;
+use Utopia\Database\Migration\MigrationGenerator;
+use Utopia\Database\Migration\MigrationRunner;
+use Utopia\Validator\Integer;
+use Utopia\Validator\Text;
+
+/**
+ * @Example
+ * docker compose exec tests bin/cli migrate --path=migrations
+ * docker compose exec tests bin/cli migrate:rollback --path=migrations --steps=1
+ * docker compose exec tests bin/cli migrate:status --path=migrations
+ * docker compose exec tests bin/cli migrate:fresh --path=migrations
+ * docker compose exec tests bin/cli migrate:generate --name=add_users_table
+ */
+
+$cli
+    ->task('migrate')
+    ->desc('Run pending database migrations')
+    ->param('path', 'migrations', new Text(0), 'Path to migration files', true)
+    ->action(function (string $path) {
+        $migrations = loadMigrations($path);
+
+        if ($migrations === []) {
+            Console::warning('No migration files found in: ' . $path);
+
+            return;
+        }
+
+        Console::info('Running migrations...');
+
+        $db = getDatabase();
+        $runner = new MigrationRunner($db);
+        $count = $runner->migrate($migrations);
+
+        Console::success("Ran {$count} migration(s).");
+    });
+
+$cli
+    ->task('migrate:rollback')
+    ->desc('Rollback the last batch of migrations')
+    ->param('path', 'migrations', new Text(0), 'Path to migration files', true)
+    ->param('steps', 1, new Integer(true), 'Number of batches to rollback', true)
+    ->action(function (string $path, int $steps) {
+        $migrations = loadMigrations($path);
+        $db = getDatabase();
+        $runner = new MigrationRunner($db);
+        $count = $runner->rollback($migrations, $steps);
+
+        Console::success("Rolled back {$count} migration(s).");
+    });
+
+$cli
+    ->task('migrate:status')
+    ->desc('Show the status of all migrations')
+    ->param('path', 'migrations', new Text(0), 'Path to migration files', true)
+    ->action(function (string $path) {
+        $migrations = loadMigrations($path);
+        $db = getDatabase();
+        $runner = new MigrationRunner($db);
+        $status = $runner->status($migrations);
+
+        Console::info(\str_pad('Version', 20) . \str_pad('Name', 40) . 'Applied');
+        Console::info(\str_repeat('-', 70));
+
+        foreach ($status as $entry) {
+            $applied = $entry['applied'] ? 'Yes' : 'No';
+            Console::log(\str_pad($entry['version'], 20) . \str_pad($entry['name'], 40) . $applied);
+        }
+    });
+
+$cli
+    ->task('migrate:fresh')
+    ->desc('Drop all collections and re-run all migrations')
+    ->param('path', 'migrations', new Text(0), 'Path to migration files', true)
+    ->action(function (string $path) {
+        $migrations = loadMigrations($path);
+        $db = getDatabase();
+        $runner = new MigrationRunner($db);
+
+        Console::warning('Dropping all collections and re-migrating...');
+        $count = $runner->fresh($migrations);
+
+        Console::success("Fresh migration complete. Ran {$count} migration(s).");
+    });
+
+$cli
+    ->task('migrate:generate')
+    ->desc('Generate an empty migration file')
+    ->param('name', '', new Text(0), 'Migration name (e.g. add_users_table)')
+    ->param('path', 'migrations', new Text(0), 'Output directory', true)
+    ->action(function (string $name, string $path) {
+        $timestamp = \date('YmdHis');
+        $className = 'V' . $timestamp . '_' . \str_replace(' ', '', \ucwords(\str_replace('_', ' ', $name)));
+
+        $generator = new MigrationGenerator();
+        $content = $generator->generateEmpty($className);
+
+        if (! \is_dir($path)) {
+            \mkdir($path, 0755, true);
+        }
+
+        $filePath = $path . '/' . $className . '.php';
+        \file_put_contents($filePath, $content);
+
+        Console::success("Created migration: {$filePath}");
+    });
+
+/**
+ * @return array<Migration>
+ */
+function loadMigrations(string $path): array
+{
+    if (! \is_dir($path)) {
+        return [];
+    }
+
+    $migrations = [];
+    $files = \glob($path . '/*.php');
+
+    if ($files === false) {
+        return [];
+    }
+
+    foreach ($files as $file) {
+        require_once $file;
+
+        $className = \pathinfo($file, PATHINFO_FILENAME);
+        if (\class_exists($className) && \is_subclass_of($className, Migration::class)) {
+            $migrations[] = new $className();
+        }
+    }
+
+    return $migrations;
+}
+
+/**
+ * Placeholder — in a real setup, this would be provided by the application container.
+ */
+function getDatabase(): \Utopia\Database\Database
+{
+    throw new \RuntimeException('getDatabase() must be implemented by the application. Override this function to return your Database instance.');
+}
diff --git a/bin/tasks/operators.php b/bin/tasks/operators.php
index d351b0ca1..008926ed0 100644
--- a/bin/tasks/operators.php
+++ b/bin/tasks/operators.php
@@ -14,7 +14,6 @@
  * 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;
@@ -41,14 +40,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 +90,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 +128,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 +140,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)) {
@@ -210,7 +211,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 +222,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 +244,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 +263,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 +344,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 +358,7 @@ function ($doc) {
         Operator::decrement(1),
         function ($doc) {
             $doc->setAttribute('counter', $doc->getAttribute('counter', 100) - 1);
+
             return $doc;
         },
         ['counter' => 100]
@@ -369,6 +372,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 +386,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 +401,7 @@ function ($doc) {
         function ($doc) {
             $val = $doc->getAttribute('modulo_val', 100);
             $doc->setAttribute('modulo_val', $val % 7);
+
             return $doc;
         },
         ['modulo_val' => 100]
@@ -409,6 +415,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 +429,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 +444,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 +458,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 +476,7 @@ function ($doc) {
             $tags = $doc->getAttribute('tags', ['initial']);
             $tags[] = 'new';
             $doc->setAttribute('tags', $tags);
+
             return $doc;
         },
         ['tags' => ['initial']]
@@ -481,6 +492,7 @@ function ($doc) {
             $tags = $doc->getAttribute('tags', ['initial']);
             array_unshift($tags, 'first');
             $doc->setAttribute('tags', $tags);
+
             return $doc;
         },
         ['tags' => ['initial']]
@@ -496,6 +508,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 +524,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 +539,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 +554,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 +569,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 +584,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 +601,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 +617,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 +631,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 +658,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 +671,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 +683,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 +701,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 +710,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 +739,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 +774,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()->getSupportForUpserts()) {
             Console::warning("  Skipping {$opType} (not supported by adapter)");
+
             continue;
         }
 
@@ -772,7 +794,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 +802,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 +814,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 +937,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 +953,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 +963,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 +1012,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 +1020,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 +1063,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 +1086,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 +1125,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 +1133,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 d6c998714..685c2016b 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().' = '.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 790845b9c..62851e4a1 100644
--- a/bin/tasks/relationships.php
+++ b/bin/tasks/relationships.php
@@ -20,6 +20,7 @@
 use Utopia\Database\Helpers\Role;
 use Utopia\Database\PDO;
 use Utopia\Database\Query;
+use Utopia\Query\Schema\ForeignKeyAction;
 use Utopia\Validator\Boolean;
 use Utopia\Validator\Integer;
 use Utopia\Validator\Text;
@@ -33,13 +34,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) {
@@ -111,11 +111,11 @@
             $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->createRelationship('authors', 'articles', Database::RELATION_MANY_TO_MANY, true, onDelete: ForeignKeyAction::SetNull->value);
+            $database->createRelationship('articles', 'comments', Database::RELATION_ONE_TO_MANY, true, twoWayKey: 'article', onDelete: ForeignKeyAction::Cascade->value);
+            $database->createRelationship('users', 'comments', Database::RELATION_ONE_TO_MANY, true, twoWayKey: 'user', onDelete: ForeignKeyAction::Cascade->value);
+            $database->createRelationship('authors', 'profiles', Database::RELATION_ONE_TO_ONE, true, twoWayKey: 'author', onDelete: ForeignKeyAction::Cascade->value);
+            $database->createRelationship('articles', 'categories', Database::RELATION_MANY_TO_ONE, true, id: 'category', twoWayKey: 'articles', onDelete: ForeignKeyAction::SetNull->value);
         };
 
         $dbAdapters = [
@@ -148,8 +148,9 @@
             ],
         ];
 
-        if (!isset($dbAdapters[$adapter])) {
+        if (! isset($dbAdapters[$adapter])) {
             Console::error("Adapter '{$adapter}' not supported");
+
             return;
         }
 
@@ -234,20 +235,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 +255,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 +291,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 +310,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 +322,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 +463,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 +524,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 +532,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 4afb1e677..57091f586 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 824b193a3..9bc7a29d3 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": {
@@ -41,16 +42,18 @@
         "utopia-php/console": "0.1.*",
         "utopia-php/cache": "1.*",
         "utopia-php/pools": "1.*",
-        "utopia-php/mongo": "1.*"
+        "utopia-php/mongo": "1.*",
+        "utopia-php/query": "dev-feat-builder",
+        "utopia-php/async": "@dev"
     },
     "require-dev": {
         "fakerphp/faker": "1.23.*",
-        "phpunit/phpunit": "9.*",
-        "pcov/clobber": "2.*",
+        "phpunit/phpunit": "^12.0",
+        "brianium/paratest": "^7.7",
         "swoole/ide-helper": "5.1.3",
         "utopia-php/cli": "0.22.*",
         "laravel/pint": "*",
-        "phpstan/phpstan": "1.*",
+        "phpstan/phpstan": "^2.0",
         "rregeer/phpunit-coverage-check": "0.3.*"
     },
     "suggests": {
@@ -59,6 +62,16 @@
         "mongodb/mongodb": "Needed to support MongoDB Database Adapter"
 
     },
+    "repositories": [
+        {
+            "type": "vcs",
+            "url": "https://github.com/utopia-php/query.git"
+        },
+        {
+            "type": "vcs",
+            "url": "https://github.com/utopia-php/async.git"
+        }
+    ],
     "config": {
         "allow-plugins": {
             "php-http/discovery": false,
diff --git a/composer.lock b/composer.lock
index ad3e77da1..5d122380c 100644
--- a/composer.lock
+++ b/composer.lock
@@ -4,7 +4,7 @@
         "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies",
         "This file is @generated automatically"
     ],
-    "content-hash": "e7e2b8f8ff6424bb98827b11e25323e8",
+    "content-hash": "0e67b717130969da75a82da58d886303",
     "packages": [
         {
             "name": "brick/math",
@@ -145,23 +145,23 @@
         },
         {
             "name": "google/protobuf",
-            "version": "v4.33.5",
+            "version": "v4.33.6",
             "source": {
                 "type": "git",
                 "url": "https://github.com/protocolbuffers/protobuf-php.git",
-                "reference": "ebe8010a61b2ae0cff0d246fe1c4d44e9f7dfa6d"
+                "reference": "84b008c23915ed94536737eae46f41ba3bccfe67"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/protocolbuffers/protobuf-php/zipball/ebe8010a61b2ae0cff0d246fe1c4d44e9f7dfa6d",
-                "reference": "ebe8010a61b2ae0cff0d246fe1c4d44e9f7dfa6d",
+                "url": "https://api.github.com/repos/protocolbuffers/protobuf-php/zipball/84b008c23915ed94536737eae46f41ba3bccfe67",
+                "reference": "84b008c23915ed94536737eae46f41ba3bccfe67",
                 "shasum": ""
             },
             "require": {
                 "php": ">=8.1.0"
             },
             "require-dev": {
-                "phpunit/phpunit": ">=5.0.0 <8.5.27"
+                "phpunit/phpunit": ">=10.5.62 <11.0.0"
             },
             "suggest": {
                 "ext-bcmath": "Need to support JSON deserialization"
@@ -183,9 +183,9 @@
                 "proto"
             ],
             "support": {
-                "source": "https://github.com/protocolbuffers/protobuf-php/tree/v4.33.5"
+                "source": "https://github.com/protocolbuffers/protobuf-php/tree/v4.33.6"
             },
-            "time": "2026-01-29T20:49:00+00:00"
+            "time": "2026-03-18T17:32:05+00:00"
         },
         {
             "name": "mongodb/mongodb",
@@ -410,16 +410,16 @@
         },
         {
             "name": "open-telemetry/api",
-            "version": "1.8.0",
+            "version": "1.9.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/opentelemetry-php/api.git",
-                "reference": "df5197c6fd0ddd8e9883b87de042d9341300e2ad"
+                "reference": "6f8d237ce2c304ca85f31970f788e7f074d147be"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/opentelemetry-php/api/zipball/df5197c6fd0ddd8e9883b87de042d9341300e2ad",
-                "reference": "df5197c6fd0ddd8e9883b87de042d9341300e2ad",
+                "url": "https://api.github.com/repos/opentelemetry-php/api/zipball/6f8d237ce2c304ca85f31970f788e7f074d147be",
+                "reference": "6f8d237ce2c304ca85f31970f788e7f074d147be",
                 "shasum": ""
             },
             "require": {
@@ -476,20 +476,20 @@
                 "issues": "https://github.com/open-telemetry/opentelemetry-php/issues",
                 "source": "https://github.com/open-telemetry/opentelemetry-php"
             },
-            "time": "2026-01-21T04:14:03+00:00"
+            "time": "2026-02-25T13:24:05+00:00"
         },
         {
             "name": "open-telemetry/context",
-            "version": "1.4.0",
+            "version": "1.5.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/opentelemetry-php/context.git",
-                "reference": "d4c4470b541ce72000d18c339cfee633e4c8e0cf"
+                "reference": "3c414b246e0dabb7d6145404e6a5e4536ca18d07"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/opentelemetry-php/context/zipball/d4c4470b541ce72000d18c339cfee633e4c8e0cf",
-                "reference": "d4c4470b541ce72000d18c339cfee633e4c8e0cf",
+                "url": "https://api.github.com/repos/opentelemetry-php/context/zipball/3c414b246e0dabb7d6145404e6a5e4536ca18d07",
+                "reference": "3c414b246e0dabb7d6145404e6a5e4536ca18d07",
                 "shasum": ""
             },
             "require": {
@@ -531,11 +531,11 @@
             ],
             "support": {
                 "chat": "https://app.slack.com/client/T08PSQ7BQ/C01NFPCV44V",
-                "docs": "https://opentelemetry.io/docs/php",
+                "docs": "https://opentelemetry.io/docs/languages/php",
                 "issues": "https://github.com/open-telemetry/opentelemetry-php/issues",
                 "source": "https://github.com/open-telemetry/opentelemetry-php"
             },
-            "time": "2025-09-19T00:05:49+00:00"
+            "time": "2025-10-19T06:44:33+00:00"
         },
         {
             "name": "open-telemetry/exporter-otlp",
@@ -603,16 +603,16 @@
         },
         {
             "name": "open-telemetry/gen-otlp-protobuf",
-            "version": "1.8.0",
+            "version": "1.9.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/opentelemetry-php/gen-otlp-protobuf.git",
-                "reference": "673af5b06545b513466081884b47ef15a536edde"
+                "reference": "a229cf161d42001d64c8f21e8f678581fe1c66b9"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/opentelemetry-php/gen-otlp-protobuf/zipball/673af5b06545b513466081884b47ef15a536edde",
-                "reference": "673af5b06545b513466081884b47ef15a536edde",
+                "url": "https://api.github.com/repos/opentelemetry-php/gen-otlp-protobuf/zipball/a229cf161d42001d64c8f21e8f678581fe1c66b9",
+                "reference": "a229cf161d42001d64c8f21e8f678581fe1c66b9",
                 "shasum": ""
             },
             "require": {
@@ -658,30 +658,30 @@
             ],
             "support": {
                 "chat": "https://app.slack.com/client/T08PSQ7BQ/C01NFPCV44V",
-                "docs": "https://opentelemetry.io/docs/php",
+                "docs": "https://opentelemetry.io/docs/languages/php",
                 "issues": "https://github.com/open-telemetry/opentelemetry-php/issues",
                 "source": "https://github.com/open-telemetry/opentelemetry-php"
             },
-            "time": "2025-09-17T23:10:12+00:00"
+            "time": "2025-10-19T06:44:33+00:00"
         },
         {
             "name": "open-telemetry/sdk",
-            "version": "1.13.0",
+            "version": "1.14.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/opentelemetry-php/sdk.git",
-                "reference": "c76f91203bf7ef98ab3f4e0a82ca21699af185e1"
+                "reference": "6e3d0ce93e76555dd5e2f1d19443ff45b990e410"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/opentelemetry-php/sdk/zipball/c76f91203bf7ef98ab3f4e0a82ca21699af185e1",
-                "reference": "c76f91203bf7ef98ab3f4e0a82ca21699af185e1",
+                "url": "https://api.github.com/repos/opentelemetry-php/sdk/zipball/6e3d0ce93e76555dd5e2f1d19443ff45b990e410",
+                "reference": "6e3d0ce93e76555dd5e2f1d19443ff45b990e410",
                 "shasum": ""
             },
             "require": {
                 "ext-json": "*",
                 "nyholm/psr7-server": "^1.1",
-                "open-telemetry/api": "^1.7",
+                "open-telemetry/api": "^1.8",
                 "open-telemetry/context": "^1.4",
                 "open-telemetry/sem-conv": "^1.0",
                 "php": "^8.1",
@@ -759,7 +759,7 @@
                 "issues": "https://github.com/open-telemetry/opentelemetry-php/issues",
                 "source": "https://github.com/open-telemetry/opentelemetry-php"
             },
-            "time": "2026-01-28T11:38:11+00:00"
+            "time": "2026-03-21T11:50:01+00:00"
         },
         {
             "name": "open-telemetry/sem-conv",
@@ -818,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",
@@ -2024,18 +2089,137 @@
             },
             "time": "2025-06-29T15:42:06+00:00"
         },
+        {
+            "name": "utopia-php/async",
+            "version": "dev-main",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/utopia-php/async.git",
+                "reference": "7a0c6957b41731a5c999382ad26a0b2fdbd19812"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/utopia-php/async/zipball/7a0c6957b41731a5c999382ad26a0b2fdbd19812",
+                "reference": "7a0c6957b41731a5c999382ad26a0b2fdbd19812",
+                "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"
+            },
+            "default-branch": true,
+            "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/main",
+                "issues": "https://github.com/utopia-php/async/issues"
+            },
+            "time": "2026-01-09T06:16:09+00:00"
+        },
         {
             "name": "utopia-php/cache",
-            "version": "1.0.0",
+            "version": "1.0.1",
             "source": {
                 "type": "git",
                 "url": "https://github.com/utopia-php/cache.git",
-                "reference": "7068870c086a6aea16173563a26b93ef3e408439"
+                "reference": "05ceba981436a4022553f7aaa2a05fa049d0f71c"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/utopia-php/cache/zipball/7068870c086a6aea16173563a26b93ef3e408439",
-                "reference": "7068870c086a6aea16173563a26b93ef3e408439",
+                "url": "https://api.github.com/repos/utopia-php/cache/zipball/05ceba981436a4022553f7aaa2a05fa049d0f71c",
+                "reference": "05ceba981436a4022553f7aaa2a05fa049d0f71c",
                 "shasum": ""
             },
             "require": {
@@ -2072,9 +2256,9 @@
             ],
             "support": {
                 "issues": "https://github.com/utopia-php/cache/issues",
-                "source": "https://github.com/utopia-php/cache/tree/1.0.0"
+                "source": "https://github.com/utopia-php/cache/tree/1.0.1"
             },
-            "time": "2026-01-28T10:55:44+00:00"
+            "time": "2026-03-12T03:39:09+00:00"
         },
         {
             "name": "utopia-php/console",
@@ -2126,16 +2310,16 @@
         },
         {
             "name": "utopia-php/mongo",
-            "version": "1.0.0",
+            "version": "1.0.2",
             "source": {
                 "type": "git",
                 "url": "https://github.com/utopia-php/mongo.git",
-                "reference": "45bedf36c2c946ec7a0a3e59b9f12f772de0b01d"
+                "reference": "677a21c53f7a1316c528b4b45b3fce886cee7223"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/utopia-php/mongo/zipball/45bedf36c2c946ec7a0a3e59b9f12f772de0b01d",
-                "reference": "45bedf36c2c946ec7a0a3e59b9f12f772de0b01d",
+                "url": "https://api.github.com/repos/utopia-php/mongo/zipball/677a21c53f7a1316c528b4b45b3fce886cee7223",
+                "reference": "677a21c53f7a1316c528b4b45b3fce886cee7223",
                 "shasum": ""
             },
             "require": {
@@ -2181,22 +2365,22 @@
             ],
             "support": {
                 "issues": "https://github.com/utopia-php/mongo/issues",
-                "source": "https://github.com/utopia-php/mongo/tree/1.0.0"
+                "source": "https://github.com/utopia-php/mongo/tree/1.0.2"
             },
-            "time": "2026-02-12T05:54:06+00:00"
+            "time": "2026-03-18T02:45:50+00:00"
         },
         {
             "name": "utopia-php/pools",
-            "version": "1.0.2",
+            "version": "1.0.3",
             "source": {
                 "type": "git",
                 "url": "https://github.com/utopia-php/pools.git",
-                "reference": "b7d8dd00306cdd8bf3ff6f1dc90caeaf27dabeb1"
+                "reference": "74de7c5457a2c447f27e7ec4d72e8412a7d68c10"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/utopia-php/pools/zipball/b7d8dd00306cdd8bf3ff6f1dc90caeaf27dabeb1",
-                "reference": "b7d8dd00306cdd8bf3ff6f1dc90caeaf27dabeb1",
+                "url": "https://api.github.com/repos/utopia-php/pools/zipball/74de7c5457a2c447f27e7ec4d72e8412a7d68c10",
+                "reference": "74de7c5457a2c447f27e7ec4d72e8412a7d68c10",
                 "shasum": ""
             },
             "require": {
@@ -2234,9 +2418,78 @@
             ],
             "support": {
                 "issues": "https://github.com/utopia-php/pools/issues",
-                "source": "https://github.com/utopia-php/pools/tree/1.0.2"
+                "source": "https://github.com/utopia-php/pools/tree/1.0.3"
+            },
+            "time": "2026-02-26T08:42:40+00:00"
+        },
+        {
+            "name": "utopia-php/query",
+            "version": "dev-feat-builder",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/utopia-php/query.git",
+                "reference": "3f57d89f6a62600379884cbe1b8391e9d952f107"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/utopia-php/query/zipball/3f57d89f6a62600379884cbe1b8391e9d952f107",
+                "reference": "3f57d89f6a62600379884cbe1b8391e9d952f107",
+                "shasum": ""
+            },
+            "require": {
+                "php": ">=8.4"
+            },
+            "require-dev": {
+                "laravel/pint": "*",
+                "mongodb/mongodb": "^1.20",
+                "phpstan/phpstan": "*",
+                "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/phpunit --testsuite Query"
+                ],
+                "test:integration": [
+                    "vendor/bin/phpunit --testsuite Integration"
+                ],
+                "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/feat-builder",
+                "issues": "https://github.com/utopia-php/query/issues"
             },
-            "time": "2026-01-28T13:12:36+00:00"
+            "time": "2026-03-26T01:52:53+00:00"
         },
         {
             "name": "utopia-php/telemetry",
@@ -2341,35 +2594,56 @@
     ],
     "packages-dev": [
         {
-            "name": "doctrine/instantiator",
-            "version": "2.1.0",
+            "name": "brianium/paratest",
+            "version": "v7.19.2",
             "source": {
                 "type": "git",
-                "url": "https://github.com/doctrine/instantiator.git",
-                "reference": "23da848e1a2308728fe5fdddabf4be17ff9720c7"
+                "url": "https://github.com/paratestphp/paratest.git",
+                "reference": "66e4f7910cecf67736bccf2b8bd53a2e3eb98bd9"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/doctrine/instantiator/zipball/23da848e1a2308728fe5fdddabf4be17ff9720c7",
-                "reference": "23da848e1a2308728fe5fdddabf4be17ff9720c7",
+                "url": "https://api.github.com/repos/paratestphp/paratest/zipball/66e4f7910cecf67736bccf2b8bd53a2e3eb98bd9",
+                "reference": "66e4f7910cecf67736bccf2b8bd53a2e3eb98bd9",
                 "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.40",
+                "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/",
@@ -2378,36 +2652,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.19.2"
             },
             "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-09T14:33:17+00:00"
         },
         {
             "name": "fakerphp/faker",
@@ -2472,18 +2749,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.27.1",
+            "version": "v1.29.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/laravel/pint.git",
-                "reference": "54cca2de13790570c7b6f0f94f37896bee4abcb5"
+                "reference": "bdec963f53172c5e36330f3a400604c69bf02d39"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/laravel/pint/zipball/54cca2de13790570c7b6f0f94f37896bee4abcb5",
-                "reference": "54cca2de13790570c7b6f0f94f37896bee4abcb5",
+                "url": "https://api.github.com/repos/laravel/pint/zipball/bdec963f53172c5e36330f3a400604c69bf02d39",
+                "reference": "bdec963f53172c5e36330f3a400604c69bf02d39",
                 "shasum": ""
             },
             "require": {
@@ -2494,13 +2892,14 @@
                 "php": "^8.2.0"
             },
             "require-dev": {
-                "friendsofphp/php-cs-fixer": "^3.93.1",
-                "illuminate/view": "^12.51.0",
-                "larastan/larastan": "^3.9.2",
+                "friendsofphp/php-cs-fixer": "^3.94.2",
+                "illuminate/view": "^12.54.1",
+                "larastan/larastan": "^3.9.3",
                 "laravel-zero/framework": "^12.0.5",
                 "mockery/mockery": "^1.6.12",
-                "nunomaduro/termwind": "^2.3.3",
-                "pestphp/pest": "^3.8.5"
+                "nunomaduro/termwind": "^2.4.0",
+                "pestphp/pest": "^3.8.6",
+                "shipfastlabs/agent-detector": "^1.1.0"
             },
             "bin": [
                 "builds/pint"
@@ -2537,7 +2936,7 @@
                 "issues": "https://github.com/laravel/pint/issues",
                 "source": "https://github.com/laravel/pint"
             },
-            "time": "2026-02-10T20:00:20+00:00"
+            "time": "2026-03-12T15:51:39+00:00"
         },
         {
             "name": "myclabs/deep-copy",
@@ -2601,30 +3000,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"
@@ -2646,65 +3052,31 @@
             ],
             "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",
+                "url": "https://api.github.com/repos/phar-io/manifest/zipball/54750ef60c58e43759730615a392c31c80e23176",
+                "reference": "54750ef60c58e43759730615a392c31c80e23176",
                 "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",
-                "shasum": ""
-            },
-            "require": {
-                "ext-dom": "*",
-                "ext-libxml": "*",
-                "ext-phar": "*",
-                "ext-xmlwriter": "*",
-                "phar-io/version": "^3.0.1",
-                "php": "^7.2 || ^8.0"
+                "ext-dom": "*",
+                "ext-libxml": "*",
+                "ext-phar": "*",
+                "ext-xmlwriter": "*",
+                "phar-io/version": "^3.0.1",
+                "php": "^7.2 || ^8.0"
             },
             "type": "library",
             "extra": {
@@ -2804,15 +3176,15 @@
         },
         {
             "name": "phpstan/phpstan",
-            "version": "1.12.32",
+            "version": "2.1.44",
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/phpstan/phpstan/zipball/2770dcdf5078d0b0d53f94317e06affe88419aa8",
-                "reference": "2770dcdf5078d0b0d53f94317e06affe88419aa8",
+                "url": "https://api.github.com/repos/phpstan/phpstan/zipball/4a88c083c668b2c364a425c9b3171b2d9ea5d218",
+                "reference": "4a88c083c668b2c364a425c9b3171b2d9ea5d218",
                 "shasum": ""
             },
             "require": {
-                "php": "^7.2|^8.0"
+                "php": "^7.4|^8.0"
             },
             "conflict": {
                 "phpstan/phpstan-shim": "*"
@@ -2853,39 +3225,38 @@
                     "type": "github"
                 }
             ],
-            "time": "2025-09-30T10:16:31+00:00"
+            "time": "2026-03-25T17:34:21+00:00"
         },
         {
             "name": "phpunit/php-code-coverage",
-            "version": "9.2.32",
+            "version": "12.5.3",
             "source": {
                 "type": "git",
                 "url": "https://github.com/sebastianbergmann/php-code-coverage.git",
-                "reference": "85402a822d1ecf1db1096959413d35e1c37cf1a5"
+                "reference": "b015312f28dd75b75d3422ca37dff2cd1a565e8d"
             },
             "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/b015312f28dd75b75d3422ca37dff2cd1a565e8d",
+                "reference": "b015312f28dd75b75d3422ca37dff2cd1a565e8d",
                 "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-file-iterator": "^6.0",
+                "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",
@@ -2894,7 +3265,7 @@
             "type": "library",
             "extra": {
                 "branch-alias": {
-                    "dev-main": "9.2.x-dev"
+                    "dev-main": "12.5.x-dev"
                 }
             },
             "autoload": {
@@ -2923,40 +3294,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.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/phpunit/php-code-coverage",
+                    "type": "tidelift"
                 }
             ],
-            "time": "2024-08-22T04:23:01+00:00"
+            "time": "2026-02-06T06:01:44+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": {
@@ -2983,36 +3366,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": "*"
@@ -3020,7 +3416,7 @@
             "type": "library",
             "extra": {
                 "branch-alias": {
-                    "dev-master": "3.1-dev"
+                    "dev-main": "6.0-dev"
                 }
             },
             "autoload": {
@@ -3046,7 +3442,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": [
                 {
@@ -3054,32 +3451,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": {
@@ -3105,7 +3502,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": [
                 {
@@ -3113,32 +3511,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": {
@@ -3164,7 +3562,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": [
                 {
@@ -3172,24 +3571,23 @@
                     "type": "github"
                 }
             ],
-            "time": "2020-10-26T13:16:10+00:00"
+            "time": "2025-02-07T04:59:38+00:00"
         },
         {
             "name": "phpunit/phpunit",
-            "version": "9.6.34",
+            "version": "12.5.14",
             "source": {
                 "type": "git",
                 "url": "https://github.com/sebastianbergmann/phpunit.git",
-                "reference": "b36f02317466907a230d3aa1d34467041271ef4a"
+                "reference": "47283cfd98d553edcb1353591f4e255dc1bb61f0"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/sebastianbergmann/phpunit/zipball/b36f02317466907a230d3aa1d34467041271ef4a",
-                "reference": "b36f02317466907a230d3aa1d34467041271ef4a",
+                "url": "https://api.github.com/repos/sebastianbergmann/phpunit/zipball/47283cfd98d553edcb1353591f4e255dc1bb61f0",
+                "reference": "47283cfd98d553edcb1353591f4e255dc1bb61f0",
                 "shasum": ""
             },
             "require": {
-                "doctrine/instantiator": "^1.5.0 || ^2",
                 "ext-dom": "*",
                 "ext-json": "*",
                 "ext-libxml": "*",
@@ -3199,27 +3597,23 @@
                 "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.3",
+                "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.4",
+                "sebastian/diff": "^7.0.0",
+                "sebastian/environment": "^8.0.3",
+                "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"
@@ -3227,7 +3621,7 @@
             "type": "library",
             "extra": {
                 "branch-alias": {
-                    "dev-master": "9.6-dev"
+                    "dev-main": "12.5-dev"
                 }
             },
             "autoload": {
@@ -3259,7 +3653,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.34"
+                "source": "https://github.com/sebastianbergmann/phpunit/tree/12.5.14"
             },
             "funding": [
                 {
@@ -3283,7 +3677,7 @@
                     "type": "tidelift"
                 }
             ],
-            "time": "2026-01-27T05:45:00+00:00"
+            "time": "2026-02-18T12:38:40+00:00"
         },
         {
             "name": "rregeer/phpunit-coverage-check",
@@ -3333,28 +3727,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": {
@@ -3377,153 +3771,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.4",
             "source": {
                 "type": "git",
                 "url": "https://github.com/sebastianbergmann/comparator.git",
-                "reference": "e4df00b9b3571187db2831ae9aada2c6efbd715d"
+                "reference": "6a7de5df2e094f9a80b40a522391a7e6022df5f6"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/sebastianbergmann/comparator/zipball/e4df00b9b3571187db2831ae9aada2c6efbd715d",
-                "reference": "e4df00b9b3571187db2831ae9aada2c6efbd715d",
+                "url": "https://api.github.com/repos/sebastianbergmann/comparator/zipball/6a7de5df2e094f9a80b40a522391a7e6022df5f6",
+                "reference": "6a7de5df2e094f9a80b40a522391a7e6022df5f6",
                 "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": {
@@ -3562,7 +3863,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.4"
             },
             "funding": [
                 {
@@ -3582,33 +3884,33 @@
                     "type": "tidelift"
                 }
             ],
-            "time": "2026-01-24T09:22:56+00:00"
+            "time": "2026-01-24T09:28:48+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": {
@@ -3631,7 +3933,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": [
                 {
@@ -3639,33 +3942,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": {
@@ -3697,7 +4000,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": [
                 {
@@ -3705,27 +4009,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.0.4",
             "source": {
                 "type": "git",
                 "url": "https://github.com/sebastianbergmann/environment.git",
-                "reference": "830c43a844f1f8d5b7a1f6d6076b784454d8b7ed"
+                "reference": "7b8842c2d8e85d0c3a5831236bf5869af6ab2a11"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/sebastianbergmann/environment/zipball/830c43a844f1f8d5b7a1f6d6076b784454d8b7ed",
-                "reference": "830c43a844f1f8d5b7a1f6d6076b784454d8b7ed",
+                "url": "https://api.github.com/repos/sebastianbergmann/environment/zipball/7b8842c2d8e85d0c3a5831236bf5869af6ab2a11",
+                "reference": "7b8842c2d8e85d0c3a5831236bf5869af6ab2a11",
                 "shasum": ""
             },
             "require": {
-                "php": ">=7.3"
+                "php": ">=8.3"
             },
             "require-dev": {
-                "phpunit/phpunit": "^9.3"
+                "phpunit/phpunit": "^12.0"
             },
             "suggest": {
                 "ext-posix": "*"
@@ -3733,7 +4037,7 @@
             "type": "library",
             "extra": {
                 "branch-alias": {
-                    "dev-master": "5.1-dev"
+                    "dev-main": "8.0-dev"
                 }
             },
             "autoload": {
@@ -3752,7 +4056,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",
@@ -3760,42 +4064,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.0.4"
             },
             "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-03-15T07:05:40+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": {
@@ -3837,7 +4154,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": [
                 {
@@ -3857,38 +4175,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": {
@@ -3907,13 +4222,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": [
                 {
@@ -3933,33 +4249,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": {
@@ -3982,7 +4298,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": [
                 {
@@ -3990,34 +4307,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": {
@@ -4039,7 +4356,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": [
                 {
@@ -4047,32 +4365,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": {
@@ -4094,7 +4412,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": [
                 {
@@ -4102,32 +4421,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": {
@@ -4157,7 +4476,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": [
                 {
@@ -4177,32 +4497,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": {
@@ -4217,46 +4537,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": {
@@ -4275,11 +4607,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": [
                 {
@@ -4287,60 +4620,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",
@@ -4375,54 +4707,549 @@
             "time": "2024-06-17T05:45:20+00:00"
         },
         {
-            "name": "theseer/tokenizer",
-            "version": "1.3.1",
+            "name": "symfony/console",
+            "version": "v8.0.7",
             "source": {
                 "type": "git",
-                "url": "https://github.com/theseer/tokenizer.git",
-                "reference": "b7489ce515e168639d17feec34b8847c326b0b3c"
+                "url": "https://github.com/symfony/console.git",
+                "reference": "15ed9008a4ebe2d6a78e4937f74e0c13ef2e618a"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/theseer/tokenizer/zipball/b7489ce515e168639d17feec34b8847c326b0b3c",
-                "reference": "b7489ce515e168639d17feec34b8847c326b0b3c",
+                "url": "https://api.github.com/repos/symfony/console/zipball/15ed9008a4ebe2d6a78e4937f74e0c13ef2e618a",
+                "reference": "15ed9008a4ebe2d6a78e4937f74e0c13ef2e618a",
                 "shasum": ""
             },
             "require": {
-                "ext-dom": "*",
-                "ext-tokenizer": "*",
-                "ext-xmlwriter": "*",
-                "php": "^7.2 || ^8.0"
+                "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": {
-                "classmap": [
-                    "src/"
+                "psr-4": {
+                    "Symfony\\Component\\Console\\": ""
+                },
+                "exclude-from-classmap": [
+                    "/Tests/"
                 ]
             },
             "notification-url": "https://packagist.org/downloads/",
             "license": [
-                "BSD-3-Clause"
+                "MIT"
             ],
             "authors": [
                 {
-                    "name": "Arne Blankerts",
-                    "email": "arne@blankerts.de",
-                    "role": "Developer"
+                    "name": "Fabien Potencier",
+                    "email": "fabien@symfony.com"
+                },
+                {
+                    "name": "Symfony Community",
+                    "homepage": "https://symfony.com/contributors"
                 }
             ],
-            "description": "A small library for converting tokenized PHP source code into XML and potentially other formats",
+            "description": "Eases the creation of beautiful and testable command line interfaces",
+            "homepage": "https://symfony.com",
+            "keywords": [
+                "cli",
+                "command-line",
+                "console",
+                "terminal"
+            ],
             "support": {
-                "issues": "https://github.com/theseer/tokenizer/issues",
-                "source": "https://github.com/theseer/tokenizer/tree/1.3.1"
+                "source": "https://github.com/symfony/console/tree/v8.0.7"
             },
             "funding": [
                 {
-                    "url": "https://github.com/theseer",
+                    "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-06T14:06:22+00:00"
+        },
+        {
+            "name": "symfony/polyfill-ctype",
+            "version": "v1.33.0",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/symfony/polyfill-ctype.git",
+                "reference": "a3cc8b044a6ea513310cbd48ef7333b384945638"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/symfony/polyfill-ctype/zipball/a3cc8b044a6ea513310cbd48ef7333b384945638",
+                "reference": "a3cc8b044a6ea513310cbd48ef7333b384945638",
+                "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.33.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/polyfill-intl-grapheme",
+            "version": "v1.33.0",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/symfony/polyfill-intl-grapheme.git",
+                "reference": "380872130d3a5dd3ace2f4010d95125fde5d5c70"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/symfony/polyfill-intl-grapheme/zipball/380872130d3a5dd3ace2f4010d95125fde5d5c70",
+                "reference": "380872130d3a5dd3ace2f4010d95125fde5d5c70",
+                "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.33.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": "2025-11-17T20:03:58+00:00"
+            "time": "2025-06-27T09:58:17+00:00"
+        },
+        {
+            "name": "symfony/polyfill-intl-normalizer",
+            "version": "v1.33.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.33.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.5",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/symfony/process.git",
+                "reference": "b5f3aa6762e33fd95efbaa2ec4f4bc9fdd16d674"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/symfony/process/zipball/b5f3aa6762e33fd95efbaa2ec4f4bc9fdd16d674",
+                "reference": "b5f3aa6762e33fd95efbaa2ec4f4bc9fdd16d674",
+                "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.5"
+            },
+            "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-01-26T15:08:38+00:00"
+        },
+        {
+            "name": "symfony/string",
+            "version": "v8.0.6",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/symfony/string.git",
+                "reference": "6c9e1108041b5dce21a9a4984b531c4923aa9ec4"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/symfony/string/zipball/6c9e1108041b5dce21a9a4984b531c4923aa9ec4",
+                "reference": "6c9e1108041b5dce21a9a4984b531c4923aa9ec4",
+                "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.6"
+            },
+            "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-02-09T10:14:57+00:00"
+        },
+        {
+            "name": "theseer/tokenizer",
+            "version": "2.0.1",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/theseer/tokenizer.git",
+                "reference": "7989e43bf381af0eac72e4f0ca5bcbfa81658be4"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/theseer/tokenizer/zipball/7989e43bf381af0eac72e4f0ca5bcbfa81658be4",
+                "reference": "7989e43bf381af0eac72e4f0ca5bcbfa81658be4",
+                "shasum": ""
+            },
+            "require": {
+                "ext-dom": "*",
+                "ext-tokenizer": "*",
+                "ext-xmlwriter": "*",
+                "php": "^8.1"
+            },
+            "type": "library",
+            "autoload": {
+                "classmap": [
+                    "src/"
+                ]
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "BSD-3-Clause"
+            ],
+            "authors": [
+                {
+                    "name": "Arne Blankerts",
+                    "email": "arne@blankerts.de",
+                    "role": "Developer"
+                }
+            ],
+            "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/2.0.1"
+            },
+            "funding": [
+                {
+                    "url": "https://github.com/theseer",
+                    "type": "github"
+                }
+            ],
+            "time": "2025-12-08T11:19:18+00:00"
         },
         {
             "name": "utopia-php/cli",
@@ -4477,16 +5304,16 @@
         },
         {
             "name": "utopia-php/di",
-            "version": "0.3.1",
+            "version": "0.3.2",
             "source": {
                 "type": "git",
                 "url": "https://github.com/utopia-php/di.git",
-                "reference": "68873b7267842315d01d82a83b988bae525eab31"
+                "reference": "07025d721ed5d9be27932e8e640acf1467fc4b9d"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/utopia-php/di/zipball/68873b7267842315d01d82a83b988bae525eab31",
-                "reference": "68873b7267842315d01d82a83b988bae525eab31",
+                "url": "https://api.github.com/repos/utopia-php/di/zipball/07025d721ed5d9be27932e8e640acf1467fc4b9d",
+                "reference": "07025d721ed5d9be27932e8e640acf1467fc4b9d",
                 "shasum": ""
             },
             "require": {
@@ -4522,9 +5349,9 @@
             ],
             "support": {
                 "issues": "https://github.com/utopia-php/di/issues",
-                "source": "https://github.com/utopia-php/di/tree/0.3.1"
+                "source": "https://github.com/utopia-php/di/tree/0.3.2"
             },
-            "time": "2026-03-13T05:47:23+00:00"
+            "time": "2026-03-21T07:42:10+00:00"
         },
         {
             "name": "utopia-php/servers",
@@ -4582,9 +5409,12 @@
         }
     ],
     "aliases": [],
-    "minimum-stability": "stable",
-    "stability-flags": {},
-    "prefer-stable": false,
+    "minimum-stability": "dev",
+    "stability-flags": {
+        "utopia-php/async": 20,
+        "utopia-php/query": 20
+    },
+    "prefer-stable": true,
     "prefer-lowest": false,
     "platform": {
         "php": ">=8.4",
diff --git a/docker-compose.yml b/docker-compose.yml
index 4d4e8861d..bd8ad5c46 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:
@@ -189,7 +179,7 @@ services:
     cap_add:
       - SYS_NICE
     healthcheck:
-      test: ["CMD", "mysqladmin", "ping", "-h", "localhost", "-u $$MYSQL_USER", "-p $$MYSQL_PASSWORD"]
+      test: ["CMD", "mysqladmin", "ping", "-h", "127.0.0.1", "-P", "3307", "-u", "root", "-ppassword"]
       interval: 10s
       timeout: 5s
       retries: 5
@@ -198,6 +188,7 @@ services:
   mysql-mirror:
     image: mysql:8.0.43
     container_name: utopia-mysql-mirror
+    profiles: [mysql-mirror]
     networks:
       - database
     ports:
@@ -211,7 +202,7 @@ services:
     cap_add:
       - SYS_NICE
     healthcheck:
-      test: ["CMD", "mysqladmin", "ping", "-h", "localhost", "-u $$MYSQL_USER", "-p $$MYSQL_PASSWORD"]
+      test: ["CMD", "mysqladmin", "ping", "-h", "127.0.0.1", "-P", "3307", "-u", "root", "-ppassword"]
       interval: 10s
       timeout: 5s
       retries: 5
@@ -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-baseline.neon b/phpstan-baseline.neon
new file mode 100644
index 000000000..bd37078a3
--- /dev/null
+++ b/phpstan-baseline.neon
@@ -0,0 +1,3175 @@
+parameters:
+	ignoreErrors:
+		-
+			message: '#^Argument of an invalid type mixed supplied for foreach, only iterables are supported\.$#'
+			identifier: foreach.nonIterable
+			count: 2
+			path: src/Database/Adapter/MariaDB.php
+
+		-
+			message: '#^Call to an undefined method object\:\:exec\(\)\.$#'
+			identifier: method.notFound
+			count: 1
+			path: src/Database/Adapter/MariaDB.php
+
+		-
+			message: '#^Call to an undefined method object\:\:lastInsertId\(\)\.$#'
+			identifier: method.notFound
+			count: 1
+			path: src/Database/Adapter/MariaDB.php
+
+		-
+			message: '#^Call to an undefined method object\:\:prepare\(\)\.$#'
+			identifier: method.notFound
+			count: 16
+			path: src/Database/Adapter/MariaDB.php
+
+		-
+			message: '#^Call to an undefined method object\:\:query\(\)\.$#'
+			identifier: method.notFound
+			count: 1
+			path: src/Database/Adapter/MariaDB.php
+
+		-
+			message: '#^Cannot access offset ''columnName'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 1
+			path: src/Database/Adapter/MariaDB.php
+
+		-
+			message: '#^Cannot access offset ''indexName'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 1
+			path: src/Database/Adapter/MariaDB.php
+
+		-
+			message: '#^Cannot access offset ''indexType'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 1
+			path: src/Database/Adapter/MariaDB.php
+
+		-
+			message: '#^Cannot access offset ''nonUnique'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 1
+			path: src/Database/Adapter/MariaDB.php
+
+		-
+			message: '#^Cannot access offset ''subPart'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 1
+			path: src/Database/Adapter/MariaDB.php
+
+		-
+			message: '#^Cannot call method bindParam\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 4
+			path: src/Database/Adapter/MariaDB.php
+
+		-
+			message: '#^Cannot call method bindValue\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 4
+			path: src/Database/Adapter/MariaDB.php
+
+		-
+			message: '#^Cannot call method closeCursor\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 2
+			path: src/Database/Adapter/MariaDB.php
+
+		-
+			message: '#^Cannot call method execute\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 16
+			path: src/Database/Adapter/MariaDB.php
+
+		-
+			message: '#^Cannot call method fetchAll\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 2
+			path: src/Database/Adapter/MariaDB.php
+
+		-
+			message: '#^Cannot call method fetchColumn\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 5
+			path: src/Database/Adapter/MariaDB.php
+
+		-
+			message: '#^Cannot cast mixed to int\.$#'
+			identifier: cast.int
+			count: 2
+			path: src/Database/Adapter/MariaDB.php
+
+		-
+			message: '#^Method Utopia\\Database\\Adapter\\MariaDB\:\:analyzeCollection\(\) should return bool but returns mixed\.$#'
+			identifier: return.type
+			count: 1
+			path: src/Database/Adapter/MariaDB.php
+
+		-
+			message: '#^Method Utopia\\Database\\Adapter\\MariaDB\:\:create\(\) should return bool but returns mixed\.$#'
+			identifier: return.type
+			count: 1
+			path: src/Database/Adapter/MariaDB.php
+
+		-
+			message: '#^Method Utopia\\Database\\Adapter\\MariaDB\:\:createAttribute\(\) should return bool but returns mixed\.$#'
+			identifier: return.type
+			count: 1
+			path: src/Database/Adapter/MariaDB.php
+
+		-
+			message: '#^Method Utopia\\Database\\Adapter\\MariaDB\:\:createIndex\(\) should return bool but returns mixed\.$#'
+			identifier: return.type
+			count: 1
+			path: src/Database/Adapter/MariaDB.php
+
+		-
+			message: '#^Method Utopia\\Database\\Adapter\\MariaDB\:\:deleteCollection\(\) should return bool but returns mixed\.$#'
+			identifier: return.type
+			count: 1
+			path: src/Database/Adapter/MariaDB.php
+
+		-
+			message: '#^Method Utopia\\Database\\Adapter\\MariaDB\:\:deleteIndex\(\) should return bool but returns mixed\.$#'
+			identifier: return.type
+			count: 1
+			path: src/Database/Adapter/MariaDB.php
+
+		-
+			message: '#^Method Utopia\\Database\\Adapter\\MariaDB\:\:renameIndex\(\) should return bool but returns mixed\.$#'
+			identifier: return.type
+			count: 1
+			path: src/Database/Adapter/MariaDB.php
+
+		-
+			message: '#^Method Utopia\\Database\\Adapter\\MariaDB\:\:updateAttribute\(\) should return bool but returns mixed\.$#'
+			identifier: return.type
+			count: 1
+			path: src/Database/Adapter/MariaDB.php
+
+		-
+			message: '#^Possibly invalid array key type mixed\.$#'
+			identifier: offsetAccess.invalidOffset
+			count: 4
+			path: src/Database/Adapter/MariaDB.php
+
+		-
+			message: '#^Call to an undefined method object\:\:exec\(\)\.$#'
+			identifier: method.notFound
+			count: 1
+			path: src/Database/Adapter/MySQL.php
+
+		-
+			message: '#^Call to an undefined method object\:\:prepare\(\)\.$#'
+			identifier: method.notFound
+			count: 2
+			path: src/Database/Adapter/MySQL.php
+
+		-
+			message: '#^Cannot call method bindParam\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 2
+			path: src/Database/Adapter/MySQL.php
+
+		-
+			message: '#^Cannot call method execute\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 2
+			path: src/Database/Adapter/MySQL.php
+
+		-
+			message: '#^Cannot call method fetchColumn\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 2
+			path: src/Database/Adapter/MySQL.php
+
+		-
+			message: '#^Method Utopia\\Database\\Adapter\\Pool\:\:getSchemaIndexes\(\) should return array\<Utopia\\Database\\Document\> but returns mixed\.$#'
+			identifier: return.type
+			count: 1
+			path: src/Database/Adapter/Pool.php
+
+		-
+			message: '#^Method Utopia\\Database\\Adapter\\Pool\:\:getSupportForSchemaIndexes\(\) should return bool but returns mixed\.$#'
+			identifier: return.type
+			count: 1
+			path: src/Database/Adapter/Pool.php
+
+		-
+			message: '#^Call to an undefined method object\:\:beginTransaction\(\)\.$#'
+			identifier: method.notFound
+			count: 1
+			path: src/Database/Adapter/Postgres.php
+
+		-
+			message: '#^Call to an undefined method object\:\:exec\(\)\.$#'
+			identifier: method.notFound
+			count: 4
+			path: src/Database/Adapter/Postgres.php
+
+		-
+			message: '#^Call to an undefined method object\:\:inTransaction\(\)\.$#'
+			identifier: method.notFound
+			count: 1
+			path: src/Database/Adapter/Postgres.php
+
+		-
+			message: '#^Call to an undefined method object\:\:lastInsertId\(\)\.$#'
+			identifier: method.notFound
+			count: 1
+			path: src/Database/Adapter/Postgres.php
+
+		-
+			message: '#^Call to an undefined method object\:\:prepare\(\)\.$#'
+			identifier: method.notFound
+			count: 21
+			path: src/Database/Adapter/Postgres.php
+
+		-
+			message: '#^Call to an undefined method object\:\:query\(\)\.$#'
+			identifier: method.notFound
+			count: 1
+			path: src/Database/Adapter/Postgres.php
+
+		-
+			message: '#^Call to an undefined method object\:\:rollBack\(\)\.$#'
+			identifier: method.notFound
+			count: 2
+			path: src/Database/Adapter/Postgres.php
+
+		-
+			message: '#^Cannot call method bindValue\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 7
+			path: src/Database/Adapter/Postgres.php
+
+		-
+			message: '#^Cannot call method closeCursor\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 1
+			path: src/Database/Adapter/Postgres.php
+
+		-
+			message: '#^Cannot call method execute\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 8
+			path: src/Database/Adapter/Postgres.php
+
+		-
+			message: '#^Cannot call method fetchAll\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 1
+			path: src/Database/Adapter/Postgres.php
+
+		-
+			message: '#^Cannot call method fetchColumn\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 5
+			path: src/Database/Adapter/Postgres.php
+
+		-
+			message: '#^Method Utopia\\Database\\Adapter\\Postgres\:\:create\(\) should return bool but returns mixed\.$#'
+			identifier: return.type
+			count: 1
+			path: src/Database/Adapter/Postgres.php
+
+		-
+			message: '#^Method Utopia\\Database\\Adapter\\Postgres\:\:createIndex\(\) should return bool but returns mixed\.$#'
+			identifier: return.type
+			count: 1
+			path: src/Database/Adapter/Postgres.php
+
+		-
+			message: '#^Method Utopia\\Database\\Adapter\\Postgres\:\:rollbackTransaction\(\) should return bool but returns mixed\.$#'
+			identifier: return.type
+			count: 1
+			path: src/Database/Adapter/Postgres.php
+
+		-
+			message: '#^Method Utopia\\Database\\Adapter\\Postgres\:\:startTransaction\(\) should return bool but returns mixed\.$#'
+			identifier: return.type
+			count: 1
+			path: src/Database/Adapter/Postgres.php
+
+		-
+			message: '#^Argument of an invalid type mixed supplied for foreach, only iterables are supported\.$#'
+			identifier: foreach.nonIterable
+			count: 3
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Call to an undefined method object\:\:beginTransaction\(\)\.$#'
+			identifier: method.notFound
+			count: 1
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Call to an undefined method object\:\:commit\(\)\.$#'
+			identifier: method.notFound
+			count: 1
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Call to an undefined method object\:\:exec\(\)\.$#'
+			identifier: method.notFound
+			count: 2
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Call to an undefined method object\:\:getHostname\(\)\.$#'
+			identifier: method.notFound
+			count: 1
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Call to an undefined method object\:\:inTransaction\(\)\.$#'
+			identifier: method.notFound
+			count: 2
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Call to an undefined method object\:\:prepare\(\)\.$#'
+			identifier: method.notFound
+			count: 19
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Call to an undefined method object\:\:reconnect\(\)\.$#'
+			identifier: method.notFound
+			count: 1
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Call to an undefined method object\:\:rollBack\(\)\.$#'
+			identifier: method.notFound
+			count: 2
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Cannot access offset 0 on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 2
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Cannot call method bindValue\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 12
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Cannot call method closeCursor\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 6
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Cannot call method execute\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 12
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Cannot call method fetchAll\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 5
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Cannot call method getTenant\(\) on Utopia\\Database\\Hook\\Tenancy\|null\.$#'
+			identifier: method.nonObject
+			count: 1
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Cannot call method rowCount\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 1
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Method Utopia\\Database\\Adapter\\SQL\:\:buildDocumentRow\(\) has parameter \$attributeKeys with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Method Utopia\\Database\\Adapter\\SQL\:\:buildDocumentRow\(\) has parameter \$spatialAttributes with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Method Utopia\\Database\\Adapter\\SQL\:\:buildDocumentRow\(\) return type has no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Method Utopia\\Database\\Adapter\\SQL\:\:commitTransaction\(\) should return bool but returns mixed\.$#'
+			identifier: return.type
+			count: 1
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Method Utopia\\Database\\Adapter\\SQL\:\:createAttribute\(\) should return bool but returns mixed\.$#'
+			identifier: return.type
+			count: 1
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Method Utopia\\Database\\Adapter\\SQL\:\:createAttributes\(\) should return bool but returns mixed\.$#'
+			identifier: return.type
+			count: 1
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Method Utopia\\Database\\Adapter\\SQL\:\:createRelationship\(\) should return bool but returns mixed\.$#'
+			identifier: return.type
+			count: 1
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Method Utopia\\Database\\Adapter\\SQL\:\:delete\(\) should return bool but returns mixed\.$#'
+			identifier: return.type
+			count: 1
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Method Utopia\\Database\\Adapter\\SQL\:\:deleteAttribute\(\) should return bool but returns mixed\.$#'
+			identifier: return.type
+			count: 1
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Method Utopia\\Database\\Adapter\\SQL\:\:deleteCollection\(\) should return bool but returns mixed\.$#'
+			identifier: return.type
+			count: 1
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Method Utopia\\Database\\Adapter\\SQL\:\:deleteRelationship\(\) should return bool but returns mixed\.$#'
+			identifier: return.type
+			count: 1
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Method Utopia\\Database\\Adapter\\SQL\:\:getHostname\(\) should return string but returns mixed\.$#'
+			identifier: return.type
+			count: 1
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Method Utopia\\Database\\Adapter\\SQL\:\:ping\(\) should return bool but returns mixed\.$#'
+			identifier: return.type
+			count: 1
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Method Utopia\\Database\\Adapter\\SQL\:\:rawMutation\(\) should return int but returns mixed\.$#'
+			identifier: return.type
+			count: 1
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Method Utopia\\Database\\Adapter\\SQL\:\:renameAttribute\(\) should return bool but returns mixed\.$#'
+			identifier: return.type
+			count: 1
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Method Utopia\\Database\\Adapter\\SQL\:\:updateRelationship\(\) should return bool but returns mixed\.$#'
+			identifier: return.type
+			count: 1
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Parameter \#1 \$array of function array_diff expects an array of values castable to string, array\<mixed\> given\.$#'
+			identifier: argument.type
+			count: 3
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Parameter \#1 \$array of function array_intersect expects an array of values castable to string, array\<mixed\> given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Parameter \#1 \$array of function array_unique expects an array of values castable to string, array\<mixed\> given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Parameter \#1 \$query of method Utopia\\Database\\Profiler\\QueryProfiler\:\:log\(\) expects string, mixed given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Parameter \#1 \$row of method Utopia\\Database\\Adapter\:\:decorateRow\(\) expects array\<string, mixed\>, array given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Parameter \#2 \$arrays of function array_diff expects an array of values castable to string, array\<int, mixed\> given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Parameter \#2 \$arrays of function array_diff expects an array of values castable to string, array\<mixed, mixed\> given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Parameter \#2 \$arrays of function array_diff expects an array of values castable to string, array\<mixed\> given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Parameter \#2 \$arrays of function array_intersect expects an array of values castable to string, array\<mixed\> given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Possibly invalid array key type mixed\.$#'
+			identifier: offsetAccess.invalidOffset
+			count: 3
+			path: src/Database/Adapter/SQL.php
+
+		-
+			message: '#^Call to an undefined method object\:\:beginTransaction\(\)\.$#'
+			identifier: method.notFound
+			count: 1
+			path: src/Database/Adapter/SQLite.php
+
+		-
+			message: '#^Call to an undefined method object\:\:inTransaction\(\)\.$#'
+			identifier: method.notFound
+			count: 1
+			path: src/Database/Adapter/SQLite.php
+
+		-
+			message: '#^Call to an undefined method object\:\:prepare\(\)\.$#'
+			identifier: method.notFound
+			count: 14
+			path: src/Database/Adapter/SQLite.php
+
+		-
+			message: '#^Call to an undefined method object\:\:query\(\)\.$#'
+			identifier: method.notFound
+			count: 1
+			path: src/Database/Adapter/SQLite.php
+
+		-
+			message: '#^Call to an undefined method object\:\:rollBack\(\)\.$#'
+			identifier: method.notFound
+			count: 1
+			path: src/Database/Adapter/SQLite.php
+
+		-
+			message: '#^Cannot access offset 0 on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 1
+			path: src/Database/Adapter/SQLite.php
+
+		-
+			message: '#^Cannot call method bindParam\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 2
+			path: src/Database/Adapter/SQLite.php
+
+		-
+			message: '#^Cannot call method bindValue\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 3
+			path: src/Database/Adapter/SQLite.php
+
+		-
+			message: '#^Cannot call method closeCursor\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 2
+			path: src/Database/Adapter/SQLite.php
+
+		-
+			message: '#^Cannot call method execute\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 14
+			path: src/Database/Adapter/SQLite.php
+
+		-
+			message: '#^Cannot call method fetch\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 3
+			path: src/Database/Adapter/SQLite.php
+
+		-
+			message: '#^Cannot call method fetchAll\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 1
+			path: src/Database/Adapter/SQLite.php
+
+		-
+			message: '#^Cannot call method fetchColumn\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 2
+			path: src/Database/Adapter/SQLite.php
+
+		-
+			message: '#^Method Utopia\\Database\\Adapter\\SQLite\:\:createIndex\(\) should return bool but returns mixed\.$#'
+			identifier: return.type
+			count: 1
+			path: src/Database/Adapter/SQLite.php
+
+		-
+			message: '#^Method Utopia\\Database\\Adapter\\SQLite\:\:deleteAttribute\(\) should return bool but returns mixed\.$#'
+			identifier: return.type
+			count: 1
+			path: src/Database/Adapter/SQLite.php
+
+		-
+			message: '#^Method Utopia\\Database\\Adapter\\SQLite\:\:deleteIndex\(\) should return bool but returns mixed\.$#'
+			identifier: return.type
+			count: 1
+			path: src/Database/Adapter/SQLite.php
+
+		-
+			message: '#^Method Utopia\\Database\\Adapter\\SQLite\:\:startTransaction\(\) should return bool but returns mixed\.$#'
+			identifier: return.type
+			count: 1
+			path: src/Database/Adapter/SQLite.php
+
+		-
+			message: '#^Parameter \#1 \$array of function array_diff expects an array of values castable to string, array\<mixed, mixed\> given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/Adapter/SQLite.php
+
+		-
+			message: '#^Parameter \#1 \$input of class Utopia\\Database\\Document constructor expects array\<string, mixed\>, array\<mixed, mixed\> given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/Cache/QueryCache.php
+
+		-
+			message: '#^Parameter \#3 \$hash of method Utopia\\Cache\\Cache\:\:load\(\) expects string, int given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/Cache/QueryCache.php
+
+		-
+			message: '#^Binary operation "\." between mixed and ''\:\:'' results in an error\.$#'
+			identifier: binaryOp.invalid
+			count: 1
+			path: src/Database/Database.php
+
+		-
+			message: '#^Binary operation "\." between non\-falsy\-string and mixed results in an error\.$#'
+			identifier: binaryOp.invalid
+			count: 1
+			path: src/Database/Database.php
+
+		-
+			message: '#^Call to function is_null\(\) with mixed will always evaluate to false\.$#'
+			identifier: function.impossibleType
+			count: 1
+			path: src/Database/Database.php
+
+		-
+			message: '#^Cannot call method getArrayCopy\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 2
+			path: src/Database/Database.php
+
+		-
+			message: '#^Cannot cast mixed to string\.$#'
+			identifier: cast.string
+			count: 1
+			path: src/Database/Database.php
+
+		-
+			message: '#^Parameter \#1 \$callback of function array_map expects \(callable\(mixed\)\: mixed\)\|null, Closure\(Utopia\\Database\\Document\)\: Utopia\\Database\\Document given\.$#'
+			identifier: argument.type
+			count: 2
+			path: src/Database/Database.php
+
+		-
+			message: '#^Parameter \#1 \$data of static method Utopia\\Database\\Operator\:\:extractOperators\(\) expects array\<string, mixed\>, mixed given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/Database.php
+
+		-
+			message: '#^Parameter \#2 \$data of method Utopia\\Cache\\Cache\:\:save\(\) expects array\<int\|string, mixed\>\|string, mixed given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/Database.php
+
+		-
+			message: '#^Parameter \#2 \$document of method Utopia\\Database\\Adapter\:\:castingAfter\(\) expects Utopia\\Database\\Document, mixed given\.$#'
+			identifier: argument.type
+			count: 2
+			path: src/Database/Database.php
+
+		-
+			message: '#^Parameter \#2 \$document of method Utopia\\Database\\Database\:\:decode\(\) expects Utopia\\Database\\Document, mixed given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/Database.php
+
+		-
+			message: '#^Parameter \#2 \$documents of method Utopia\\Database\\Database\:\:refetchDocuments\(\) expects array\<Utopia\\Database\\Document\>, array given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/Database.php
+
+		-
+			message: '#^Parameter \#2 \$queries of method Utopia\\Database\\Adapter\:\:count\(\) expects array\<Utopia\\Database\\Query\>, array given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/Database.php
+
+		-
+			message: '#^Parameter \#2 \$queries of method Utopia\\Database\\Adapter\:\:find\(\) expects array\<Utopia\\Database\\Query\>, array given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/Database.php
+
+		-
+			message: '#^Parameter \#2 \$queries of method Utopia\\Database\\Cache\\QueryCache\:\:buildQueryKey\(\) expects array\<Utopia\\Database\\Query\>, array given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/Database.php
+
+		-
+			message: '#^Parameter \#3 \$document of method Utopia\\Database\\Database\:\:decorateDocument\(\) expects Utopia\\Database\\Document, mixed given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/Database.php
+
+		-
+			message: '#^Parameter \#3 \$queries of method Utopia\\Database\\Adapter\:\:sum\(\) expects array\<Utopia\\Database\\Query\>, array given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/Database.php
+
+		-
+			message: '#^Parameter \#4 \$tenant of method Utopia\\Database\\Cache\\QueryCache\:\:buildQueryKey\(\) expects int\|null, int\|string\|null given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/Database.php
+
+		-
+			message: '#^Method Utopia\\Database\\Document\:\:getInternalKeySet\(\) return type has no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: src/Database/Document.php
+
+		-
+			message: '#^Method Utopia\\Database\\Document\:\:getPermissionsByType\(\) should return array\<string\> but returns mixed\.$#'
+			identifier: return.type
+			count: 1
+			path: src/Database/Document.php
+
+		-
+			message: '#^Method Utopia\\Database\\Document\:\:getTenant\(\) should return int\|string\|null but returns mixed\.$#'
+			identifier: return.type
+			count: 1
+			path: src/Database/Document.php
+
+		-
+			message: '#^PHPDoc tag @param for parameter \$type with type string is incompatible with native type Utopia\\Database\\PermissionType\.$#'
+			identifier: parameter.phpDocType
+			count: 1
+			path: src/Database/Document.php
+
+		-
+			message: '#^Parameter \#1 \$array of function array_unique expects an array of values castable to string, array\<mixed, mixed\> given\.$#'
+			identifier: argument.type
+			count: 2
+			path: src/Database/Document.php
+
+		-
+			message: '#^Property Utopia\\Database\\Document\:\:\$parsedPermissions type has no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: src/Database/Document.php
+
+		-
+			message: '#^Parameter \#1 \$collection of class Utopia\\Database\\Event\\DocumentDeleted constructor expects string, mixed given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/Event/EventDispatcherHook.php
+
+		-
+			message: '#^Parameter \#2 \$documentId of class Utopia\\Database\\Event\\DocumentDeleted constructor expects string, mixed given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/Event/EventDispatcherHook.php
+
+		-
+			message: '#^Argument of an invalid type mixed supplied for foreach, only iterables are supported\.$#'
+			identifier: foreach.nonIterable
+			count: 2
+			path: src/Database/Hook/Relationships.php
+
+		-
+			message: '#^Cannot access offset mixed on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 6
+			path: src/Database/Hook/Relationships.php
+
+		-
+			message: '#^Cannot call method getAttribute\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 3
+			path: src/Database/Hook/Relationships.php
+
+		-
+			message: '#^Cannot call method getMethod\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 6
+			path: src/Database/Hook/Relationships.php
+
+		-
+			message: '#^Cannot call method getValues\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 3
+			path: src/Database/Hook/Relationships.php
+
+		-
+			message: '#^Cannot call method removeAttribute\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 1
+			path: src/Database/Hook/Relationships.php
+
+		-
+			message: '#^Cannot call method setValues\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 1
+			path: src/Database/Hook/Relationships.php
+
+		-
+			message: '#^Method Utopia\\Database\\Hook\\Relationships\:\:convertQueries\(\) has parameter \$queries with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: src/Database/Hook/Relationships.php
+
+		-
+			message: '#^Method Utopia\\Database\\Hook\\Relationships\:\:convertQueries\(\) has parameter \$relationships with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: src/Database/Hook/Relationships.php
+
+		-
+			message: '#^Method Utopia\\Database\\Hook\\Relationships\:\:convertQueries\(\) return type has no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: src/Database/Hook/Relationships.php
+
+		-
+			message: '#^Method Utopia\\Database\\Hook\\Relationships\:\:populateDocuments\(\) has parameter \$documents with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: src/Database/Hook/Relationships.php
+
+		-
+			message: '#^Method Utopia\\Database\\Hook\\Relationships\:\:populateDocuments\(\) has parameter \$selects with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: src/Database/Hook/Relationships.php
+
+		-
+			message: '#^Method Utopia\\Database\\Hook\\Relationships\:\:populateDocuments\(\) return type has no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: src/Database/Hook/Relationships.php
+
+		-
+			message: '#^Method Utopia\\Database\\Hook\\Relationships\:\:processQueries\(\) has parameter \$queries with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: src/Database/Hook/Relationships.php
+
+		-
+			message: '#^Method Utopia\\Database\\Hook\\Relationships\:\:processQueries\(\) has parameter \$relationships with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: src/Database/Hook/Relationships.php
+
+		-
+			message: '#^Method Utopia\\Database\\Hook\\Relationships\:\:processQueries\(\) return type has no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: src/Database/Hook/Relationships.php
+
+		-
+			message: '#^Parameter \#1 \$array of function array_values expects array\<T\>, mixed given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/Hook/Relationships.php
+
+		-
+			message: '#^Parameter \#1 \$documents of method Utopia\\Database\\Hook\\Relationships\:\:populateSingleRelationshipBatch\(\) expects array\<Utopia\\Database\\Document\>, array given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/Hook/Relationships.php
+
+		-
+			message: '#^Parameter \#1 \$haystack of function str_contains expects string, mixed given\.$#'
+			identifier: argument.type
+			count: 3
+			path: src/Database/Hook/Relationships.php
+
+		-
+			message: '#^Parameter \#1 \$method of class Utopia\\Database\\Query constructor expects string\|Utopia\\Query\\Method, mixed given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/Hook/Relationships.php
+
+		-
+			message: '#^Parameter \#2 \$attribute of static method Utopia\\Database\\Relationship\:\:fromDocument\(\) expects Utopia\\Database\\Document, mixed given\.$#'
+			identifier: argument.type
+			count: 2
+			path: src/Database/Hook/Relationships.php
+
+		-
+			message: '#^Parameter \#2 \$callback of function array_filter expects \(callable\(mixed\)\: bool\)\|null, Closure\(Utopia\\Database\\Document\)\: bool given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/Hook/Relationships.php
+
+		-
+			message: '#^Parameter \#2 \$queries of method Utopia\\Database\\Hook\\Relationships\:\:processQueries\(\) expects array, mixed given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/Hook/Relationships.php
+
+		-
+			message: '#^Parameter \#2 \$string of function explode expects string, mixed given\.$#'
+			identifier: argument.type
+			count: 2
+			path: src/Database/Hook/Relationships.php
+
+		-
+			message: '#^Parameter \#3 \$queries of method Utopia\\Database\\Hook\\Relationships\:\:populateSingleRelationshipBatch\(\) expects array\<Utopia\\Database\\Query\>, mixed given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/Hook/Relationships.php
+
+		-
+			message: '#^Parameter \#3 \$values of class Utopia\\Database\\Query constructor expects array\<mixed\>, mixed given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/Hook/Relationships.php
+
+		-
+			message: '#^Parameter \$attributes of class Utopia\\Database\\Index constructor expects array\<string\>, mixed given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/Index.php
+
+		-
+			message: '#^Parameter \$key of class Utopia\\Database\\Index constructor expects string, mixed given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/Index.php
+
+		-
+			message: '#^Parameter \$lengths of class Utopia\\Database\\Index constructor expects array\<int\|null\>, mixed given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/Index.php
+
+		-
+			message: '#^Parameter \$orders of class Utopia\\Database\\Index constructor expects array\<string\|null\>, mixed given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/Index.php
+
+		-
+			message: '#^Parameter \$ttl of class Utopia\\Database\\Index constructor expects int, mixed given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/Index.php
+
+		-
+			message: '#^Negated boolean expression is always true\.$#'
+			identifier: booleanNot.alwaysTrue
+			count: 1
+			path: src/Database/Loading/LazyProxy.php
+
+		-
+			message: '#^Property Utopia\\Database\\Loading\\LazyProxy\:\:\$batchLoader \(Utopia\\Database\\Loading\\BatchLoader\|null\) is never assigned null so it can be removed from the property type\.$#'
+			identifier: property.unusedType
+			count: 1
+			path: src/Database/Loading/LazyProxy.php
+
+		-
+			message: '#^Property Utopia\\Database\\Loading\\LazyProxy\:\:\$realDocument is never read, only written\.$#'
+			identifier: property.onlyWritten
+			count: 1
+			path: src/Database/Loading/LazyProxy.php
+
+		-
+			message: '#^Parameter \#1 \$version of method Utopia\\Database\\Migration\\MigrationTracker\:\:markRolledBack\(\) expects string, mixed given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/Migration/MigrationRunner.php
+
+		-
+			message: '#^Possibly invalid array key type mixed\.$#'
+			identifier: offsetAccess.invalidOffset
+			count: 2
+			path: src/Database/Migration/MigrationRunner.php
+
+		-
+			message: '#^Cannot cast mixed to int\.$#'
+			identifier: cast.int
+			count: 1
+			path: src/Database/Migration/MigrationTracker.php
+
+		-
+			message: '#^Method Utopia\\Database\\Migration\\MigrationTracker\:\:getAppliedVersions\(\) should return array\<string\> but returns array\<mixed\>\.$#'
+			identifier: return.type
+			count: 1
+			path: src/Database/Migration/MigrationTracker.php
+
+		-
+			message: '#^Call to function method_exists\(\) with Utopia\\Database\\Adapter and ''enableAlterLocks'' will always evaluate to true\.$#'
+			identifier: function.alreadyNarrowedType
+			count: 2
+			path: src/Database/Migration/Strategy/OnlineSchemaChange.php
+
+		-
+			message: '#^Right side of && is always true\.$#'
+			identifier: booleanAnd.rightAlwaysTrue
+			count: 1
+			path: src/Database/Migration/Strategy/OnlineSchemaChange.php
+
+		-
+			message: '#^Parameter \#1 \$class of class ReflectionProperty constructor expects class\-string\|object, string given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/ORM/EntityMapper.php
+
+		-
+			message: '#^Parameter \#1 \$objectOrClass of class ReflectionClass constructor expects class\-string\<T of object\>\|T of object, string given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/ORM/EntityMapper.php
+
+		-
+			message: '#^Method Utopia\\Database\\ORM\\MetadataFactory\:\:parseLifecycleCallbacks\(\) has parameter \$ref with generic class ReflectionClass but does not specify its types\: T$#'
+			identifier: missingType.generics
+			count: 1
+			path: src/Database/ORM/MetadataFactory.php
+
+		-
+			message: '#^Parameter \#1 \$objectOrClass of class ReflectionClass constructor expects class\-string\<T of object\>\|T of object, string given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/ORM/MetadataFactory.php
+
+		-
+			message: '#^Cannot access constant class on mixed\.$#'
+			identifier: classConstant.nonObject
+			count: 2
+			path: src/Database/ORM/UnitOfWork.php
+
+		-
+			message: '#^Cannot assign offset mixed to SplObjectStorage\<object, array\<string, mixed\>\>\.$#'
+			identifier: offsetAssign.dimType
+			count: 1
+			path: src/Database/ORM/UnitOfWork.php
+
+		-
+			message: '#^Parameter \#1 \$className of method Utopia\\Database\\ORM\\MetadataFactory\:\:getMetadata\(\) expects string, mixed given\.$#'
+			identifier: argument.type
+			count: 2
+			path: src/Database/ORM/UnitOfWork.php
+
+		-
+			message: '#^Parameter \#1 \$entity of method Utopia\\Database\\ORM\\EntityMapper\:\:getId\(\) expects object, mixed given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/ORM/UnitOfWork.php
+
+		-
+			message: '#^Parameter \#1 \$entity of method Utopia\\Database\\ORM\\EntityMapper\:\:takeSnapshot\(\) expects object, mixed given\.$#'
+			identifier: argument.type
+			count: 2
+			path: src/Database/ORM/UnitOfWork.php
+
+		-
+			message: '#^Parameter \#1 \$entity of method Utopia\\Database\\ORM\\EntityMapper\:\:toDocument\(\) expects object, mixed given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/ORM/UnitOfWork.php
+
+		-
+			message: '#^Parameter \#1 \$entity of method Utopia\\Database\\ORM\\UnitOfWork\:\:invokeCallbacks\(\) expects object, mixed given\.$#'
+			identifier: argument.type
+			count: 2
+			path: src/Database/ORM/UnitOfWork.php
+
+		-
+			message: '#^Parameter \#1 \$object of method SplObjectStorage\<object,Utopia\\Database\\ORM\\EntityState\>\:\:contains\(\) expects object, mixed given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/ORM/UnitOfWork.php
+
+		-
+			message: '#^Parameter \#1 \$object of method SplObjectStorage\<object,array\<string, mixed\>\>\:\:contains\(\) expects object, mixed given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/ORM/UnitOfWork.php
+
+		-
+			message: '#^Parameter \#2 \$entity of method Utopia\\Database\\ORM\\EntityMapper\:\:applyDocumentToEntity\(\) expects object, mixed given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/ORM/UnitOfWork.php
+
+		-
+			message: '#^Offset ''function'' on array\{function\: string, line\?\: int, file\?\: string, class\?\: class\-string, type\?\: ''\-\>''\|''\:\:'', args\?\: list\<mixed\>, object\?\: object\} on left side of \?\? always exists and is not nullable\.$#'
+			identifier: nullCoalesce.offset
+			count: 1
+			path: src/Database/Profiler/QueryProfiler.php
+
+		-
+			message: '#^Parameter \#2 \$values of static method Utopia\\Query\\Query\:\:equal\(\) expects array\<array\<mixed\>\|bool\|float\|int\|string\|null\>, array\<mixed\> given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/Repository/Repository.php
+
+		-
+			message: '#^Parameter \#3 \$type of method Utopia\\Database\\Database\:\:updateAttribute\(\) expects string\|Utopia\\Query\\Schema\\ColumnType\|null, Utopia\\Database\\Attribute given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/Schema/DiffResult.php
+
+		-
+			message: '#^Method Utopia\\Database\\Seeder\\Factory\:\:createMany\(\) should return array\<Utopia\\Database\\Document\> but returns int\.$#'
+			identifier: return.type
+			count: 1
+			path: src/Database/Seeder/Factory.php
+
+		-
+			message: '#^Method Utopia\\Database\\Type\\EmbeddableType\:\:compose\(\) has parameter \$values with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: src/Database/Type/EmbeddableType.php
+
+		-
+			message: '#^Parameter \#1 \$array of function array_unique expects an array of values castable to string, array\<mixed\> given\.$#'
+			identifier: argument.type
+			count: 1
+			path: src/Database/Validator/Query/Select.php
+
+		-
+			message: '#^Ternary operator condition is always true\.$#'
+			identifier: ternary.alwaysTrue
+			count: 1
+			path: src/Database/Validator/Sequence.php
+
+		-
+			message: '#^Argument of an invalid type mixed supplied for foreach, only iterables are supported\.$#'
+			identifier: foreach.nonIterable
+			count: 4
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Binary operation "\*" between mixed and 2 results in an error\.$#'
+			identifier: binaryOp.invalid
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Binary operation "\+" between mixed and 1 results in an error\.$#'
+			identifier: binaryOp.invalid
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Binary operation "\+" between mixed and 7 results in an error\.$#'
+			identifier: binaryOp.invalid
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Binary operation "\-" between mixed and 1 results in an error\.$#'
+			identifier: binaryOp.invalid
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Binary operation "\." between mixed and ''_'' results in an error\.$#'
+			identifier: binaryOp.invalid
+			count: 2
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Binary operation "\." between mixed and ''new_value'' results in an error\.$#'
+			identifier: binaryOp.invalid
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Binary operation "\." between non\-falsy\-string and mixed results in an error\.$#'
+			identifier: binaryOp.invalid
+			count: 2
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Call to function is_string\(\) with string will always evaluate to true\.$#'
+			identifier: function.alreadyNarrowedType
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Call to method PHPUnit\\Framework\\Assert\:\:assertFalse\(\) with false will always evaluate to false\.$#'
+			identifier: method.impossibleType
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Call to method PHPUnit\\Framework\\Assert\:\:assertIsArray\(\) with array\<Utopia\\Database\\Document\> will always evaluate to true\.$#'
+			identifier: method.alreadyNarrowedType
+			count: 4
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Call to method PHPUnit\\Framework\\Assert\:\:assertIsString\(\) with string will always evaluate to true\.$#'
+			identifier: method.alreadyNarrowedType
+			count: 3
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Call to method PHPUnit\\Framework\\Assert\:\:assertNotNull\(\) with Utopia\\Database\\Document will always evaluate to true\.$#'
+			identifier: method.alreadyNarrowedType
+			count: 5
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Call to method PHPUnit\\Framework\\Assert\:\:assertNotNull\(\) with string will always evaluate to true\.$#'
+			identifier: method.alreadyNarrowedType
+			count: 6
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Call to method PHPUnit\\Framework\\Assert\:\:assertTrue\(\) with true and ''Exception thrown as…'' will always evaluate to true\.$#'
+			identifier: method.alreadyNarrowedType
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Call to method PHPUnit\\Framework\\Assert\:\:assertTrue\(\) with true will always evaluate to true\.$#'
+			identifier: method.alreadyNarrowedType
+			count: 10
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''\$id'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 158
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''age'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''array'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 11
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''attributes'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 6
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''avatar'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 2
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''birds'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 2
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''boolean'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 2
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''buildings'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 4
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''bulkUpdated'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''capital'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 2
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''children'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 3
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''country'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 3
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''cows'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 3
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''cpu'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''data'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''date'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''debug'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''default'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 12
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''description'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 2
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''dormitory'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 2
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''emoji'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 2
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''farmer'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 2
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''filters'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 2
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''float'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''floor'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 2
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''format'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 10
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''formatOptions'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 16
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''home'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 2
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''info'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 3
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''inspections'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 11
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''key'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 20
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''lengths'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 7
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''level1'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 2
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''level2'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 2
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''level2OneToManyChild'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 2
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''level3'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 2
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''level3ManyToOneParent'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 4
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''level3OneToMany'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 9
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''level3OneToManyChild'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 2
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''level3OneToOne'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 4
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''level3OneToOneNull'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 4
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''level4'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 2
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''level5'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 2
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''matrix'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''max'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 3
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''mayor'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 8
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''min'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 3
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''name'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 25
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''null_value'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''number'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 2
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''options'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 54
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''orders'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 2
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''origin'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''owner'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 2
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''pattern'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 2
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''pets'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 8
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''platforms'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 2
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''players'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 3
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''plot'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 3
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''prizes'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 4
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''projects'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''publisher'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 3
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''relatedCollection'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 13
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''relationType'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 13
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''required'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 13
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''rooms'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 3
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''signed'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 11
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''size'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 13
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''skills'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''stones'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 2
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''string'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 2
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''supporters'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 3
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''teacher'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 2
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''team'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 2
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''toppings'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 8
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''towns'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 3
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''toys'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 2
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''twoWay'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 13
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''twoWayKey'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 15
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''type'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 43
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''user'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 3
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''version'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 3
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset ''year'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 6
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset 0 on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 214
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset 1 on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 60
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset 2 on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 5
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset 4 on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 10
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot access offset int\<0, 2\> on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot call method assertEquals\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot call method getArrayCopy\(\) on array\<string, mixed\>\.$#'
+			identifier: method.nonObject
+			count: 3
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot call method getAttribute\(\) on Utopia\\Database\\Document\|null\.$#'
+			identifier: method.nonObject
+			count: 2
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot call method getAttribute\(\) on array\<string, mixed\>\.$#'
+			identifier: method.nonObject
+			count: 4
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot call method getAttribute\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 47
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot call method getId\(\) on Utopia\\Database\\Document\|false\.$#'
+			identifier: method.nonObject
+			count: 2
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot call method getId\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 77
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot call method getPermissions\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 6
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot call method isEmpty\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot call method setAttribute\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 7
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot call method setDefaultStatus\(\) on Utopia\\Database\\Validator\\Authorization\|null\.$#'
+			identifier: method.nonObject
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot cast mixed to float\.$#'
+			identifier: cast.double
+			count: 16
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Cannot cast mixed to int\.$#'
+			identifier: cast.int
+			count: 16
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Match expression does not handle remaining value\: string$#'
+			identifier: match.unhandled
+			count: 5
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Method Tests\\E2E\\Adapter\\Base\:\:cleanupAggCollections\(\) has parameter \$collections with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Method Tests\\E2E\\Adapter\\Base\:\:groupByCountProvider\(\) should return array\<string, array\{string, array\<string\>, array\<Utopia\\Database\\Query\>, int\}\> but returns array\{''group by category no filter''\: array\{''category'', array\{\}, 3\}, ''group by category price \> 50''\: array\{''category'', array\{Utopia\\Database\\Query\}, 3\}, ''group by category price \> 200''\: array\{''category'', array\{Utopia\\Database\\Query\}, 1\}\}\.$#'
+			identifier: return.type
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Method Tests\\E2E\\Adapter\\Base\:\:initMoviesFixture\(\) return type has no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Method Tests\\E2E\\Adapter\\Base\:\:invalidDefaultValues\(\) should return array\<array\<bool\|float\|int\|string\>\> but returns array\<int, list\<bool\|float\|int\|string\|Utopia\\Query\\Schema\\ColumnType\>\>\.$#'
+			identifier: return.type
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Method Tests\\E2E\\Adapter\\Base\:\:singleAggregationProvider\(\) should return array\<string, array\{string, string, string, array\<Utopia\\Database\\Query\>, float\|int\}\> but returns array\{''count all products''\: array\{''cnt'', ''count'', ''\*'', ''total'', array\{\}, 9\}, ''count electronics''\: array\{''cnt'', ''count'', ''\*'', ''total'', array\{Utopia\\Database\\Query\}, 3\}, ''count clothing''\: array\{''cnt'', ''count'', ''\*'', ''total'', array\{Utopia\\Database\\Query\}, 3\}, ''count books''\: array\{''cnt'', ''count'', ''\*'', ''total'', array\{Utopia\\Database\\Query\}, 3\}, ''count price \> 100''\: array\{''cnt'', ''count'', ''\*'', ''total'', array\{Utopia\\Database\\Query\}, 4\}, ''count price \<\= 50''\: array\{''cnt'', ''count'', ''\*'', ''total'', array\{Utopia\\Database\\Query\}, 4\}, ''sum all prices''\: array\{''sum'', ''sum'', ''price'', ''total'', array\{\}, 2785\}, ''sum electronics''\: array\{''sum'', ''sum'', ''price'', ''total'', array\{Utopia\\Database\\Query\}, 2500\}, \.\.\.\}\.$#'
+			identifier: return.type
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Method Utopia\\Database\\Hook\\Lifecycle@anonymous/tests/e2e/Adapter/Scopes/CollectionTests\.php\:1084\:\:__construct\(\) has parameter \$events with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Method Utopia\\Database\\Hook\\Lifecycle@anonymous/tests/e2e/Adapter/Scopes/CollectionTests\.php\:1084\:\:__construct\(\) has parameter \$test with no type specified\.$#'
+			identifier: missingType.parameter
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^PHPDoc tag @param for parameter \$type with type string is incompatible with native type Utopia\\Query\\Schema\\ColumnType\.$#'
+			identifier: parameter.phpDocType
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^PHPDoc tag @return with type array\<Utopia\\Database\\Document\> is incompatible with native type void\.$#'
+			identifier: return.phpDocType
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^PHPDoc tag @throws with type Tests\\E2E\\Adapter\\Scopes\\AuthorizationException\|Tests\\E2E\\Adapter\\Scopes\\ConflictException\|Tests\\E2E\\Adapter\\Scopes\\DatabaseException\|Tests\\E2E\\Adapter\\Scopes\\LimitException\|Tests\\E2E\\Adapter\\Scopes\\StructureException\|Utopia\\Database\\Exception\\Duplicate is not subtype of Throwable$#'
+			identifier: throws.notThrowable
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^PHPDoc tag @throws with type Tests\\E2E\\Adapter\\Scopes\\DatabaseException\|Tests\\E2E\\Adapter\\Scopes\\QueryException\|Utopia\\Database\\Exception\\Authorization\|Utopia\\Database\\Exception\\Duplicate\|Utopia\\Database\\Exception\\Limit\|Utopia\\Database\\Exception\\Structure\|Utopia\\Database\\Exception\\Timeout is not subtype of Throwable$#'
+			identifier: throws.notThrowable
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^PHPDoc tag @throws with type Tests\\E2E\\Adapter\\Scopes\\DatabaseException\|Utopia\\Database\\Exception\\Duplicate\|Utopia\\Database\\Exception\\Limit is not subtype of Throwable$#'
+			identifier: throws.notThrowable
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Parameter \#1 \$array of function end expects array\|object, mixed given\.$#'
+			identifier: argument.type
+			count: 3
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Parameter \#1 \$array of function sort expects TArray of array\<T\>, mixed given\.$#'
+			identifier: argument.type
+			count: 4
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Parameter \#1 \$datetime of class DateTime constructor expects string, mixed given\.$#'
+			identifier: argument.type
+			count: 27
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Parameter \#1 \$id of method Utopia\\Database\\Database\:\:deleteCollection\(\) expects string, mixed given\.$#'
+			identifier: argument.type
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Parameter \#1 \$json of function json_decode expects string, mixed given\.$#'
+			identifier: argument.type
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Parameter \#1 \$min of class Utopia\\Validator\\Range constructor expects float\|int, mixed given\.$#'
+			identifier: argument.type
+			count: 3
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Parameter \#1 \$string of function base64_decode expects string, mixed given\.$#'
+			identifier: argument.type
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Parameter \#1 \$string of function base64_encode expects string, mixed given\.$#'
+			identifier: argument.type
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Parameter \#1 \$string of function strlen expects string, mixed given\.$#'
+			identifier: argument.type
+			count: 6
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Parameter \#1 \$string of function strlen expects string, string\|null given\.$#'
+			identifier: argument.type
+			count: 2
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Parameter \#1 \$string of function substr expects string, string\|null given\.$#'
+			identifier: argument.type
+			count: 2
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Parameter \#1 \$string1 of function strcmp expects string, mixed given\.$#'
+			identifier: argument.type
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Parameter \#1 \$value of function count expects array\|Countable, mixed given\.$#'
+			identifier: argument.type
+			count: 60
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Parameter \#1 \.\.\.\$arrays of function array_merge expects array, mixed given\.$#'
+			identifier: argument.type
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Parameter \#2 \$array of function array_map expects array, mixed given\.$#'
+			identifier: argument.type
+			count: 2
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Parameter \#2 \$array of method PHPUnit\\Framework\\Assert\:\:assertArrayHasKey\(\) expects array\<mixed\>\|ArrayAccess\<\(int\|string\), mixed\>, Utopia\\Database\\Document\|null given\.$#'
+			identifier: argument.type
+			count: 2
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Parameter \#2 \$array of method PHPUnit\\Framework\\Assert\:\:assertArrayHasKey\(\) expects array\<mixed\>\|ArrayAccess\<\(int\|string\), mixed\>, mixed given\.$#'
+			identifier: argument.type
+			count: 28
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Parameter \#2 \$array of method PHPUnit\\Framework\\Assert\:\:assertArrayNotHasKey\(\) expects array\<mixed\>\|ArrayAccess\<\(int\|string\), mixed\>, mixed given\.$#'
+			identifier: argument.type
+			count: 108
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Parameter \#2 \$collection of method Utopia\\Database\\Database\:\:exists\(\) expects string\|null, mixed given\.$#'
+			identifier: argument.type
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Parameter \#2 \$haystack of method PHPUnit\\Framework\\Assert\:\:assertContains\(\) expects iterable, mixed given\.$#'
+			identifier: argument.type
+			count: 12
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Parameter \#2 \$haystack of method PHPUnit\\Framework\\Assert\:\:assertCount\(\) expects Countable\|iterable, mixed given\.$#'
+			identifier: argument.type
+			count: 92
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Parameter \#2 \$haystack of method PHPUnit\\Framework\\Assert\:\:assertNotContains\(\) expects iterable, mixed given\.$#'
+			identifier: argument.type
+			count: 3
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Parameter \#2 \$haystack of method PHPUnit\\Framework\\Assert\:\:assertStringContainsString\(\) expects string, mixed given\.$#'
+			identifier: argument.type
+			count: 3
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Parameter \#2 \$haystack of method PHPUnit\\Framework\\Assert\:\:assertStringNotContainsString\(\) expects string, mixed given\.$#'
+			identifier: argument.type
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Parameter \#2 \$id of method Utopia\\Database\\Database\:\:getDocument\(\) expects string, mixed given\.$#'
+			identifier: argument.type
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Parameter \#2 \$max of class Utopia\\Validator\\Range constructor expects float\|int, mixed given\.$#'
+			identifier: argument.type
+			count: 3
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Parameter \#2 \$string of method PHPUnit\\Framework\\Assert\:\:assertStringEndsWith\(\) expects string, mixed given\.$#'
+			identifier: argument.type
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Parameter \#2 \$string of method PHPUnit\\Framework\\Assert\:\:assertStringStartsWith\(\) expects string, mixed given\.$#'
+			identifier: argument.type
+			count: 6
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Parameter \#2 \$string2 of function strcmp expects string, mixed given\.$#'
+			identifier: argument.type
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Parameter \#2 \$subject of function preg_match expects string, mixed given\.$#'
+			identifier: argument.type
+			count: 19
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Parameter \#2 \$value of static method Utopia\\Query\\Query\:\:greaterThanEqual\(\) expects bool\|float\|int\|string, string\|null given\.$#'
+			identifier: argument.type
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Parameter \#2 \$values of static method Utopia\\Query\\Query\:\:equal\(\) expects array\<array\<mixed\>\|bool\|float\|int\|string\|null\>, array\<int, mixed\> given\.$#'
+			identifier: argument.type
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Part \$doc\-\>getId\(\) \(mixed\) of encapsed string cannot be cast to string\.$#'
+			identifier: encapsedStringPart.nonString
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Part \$finalQuantity \(mixed\) of encapsed string cannot be cast to string\.$#'
+			identifier: encapsedStringPart.nonString
+			count: 2
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Part \$finalScore \(mixed\) of encapsed string cannot be cast to string\.$#'
+			identifier: encapsedStringPart.nonString
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Part \$finalTitle \(mixed\) of encapsed string cannot be cast to string\.$#'
+			identifier: encapsedStringPart.nonString
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Part \$lastNumber \(mixed\) of encapsed string cannot be cast to string\.$#'
+			identifier: encapsedStringPart.nonString
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Part \$name \(mixed\) of encapsed string cannot be cast to string\.$#'
+			identifier: encapsedStringPart.nonString
+			count: 7
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Part \$num \(mixed\) of encapsed string cannot be cast to string\.$#'
+			identifier: encapsedStringPart.nonString
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Part \$text \(mixed\) of encapsed string cannot be cast to string\.$#'
+			identifier: encapsedStringPart.nonString
+			count: 2
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Part \$value \(mixed\) of encapsed string cannot be cast to string\.$#'
+			identifier: encapsedStringPart.nonString
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Possibly invalid array key type mixed\.$#'
+			identifier: offsetAccess.invalidOffset
+			count: 24
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Property Tests\\E2E\\Adapter\\Base\:\:\$moviesFixtureData type has no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Unreachable statement \- code above always terminates\.$#'
+			identifier: deadCode.unreachable
+			count: 1
+			path: tests/e2e/Adapter/Base.php
+
+		-
+			message: '#^Access to protected constant COLLECTION of class Utopia\\Database\\Database\.$#'
+			identifier: classConstant.protected
+			count: 2
+			path: tests/unit/Attributes/AttributeValidationTest.php
+
+		-
+			message: '#^Method Tests\\Unit\\Attributes\\AttributeValidationTest\:\:setupCollection\(\) has parameter \$attributes with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/Attributes/AttributeValidationTest.php
+
+		-
+			message: '#^Call to an undefined method Utopia\\Database\\Adapter\:\:method\(\)\.$#'
+			identifier: method.notFound
+			count: 30
+			path: tests/unit/Authorization/PermissionCheckTest.php
+
+		-
+			message: '#^Cannot call method willReturn\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 8
+			path: tests/unit/Authorization/PermissionCheckTest.php
+
+		-
+			message: '#^Cannot call method willReturnCallback\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 22
+			path: tests/unit/Authorization/PermissionCheckTest.php
+
+		-
+			message: '#^Method Tests\\Unit\\Authorization\\PermissionCheckTest\:\:buildCollectionDoc\(\) has parameter \$permissions with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/Authorization/PermissionCheckTest.php
+
+		-
+			message: '#^Call to an undefined method Utopia\\Cache\\Cache\:\:method\(\)\.$#'
+			identifier: method.notFound
+			count: 5
+			path: tests/unit/Cache/QueryCacheTest.php
+
+		-
+			message: '#^Cannot call method willReturn\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 5
+			path: tests/unit/Cache/QueryCacheTest.php
+
+		-
+			message: '#^Cannot access offset 0 on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 2
+			path: tests/unit/CollectionModelTest.php
+
+		-
+			message: '#^Parameter \#2 \$haystack of method PHPUnit\\Framework\\Assert\:\:assertCount\(\) expects Countable\|iterable, mixed given\.$#'
+			identifier: argument.type
+			count: 4
+			path: tests/unit/CollectionModelTest.php
+
+		-
+			message: '#^Call to an undefined method Utopia\\Database\\Adapter\:\:method\(\)\.$#'
+			identifier: method.notFound
+			count: 6
+			path: tests/unit/CustomDocumentTypeTest.php
+
+		-
+			message: '#^Cannot call method willReturn\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 1
+			path: tests/unit/CustomDocumentTypeTest.php
+
+		-
+			message: '#^Cannot call method willReturnCallback\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 5
+			path: tests/unit/CustomDocumentTypeTest.php
+
+		-
+			message: '#^Cannot access offset ''\$id'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 2
+			path: tests/unit/DocumentAdvancedTest.php
+
+		-
+			message: '#^Call to method PHPUnit\\Framework\\Assert\:\:assertIsArray\(\) with array\<Utopia\\Database\\Document\> will always evaluate to true\.$#'
+			identifier: method.alreadyNarrowedType
+			count: 1
+			path: tests/unit/Documents/AggregationErrorTest.php
+
+		-
+			message: '#^Method Tests\\Unit\\Documents\\AggregationErrorTest\:\:buildDatabase\(\) has parameter \$capabilities with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/Documents/AggregationErrorTest.php
+
+		-
+			message: '#^Access to protected constant COLLECTION of class Utopia\\Database\\Database\.$#'
+			identifier: classConstant.protected
+			count: 1
+			path: tests/unit/Documents/ConflictDetectionTest.php
+
+		-
+			message: '#^Method Tests\\Unit\\Documents\\ConflictDetectionTest\:\:setupCollectionAndDocument\(\) has parameter \$attributes with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/Documents/ConflictDetectionTest.php
+
+		-
+			message: '#^Access to protected constant COLLECTION of class Utopia\\Database\\Database\.$#'
+			identifier: classConstant.protected
+			count: 1
+			path: tests/unit/Documents/CreateDocumentLogicTest.php
+
+		-
+			message: '#^Call to method PHPUnit\\Framework\\Assert\:\:assertIsArray\(\) with array\<string\> will always evaluate to true\.$#'
+			identifier: method.alreadyNarrowedType
+			count: 1
+			path: tests/unit/Documents/CreateDocumentLogicTest.php
+
+		-
+			message: '#^Method Tests\\Unit\\Documents\\CreateDocumentLogicTest\:\:setupCollection\(\) has parameter \$attributes with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/Documents/CreateDocumentLogicTest.php
+
+		-
+			message: '#^Method Tests\\Unit\\Documents\\CreateDocumentLogicTest\:\:setupCollection\(\) has parameter \$permissions with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/Documents/CreateDocumentLogicTest.php
+
+		-
+			message: '#^Access to protected constant COLLECTION of class Utopia\\Database\\Database\.$#'
+			identifier: classConstant.protected
+			count: 1
+			path: tests/unit/Documents/FindLogicTest.php
+
+		-
+			message: '#^Argument of an invalid type mixed supplied for foreach, only iterables are supported\.$#'
+			identifier: foreach.nonIterable
+			count: 3
+			path: tests/unit/Documents/FindLogicTest.php
+
+		-
+			message: '#^Cannot access offset 0 on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 1
+			path: tests/unit/Documents/FindLogicTest.php
+
+		-
+			message: '#^Cannot access offset 1 on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 1
+			path: tests/unit/Documents/FindLogicTest.php
+
+		-
+			message: '#^Cannot access property \$value on mixed\.$#'
+			identifier: property.nonObject
+			count: 2
+			path: tests/unit/Documents/FindLogicTest.php
+
+		-
+			message: '#^Cannot call method expects\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 2
+			path: tests/unit/Documents/FindLogicTest.php
+
+		-
+			message: '#^Cannot call method getAttribute\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 1
+			path: tests/unit/Documents/FindLogicTest.php
+
+		-
+			message: '#^Cannot call method getMethod\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 2
+			path: tests/unit/Documents/FindLogicTest.php
+
+		-
+			message: '#^Cannot call method method\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 2
+			path: tests/unit/Documents/FindLogicTest.php
+
+		-
+			message: '#^Cannot call method willReturn\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 2
+			path: tests/unit/Documents/FindLogicTest.php
+
+		-
+			message: '#^Cannot call method with\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 1
+			path: tests/unit/Documents/FindLogicTest.php
+
+		-
+			message: '#^Method Tests\\Unit\\Documents\\FindLogicTest\:\:buildDbWithCapabilities\(\) has parameter \$capabilities with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/Documents/FindLogicTest.php
+
+		-
+			message: '#^Method Tests\\Unit\\Documents\\FindLogicTest\:\:collectionDoc\(\) has parameter \$attributes with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/Documents/FindLogicTest.php
+
+		-
+			message: '#^Method Tests\\Unit\\Documents\\FindLogicTest\:\:collectionDoc\(\) has parameter \$indexes with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/Documents/FindLogicTest.php
+
+		-
+			message: '#^Method Tests\\Unit\\Documents\\FindLogicTest\:\:collectionDoc\(\) has parameter \$permissions with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/Documents/FindLogicTest.php
+
+		-
+			message: '#^Method Tests\\Unit\\Documents\\FindLogicTest\:\:setupCollectionLookup\(\) has parameter \$attributes with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/Documents/FindLogicTest.php
+
+		-
+			message: '#^Method Tests\\Unit\\Documents\\FindLogicTest\:\:setupCollectionLookup\(\) has parameter \$indexes with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/Documents/FindLogicTest.php
+
+		-
+			message: '#^Method Tests\\Unit\\Documents\\FindLogicTest\:\:setupCollectionLookup\(\) has parameter \$permissions with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/Documents/FindLogicTest.php
+
+		-
+			message: '#^Offset ''\$sequence'' on array\{\} on left side of \?\? does not exist\.$#'
+			identifier: nullCoalesce.offset
+			count: 1
+			path: tests/unit/Documents/FindLogicTest.php
+
+		-
+			message: '#^Parameter \#1 \$array of function array_count_values expects array, mixed given\.$#'
+			identifier: argument.type
+			count: 1
+			path: tests/unit/Documents/FindLogicTest.php
+
+		-
+			message: '#^Parameter \#2 \$haystack of function in_array expects array, mixed given\.$#'
+			identifier: argument.type
+			count: 4
+			path: tests/unit/Documents/FindLogicTest.php
+
+		-
+			message: '#^Strict comparison using \=\=\= between 0 and 1 will always evaluate to false\.$#'
+			identifier: identical.alwaysFalse
+			count: 1
+			path: tests/unit/Documents/FindLogicTest.php
+
+		-
+			message: '#^Access to protected constant COLLECTION of class Utopia\\Database\\Database\.$#'
+			identifier: classConstant.protected
+			count: 1
+			path: tests/unit/Documents/IncreaseDecreaseTest.php
+
+		-
+			message: '#^Method Tests\\Unit\\Documents\\IncreaseDecreaseTest\:\:setupCollectionWithDocument\(\) has parameter \$attributes with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/Documents/IncreaseDecreaseTest.php
+
+		-
+			message: '#^Access to protected constant COLLECTION of class Utopia\\Database\\Database\.$#'
+			identifier: classConstant.protected
+			count: 2
+			path: tests/unit/Documents/SkipPermissionsTest.php
+
+		-
+			message: '#^Access to protected constant COLLECTION of class Utopia\\Database\\Database\.$#'
+			identifier: classConstant.protected
+			count: 1
+			path: tests/unit/Documents/UpdateDocumentLogicTest.php
+
+		-
+			message: '#^Method Tests\\Unit\\Documents\\UpdateDocumentLogicTest\:\:setupCollectionAndDocument\(\) has parameter \$attributes with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/Documents/UpdateDocumentLogicTest.php
+
+		-
+			message: '#^Method Tests\\Unit\\Documents\\UpdateDocumentLogicTest\:\:setupCollectionAndDocument\(\) has parameter \$collectionPermissions with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/Documents/UpdateDocumentLogicTest.php
+
+		-
+			message: '#^Access to protected constant COLLECTION of class Utopia\\Database\\Database\.$#'
+			identifier: classConstant.protected
+			count: 1
+			path: tests/unit/Indexes/IndexValidationTest.php
+
+		-
+			message: '#^Method Tests\\Unit\\Indexes\\IndexValidationTest\:\:setupCollection\(\) has parameter \$attributes with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/Indexes/IndexValidationTest.php
+
+		-
+			message: '#^Method Tests\\Unit\\Indexes\\IndexValidationTest\:\:setupCollection\(\) has parameter \$indexes with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/Indexes/IndexValidationTest.php
+
+		-
+			message: '#^Call to an undefined method Utopia\\Database\\Database\:\:method\(\)\.$#'
+			identifier: method.notFound
+			count: 5
+			path: tests/unit/Loading/LazyProxyTest.php
+
+		-
+			message: '#^Cannot call method willReturn\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 5
+			path: tests/unit/Loading/LazyProxyTest.php
+
+		-
+			message: '#^Call to method PHPUnit\\Framework\\Assert\:\:assertTrue\(\) with false will always evaluate to false\.$#'
+			identifier: method.impossibleType
+			count: 1
+			path: tests/unit/Loading/NPlusOneDetectorTest.php
+
+		-
+			message: '#^Call to an undefined method Utopia\\Database\\Database\:\:method\(\)\.$#'
+			identifier: method.notFound
+			count: 7
+			path: tests/unit/Migration/MigrationRunnerTest.php
+
+		-
+			message: '#^Call to method PHPUnit\\Framework\\Assert\:\:assertIsString\(\) with string will always evaluate to true\.$#'
+			identifier: method.alreadyNarrowedType
+			count: 1
+			path: tests/unit/Migration/MigrationRunnerTest.php
+
+		-
+			message: '#^Cannot call method willReturnCallback\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 7
+			path: tests/unit/Migration/MigrationRunnerTest.php
+
+		-
+			message: '#^Method Tests\\Unit\\Migration\\MigrationRunnerTest\:\:createTrackerMock\(\) has parameter \$appliedVersions with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/Migration/MigrationRunnerTest.php
+
+		-
+			message: '#^Method Tests\\Unit\\Migration\\MigrationRunnerTest\:\:createTrackerMock\(\) has parameter \$batchDocs with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/Migration/MigrationRunnerTest.php
+
+		-
+			message: '#^Call to an undefined method Utopia\\Database\\Database\:\:expects\(\)\.$#'
+			identifier: method.notFound
+			count: 19
+			path: tests/unit/ORM/EntityManagerTest.php
+
+		-
+			message: '#^Call to an undefined method Utopia\\Database\\Database\:\:method\(\)\.$#'
+			identifier: method.notFound
+			count: 9
+			path: tests/unit/ORM/EntityManagerTest.php
+
+		-
+			message: '#^Cannot call method method\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 19
+			path: tests/unit/ORM/EntityManagerTest.php
+
+		-
+			message: '#^Cannot call method willReturn\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 20
+			path: tests/unit/ORM/EntityManagerTest.php
+
+		-
+			message: '#^Cannot call method willReturnCallback\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 3
+			path: tests/unit/ORM/EntityManagerTest.php
+
+		-
+			message: '#^Cannot call method with\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 10
+			path: tests/unit/ORM/EntityManagerTest.php
+
+		-
+			message: '#^Cannot access offset 0 on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 1
+			path: tests/unit/ORM/EntityMapperAdvancedTest.php
+
+		-
+			message: '#^Parameter \#2 \$haystack of method PHPUnit\\Framework\\Assert\:\:assertCount\(\) expects Countable\|iterable, mixed given\.$#'
+			identifier: argument.type
+			count: 1
+			path: tests/unit/ORM/EntityMapperAdvancedTest.php
+
+		-
+			message: '#^Call to an undefined method Utopia\\Database\\Database\:\:expects\(\)\.$#'
+			identifier: method.notFound
+			count: 29
+			path: tests/unit/ORM/EntitySchemasSyncTest.php
+
+		-
+			message: '#^Cannot call method method\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 29
+			path: tests/unit/ORM/EntitySchemasSyncTest.php
+
+		-
+			message: '#^Cannot call method willReturn\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 16
+			path: tests/unit/ORM/EntitySchemasSyncTest.php
+
+		-
+			message: '#^Cannot call method with\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 18
+			path: tests/unit/ORM/EntitySchemasSyncTest.php
+
+		-
+			message: '#^Call to method PHPUnit\\Framework\\Assert\:\:assertIsString\(\) with string will always evaluate to true\.$#'
+			identifier: method.alreadyNarrowedType
+			count: 6
+			path: tests/unit/ORM/LifecycleCallbackTest.php
+
+		-
+			message: '#^Property Tests\\Unit\\ORM\\LifecycleEntity\:\:\$callLog type has no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/ORM/LifecycleCallbackTest.php
+
+		-
+			message: '#^Property Tests\\Unit\\ORM\\MultiCallbackEntity\:\:\$callLog type has no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/ORM/LifecycleCallbackTest.php
+
+		-
+			message: '#^Property Tests\\Unit\\ORM\\TestAllRelationsEntity\:\:\$posts type has no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/ORM/TestAllRelationsEntity.php
+
+		-
+			message: '#^Property Tests\\Unit\\ORM\\TestAllRelationsEntity\:\:\$tags type has no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/ORM/TestAllRelationsEntity.php
+
+		-
+			message: '#^Property Tests\\Unit\\ORM\\TestEntity\:\:\$permissions type has no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/ORM/TestEntity.php
+
+		-
+			message: '#^Property Tests\\Unit\\ORM\\TestEntity\:\:\$posts type has no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/ORM/TestEntity.php
+
+		-
+			message: '#^Cannot access offset ''name'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 1
+			path: tests/unit/ObjectAttribute/ObjectAttributeValidationTest.php
+
+		-
+			message: '#^Cannot access offset ''theme'' on mixed\.$#'
+			identifier: offsetAccess.nonOffsetAccessible
+			count: 1
+			path: tests/unit/ObjectAttribute/ObjectAttributeValidationTest.php
+
+		-
+			message: '#^Cannot call method getId\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 1
+			path: tests/unit/ObjectAttribute/ObjectAttributeValidationTest.php
+
+		-
+			message: '#^Method Tests\\Unit\\ObjectAttribute\\ObjectAttributeValidationTest\:\:makeCollection\(\) has parameter \$attributes with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/ObjectAttribute/ObjectAttributeValidationTest.php
+
+		-
+			message: '#^Method Tests\\Unit\\ObjectAttribute\\ObjectAttributeValidationTest\:\:setupCollections\(\) has parameter \$collections with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/ObjectAttribute/ObjectAttributeValidationTest.php
+
+		-
+			message: '#^Possibly invalid array key type mixed\.$#'
+			identifier: offsetAccess.invalidOffset
+			count: 1
+			path: tests/unit/ObjectAttribute/ObjectAttributeValidationTest.php
+
+		-
+			message: '#^Cannot call method toDocument\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 1
+			path: tests/unit/Operator/OperatorValidationTest.php
+
+		-
+			message: '#^Method Tests\\Unit\\Operator\\OperatorValidationTest\:\:makeCollection\(\) has parameter \$attributes with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/Operator/OperatorValidationTest.php
+
+		-
+			message: '#^Method Tests\\Unit\\Operator\\OperatorValidationTest\:\:makeOperator\(\) has parameter \$values with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/Operator/OperatorValidationTest.php
+
+		-
+			message: '#^Method Tests\\Unit\\Operator\\OperatorValidationTest\:\:makeValidator\(\) has parameter \$attributes with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/Operator/OperatorValidationTest.php
+
+		-
+			message: '#^Cannot call method getMethod\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 1
+			path: tests/unit/OperatorTest.php
+
+		-
+			message: '#^Call to method PHPUnit\\Framework\\Assert\:\:assertNotNull\(\) with null will always evaluate to false\.$#'
+			identifier: method.impossibleType
+			count: 1
+			path: tests/unit/Profiler/QueryProfilerAdvancedTest.php
+
+		-
+			message: '#^Cannot access property \$collection on mixed\.$#'
+			identifier: property.nonObject
+			count: 1
+			path: tests/unit/Profiler/QueryProfilerAdvancedTest.php
+
+		-
+			message: '#^Cannot access property \$durationMs on mixed\.$#'
+			identifier: property.nonObject
+			count: 1
+			path: tests/unit/Profiler/QueryProfilerAdvancedTest.php
+
+		-
+			message: '#^Cannot access property \$query on mixed\.$#'
+			identifier: property.nonObject
+			count: 1
+			path: tests/unit/Profiler/QueryProfilerAdvancedTest.php
+
+		-
+			message: '#^Call to method PHPUnit\\Framework\\Assert\:\:assertTrue\(\) with false will always evaluate to false\.$#'
+			identifier: method.impossibleType
+			count: 1
+			path: tests/unit/Profiler/QueryProfilerTest.php
+
+		-
+			message: '#^Call to method PHPUnit\\Framework\\Assert\:\:assertNotNull\(\) with Utopia\\Database\\Document will always evaluate to true\.$#'
+			identifier: method.alreadyNarrowedType
+			count: 2
+			path: tests/unit/Relationships/RelationshipValidationTest.php
+
+		-
+			message: '#^Call to new Utopia\\Database\\Relationship\(\) on a separate line has no effect\.$#'
+			identifier: new.resultUnused
+			count: 1
+			path: tests/unit/Relationships/RelationshipValidationTest.php
+
+		-
+			message: '#^Method Tests\\Unit\\Relationships\\RelationshipValidationTest\:\:makeCollection\(\) has parameter \$attributes with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/Relationships/RelationshipValidationTest.php
+
+		-
+			message: '#^Method Tests\\Unit\\Relationships\\RelationshipValidationTest\:\:makeCollection\(\) has parameter \$permissions with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/Relationships/RelationshipValidationTest.php
+
+		-
+			message: '#^Parameter \$type of class Utopia\\Database\\Relationship constructor expects Utopia\\Database\\RelationType, string given\.$#'
+			identifier: argument.type
+			count: 1
+			path: tests/unit/Relationships/RelationshipValidationTest.php
+
+		-
+			message: '#^Call to an undefined method Utopia\\Database\\Database\:\:expects\(\)\.$#'
+			identifier: method.notFound
+			count: 12
+			path: tests/unit/Repository/RepositoryTest.php
+
+		-
+			message: '#^Call to an undefined method Utopia\\Database\\Database\:\:method\(\)\.$#'
+			identifier: method.notFound
+			count: 1
+			path: tests/unit/Repository/RepositoryTest.php
+
+		-
+			message: '#^Cannot access property \$value on mixed\.$#'
+			identifier: property.nonObject
+			count: 1
+			path: tests/unit/Repository/RepositoryTest.php
+
+		-
+			message: '#^Cannot call method getMethod\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 1
+			path: tests/unit/Repository/RepositoryTest.php
+
+		-
+			message: '#^Cannot call method getValues\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 1
+			path: tests/unit/Repository/RepositoryTest.php
+
+		-
+			message: '#^Cannot call method method\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 12
+			path: tests/unit/Repository/RepositoryTest.php
+
+		-
+			message: '#^Cannot call method willReturn\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 13
+			path: tests/unit/Repository/RepositoryTest.php
+
+		-
+			message: '#^Cannot call method with\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 12
+			path: tests/unit/Repository/RepositoryTest.php
+
+		-
+			message: '#^Parameter \#1 \$callback of function array_map expects \(callable\(mixed\)\: mixed\)\|null, Closure\(Utopia\\Database\\Query\)\: \(''and''\|''avg''\|''between''\|''bitAnd''\|''bitOr''\|''bitXor''\|''contains''\|''containsAll''\|''containsAny''\|''count''\|''countDistinct''\|''covers''\|''crosses''\|''crossJoin''\|''cursorAfter''\|''cursorBefore''\|''distanceEqual''\|''distanceGreaterThan''\|''distanceLessThan''\|''distanceNotEqual''\|''distinct''\|''elemMatch''\|''endsWith''\|''equal''\|''exists''\|''fullOuterJoin''\|''greaterThan''\|''greaterThanEqual''\|''groupBy''\|''having''\|''intersects''\|''isNotNull''\|''isNull''\|''join''\|''jsonContains''\|''jsonNotContains''\|''jsonOverlaps''\|''jsonPath''\|''leftJoin''\|''lessThan''\|''lessThanEqual''\|''limit''\|''max''\|''min''\|''naturalJoin''\|''notBetween''\|''notContains''\|''notCovers''\|''notCrosses''\|''notEndsWith''\|''notEqual''\|''notExists''\|''notIntersects''\|''notOverlaps''\|''notSearch''\|''notSpatialEquals''\|''notStartsWith''\|''notTouches''\|''offset''\|''or''\|''orderAsc''\|''orderDesc''\|''orderRandom''\|''orderVectorDistance''\|''overlaps''\|''raw''\|''regex''\|''rightJoin''\|''search''\|''select''\|''spatialEquals''\|''startsWith''\|''stddev''\|''stddevPop''\|''stddevSamp''\|''sum''\|''touches''\|''union''\|''unionAll''\|''variance''\|''varPop''\|''varSamp''\|''vectorCosine''\|''vectorDot''\|''vectorEuclidean''\) given\.$#'
+			identifier: argument.type
+			count: 1
+			path: tests/unit/Repository/RepositoryTest.php
+
+		-
+			message: '#^Call to an undefined method Utopia\\Database\\Database\:\:expects\(\)\.$#'
+			identifier: method.notFound
+			count: 12
+			path: tests/unit/Repository/ScopeTest.php
+
+		-
+			message: '#^Cannot call method getAttribute\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 1
+			path: tests/unit/Repository/ScopeTest.php
+
+		-
+			message: '#^Cannot call method method\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 12
+			path: tests/unit/Repository/ScopeTest.php
+
+		-
+			message: '#^Cannot call method willReturn\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 12
+			path: tests/unit/Repository/ScopeTest.php
+
+		-
+			message: '#^Cannot call method with\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 12
+			path: tests/unit/Repository/ScopeTest.php
+
+		-
+			message: '#^Parameter \#1 \$callback of function array_map expects \(callable\(mixed\)\: mixed\)\|null, Closure\(Utopia\\Database\\Query\)\: string given\.$#'
+			identifier: argument.type
+			count: 6
+			path: tests/unit/Repository/ScopeTest.php
+
+		-
+			message: '#^Cannot access property \$key on Utopia\\Database\\Attribute\|null\.$#'
+			identifier: property.nonObject
+			count: 2
+			path: tests/unit/Schema/SchemaDiffTest.php
+
+		-
+			message: '#^Cannot access property \$key on Utopia\\Database\\Index\|null\.$#'
+			identifier: property.nonObject
+			count: 1
+			path: tests/unit/Schema/SchemaDiffTest.php
+
+		-
+			message: '#^Cannot access property \$size on Utopia\\Database\\Attribute\|null\.$#'
+			identifier: property.nonObject
+			count: 2
+			path: tests/unit/Schema/SchemaDiffTest.php
+
+		-
+			message: '#^Cannot call method getId\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 1
+			path: tests/unit/Schemaless/SchemalessValidationTest.php
+
+		-
+			message: '#^Method Tests\\Unit\\Schemaless\\SchemalessValidationTest\:\:makeCollection\(\) has parameter \$attributes with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/Schemaless/SchemalessValidationTest.php
+
+		-
+			message: '#^Method Tests\\Unit\\Schemaless\\SchemalessValidationTest\:\:makeCollection\(\) has parameter \$indexes with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/Schemaless/SchemalessValidationTest.php
+
+		-
+			message: '#^Method Tests\\Unit\\Schemaless\\SchemalessValidationTest\:\:setupCollections\(\) has parameter \$collections with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/Schemaless/SchemalessValidationTest.php
+
+		-
+			message: '#^Possibly invalid array key type mixed\.$#'
+			identifier: offsetAccess.invalidOffset
+			count: 1
+			path: tests/unit/Schemaless/SchemalessValidationTest.php
+
+		-
+			message: '#^Call to method PHPUnit\\Framework\\Assert\:\:assertNotNull\(\) with Faker\\Generator will always evaluate to true\.$#'
+			identifier: method.alreadyNarrowedType
+			count: 1
+			path: tests/unit/Seeder/FactoryTest.php
+
+		-
+			message: '#^Cannot call method email\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 2
+			path: tests/unit/Seeder/FactoryTest.php
+
+		-
+			message: '#^Cannot call method name\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 3
+			path: tests/unit/Seeder/FactoryTest.php
+
+		-
+			message: '#^Cannot call method numberBetween\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 1
+			path: tests/unit/Seeder/FactoryTest.php
+
+		-
+			message: '#^Call to an undefined method Utopia\\Database\\Database\:\:expects\(\)\.$#'
+			identifier: method.notFound
+			count: 7
+			path: tests/unit/Seeder/FixtureTest.php
+
+		-
+			message: '#^Call to an undefined method Utopia\\Database\\Database\:\:method\(\)\.$#'
+			identifier: method.notFound
+			count: 6
+			path: tests/unit/Seeder/FixtureTest.php
+
+		-
+			message: '#^Cannot call method method\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 7
+			path: tests/unit/Seeder/FixtureTest.php
+
+		-
+			message: '#^Cannot call method willReturn\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 6
+			path: tests/unit/Seeder/FixtureTest.php
+
+		-
+			message: '#^Cannot call method willReturnCallback\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 1
+			path: tests/unit/Seeder/FixtureTest.php
+
+		-
+			message: '#^Cannot call method willReturnOnConsecutiveCalls\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 2
+			path: tests/unit/Seeder/FixtureTest.php
+
+		-
+			message: '#^Cannot call method willThrowException\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 1
+			path: tests/unit/Seeder/FixtureTest.php
+
+		-
+			message: '#^Cannot call method with\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 3
+			path: tests/unit/Seeder/FixtureTest.php
+
+		-
+			message: '#^Method Utopia\\Database\\Seeder\\Seeder@anonymous/tests/unit/Seeder/SeederRunnerTest\.php\:16\:\:__construct\(\) has parameter \$order with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/Seeder/SeederRunnerTest.php
+
+		-
+			message: '#^Method Utopia\\Database\\Seeder\\Seeder@anonymous/tests/unit/Seeder/SeederRunnerTest\.php\:30\:\:__construct\(\) has parameter \$order with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/Seeder/SeederRunnerTest.php
+
+		-
+			message: '#^Method Utopia\\Database\\Seeder\\Seeder@anonymous/tests/unit/Seeder/SeederRunnerTest\.php\:30\:\:dependencies\(\) should return array\<class\-string\<Utopia\\Database\\Seeder\\Seeder\>\> but returns array\<int, string\>\.$#'
+			identifier: return.type
+			count: 1
+			path: tests/unit/Seeder/SeederRunnerTest.php
+
+		-
+			message: '#^Property Utopia\\Database\\Seeder\\Seeder@anonymous/tests/unit/Seeder/SeederRunnerTest\.php\:16\:\:\$order is never read, only written\.$#'
+			identifier: property.onlyWritten
+			count: 1
+			path: tests/unit/Seeder/SeederRunnerTest.php
+
+		-
+			message: '#^Property Utopia\\Database\\Seeder\\Seeder@anonymous/tests/unit/Seeder/SeederRunnerTest\.php\:16\:\:\$order type has no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/Seeder/SeederRunnerTest.php
+
+		-
+			message: '#^Property Utopia\\Database\\Seeder\\Seeder@anonymous/tests/unit/Seeder/SeederRunnerTest\.php\:30\:\:\$order is never read, only written\.$#'
+			identifier: property.onlyWritten
+			count: 1
+			path: tests/unit/Seeder/SeederRunnerTest.php
+
+		-
+			message: '#^Property Utopia\\Database\\Seeder\\Seeder@anonymous/tests/unit/Seeder/SeederRunnerTest\.php\:30\:\:\$order type has no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/Seeder/SeederRunnerTest.php
+
+		-
+			message: '#^Cannot call method getId\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 1
+			path: tests/unit/Spatial/SpatialValidationTest.php
+
+		-
+			message: '#^Method Tests\\Unit\\Spatial\\SpatialValidationTest\:\:makeCollection\(\) has parameter \$attributes with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/Spatial/SpatialValidationTest.php
+
+		-
+			message: '#^Method Tests\\Unit\\Spatial\\SpatialValidationTest\:\:makeCollection\(\) has parameter \$indexes with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/Spatial/SpatialValidationTest.php
+
+		-
+			message: '#^Method Tests\\Unit\\Spatial\\SpatialValidationTest\:\:setupCollections\(\) has parameter \$collections with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/Spatial/SpatialValidationTest.php
+
+		-
+			message: '#^Possibly invalid array key type mixed\.$#'
+			identifier: offsetAccess.invalidOffset
+			count: 1
+			path: tests/unit/Spatial/SpatialValidationTest.php
+
+		-
+			message: '#^Binary operation "\*" between mixed and 100 results in an error\.$#'
+			identifier: binaryOp.invalid
+			count: 1
+			path: tests/unit/Type/TypeRegistryTest.php
+
+		-
+			message: '#^Binary operation "/" between mixed and 100 results in an error\.$#'
+			identifier: binaryOp.invalid
+			count: 1
+			path: tests/unit/Type/TypeRegistryTest.php
+
+		-
+			message: '#^Call to method PHPUnit\\Framework\\Assert\:\:assertNotNull\(\) with string will always evaluate to true\.$#'
+			identifier: method.alreadyNarrowedType
+			count: 3
+			path: tests/unit/Vector/VectorValidationTest.php
+
+		-
+			message: '#^Call to method PHPUnit\\Framework\\Assert\:\:assertTrue\(\) with true will always evaluate to true\.$#'
+			identifier: method.alreadyNarrowedType
+			count: 1
+			path: tests/unit/Vector/VectorValidationTest.php
+
+		-
+			message: '#^Cannot call method getId\(\) on mixed\.$#'
+			identifier: method.nonObject
+			count: 1
+			path: tests/unit/Vector/VectorValidationTest.php
+
+		-
+			message: '#^Method Tests\\Unit\\Vector\\VectorValidationTest\:\:makeCollection\(\) has parameter \$attributes with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/Vector/VectorValidationTest.php
+
+		-
+			message: '#^Method Tests\\Unit\\Vector\\VectorValidationTest\:\:makeCollection\(\) has parameter \$indexes with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/Vector/VectorValidationTest.php
+
+		-
+			message: '#^Method Tests\\Unit\\Vector\\VectorValidationTest\:\:setupCollections\(\) has parameter \$collections with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/Vector/VectorValidationTest.php
+
+		-
+			message: '#^Method Tests\\Unit\\Vector\\VectorValidationTest\:\:vectorCollection\(\) has parameter \$extraAttrs with no value type specified in iterable type array\.$#'
+			identifier: missingType.iterableValue
+			count: 1
+			path: tests/unit/Vector/VectorValidationTest.php
+
+		-
+			message: '#^Possibly invalid array key type mixed\.$#'
+			identifier: offsetAccess.invalidOffset
+			count: 1
+			path: tests/unit/Vector/VectorValidationTest.php
diff --git a/phpstan.neon b/phpstan.neon
new file mode 100644
index 000000000..6d78fe652
--- /dev/null
+++ b/phpstan.neon
@@ -0,0 +1,12 @@
+includes:
+    - phpstan-baseline.neon
+
+parameters:
+    level: max
+    paths:
+        - src
+        - tests
+    ignoreErrors:
+        -
+          message: '#(PDOStatementProxy|DetectsLostConnections)#'
+          reportUnmatched: false
diff --git a/phpunit.xml b/phpunit.xml
index 2a0531cfd..fa3248552 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 a0c1c238a..a805bcc5e 100644
--- a/src/Database/Adapter.php
+++ b/src/Database/Adapter.php
@@ -2,7 +2,11 @@
 
 namespace Utopia\Database;
 
+use BadMethodCallException;
+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 +16,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 = '';
@@ -39,11 +52,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>
@@ -51,13 +62,48 @@ 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 */
+    private ?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]);
+    }
+
     /**
-     * @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
@@ -67,39 +113,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;
     }
 
     /**
@@ -107,11 +165,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
     {
@@ -124,9 +181,6 @@ public function setNamespace(string $namespace): static
      * Get Namespace.
      *
      * Get namespace of current set scope
-     *
-     * @return string
-     *
      */
     public function getNamespace(): string
     {
@@ -136,7 +190,6 @@ public function getNamespace(): string
     /**
      * Set Hostname.
      *
-     * @param string $hostname
      * @return $this
      */
     public function setHostname(string $hostname): static
@@ -148,52 +201,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
     {
@@ -206,8 +223,6 @@ public function setSharedTables(bool $sharedTables): bool
      * Get Share Tables.
      *
      * Get whether to share tables between tenants
-     *
-     * @return bool
      */
     public function getSharedTables(): bool
     {
@@ -218,10 +233,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
     {
@@ -233,12 +244,16 @@ public function setTenant(int|string|null $tenant): bool
     /**
      * Get Tenant.
      *
-     * Get tenant to use for shared tables
-     *
-     * @return int|string|null
+     * Get tenant to use for shared tables.
+     * Numeric values are normalized to int for consistent comparison
+     * across adapters that may return string representations.
      */
     public function getTenant(): int|string|null
     {
+        if (\is_string($this->tenant) && \ctype_digit($this->tenant)) {
+            return (int) $this->tenant;
+        }
+
         return $this->tenant;
     }
 
@@ -246,10 +261,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
     {
@@ -262,34 +273,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;
     }
 
@@ -316,22 +350,21 @@ public function resetMetadata(): static
     }
 
     /**
-     * Set a global timeout for database queries in milliseconds.
-     *
-     * 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.
-     *
-     * @param int $milliseconds The timeout value in milliseconds for database queries.
-     * @param string $event     The event the timeout should fire for
-     * @return void
+     * Set a global timeout for database queries.
      *
-     * @throws Exception The provided timeout value must be greater than or equal to 0.
+     * @param int $milliseconds Timeout duration in milliseconds.
+     * @param Event $event The event scope for the timeout.
      */
-    abstract public function setTimeout(int $milliseconds, string $event = Database::EVENT_ALL): void;
+    public function setTimeout(int $milliseconds, Event $event = Event::All): void
+    {
+        $this->timeout = $milliseconds;
+    }
 
+    /**
+     * Get the current query timeout value.
+     *
+     * @return int Timeout in milliseconds, or 0 if no timeout is set.
+     */
     public function getTimeout(): int
     {
         return $this->timeout;
@@ -339,14 +372,153 @@ public function getTimeout(): int
 
     /**
      * Clears a global timeout for database queries.
+     */
+    public function clearTimeout(Event $event = Event::All): void
+    {
+        $this->timeout = 0;
+    }
+
+    /**
+     * Enable or disable LOCK=SHARED during ALTER TABLE operations.
+     *
+     * @param bool $enable True to enable alter locks.
+     * @return $this
+     */
+    public function enableAlterLocks(bool $enable): self
+    {
+        $this->alterLocks = $enable;
+
+        return $this;
+    }
+
+    /**
+     * Set support for attributes
+     */
+    abstract public function setSupportForAttributes(bool $support): bool;
+
+    /**
+     * Register a write hook that intercepts document write operations.
+     *
+     * @param Write $hook The write hook to add.
+     * @return $this
+     */
+    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 getTenantHook(): ?Hook\Tenancy
+    {
+        foreach ($this->writeHooks as $hook) {
+            if ($hook instanceof Hook\Tenancy) {
+                return $hook;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Remove a write hook by its class name.
+     *
+     * @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 resetTransforms(): static
+    {
+        $this->queryTransforms = [];
+
+        return $this;
+    }
+
+    /**
+     * Ping Database
+     */
+    abstract public function ping(): bool;
+
+    /**
+     * Reconnect Database
+     */
+    abstract public function reconnect(): void;
+
+    /**
+     * Get the unique identifier for the current database connection.
      *
-     * @param string $event
-     * @return void
+     * @return string The connection ID, or empty string if not applicable.
      */
-    public function clearTimeout(string $event): void
+    public function getConnectionId(): string
     {
-        // Clear existing callback
-        $this->before($event, 'timeout');
+        return '';
     }
 
     /**
@@ -354,7 +526,6 @@ public function clearTimeout(string $event): 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;
@@ -366,7 +537,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;
@@ -377,15 +547,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
     {
@@ -394,9 +561,11 @@ public function inTransaction(): bool
 
     /**
      * @template T
-     * @param callable(): T $callback
+     *
+     * @param  callable(): T  $callback
      * @return T
-     * @throws \Throwable
+     *
+     * @throws Throwable
      */
     public function withTransaction(callable $callback): mixed
     {
@@ -408,13 +577,15 @@ public function withTransaction(callable $callback): mixed
                 $this->startTransaction();
                 $result = $callback();
                 $this->commitTransaction();
+
                 return $result;
-            } catch (\Throwable $action) {
+            } catch (Throwable $action) {
                 try {
                     $this->rollbackTransaction();
-                } catch (\Throwable $rollback) {
+                } catch (Throwable $rollback) {
                     if ($attempts < $retries) {
                         \usleep($sleep * ($attempts + 1));
+
                         continue;
                     }
 
@@ -435,6 +606,7 @@ public function withTransaction(callable $callback): mixed
 
                 if ($attempts < $retries) {
                     \usleep($sleep * ($attempts + 1));
+
                     continue;
                 }
 
@@ -446,79 +618,18 @@ public function withTransaction(callable $callback): mixed
     }
 
     /**
-     * Apply a transformation to a query before an event occurs
-     *
-     * @param string $event
-     * @param string $name
-     * @param ?callable $callback
-     * @return static
+     * Create Database
      */
-    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;
-        }
+    abstract public function create(string $name): bool;
 
-        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;
+    /**
+     * Check if database exists
+     * Optionally check if collection exists in database
+     *
+     * @param  string  $database  database name
+     * @param  string|null  $collection  (optional) collection name
+     */
+    abstract public function exists(string $database, ?string $collection = null): bool;
 
     /**
      * List Databases
@@ -529,61 +640,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
      */
@@ -591,145 +681,79 @@ 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
+     * Create a relationship between two collections in the database schema.
      *
-     * @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
+     * @param Relationship $relationship The relationship definition.
+     * @return bool True on success.
      */
-    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;
+    public function createRelationship(Relationship $relationship): bool
+    {
+        return true;
+    }
 
     /**
-     * Delete Relationship
+     * Update an existing relationship, optionally renaming keys.
      *
-     * @param string $collection
-     * @param string $relatedCollection
-     * @param string $type
-     * @param bool $twoWay
-     * @param string $key
-     * @param string $twoWayKey
-     * @param string $side
-     * @return bool
+     * @param Relationship $relationship The current relationship definition.
+     * @param string|null $newKey New key name for the parent side, or null to keep unchanged.
+     * @param string|null $newTwoWayKey New key name for the child side, or null to keep unchanged.
+     * @return bool True on success.
      */
-    abstract public function deleteRelationship(string $collection, string $relatedCollection, string $type, bool $twoWay, string $key, string $twoWayKey, string $side): bool;
+    public function updateRelationship(Relationship $relationship, ?string $newKey = null, ?string $newTwoWayKey = null): bool
+    {
+        return true;
+    }
 
     /**
-     * Rename Index
+     * Delete a relationship from the database schema.
      *
-     * @param string $collection
-     * @param string $old
-     * @param string $new
-     * @return bool
+     * @param Relationship $relationship The relationship to delete.
+     * @return bool True on success.
      */
-    abstract public function renameIndex(string $collection, string $old, string $new): bool;
+    public function deleteRelationship(Relationship $relationship): bool
+    {
+        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 array<string,string> $indexAttributeTypes
-     * @param array<string, mixed> $collation
-     * @param int $ttl
-     *
-     * @return bool
+     * @param  array<string, string>  $indexAttributeTypes
+     * @param  array<string, mixed>  $collation
      */
-    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
@@ -737,14 +761,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;
 
@@ -753,57 +777,49 @@ 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.
-     *
-     * @param Document $collection
-     * @param string $attribute
-     * @param array<Change> $changes
+     * @param  array<Change>  $changes
      * @return array<Document>
      */
-    abstract public function upsertDocuments(
+    public function upsertDocuments(
         Document $collection,
         string $attribute,
         array $changes
-    ): array;
+    ): array {
+        return [];
+    }
 
     /**
-     * @param string $collection
-     * @param array<Document> $documents
-     * @return array<Document>
+     * Increase or decrease attribute value
+     *
+     * @throws Exception
      */
-    abstract public function getSequences(string $collection, array $documents): array;
+    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;
 
     /**
      * 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;
 
@@ -812,493 +828,391 @@ 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;
 
     /**
      * 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
+     * Get the primitive type of the primary key type for this adapter
      */
-    abstract public function getSupportForIndex(): bool;
+    abstract public function getIdAttributeType(): string;
 
     /**
-     * Is indexing array supported?
+     * Get Collection Size of the raw data
      *
-     * @return bool
+     * @throws DatabaseException
      */
-    abstract public function getSupportForIndexArray(): bool;
+    abstract public function getSizeOfCollection(string $collection): int;
 
     /**
-     * Is cast index as array supported?
+     * Get Collection Size on the disk
      *
-     * @return bool
+     * @throws DatabaseException
      */
-    abstract public function getSupportForCastIndexArray(): bool;
+    abstract public function getSizeOfCollectionOnDisk(string $collection): int;
 
     /**
-     * Is unique index supported?
-     *
-     * @return bool
+     * Get maximum width, in bytes, allowed for a SQL row
+     * Return 0 when no restrictions apply
      */
-    abstract public function getSupportForUniqueIndex(): bool;
+    abstract public function getDocumentSizeLimit(): int;
 
     /**
-     * Is fulltext index 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 getSupportForFulltextIndex(): bool;
+    abstract public function getAttributeWidth(Document $collection): int;
 
     /**
-     * Is fulltext wildcard supported?
-     *
-     * @return bool
+     * Get current attribute count from collection document
      */
-    abstract public function getSupportForFulltextWildcardIndex(): bool;
-
+    abstract public function getCountOfAttributes(Document $collection): int;
 
     /**
-     * Does the adapter handle casting?
-     *
-     * @return bool
+     * Get current index count from collection document
      */
-    abstract public function getSupportForCasting(): bool;
+    abstract public function getCountOfIndexes(Document $collection): int;
 
     /**
-     * Does the adapter handle array Contains?
-     *
-     * @return bool
+     * Returns number of attributes used by default.
      */
-    abstract public function getSupportForQueryContains(): bool;
+    abstract public function getCountOfDefaultAttributes(): int;
 
     /**
-     * Are timeouts supported?
-     *
-     * @return bool
+     * Returns number of indexes used by default.
      */
-    abstract public function getSupportForTimeouts(): bool;
+    abstract public function getCountOfDefaultIndexes(): int;
 
     /**
-     * Are relationships supported?
+     * Get list of keywords that cannot be used
      *
-     * @return bool
+     * @return array<string>
      */
-    abstract public function getSupportForRelationships(): bool;
-
-    abstract public function getSupportForUpdateLock(): bool;
+    abstract public function getKeywords(): array;
 
     /**
-     * Are batch operations supported?
+     * Get List of internal index keys names
      *
-     * @return bool
+     * @return array<string>
      */
-    abstract public function getSupportForBatchOperations(): bool;
+    abstract public function getInternalIndexesKeys(): array;
 
     /**
-     * Is attribute resizing supported?
+     * Get the physical schema attributes for a collection from the database engine.
      *
-     * @return bool
+     * @param string $collection The collection identifier.
+     * @return array<Document>
      */
-    abstract public function getSupportForAttributeResizing(): bool;
+    public function getSchemaAttributes(string $collection): array
+    {
+        return [];
+    }
 
     /**
-     * Is get connection id supported?
+     * Get the physical schema indexes for a collection from the database engine.
      *
-     * @return bool
-     */
-    abstract public function getSupportForGetConnectionId(): bool;
-
-    /**
-     * Is upserting supported?
+     * Returns physical index definitions from the database schema.
      *
-     * @return bool
+     * @param string $collection The collection identifier.
+     * @return array<Document>
      */
-    abstract public function getSupportForUpserts(): bool;
+    public function getSchemaIndexes(string $collection): array
+    {
+        return [];
+    }
 
     /**
-     * Is vector type supported?
+     * Get the expected column type for a given attribute type.
      *
-     * @return bool
-     */
-    abstract public function getSupportForVectors(): bool;
-
-    /**
-     * Is Cache Fallback supported?
+     * 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.
      *
-     * @return bool
+     * @throws DatabaseException For unknown types on adapters that support column-type resolution.
      */
-    abstract public function getSupportForCacheSkipOnFailure(): bool;
+    public function getColumnType(string $type, int $size, bool $signed = true, bool $array = false, bool $required = false): string
+    {
+        return '';
+    }
 
     /**
-     * Is reconnection 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
      */
-    abstract public function getSupportForReconnection(): bool;
+    abstract public function getTenantQuery(string $collection, string $alias = ''): string;
 
     /**
-     * Is hostname supported?
-     *
-     * @return bool
+     * Handle non utf characters supported?
      */
-    abstract public function getSupportForHostname(): bool;
+    public function getSupportNonUtfCharacters(): bool
+    {
+        return false;
+    }
 
     /**
-     * Is creating multiple attributes in a single query supported?
+     * Apply adapter-specific type casting before writing a document.
      *
-     * @return bool
+     * @param Document $collection The collection definition.
+     * @param Document $document The document to cast.
+     * @return Document The document with casting applied.
      */
-    abstract public function getSupportForBatchCreateAttributes(): bool;
+    public function castingBefore(Document $collection, Document $document): Document
+    {
+        return $document;
+    }
 
     /**
-     * Is spatial attributes supported?
+     * Apply adapter-specific type casting after reading a document.
      *
-     * @return bool
+     * @param Document $collection The collection definition.
+     * @param Document $document The document to cast.
+     * @return Document The document with casting applied.
      */
-    abstract public function getSupportForSpatialAttributes(): bool;
+    public function castingAfter(Document $collection, Document $document): Document
+    {
+        return $document;
+    }
 
     /**
-     * Are object (JSON) attributes supported?
+     * Convert a datetime string to UTC format for the adapter.
      *
-     * @return bool
+     * @param string $value The datetime string to convert.
+     * @return mixed The converted datetime value.
      */
-    abstract public function getSupportForObject(): bool;
+    public function setUTCDatetime(string $value): mixed
+    {
+        return $value;
+    }
 
     /**
-     * Are object (JSON) indexes supported?
+     * Decode a WKB point value into an array of floats.
      *
-     * @return bool
-     */
-    abstract public function getSupportForObjectIndexes(): bool;
-
-    /**
-     * Does the adapter support null values in spatial indexes?
+     * @return array<float>
      *
-     * @return bool
+     * @throws BadMethodCallException
      */
-    abstract public function getSupportForSpatialIndexNull(): bool;
+    public function decodePoint(string $wkb): array
+    {
+        throw new BadMethodCallException('decodePoint is not implemented by this adapter');
+    }
 
     /**
-     * Does the adapter support operators?
+     * Decode a WKB linestring value into an array of point arrays.
      *
-     * @return bool
-     */
-    abstract public function getSupportForOperators(): bool;
-
-    /**
-     * Adapter supports optional spatial attributes with existing rows.
+     * @return array<array<float>>
      *
-     * @return bool
+     * @throws BadMethodCallException
      */
-    abstract public function getSupportForOptionalSpatialAttributeWithExistingRows(): bool;
+    public function decodeLinestring(string $wkb): array
+    {
+        throw new BadMethodCallException('decodeLinestring is not implemented by this adapter');
+    }
 
     /**
-     * Does the adapter support order attribute in spatial indexes?
+     * Decode a WKB polygon value into an array of linestring arrays.
      *
-     * @return bool
-     */
-    abstract public function getSupportForSpatialIndexOrder(): bool;
-
-    /**
-     * Does the adapter support spatial axis order specification?
+     * @return array<array<array<float>>>
      *
-     * @return bool
+     * @throws BadMethodCallException
      */
-    abstract public function getSupportForSpatialAxisOrder(): bool;
+    public function decodePolygon(string $wkb): array
+    {
+        throw new BadMethodCallException('decodePolygon is not implemented by this adapter');
+    }
 
     /**
-     * Does the adapter includes boundary during spatial contains?
+     * Execute a raw query and return results as Documents.
      *
-     * @return bool
-     */
-    abstract public function getSupportForBoundaryInclusiveContains(): bool;
-
-    /**
-     * Does the adapter support calculating distance(in meters) between multidimension geometry(line, polygon,etc)?
+     * @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
      *
-     * @return bool
+     * @throws DatabaseException
      */
-    abstract public function getSupportForDistanceBetweenMultiDimensionGeometryInMeters(): bool;
+    public function rawQuery(string $query, array $bindings = []): array
+    {
+        throw new DatabaseException('Raw queries are not supported by this adapter');
+    }
 
     /**
-     * Does the adapter support multiple fulltext indexes?
+     * @param  array<mixed>  $bindings
      *
-     * @return bool
+     * @throws DatabaseException
      */
-    abstract public function getSupportForMultipleFulltextIndexes(): bool;
-
+    public function rawMutation(string $query, array $bindings = []): int
+    {
+        throw new DatabaseException('Raw mutations are not supported by this adapter');
+    }
 
-    /**
-     * Does the adapter support identical indexes?
-     *
-     * @return bool
-     */
-    abstract public function getSupportForIdenticalIndexes(): bool;
+    public function getBuilder(string $collection): \Utopia\Query\Builder
+    {
+        throw new DatabaseException('Query builder is not supported by this adapter');
+    }
 
-    /**
-     * Does the adapter support random order by?
-     *
-     * @return bool
-     */
-    abstract public function getSupportForOrderRandom(): bool;
+    public function getSchema(): \Utopia\Query\Schema
+    {
+        throw new DatabaseException('Schema builder is not supported by this adapter');
+    }
 
     /**
-     * Get current attribute count from collection document
+     * Filter Keys
      *
-     * @param Document $collection
-     * @return int
+     * @throws DatabaseException
      */
-    abstract public function getCountOfAttributes(Document $collection): int;
+    public function filter(string $value): string
+    {
+        $value = \preg_replace("/[^A-Za-z0-9_\-]/", '', $value);
 
-    /**
-     * Get current index count from collection document
-     *
-     * @param Document $collection
-     * @return int
-     */
-    abstract public function getCountOfIndexes(Document $collection): int;
+        if (\is_null($value)) {
+            throw new DatabaseException('Failed to filter key');
+        }
 
-    /**
-     * Returns number of attributes used by default.
-     *
-     * @return int
-     */
-    abstract public function getCountOfDefaultAttributes(): int;
+        return $value;
+    }
 
     /**
-     * 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 = [
@@ -1316,7 +1230,7 @@ protected function escapeWildcards(string $value): string
             ')',
             '{',
             '}',
-            '|'
+            '|',
         ];
 
         foreach ($wildcards as $wildcard) {
@@ -1327,258 +1241,9 @@ 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;
-
-    /**
-        * 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;
 }
diff --git a/src/Database/Adapter/Feature/Attributes.php b/src/Database/Adapter/Feature/Attributes.php
new file mode 100644
index 000000000..9594f1263
--- /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 000000000..69d311fca
--- /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/ConnectionId.php b/src/Database/Adapter/Feature/ConnectionId.php
new file mode 100644
index 000000000..5d85ddb92
--- /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 000000000..9d38aed76
--- /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 000000000..69d5dac8b
--- /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 $value The value to add (negative to decrease).
+     * @param string $updatedAt The timestamp to set as the updated time.
+     * @param int|float|null $min Optional minimum bound for the resulting value.
+     * @param int|float|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 $value,
+        string $updatedAt,
+        int|float|null $min = null,
+        int|float|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 000000000..14e649331
--- /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 000000000..37a568554
--- /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/Relationships.php b/src/Database/Adapter/Feature/Relationships.php
new file mode 100644
index 000000000..1fe5785a2
--- /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 000000000..518eaeba5
--- /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/Spatial.php b/src/Database/Adapter/Feature/Spatial.php
new file mode 100644
index 000000000..81c120bc9
--- /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 000000000..8c05c61f9
--- /dev/null
+++ b/src/Database/Adapter/Feature/Timeouts.php
@@ -0,0 +1,20 @@
+<?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;
+}
diff --git a/src/Database/Adapter/Feature/Transactions.php b/src/Database/Adapter/Feature/Transactions.php
new file mode 100644
index 000000000..f91fd64cf
--- /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 000000000..a962a90fb
--- /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 000000000..41e80bf80
--- /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 223f91e71..1b91f64d1 100644
--- a/src/Database/Adapter/MariaDB.php
+++ b/src/Database/Adapter/MariaDB.php
@@ -4,8 +4,12 @@
 
 use Exception;
 use PDOException;
+use Swoole\Database\PDOStatementProxy;
+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;
@@ -15,52 +19,91 @@
 use Utopia\Database\Exception\Query as QueryException;
 use Utopia\Database\Exception\Timeout as TimeoutException;
 use Utopia\Database\Exception\Truncate as TruncateException;
-use Utopia\Database\Helpers\ID;
+use Utopia\Database\Index;
 use Utopia\Database\Operator;
+use Utopia\Database\OperatorType;
 use Utopia\Database\Query;
-
-class MariaDB extends SQL
+use Utopia\Database\Relationship;
+use Utopia\Database\RelationSide;
+use Utopia\Database\RelationType;
+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\Blueprint;
+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\Relationships, Feature\SchemaAttributes, Feature\Spatial, Feature\Timeouts, Feature\Upserts
 {
     /**
-     * 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,
+        ]);
+    }
+
+    /**
+     * 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)
@@ -70,200 +113,248 @@ 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
      */
     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)
-            );
-
-            // Ignore relationships with virtual attributes
-            if ($attribute->getAttribute('type') === Database::VAR_RELATIONSHIP) {
-                $options = $attribute->getAttribute('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)
-                ) {
-                    continue;
+        // Build main collection table using schema builder
+        $collectionResult = $schema->create($this->getSQLTableRaw($id), function (Blueprint $table) use ($attributes, $indexes, $hash, $sharedTables) {
+            // System columns
+            $table->id('_id');
+            $table->string('_uid', 255);
+            $table->datetime('_createdAt', 3)->nullable()->default(null);
+            $table->datetime('_updatedAt', 3)->nullable()->default(null);
+            $table->mediumText('_permissions')->nullable()->default(null);
+            $table->rawColumn('`_version` INT(11) UNSIGNED DEFAULT 1');
+
+            // User-defined attribute columns (raw SQL via getSQLType())
+            foreach ($attributes as $attribute) {
+                $attrId = $this->filter($attribute->key);
+
+                // Skip virtual relationship attributes
+                if ($attribute->type === ColumnType::Relationship) {
+                    $options = $attribute->options ?? [];
+                    $relationType = $options['relationType'] ?? null;
+                    $twoWay = $options['twoWay'] ?? false;
+                    $side = $options['side'] ?? null;
+
+                    if (
+                        $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;
+                    }
                 }
+
+                $attrType = $this->getSQLType(
+                    $attribute->type,
+                    $attribute->size,
+                    $attribute->signed,
+                    $attribute->array,
+                    $attribute->required
+                );
+                $table->rawColumn("`{$attrId}` {$attrType}");
             }
 
-            $attributeStrings[$key] = "`{$attrId}` {$attrType}, ";
-        }
+            // User-defined indexes
+            foreach ($indexes as $index) {
+                $indexId = $this->filter($index->key);
+                $indexType = $index->type;
+                $indexAttributes = $index->attributes;
 
-        foreach ($indexes as $key => $index) {
-            $indexId = $this->filter($index->getId());
-            $indexType = $index->getAttribute('type');
-
-            $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)) {
-                    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);
+                $regularColumns = [];
+                $indexLengths = [];
+                $indexOrders = [];
+                $rawCastColumns = [];
 
-                if ($indexType === Database::INDEX_FULLTEXT) {
-                    $indexOrder = '';
-                }
+                foreach ($indexAttributes as $nested => $attribute) {
+                    $indexLength = $index->lengths[$nested] ?? '';
+                    $indexOrder = $index->orders[$nested] ?? '';
+
+                    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->filter($this->getInternalKeyForAttribute($attribute));
 
-                $indexAttributes[$nested] = "`{$indexAttribute}`{$indexLength} {$indexOrder}";
+                    if ($indexType === IndexType::Fulltext) {
+                        $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 ($sharedTables && $indexType !== IndexType::Fulltext && $indexType !== IndexType::Spatial) {
+                    \array_unshift($regularColumns, '_tenant');
+                }
 
-            if ($this->sharedTables && $indexType !== Database::INDEX_FULLTEXT && $indexType !== Database::INDEX_SPATIAL) {
-                // Add tenant as first index column for best performance
-                $indexAttributes = "_tenant, {$indexAttributes}";
+                $table->addIndex(
+                    $indexId,
+                    $regularColumns,
+                    $indexType,
+                    $indexLengths,
+                    $indexOrders,
+                    rawColumns: $rawCastColumns,
+                );
             }
 
-            $indexStrings[$key] = "{$indexType} `{$indexId}` ({$indexAttributes}),";
-        }
+            // Tenant column and system indexes
+            if ($sharedTables) {
+                $table->rawColumn('_tenant INT(11) UNSIGNED DEFAULT NULL');
+                $table->uniqueIndex(['_uid', '_tenant'], '_uid');
+                $table->index(['_tenant', '_createdAt'], '_created_at');
+                $table->index(['_tenant', '_updatedAt'], '_updated_at');
+                $table->index(['_tenant', '_id'], '_tenant_id');
+            } else {
+                $table->uniqueIndex(['_uid'], '_uid');
+                $table->index(['_createdAt'], '_created_at');
+                $table->index(['_updatedAt'], '_updated_at');
+            }
+        });
+        $collection = $collectionResult->query;
+
+        // Build permissions table using schema builder
+        $permsResult = $schema->create($this->getSQLTableRaw($id.'_perms'), function (Blueprint $table) use ($sharedTables) {
+            $table->id('_id');
+            $table->string('_type', 12);
+            $table->string('_permission', 255);
+            $table->string('_document', 255);
+
+            if ($sharedTables) {
+                $table->integer('_tenant')->unsigned()->nullable()->default(null);
+                $table->uniqueIndex(['_document', '_tenant', '_type', '_permission'], '_index1');
+                $table->index(['_tenant', '_permission', '_type'], '_permission');
+            } else {
+                $table->uniqueIndex(['_document', '_type', '_permission'], '_index1');
+                $table->index(['_permission', '_type'], '_permission');
+            }
+        });
+        $permissions = $permsResult->query;
 
-        $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)
-			";
-        } else {
-            $collection .= "
-				UNIQUE KEY _uid (_uid),
-				KEY _created_at (_createdAt),
-				KEY _updated_at (_updatedAt)
-			";
+        try {
+            $this->getPDO()->prepare($collection)->execute();
+            $this->getPDO()->prepare($permissions)->execute();
+        } catch (PDOException $e) {
+            throw $this->processException($e);
         }
 
-        $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)
-            ";
-        } else {
-            $permissions .= "
-                UNIQUE INDEX _index1 (_document, _type, _permission),
-                INDEX _permission (_permission, _type)
-            ";
-        }
+        return true;
+    }
 
-        $permissions .= ")";
-        $permissions = $this->trigger(Database::EVENT_COLLECTION_CREATE, $permissions);
+    /**
+     * Delete collection
+     *
+     * @throws Exception
+     * @throws PDOException
+     */
+    public function deleteCollection(string $id): bool
+    {
+        $id = $this->filter($id);
 
-        try {
-            $this->getPDO()
-                ->prepare($collection)
-                ->execute();
+        $schema = $this->createSchemaBuilder();
+        $mainResult = $schema->drop($this->getSQLTableRaw($id));
+        $permsResult = $schema->drop($this->getSQLTableRaw($id.'_perms'));
+
+        $sql = $mainResult->query.'; '.$permsResult->query;
 
-            $this->getPDO()
-                ->prepare($permissions)
+        try {
+            return $this->getPDO()
+                ->prepare($sql)
                 ->execute();
         } catch (PDOException $e) {
             throw $this->processException($e);
         }
+    }
 
-        return true;
+    /**
+     * Analyze a collection updating it's metadata on the database engine
+     *
+     * @throws DatabaseException
+     */
+    public function analyzeCollection(string $collection): bool
+    {
+        $name = $this->filter($collection);
+
+        $result = $this->createSchemaBuilder()->analyzeTable($this->getSQLTableRaw($name));
+        $sql = $result->query;
+
+        $stmt = $this->getPDO()->prepare($sql);
+
+        return $stmt->execute();
     }
 
     /**
      * 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;
+        $collection = $this->getNamespace().'_'.$collection;
         $database = $this->getDatabase();
-        $name = $database . '/' . $collection;
-        $permissions = $database . '/' . $collection . '_perms';
+        $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
-         ");
+        $builder = $this->createBuilder();
 
-        $permissionsSize = $this->getPDO()->prepare("
-            SELECT SUM(FS_BLOCK_SIZE + ALLOCATED_SIZE)  
-            FROM INFORMATION_SCHEMA.INNODB_SYS_TABLESPACES
-            WHERE NAME = :permissions
-        ");
+        $collectionResult = $builder
+            ->from('INFORMATION_SCHEMA.INNODB_SYS_TABLESPACES')
+            ->selectRaw('SUM(FS_BLOCK_SIZE + ALLOCATED_SIZE)')
+            ->filter([BaseQuery::equal('NAME', [$name])])
+            ->build();
 
-        $collectionSize->bindParam(':name', $name);
-        $permissionsSize->bindParam(':permissions', $permissions);
+        $permissionsResult = $builder->reset()
+            ->from('INFORMATION_SCHEMA.INNODB_SYS_TABLESPACES')
+            ->selectRaw('SUM(FS_BLOCK_SIZE + ALLOCATED_SIZE)')
+            ->filter([BaseQuery::equal('NAME', [$permissions])])
+            ->build();
+
+        $collectionSize = $this->getPDO()->prepare($collectionResult->query);
+        $permissionsSize = $this->getPDO()->prepare($permissionsResult->query);
+
+        foreach ($collectionResult->bindings as $i => $v) {
+            $collectionSize->bindValue($i + 1, $v);
+        }
+        foreach ($permissionsResult->bindings as $i => $v) {
+            $permissionsSize->bindValue($i + 1, $v);
+        }
 
         try {
             $collectionSize->execute();
             $permissionsSize->execute();
-            $size = $collectionSize->fetchColumn() + $permissionsSize->fetchColumn();
+            $collSizeVal = $collectionSize->fetchColumn();
+            $permSizeVal = $permissionsSize->fetchColumn();
+            $size = (int) (\is_numeric($collSizeVal) ? $collSizeVal : 0) + (int) (\is_numeric($permSizeVal) ? $permSizeVal : 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;
@@ -272,62 +363,111 @@ public function getSizeOfCollectionOnDisk(string $collection): int
     /**
      * 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;
+        $collection = $this->getNamespace().'_'.$collection;
         $database = $this->getDatabase();
-        $permissions = $collection . '_perms';
-
-        $collectionSize = $this->getPDO()->prepare("
-            SELECT SUM(data_length + index_length)  
-            FROM INFORMATION_SCHEMA.TABLES
-            WHERE table_name = :name AND
-            table_schema = :database
-         ");
-
-        $permissionsSize = $this->getPDO()->prepare("
-            SELECT SUM(data_length + index_length)  
-            FROM INFORMATION_SCHEMA.TABLES
-            WHERE table_name = :permissions AND
-            table_schema = :database
-        ");
-
-        $collectionSize->bindParam(':name', $collection);
-        $collectionSize->bindParam(':database', $database);
-        $permissionsSize->bindParam(':permissions', $permissions);
-        $permissionsSize->bindParam(':database', $database);
+        $permissions = $collection.'_perms';
+
+        $builder = $this->createBuilder();
+
+        $collectionResult = $builder
+            ->from('INFORMATION_SCHEMA.TABLES')
+            ->selectRaw('SUM(data_length + index_length)')
+            ->filter([
+                BaseQuery::equal('table_name', [$collection]),
+                BaseQuery::equal('table_schema', [$database]),
+            ])
+            ->build();
+
+        $permissionsResult = $builder->reset()
+            ->from('INFORMATION_SCHEMA.TABLES')
+            ->selectRaw('SUM(data_length + index_length)')
+            ->filter([
+                BaseQuery::equal('table_name', [$permissions]),
+                BaseQuery::equal('table_schema', [$database]),
+            ])
+            ->build();
+
+        $collectionSize = $this->getPDO()->prepare($collectionResult->query);
+        $permissionsSize = $this->getPDO()->prepare($permissionsResult->query);
+
+        foreach ($collectionResult->bindings as $i => $v) {
+            $collectionSize->bindValue($i + 1, $v);
+        }
+        foreach ($permissionsResult->bindings as $i => $v) {
+            $permissionsSize->bindValue($i + 1, $v);
+        }
 
         try {
             $collectionSize->execute();
             $permissionsSize->execute();
-            $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;
     }
 
     /**
-     * Delete collection
+     * Create a new attribute column, handling spatial types with MariaDB-specific syntax.
      *
-     * @param string $id
+     * @param string $collection The collection name
+     * @param Attribute $attribute The attribute definition
      * @return bool
-     * @throws Exception
-     * @throws PDOException
+     *
+     * @throws DatabaseException
      */
-    public function deleteCollection(string $id): bool
+    public function createAttribute(string $collection, Attribute $attribute): bool
     {
-        $id = $this->filter($id);
+        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;
+            }
+
+            try {
+                return $this->getPDO()->prepare($sql)->execute();
+            } catch (PDOException $e) {
+                throw $this->processException($e);
+            }
+        }
+
+        return parent::createAttribute($collection, $attribute);
+    }
+
+    /**
+     * Update Attribute
+     *
+     * @throws DatabaseException
+     */
+    public function updateAttribute(string $collection, Attribute $attribute, ?string $newKey = null): bool
+    {
+        $name = $this->filter($collection);
+        $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);
+        /** @var MySQLSchema $schema */
+        $schema = $this->createSchemaBuilder();
+        $tableRaw = $this->getSQLTableRaw($name);
 
-        $sql = "DROP TABLE {$this->getSQLTable($id)}, {$this->getSQLTable($id . '_perms')};";
+        if (! empty($newKey)) {
+            $result = $schema->changeColumn($tableRaw, $id, $newKey, $sqlType);
+        } else {
+            $result = $schema->modifyColumn($tableRaw, $id, $sqlType);
+        }
 
-        $sql = $this->trigger(Database::EVENT_COLLECTION_DELETE, $sql);
+        $sql = $result->query;
 
         try {
             return $this->getPDO()
@@ -339,155 +479,142 @@ public function deleteCollection(string $id): bool
     }
 
     /**
-     * Analyze a collection updating it's metadata on the database engine
+     * Create Index
+     *
+     * @param  array<string,string>  $indexAttributeTypes
+     * @param  array<string, mixed>  $collation
      *
-     * @param string $collection
-     * @return bool
      * @throws DatabaseException
      */
-    public function analyzeCollection(string $collection): bool
+    public function createIndex(string $collection, Index $index, array $indexAttributeTypes = [], array $collation = []): bool
     {
-        $name = $this->filter($collection);
+        $metadataCollection = new Document(['$id' => Database::METADATA]);
+        $collection = $this->getDocument($metadataCollection, $collection);
 
-        $sql = "ANALYZE TABLE {$this->getSQLTable($name)}";
+        if ($collection->isEmpty()) {
+            throw new NotFoundException('Collection not found');
+        }
 
-        $stmt = $this->getPDO()->prepare($sql);
-        return $stmt->execute();
-    }
+        $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;
 
-    /**
-     * Get Schema Attributes
-     *
-     * @param string $collection
-     * @return array<Document>
-     * @throws DatabaseException
-     */
-    public function getSchemaAttributes(string $collection): array
-    {
-        $schema = $this->getDatabase();
-        $collection = $this->getNamespace().'_'.$this->filter($collection);
+        $schema = $this->createSchemaBuilder();
+        $tableName = $this->getSQLTableRaw($collection->getId());
 
-        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();
+        // Build column lists, separating regular columns from raw CAST ARRAY expressions
+        $schemaColumns = [];
+        $schemaLengths = [];
+        $schemaOrders = [];
+        $rawExpressions = [];
 
-            foreach ($results as $index => $document) {
-                $document['$id'] = $document['_id'];
-                unset($document['_id']);
+        foreach ($attributes as $i => $attr) {
+            $attribute = null;
+            foreach ($collectionAttributes as $collectionAttribute) {
+                $collAttrId = $collectionAttribute['$id'] ?? '';
+                if (\strtolower(\is_string($collAttrId) ? $collAttrId : '') === \strtolower($attr)) {
+                    $attribute = $collectionAttribute;
+                    break;
+                }
+            }
+
+            $attr = $this->filter($this->getInternalKeyForAttribute($attr));
+            $order = empty($orders[$i]) || $type === IndexType::Fulltext ? '' : $orders[$i];
+            $length = empty($lengths[$i]) ? 0 : (int) $lengths[$i];
 
-                $results[$index] = new Document($document);
+            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;
+                }
             }
+        }
 
-            return $results;
+        if ($this->sharedTables && $type !== IndexType::Fulltext && $type !== IndexType::Spatial) {
+            \array_unshift($schemaColumns, '_tenant');
+        }
 
+        $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();
         } catch (PDOException $e) {
-            throw new DatabaseException('Failed to get schema attributes', $e->getCode(), $e);
+            throw $this->processException($e);
         }
     }
 
     /**
-     * Update Attribute
+     * Delete 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 DatabaseException
+     * @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 deleteIndex(string $collection, string $id): 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};";
-        }
 
-        $sql = $this->trigger(Database::EVENT_ATTRIBUTE_UPDATE, $sql);
+        $schema = $this->createSchemaBuilder();
+        $result = $schema->dropIndex($this->getSQLTableRaw($name), $id);
+
+        $sql = $result->query;
 
         try {
             return $this->getPDO()
-            ->prepare($sql)
-            ->execute();
+                ->prepare($sql)
+                ->execute();
         } catch (PDOException $e) {
-            throw $this->processException($e);
+            if ($e->getCode() === '42000' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1091) {
+                return true;
+            }
+
+            throw $e;
         }
     }
 
     /**
-     * @param string $collection
-     * @param string $id
-     * @param string $type
-     * @param string $relatedCollection
-     * @param bool $twoWay
-     * @param string $twoWayKey
-     * @return bool
-     * @throws DatabaseException
+     * Rename 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);
-        $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;";
-
-                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');
-        }
+    public function renameIndex(string $collection, string $old, string $new): bool
+    {
+        $collection = $this->filter($collection);
+        $old = $this->filter($old);
+        $new = $this->filter($new);
 
-        $sql = $this->trigger(Database::EVENT_ATTRIBUTE_CREATE, $sql);
+        $result = $this->createSchemaBuilder()->renameIndex($this->getSQLTableRaw($collection), $old, $new);
+        $sql = $result->query;
 
         return $this->getPDO()
             ->prepare($sql)
@@ -495,1539 +622,379 @@ public function createRelationship(
     }
 
     /**
-     * @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
+     *
+     * @throws Exception
+     * @throws PDOException
+     * @throws DuplicateException
+     * @throws \Throwable
      */
-    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 = '';
+    public function createDocument(Document $collection, Document $document): Document
+    {
+        try {
+            $this->syncWriteHooks();
 
-        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());
-
-                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');
-        }
-
-        if (empty($sql)) {
-            return true;
-        }
-
-        $sql = $this->trigger(Database::EVENT_ATTRIBUTE_UPDATE, $sql);
-
-        return $this->getPDO()
-            ->prepare($sql)
-            ->execute();
-    }
-
-    /**
-     * @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
-     */
-    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);
-
-        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');
-        }
-
-        if (empty($sql)) {
-            return true;
-        }
-
-        $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 = $this->trigger(Database::EVENT_INDEX_RENAME, $sql);
-
-        return $this->getPDO()
-            ->prepare($sql)
-            ->execute();
-    }
-
-    /**
-     * 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
-     * @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
-    {
-        $metadataCollection = new 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);
-
-        $id = $this->filter($id);
-
-        foreach ($attributes as $i => $attr) {
-            $attribute = null;
-            foreach ($collectionAttributes as $collectionAttribute) {
-                if (\strtolower($collectionAttribute['$id']) === \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}";
-
-            if ($this->getSupportForCastIndexArray() && !empty($attribute['array'])) {
-                $attributes[$i] = '(CAST(`' . $attr . '` AS char(' . Database::MAX_ARRAY_INDEX_LENGTH . ') ARRAY))';
-            }
-        }
-
-        $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}";
-        }
-
-        $sql =  "CREATE {$sqlType} `{$id}` ON {$this->getSQLTable($collection->getId())} ({$attributes})";
-        $sql = $this->trigger(Database::EVENT_INDEX_CREATE, $sql);
-
-        try {
-            return $this->getPDO()
-                ->prepare($sql)
-                ->execute();
-        } catch (PDOException $e) {
-            throw $this->processException($e);
-        }
-    }
-
-    /**
-     * Delete Index
-     *
-     * @param string $collection
-     * @param string $id
-     * @return bool
-     * @throws Exception
-     * @throws PDOException
-     */
-    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}`;";
-
-        $sql = $this->trigger(Database::EVENT_INDEX_DELETE, $sql);
-
-        try {
-            return $this->getPDO()
-                ->prepare($sql)
-                ->execute();
-        } catch (PDOException $e) {
-            if ($e->getCode() === "42000" && $e->errorInfo[1] === 1091) {
-                return true;
-            }
-
-            throw $e;
-        }
-    }
-
-    /**
-     * Create Document
-     *
-     * @param Document $collection
-     * @param Document $document
-     * @return Document
-     * @throws Exception
-     * @throws PDOException
-     * @throws DuplicateException
-     * @throws \Throwable
-     */
-    public function createDocument(Document $collection, Document $document): Document
-    {
-        try {
-            $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();
-            }
-
-            $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);
-
-            $stmt = $this->getPDO()->prepare($sql);
-
-            $stmt->bindValue(':_uid', $document->getId());
-
-            if (!empty($document->getSequence())) {
-                $stmt->bindValue(':_id', $document->getSequence());
-            }
-
-            $attributeIndex = 0;
-            foreach ($attributes as $value) {
-                if (\is_array($value)) {
-                    $value = \json_encode($value);
-                }
-
-                $bindKey = 'key_' . $attributeIndex;
-                $attribute = $this->filter($attribute);
-                $value = (\is_bool($value)) ? (int)$value : $value;
-                $stmt->bindValue(':' . $bindKey, $value, $this->getPDOType($value));
-                $attributeIndex++;
-            }
-
-            $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 (!empty($permissions)) {
-                $tenantColumn = $this->sharedTables ? ', _tenant' : '';
-                $permissions = \implode(', ', $permissions);
-
-                $sqlPermissions = "
-                    INSERT INTO {$this->getSQLTable($name . '_perms')} (_type, _permission, _document {$tenantColumn})
-                    VALUES {$permissions};
-                ";
-
-                $stmtPermissions = $this->getPDO()->prepare($sqlPermissions);
-                $stmtPermissions->bindValue(':_uid', $document->getId());
-                if ($this->sharedTables) {
-                    $stmtPermissions->bindValue(':_tenant', $document->getTenant());
-                }
-            }
-
-            $stmt->execute();
-
-            $document['$sequence'] = $this->pdo->lastInsertId();
-
-            if (empty($document['$sequence'])) {
-                throw new DatabaseException('Error creating document empty "$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;
-                    }
-
-                    // 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();
-
-                    $stmtPermissions->execute();
-                }
-            }
-        } 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
-     * @throws \Throwable
-     */
-    public function updateDocument(Document $collection, string $id, Document $document, bool $skipPermissions): Document
-    {
-        try {
-            $spatialAttributes = $this->getSpatialAttributes($collection);
-            $collection = $collection->getId();
-            $attributes = $document->getAttributes();
-            $attributes['_createdAt'] = $document->getCreatedAt();
-            $attributes['_updatedAt'] = $document->getUpdatedAt();
-            $attributes['_permissions'] = json_encode($document->getPermissions());
-
-            $name = $this->filter($collection);
-            $columns = '';
-
-            if (!$skipPermissions) {
-                $sql = "
-			    SELECT _type, _permission
-			    FROM {$this->getSQLTable($name . '_perms')}
-			    WHERE _document = :_uid
-			    {$this->getTenantQuery($collection)}
-			";
-
-                $sql = $this->trigger(Database::EVENT_PERMISSIONS_READ, $sql);
-
-                /**
-                 * Get current permissions from the database
-                 */
-                $sqlPermissions = $this->getPDO()->prepare($sql);
-                $sqlPermissions->bindValue(':_uid', $document->getId());
-
-                if ($this->sharedTables) {
-                    $sqlPermissions->bindValue(':_tenant', $this->tenant);
-                }
-
-                $sqlPermissions->execute();
-                $permissions = $sqlPermissions->fetchAll();
-                $sqlPermissions->closeCursor();
-
-                $initial = [];
-                foreach (Database::PERMISSIONS as $type) {
-                    $initial[$type] = [];
-                }
-
-                $permissions = array_reduce($permissions, function (array $carry, array $item) {
-                    $carry[$item['_type']][] = $item['_permission'];
-
-                    return $carry;
-                }, $initial);
-
-                /**
-                 * Get removed Permissions
-                 */
-                $removals = [];
-                foreach (Database::PERMISSIONS as $type) {
-                    $diff = \array_diff($permissions[$type], $document->getPermissionsByType($type));
-                    if (!empty($diff)) {
-                        $removals[$type] = $diff;
-                    }
-                }
-
-                /**
-                 * Get added Permissions
-                 */
-                $additions = [];
-                foreach (Database::PERMISSIONS as $type) {
-                    $diff = \array_diff($document->getPermissionsByType($type), $permissions[$type]);
-                    if (!empty($diff)) {
-                        $additions[$type] = $diff;
-                    }
-                }
-
-                /**
-                 * Query to remove permissions
-                 */
-                $removeQuery = '';
-                if (!empty($removals)) {
-                    $removeQuery = ' AND (';
-                    foreach ($removals as $type => $permissions) {
-                        $removeQuery .= "(
-                    _type = '{$type}'
-                    AND _permission IN (" . implode(', ', \array_map(fn (string $i) => ":_remove_{$type}_{$i}", \array_keys($permissions))) . ")
-                )";
-                        if ($type !== \array_key_last($removals)) {
-                            $removeQuery .= ' OR ';
-                        }
-                    }
-                }
-                if (!empty($removeQuery)) {
-                    $removeQuery .= ')';
-                    $sql = "
-				    DELETE
-                    FROM {$this->getSQLTable($name . '_perms')}
-                    WHERE _document = :_uid
-                    {$this->getTenantQuery($collection)}
-                ";
-
-                    $removeQuery = $sql . $removeQuery;
-
-                    $removeQuery = $this->trigger(Database::EVENT_PERMISSIONS_DELETE, $removeQuery);
-
-                    $stmtRemovePermissions = $this->getPDO()->prepare($removeQuery);
-                    $stmtRemovePermissions->bindValue(':_uid', $document->getId());
-
-                    if ($this->sharedTables) {
-                        $stmtRemovePermissions->bindValue(':_tenant', $this->tenant);
-                    }
-
-                    foreach ($removals as $type => $permissions) {
-                        foreach ($permissions as $i => $permission) {
-                            $stmtRemovePermissions->bindValue(":_remove_{$type}_{$i}", $permission);
-                        }
-                    }
-                }
-
-                /**
-                 * Query to add permissions
-                 */
-                if (!empty($additions)) {
-                    $values = [];
-                    foreach ($additions as $type => $permissions) {
-                        foreach ($permissions as $i => $_) {
-                            $value = "( :_uid, '{$type}', :_add_{$type}_{$i}";
-
-                            if ($this->sharedTables) {
-                                $value .= ", :_tenant)";
-                            } else {
-                                $value .= ")";
-                            }
-
-                            $values[] = $value;
-                        }
-                    }
-
-                    $sql = "
-				    INSERT INTO {$this->getSQLTable($name . '_perms')} (_document, _type, _permission
-				";
-
-                    if ($this->sharedTables) {
-                        $sql .= ', _tenant)';
-                    } else {
-                        $sql .= ')';
-                    }
-
-                    $sql .= " VALUES " . \implode(', ', $values);
-
-                    $sql = $this->trigger(Database::EVENT_PERMISSIONS_CREATE, $sql);
-
-                    $stmtAddPermissions = $this->getPDO()->prepare($sql);
-
-                    $stmtAddPermissions->bindValue(":_uid", $document->getId());
-
-                    if ($this->sharedTables) {
-                        $stmtAddPermissions->bindValue(":_tenant", $this->tenant);
-                    }
-
-                    foreach ($additions as $type => $permissions) {
-                        foreach ($permissions as $i => $permission) {
-                            $stmtAddPermissions->bindValue(":_add_{$type}_{$i}", $permission);
-                        }
-                    }
-                }
-            }
-
-            /**
-             * Update Attributes
-             */
-            $keyIndex = 0;
-            $opIndex = 0;
-            $operators = [];
-
-            // Separate regular attributes from operators
-            foreach ($attributes as $attribute => $value) {
-                if (Operator::isOperator($value)) {
-                    $operators[$attribute] = $value;
-                }
-            }
-
-            foreach ($attributes as $attribute => $value) {
-                $column = $this->filter($attribute);
-
-                // Check if this is an operator or regular attribute
-                if (isset($operators[$attribute])) {
-                    $operatorSQL = $this->getOperatorSQL($column, $operators[$attribute], $opIndex);
-                    $columns .= $operatorSQL . ',';
-                } else {
-                    $bindKey = 'key_' . $keyIndex;
-
-                    if (in_array($attribute, $spatialAttributes)) {
-                        $columns .= "`{$column}`" . '=' . $this->getSpatialGeomFromText(':' . $bindKey) . ',';
-                    } else {
-                        $columns .= "`{$column}`" . '=:' . $bindKey . ',';
-                    }
-                    $keyIndex++;
-                }
-            }
-
-            $sql = "
-                UPDATE {$this->getSQLTable($name)}
-                SET {$columns} _uid = :_newUid
-                WHERE _id=:_sequence
-                {$this->getTenantQuery($collection)}
-			";
-
-            $sql = $this->trigger(Database::EVENT_DOCUMENT_UPDATE, $sql);
-
-            $stmt = $this->getPDO()->prepare($sql);
-
-            $stmt->bindValue(':_sequence', $document->getSequence());
-            $stmt->bindValue(':_newUid', $document->getId());
-
-            if ($this->sharedTables) {
-                $stmt->bindValue(':_tenant', $this->tenant);
-            }
-
-            $keyIndex = 0;
-            $opIndexForBinding = 0;
-            foreach ($attributes as $attribute => $value) {
-                // Handle operators separately
-                if (isset($operators[$attribute])) {
-                    $this->bindOperatorParams($stmt, $operators[$attribute], $opIndexForBinding);
-                } else {
-                    // 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);
-                    }
-
-                    $bindKey = 'key_' . $keyIndex;
-                    $value = (is_bool($value)) ? (int)$value : $value;
-                    $stmt->bindValue(':' . $bindKey, $value, $this->getPDOType($value));
-                    $keyIndex++;
-                }
-            }
-
-            $stmt->execute();
-
-            if (isset($stmtRemovePermissions)) {
-                $stmtRemovePermissions->execute();
-            }
-            if (isset($stmtAddPermissions)) {
-                $stmtAddPermissions->execute();
-            }
-
-        } catch (PDOException $e) {
-            throw $this->processException($e);
-        }
-
-        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
-     * @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 = [];
-        $opIndex = 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], $opIndex);
-                    if ($operatorSQL !== null) {
-                        $updateColumns[] = $operatorSQL;
-                    }
-                } else {
-                    if (!in_array($attr, ['_uid', '_id', '_createdAt', '_tenant'])) {
-                        $updateColumns[] = $getUpdateClause($filteredAttr);
-                    }
-                }
-            }
-        }
-
-        $stmt = $this->getPDO()->prepare(
-            "
-            INSERT INTO {$this->getSQLTable($tableName)} {$columns}
-            VALUES " . \implode(', ', $batchKeys) . "
-            ON DUPLICATE KEY UPDATE
-                " . \implode(', ', $updateColumns)
-        );
-
-        foreach ($bindValues as $key => $binding) {
-            $stmt->bindValue($key, $binding, $this->getPDOType($binding));
-        }
-
-        $opIndexForBinding = 0;
-        foreach (\array_keys($attributes) as $attr) {
-            if (isset($operators[$attr])) {
-                $this->bindOperatorParams($stmt, $operators[$attr], $opIndexForBinding);
-            }
-        }
-
-        return $stmt;
-    }
-
-    /**
-     * 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
-     */
-    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)}
-		";
-
-        $sql .= $sqlMax . $sqlMin;
-
-        $sql = $this->trigger(Database::EVENT_DOCUMENT_UPDATE, $sql);
-
-        $stmt = $this->getPDO()->prepare($sql);
-        $stmt->bindValue(':_uid', $id);
-        $stmt->bindValue(':val', $value);
-        $stmt->bindValue(':updatedAt', $updatedAt);
-
-        if ($max !== null) {
-            $stmt->bindValue(':max', $max);
-        }
-        if ($min !== null) {
-            $stmt->bindValue(':min', $min);
-        }
-        if ($this->sharedTables) {
-            $stmt->bindValue(':_tenant', $this->tenant);
-        }
-
-        try {
-            $stmt->execute();
-        } catch (PDOException $e) {
-            throw $this->processException($e);
-        }
-
-        return true;
-    }
-
-    /**
-     * Delete Document
-     *
-     * @param string $collection
-     * @param string $id
-     * @return bool
-     * @throws Exception
-     * @throws PDOException
-     */
-    public function deleteDocument(string $collection, string $id): bool
-    {
-        try {
-            $name = $this->filter($collection);
-
-            $sql = "
-                DELETE FROM {$this->getSQLTable($name)} 
-                WHERE _uid = :_uid
-                {$this->getTenantQuery($collection)}
-		    ";
-
-            $sql = $this->trigger(Database::EVENT_DOCUMENT_DELETE, $sql);
-
-            $stmt = $this->getPDO()->prepare($sql);
-
-            $stmt->bindValue(':_uid', $id);
-
-            if ($this->sharedTables) {
-                $stmt->bindValue(':_tenant', $this->tenant);
-            }
-
-            $sql = "
-			    DELETE FROM {$this->getSQLTable($name . '_perms')} 
-		        WHERE _document = :_uid
-		        {$this->getTenantQuery($collection)}
-		    ";
-
-            $sql = $this->trigger(Database::EVENT_PERMISSIONS_DELETE, $sql);
-
-            $stmtPermissions = $this->getPDO()->prepare($sql);
-            $stmtPermissions->bindValue(':_uid', $id);
-
-            if ($this->sharedTables) {
-                $stmtPermissions->bindValue(':_tenant', $this->tenant);
-            }
-
-            if (!$stmt->execute()) {
-                throw new DatabaseException('Failed to delete document');
-            }
-
-            $deleted = $stmt->rowCount();
-
-            if (!$stmtPermissions->execute()) {
-                throw new DatabaseException('Failed to delete permissions');
-            }
-        } catch (\Throwable $e) {
-            throw new DatabaseException($e->getMessage(), $e->getCode(), $e);
-        }
-
-        return $deleted;
-    }
-
-    /**
-     * 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
-    */
-    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 Query $query
-     * @param array<string, mixed> $binds
-     * @param string $attribute
-     * @param string $type
-     * @param string $alias
-     * @param string $placeholder
-     * @return 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", null) . ")";
-
-            case Query::TYPE_NOT_CROSSES:
-                $binds[":{$placeholder}_0"] = $this->convertArrayToWKT($query->getValues()[0]);
-                return "NOT ST_Crosses({$alias}.{$attribute}, " . $this->getSpatialGeomFromText(":{$placeholder}_0", null) . ")";
-
-            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);
-
-            case Query::TYPE_INTERSECTS:
-                $binds[":{$placeholder}_0"] = $this->convertArrayToWKT($query->getValues()[0]);
-                return "ST_Intersects({$alias}.{$attribute}, " . $this->getSpatialGeomFromText(":{$placeholder}_0", null) . ")";
-
-            case Query::TYPE_NOT_INTERSECTS:
-                $binds[":{$placeholder}_0"] = $this->convertArrayToWKT($query->getValues()[0]);
-                return "NOT ST_Intersects({$alias}.{$attribute}, " . $this->getSpatialGeomFromText(":{$placeholder}_0", null) . ")";
-
-            case Query::TYPE_OVERLAPS:
-                $binds[":{$placeholder}_0"] = $this->convertArrayToWKT($query->getValues()[0]);
-                return "ST_Overlaps({$alias}.{$attribute}, " . $this->getSpatialGeomFromText(":{$placeholder}_0", null) . ")";
-
-            case Query::TYPE_NOT_OVERLAPS:
-                $binds[":{$placeholder}_0"] = $this->convertArrayToWKT($query->getValues()[0]);
-                return "NOT ST_Overlaps({$alias}.{$attribute}, " . $this->getSpatialGeomFromText(":{$placeholder}_0", null) . ")";
-
-            case Query::TYPE_TOUCHES:
-                $binds[":{$placeholder}_0"] = $this->convertArrayToWKT($query->getValues()[0]);
-                return "ST_Touches({$alias}.{$attribute}, " . $this->getSpatialGeomFromText(":{$placeholder}_0", null) . ")";
-
-            case Query::TYPE_NOT_TOUCHES:
-                $binds[":{$placeholder}_0"] = $this->convertArrayToWKT($query->getValues()[0]);
-                return "NOT ST_Touches({$alias}.{$attribute}, " . $this->getSpatialGeomFromText(":{$placeholder}_0", null) . ")";
-
-            case Query::TYPE_EQUAL:
-                $binds[":{$placeholder}_0"] = $this->convertArrayToWKT($query->getValues()[0]);
-                return "ST_Equals({$alias}.{$attribute}, " . $this->getSpatialGeomFromText(":{$placeholder}_0", null) . ")";
-
-            case Query::TYPE_NOT_EQUAL:
-                $binds[":{$placeholder}_0"] = $this->convertArrayToWKT($query->getValues()[0]);
-                return "NOT ST_Equals({$alias}.{$attribute}, " . $this->getSpatialGeomFromText(":{$placeholder}_0", null) . ")";
-
-            case Query::TYPE_CONTAINS:
-                $binds[":{$placeholder}_0"] = $this->convertArrayToWKT($query->getValues()[0]);
-                return "ST_Contains({$alias}.{$attribute}, " . $this->getSpatialGeomFromText(":{$placeholder}_0", null) . ")";
-
-            case Query::TYPE_NOT_CONTAINS:
-                $binds[":{$placeholder}_0"] = $this->convertArrayToWKT($query->getValues()[0]);
-                return "NOT ST_Contains({$alias}.{$attribute}, " . $this->getSpatialGeomFromText(":{$placeholder}_0", null) . ")";
-
-            default:
-                throw new DatabaseException('Unknown spatial query method: ' . $query->getMethod());
-        }
-    }
-
-    /**
-     * Get SQL Condition
-     *
-     * @param Query $query
-     * @param array<string, mixed> $binds
-     * @return string
-     * @throws Exception
-     */
-    protected function getSQLCondition(Query $query, array &$binds): 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();
-
-        if ($query->isSpatialAttribute()) {
-            return $this->handleSpatialQueries($query, $binds, $attribute, $query->getAttributeType(), $alias, $placeholder);
-        }
-
-        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);
-                }
-
-                $method = strtoupper($query->getMethod());
-
-                return empty($conditions) ? '' : ' '. $method .' (' . implode(' AND ', $conditions) . ')';
+            $spatialAttributes = $this->getSpatialAttributes($collection);
+            $collection = $collection->getId();
+            $attributes = $document->getAttributes();
+            $attributes['_createdAt'] = $document->getCreatedAt();
+            $attributes['_updatedAt'] = $document->getUpdatedAt();
+            $attributes['_permissions'] = \json_encode($document->getPermissions());
+            $version = $document->getVersion();
+            if ($version !== null) {
+                $attributes['_version'] = $version;
+            }
 
-            case Query::TYPE_SEARCH:
-                $binds[":{$placeholder}_0"] = $this->getFulltextValue($query->getValue());
+            $name = $this->filter($collection);
 
-                return "MATCH({$alias}.{$attribute}) AGAINST (:{$placeholder}_0 IN BOOLEAN MODE)";
+            // Build document INSERT using query builder
+            // Spatial columns use insertColumnExpression() for ST_GeomFromText() wrapping
+            $builder = $this->createBuilder()->into($this->getSQLTableRaw($name));
+            $row = ['_uid' => $document->getId()];
 
-            case Query::TYPE_NOT_SEARCH:
-                $binds[":{$placeholder}_0"] = $this->getFulltextValue($query->getValue());
+            if (! empty($document->getSequence())) {
+                $row['_id'] = $document->getSequence();
+            }
 
-                return "NOT (MATCH({$alias}.{$attribute}) AGAINST (:{$placeholder}_0 IN BOOLEAN MODE))";
+            foreach ($attributes as $attr => $value) {
+                $column = $this->filter($attr);
 
-            case Query::TYPE_BETWEEN:
-                $binds[":{$placeholder}_0"] = $query->getValues()[0];
-                $binds[":{$placeholder}_1"] = $query->getValues()[1];
+                if (\in_array($attr, $spatialAttributes, true)) {
+                    if (\is_array($value)) {
+                        $value = $this->convertArrayToWKT($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;
+                }
+            }
 
-                return "{$alias}.{$attribute} BETWEEN :{$placeholder}_0 AND :{$placeholder}_1";
+            $row = $this->decorateRow($row, $this->documentMetadata($document));
+            $builder->set($row);
+            $result = $builder->insert();
+            $stmt = $this->executeResult($result, Event::DocumentCreate);
 
-            case Query::TYPE_NOT_BETWEEN:
-                $binds[":{$placeholder}_0"] = $query->getValues()[0];
-                $binds[":{$placeholder}_1"] = $query->getValues()[1];
+            $stmt->execute();
 
-                return "{$alias}.{$attribute} NOT BETWEEN :{$placeholder}_0 AND :{$placeholder}_1";
+            $document['$sequence'] = $this->pdo->lastInsertId();
 
-            case Query::TYPE_IS_NULL:
-            case Query::TYPE_IS_NOT_NULL:
+            if (empty($document['$sequence'])) {
+                throw new DatabaseException('Error creating document empty "$sequence"');
+            }
 
-                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 ($this->getSupportForJSONOverlaps() && $query->onArray()) {
-                    $binds[":{$placeholder}_0"] = json_encode($query->getValues());
-                    $isNot = $query->getMethod() === Query::TYPE_NOT_CONTAINS;
-                    return $isNot
-                        ? "NOT (JSON_OVERLAPS({$alias}.{$attribute}, :{$placeholder}_0))"
-                        : "JSON_OVERLAPS({$alias}.{$attribute}, :{$placeholder}_0)";
-                }
-                // 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->onArray()) ? \json_encode($value) : '%' . $this->escapeWildcards($value) . '%',
-                        Query::TYPE_NOT_CONTAINS => ($query->onArray()) ? \json_encode($value) : '%' . $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}";
-                    }
+            $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(), '_index1');
+
+                if (! $isOrphanedPermission) {
+                    throw $e;
                 }
 
-                $separator = $isNotQuery ? ' AND ' : ' OR ';
-                return empty($conditions) ? '' : '(' . implode($separator, $conditions) . ')';
+                // Clean up orphaned permissions from a previous failed delete, then retry
+                $cleanupBuilder = $this->newBuilder($name.'_perms');
+                $cleanupBuilder->filter([BaseQuery::equal('_document', [$document->getId()])]);
+                $cleanupResult = $cleanupBuilder->delete();
+                $cleanupStmt = $this->executeResult($cleanupResult);
+                $cleanupStmt->execute();
+
+                $this->runWriteHooks(fn ($hook) => $hook->afterDocumentCreate($name, [$document], $ctx));
+            }
+        } catch (PDOException $e) {
+            throw $this->processException($e);
         }
+
+        return $document;
     }
 
     /**
-     * Get SQL Type
+     * Update Document
      *
-     * @param string $type
-     * @param int $size
-     * @param bool $signed
-     * @param bool $array
-     * @param bool $required
-     * @return string
-     * @throws DatabaseException
+     * @throws Exception
+     * @throws PDOException
+     * @throws DuplicateException
+     * @throws \Throwable
      */
-    protected function getSQLType(string $type, int $size, bool $signed = true, bool $array = false, bool $required = false): string
+    public function updateDocument(Document $collection, string $id, Document $document, bool $skipPermissions): Document
     {
-        if (in_array($type, Database::SPATIAL_TYPES)) {
-            return $this->getSpatialSQLType($type, $required);
-        }
-        if ($array === true) {
-            return 'JSON';
-        }
-
-        switch ($type) {
-            case Database::VAR_ID:
-                return 'BIGINT UNSIGNED';
-
-            case Database::VAR_STRING:
-                // $size = $size * 4; // Convert utf8mb4 size to bytes
-                if ($size > 16777215) {
-                    return 'LONGTEXT';
-                }
+        try {
+            $this->syncWriteHooks();
 
-                if ($size > 65535) {
-                    return 'MEDIUMTEXT';
-                }
+            $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 ($size > $this->getMaxVarcharLength()) {
-                    return 'TEXT';
-                }
+            $version = $document->getVersion();
+            if ($version !== null) {
+                $attributes['_version'] = $version;
+            }
 
-                return "VARCHAR({$size})";
+            $name = $this->filter($collection);
 
-            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.');
+            $operators = [];
+            foreach ($attributes as $attribute => $value) {
+                if (Operator::isOperator($value)) {
+                    $operators[$attribute] = $value;
                 }
-                return "VARCHAR({$size})";
-
-            case Database::VAR_TEXT:
-                return 'TEXT';
-
-            case Database::VAR_MEDIUMTEXT:
-                return 'MEDIUMTEXT';
+            }
 
-            case Database::VAR_LONGTEXT:
-                return 'LONGTEXT';
+            $builder = $this->newBuilder($name);
+            $regularRow = ['_uid' => $document->getId()];
 
-            case Database::VAR_INTEGER:  // We don't support zerofill: https://stackoverflow.com/a/5634147/2299554
-                $signed = ($signed) ? '' : ' UNSIGNED';
+            foreach ($attributes as $attribute => $value) {
+                $column = $this->filter($attribute);
 
-                if ($size >= 8) { // INT = 4 bytes, BIGINT = 8 bytes
-                    return 'BIGINT' . $signed;
+                if (isset($operators[$attribute])) {
+                    $op = $operators[$attribute];
+                    if ($op instanceof Operator) {
+                        $opResult = $this->getOperatorBuilderExpression($column, $op);
+                        $builder->setRaw($column, $opResult['expression'], $opResult['bindings']);
+                    }
+                } elseif (\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;
                 }
+            }
 
-                return 'INT' . $signed;
-
-            case Database::VAR_FLOAT:
-                $signed = ($signed) ? '' : ' UNSIGNED';
-                return 'DOUBLE' . $signed;
-
-            case Database::VAR_BOOLEAN:
-                return 'TINYINT(1)';
-
-            case Database::VAR_RELATIONSHIP:
-                return 'VARCHAR(255)';
+            $builder->set($regularRow);
+            $builder->filter([BaseQuery::equal('_id', [$document->getSequence()])]);
+            $result = $builder->update();
+            $stmt = $this->executeResult($result, Event::DocumentUpdate);
 
-            case Database::VAR_DATETIME:
-                return 'DATETIME(3)';
+            $stmt->execute();
 
-            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_FLOAT . ', ' . Database::VAR_BOOLEAN . ', ' . Database::VAR_DATETIME . ', ' . Database::VAR_RELATIONSHIP . ', ' . Database::VAR_POINT . ', ' . Database::VAR_LINESTRING . ', ' . Database::VAR_POLYGON);
+            $ctx = $this->buildWriteContext($name);
+            $this->runWriteHooks(fn ($hook) => $hook->afterDocumentUpdate($name, $document, $skipPermissions, $ctx));
+        } catch (PDOException $e) {
+            throw $this->processException($e);
         }
-    }
 
-    /**
-     * Get PDO Type
-     *
-     * @param mixed $value
-     * @return int
-     * @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)),
-        };
+        return $document;
     }
 
     /**
-     * Get the SQL function for random ordering
+     * Set max execution time
      *
-     * @return string
+     * @throws DatabaseException
      */
-    protected function getRandomOrder(): string
+    public function setTimeout(int $milliseconds, Event $event = Event::All): void
     {
-        return 'RAND()';
+        if ($milliseconds <= 0) {
+            throw new DatabaseException('Timeout must be greater than 0');
+        }
+
+        $this->timeout = $milliseconds;
     }
 
     /**
      * Size of POINT spatial type
-     *
-     * @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
+    protected function execute(mixed $stmt): bool
     {
-        return new \DateTime('1000-01-01 00:00:00');
-    }
+        $seconds = $this->timeout > 0 ? $this->timeout / 1000 : 0;
+        $this->getPDO()->exec("SET max_statement_time = " . (float) $seconds);
 
-    public function getMaxDateTime(): \DateTime
-    {
-        return new \DateTime('9999-12-31 23:59:59');
+        /** @var \PDOStatement|PDOStatementProxy $stmt */
+        return $stmt->execute();
     }
 
     /**
-     * Is fulltext Wildcard index supported?
-     *
-     * @return bool
+     * {@inheritDoc}
      */
-    public function getSupportForFulltextWildcardIndex(): bool
+    protected function getConflictTenantExpression(string $column): string
     {
-        return true;
+        $quoted = $this->quote($this->filter($column));
+
+        return "IF(_tenant = VALUES(_tenant), VALUES({$quoted}), {$quoted})";
     }
 
     /**
-     * Does the adapter handle Query Array Overlaps?
-     *
-     * @return bool
+     * {@inheritDoc}
      */
-    public function getSupportForJSONOverlaps(): bool
+    protected function getConflictIncrementExpression(string $column): string
     {
-        return true;
-    }
+        $quoted = $this->quote($this->filter($column));
 
-    public function getSupportForIntegerBooleans(): bool
-    {
-        return true;
+        return "{$quoted} + VALUES({$quoted})";
     }
 
     /**
-     * Are timeouts supported?
-     *
-     * @return bool
+     * {@inheritDoc}
      */
-    public function getSupportForTimeouts(): bool
-    {
-        return true;
-    }
-
-    public function getSupportForUpserts(): bool
+    protected function getConflictTenantIncrementExpression(string $column): string
     {
-        return true;
-    }
+        $quoted = $this->quote($this->filter($column));
 
-    public function getSupportForSchemaAttributes(): bool
-    {
-        return true;
+        return "IF(_tenant = VALUES(_tenant), {$quoted} + VALUES({$quoted}), {$quoted})";
     }
 
-    public function getSupportForSchemaIndexes(): bool
+    /**
+     * 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
     {
-        return true;
-    }
+        /** @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];
 
-    public function getSchemaIndexes(string $collection): array
-    {
-        $schema = $this->getDatabase();
-        $collection = $this->getNamespace() . '_' . $this->filter($collection);
+        $useMeters = isset($distanceParams[2]) && $distanceParams[2] === true;
 
-        try {
-            $stmt = $this->getPDO()->prepare('
-                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
-            ');
-            $stmt->bindParam(':schema', $schema);
-            $stmt->bindParam(':table', $collection);
-            $stmt->execute();
-            $rows = $stmt->fetchAll();
-            $stmt->closeCursor();
+        $operator = match ($query->getMethod()) {
+            Method::DistanceEqual => '=',
+            Method::DistanceNotEqual => '!=',
+            Method::DistanceGreaterThan => '>',
+            Method::DistanceLessThan => '<',
+            default => throw new DatabaseException('Unknown spatial query method: '.$query->getMethod()->value),
+        };
 
-            $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;
+        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);
             }
 
-            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');
+            return "ST_DISTANCE_SPHERE({$alias}.{$attribute}, ".$this->getSpatialGeomFromText(":{$placeholder}_0", null).', '.Database::EARTH_RADIUS.") {$operator} :{$placeholder}_1";
         }
 
-        $this->timeout = $milliseconds;
-
-        $seconds = $milliseconds / 1000;
-
-        $this->before($event, 'timeout', function ($sql) use ($seconds) {
-            return "SET STATEMENT max_statement_time = {$seconds} FOR " . $sql;
-        });
+        return "ST_Distance({$alias}.{$attribute}, ".$this->getSpatialGeomFromText(":{$placeholder}_0", null).") {$operator} :{$placeholder}_1";
     }
 
     /**
-     * @return string
+     * Handle spatial queries
+     *
+     * @param  array<string, mixed>  $binds
      */
-    public function getConnectionId(): string
+    protected function handleSpatialQueries(Query $query, array &$binds, string $attribute, string $type, string $alias, string $placeholder): string
     {
-        $stmt = $this->getPDO()->query("SELECT CONNECTION_ID();");
-        return $stmt->fetchColumn();
+        /** @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),
+        };
     }
 
-    public function getInternalIndexesKeys(): array
+    protected function createBuilder(): SQLBuilder
     {
-        return ['primary', '_created_at', '_updated_at', '_tenant_id'];
+        return new MariaDBBuilder();
     }
 
-    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);
-        }
-
-        // 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) {
-            $message = $e->getMessage();
-            if (\str_contains($message, '_index1')) {
-                return new DuplicateException('Duplicate permissions for document', $e->getCode(), $e);
-            }
-            if (!\str_contains($message, '_uid')) {
-                return new DuplicateException('Document with the requested unique attributes already exists', $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] === 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);
-        }
+    /**
+     * Get the SQL function for random ordering.
+     */
+    protected function getRandomOrder(): string
+    {
+        return 'RAND()';
+    }
 
-        // Unknown database
-        if ($e->getCode() === '42000' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1049) {
-            return new NotFoundException('Database not found', $e->getCode(), $e);
-        }
+    /**
+     * Get Schema Attributes
+     *
+     * @return array<Document>
+     *
+     * @throws DatabaseException
+     */
+    public function getSchemaAttributes(string $collection): array
+    {
+        $schema = $this->getDatabase();
+        $collection = $this->getNamespace().'_'.$this->filter($collection);
 
-        // Unknown collection
-        if ($e->getCode() === '42S02' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1049) {
-            return new NotFoundException('Collection not found', $e->getCode(), $e);
-        }
+        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();
 
-        // 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);
-        }
+            $docs = [];
+            foreach ($results as $document) {
+                /** @var array<string, mixed> $document */
+                $document['$id'] = $document['_id'];
+                unset($document['_id']);
 
-        // Unknown column
-        if ($e->getCode() === '42000' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1091) {
-            return new NotFoundException('Attribute not found', $e->getCode(), $e);
-        }
+                $docs[] = new Document($document);
+            }
+            $results = $docs;
 
-        return $e;
-    }
+            return $results;
 
-    protected function quote(string $string): string
-    {
-        return "`{$string}`";
+        } catch (PDOException $e) {
+            throw new DatabaseException('Failed to get schema attributes', $e->getCode(), $e);
+        }
     }
 
     /**
      * Get operator SQL
      * Override to handle MariaDB/MySQL-specific operators
-     *
-     * @param string $column
-     * @param Operator $operator
-     * @param int &$bindIndex
-     * @return ?string
      */
     protected function getOperatorSQL(string $column, Operator $operator, int &$bindIndex): ?string
     {
@@ -2037,40 +1004,45 @@ protected function getOperatorSQL(string $column, Operator $operator, int &$bind
 
         switch ($method) {
             // Numeric operators
-            case Operator::TYPE_INCREMENT:
+            case OperatorType::Increment:
                 $bindKey = "op_{$bindIndex}";
                 $bindIndex++;
                 if (isset($values[1])) {
                     $maxKey = "op_{$bindIndex}";
                     $bindIndex++;
+
                     return "{$quotedColumn} = CASE
                         WHEN COALESCE({$quotedColumn}, 0) >= :$maxKey THEN :$maxKey
                         WHEN COALESCE({$quotedColumn}, 0) > :$maxKey - :$bindKey THEN :$maxKey
                         ELSE COALESCE({$quotedColumn}, 0) + :$bindKey
                     END";
                 }
+
                 return "{$quotedColumn} = COALESCE({$quotedColumn}, 0) + :$bindKey";
 
-            case Operator::TYPE_DECREMENT:
+            case OperatorType::Decrement:
                 $bindKey = "op_{$bindIndex}";
                 $bindIndex++;
                 if (isset($values[1])) {
                     $minKey = "op_{$bindIndex}";
                     $bindIndex++;
+
                     return "{$quotedColumn} = CASE
                         WHEN COALESCE({$quotedColumn}, 0) <= :$minKey THEN :$minKey
                         WHEN COALESCE({$quotedColumn}, 0) < :$minKey + :$bindKey THEN :$minKey
                         ELSE COALESCE({$quotedColumn}, 0) - :$bindKey
                     END";
                 }
+
                 return "{$quotedColumn} = COALESCE({$quotedColumn}, 0) - :$bindKey";
 
-            case Operator::TYPE_MULTIPLY:
+            case OperatorType::Multiply:
                 $bindKey = "op_{$bindIndex}";
                 $bindIndex++;
                 if (isset($values[1])) {
                     $maxKey = "op_{$bindIndex}";
                     $bindIndex++;
+
                     return "{$quotedColumn} = CASE
                         WHEN COALESCE({$quotedColumn}, 0) >= :$maxKey THEN :$maxKey
                         WHEN :$bindKey > 0 AND COALESCE({$quotedColumn}, 0) > :$maxKey / :$bindKey THEN :$maxKey
@@ -2078,32 +1050,37 @@ protected function getOperatorSQL(string $column, Operator $operator, int &$bind
                         ELSE COALESCE({$quotedColumn}, 0) * :$bindKey
                     END";
                 }
+
                 return "{$quotedColumn} = COALESCE({$quotedColumn}, 0) * :$bindKey";
 
-            case Operator::TYPE_DIVIDE:
+            case OperatorType::Divide:
                 $bindKey = "op_{$bindIndex}";
                 $bindIndex++;
                 if (isset($values[1])) {
                     $minKey = "op_{$bindIndex}";
                     $bindIndex++;
+
                     return "{$quotedColumn} = CASE
                         WHEN :$bindKey != 0 AND COALESCE({$quotedColumn}, 0) / :$bindKey <= :$minKey THEN :$minKey
                         ELSE COALESCE({$quotedColumn}, 0) / :$bindKey
                     END";
                 }
+
                 return "{$quotedColumn} = COALESCE({$quotedColumn}, 0) / :$bindKey";
 
-            case Operator::TYPE_MODULO:
+            case OperatorType::Modulo:
                 $bindKey = "op_{$bindIndex}";
                 $bindIndex++;
+
                 return "{$quotedColumn} = MOD(COALESCE({$quotedColumn}, 0), :$bindKey)";
 
-            case Operator::TYPE_POWER:
+            case OperatorType::Power:
                 $bindKey = "op_{$bindIndex}";
                 $bindIndex++;
                 if (isset($values[1])) {
                     $maxKey = "op_{$bindIndex}";
                     $bindIndex++;
+
                     return "{$quotedColumn} = CASE
                         WHEN COALESCE({$quotedColumn}, 0) >= :$maxKey THEN :$maxKey
                         WHEN COALESCE({$quotedColumn}, 0) <= 1 THEN COALESCE({$quotedColumn}, 0)
@@ -2111,65 +1088,73 @@ protected function getOperatorSQL(string $column, Operator $operator, int &$bind
                         ELSE POWER(COALESCE({$quotedColumn}, 0), :$bindKey)
                     END";
                 }
+
                 return "{$quotedColumn} = POWER(COALESCE({$quotedColumn}, 0), :$bindKey)";
 
                 // String operators
-            case Operator::TYPE_STRING_CONCAT:
+            case OperatorType::StringConcat:
                 $bindKey = "op_{$bindIndex}";
                 $bindIndex++;
+
                 return "{$quotedColumn} = CONCAT(COALESCE({$quotedColumn}, ''), :$bindKey)";
 
-            case Operator::TYPE_STRING_REPLACE:
+            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:
+            case OperatorType::ArrayAppend:
                 $bindKey = "op_{$bindIndex}";
                 $bindIndex++;
+
                 return "{$quotedColumn} = JSON_MERGE_PRESERVE(IFNULL({$quotedColumn}, JSON_ARRAY()), :$bindKey)";
 
-            case Operator::TYPE_ARRAY_PREPEND:
+            case OperatorType::ArrayPrepend:
                 $bindKey = "op_{$bindIndex}";
                 $bindIndex++;
+
                 return "{$quotedColumn} = JSON_MERGE_PRESERVE(:$bindKey, IFNULL({$quotedColumn}, JSON_ARRAY()))";
 
-            case Operator::TYPE_ARRAY_INSERT:
+            case OperatorType::ArrayInsert:
                 $indexKey = "op_{$bindIndex}";
                 $bindIndex++;
                 $valueKey = "op_{$bindIndex}";
                 $bindIndex++;
+
                 return "{$quotedColumn} = JSON_ARRAY_INSERT(
-                    {$quotedColumn}, 
-                    CONCAT('$[', :$indexKey, ']'), 
+                    {$quotedColumn},
+                    CONCAT('$[', :$indexKey, ']'),
                     JSON_EXTRACT(:$valueKey, '$')
                 )";
 
-            case Operator::TYPE_ARRAY_REMOVE:
+            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:
+            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
@@ -2179,9 +1164,10 @@ protected function getOperatorSQL(string $column, Operator $operator, int &$bind
                     )
                 ), JSON_ARRAY())";
 
-            case Operator::TYPE_ARRAY_DIFF:
+            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
@@ -2191,11 +1177,12 @@ protected function getOperatorSQL(string $column, Operator $operator, int &$bind
                     )
                 ), JSON_ARRAY())";
 
-            case Operator::TYPE_ARRAY_FILTER:
+            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
@@ -2213,167 +1200,170 @@ protected function getOperatorSQL(string $column, Operator $operator, int &$bind
                 ), JSON_ARRAY())";
 
                 // Date operators
-            case Operator::TYPE_DATE_ADD_DAYS:
+            case OperatorType::DateAddDays:
                 $bindKey = "op_{$bindIndex}";
                 $bindIndex++;
+
                 return "{$quotedColumn} = DATE_ADD({$quotedColumn}, INTERVAL :$bindKey DAY)";
 
-            case Operator::TYPE_DATE_SUB_DAYS:
+            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;
+        $attribute = $this->filter($this->getInternalKeyForAttribute($query->getAttribute()));
+        $attribute = $this->quote($attribute);
+        $quotedAlias = $this->quote($alias);
+        $searchVal = $query->getValue();
+        $term = $this->getFulltextValue(\is_string($searchVal) ? $searchVal : '');
+
+        return [
+            'expression' => "MATCH({$quotedAlias}.{$attribute}) AGAINST (? IN BOOLEAN MODE) AS `_relevance`",
+            'order' => '`_relevance` DESC',
+            'bindings' => [$term],
+        ];
     }
 
-    public function getSupportForIndexArray(): bool
+    public function getSupportForSchemaIndexes(): bool
     {
         return true;
     }
 
-    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->getPDO()->prepare('
+                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
+            ');
+            $stmt->bindParam(':schema', $schema);
+            $stmt->bindParam(':table', $collection);
+            $stmt->execute();
+            $rows = $stmt->fetchAll();
+            $stmt->closeCursor();
 
-    /**
-     * Are object (JSON) indexes supported?
-     *
-     * @return bool
-     */
-    public function getSupportForObjectIndexes(): bool
-    {
-        return false;
-    }
+            $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;
+            }
 
-    /**
-     * Get Support for Null Values in Spatial Indexes
-     *
-     * @return bool
-     */
-    public function getSupportForSpatialIndexNull(): 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);
+        }
     }
-    /**
-     * 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
+    protected function processException(PDOException $e): Exception
     {
-        return true;
-    }
+        if ($e->getCode() === '22007' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1366) {
+            return new CharacterException('Invalid character', $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;
-    }
+        // Timeout
+        if ($e->getCode() === '70100' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1969) {
+            return new TimeoutException('Query timed out', $e->getCode(), $e);
+        }
 
-    public function getSpatialSQLType(string $type, bool $required): string
-    {
-        $srid = Database::DEFAULT_SRID;
-        $nullability = '';
+        // Duplicate table
+        if ($e->getCode() === '42S01' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1050) {
+            return new DuplicateException('Collection already exists', $e->getCode(), $e);
+        }
 
-        if (!$this->getSupportForSpatialIndexNull()) {
-            if ($required) {
-                $nullability = ' NOT NULL';
-            } else {
-                $nullability = ' NULL';
-            }
+        // Duplicate column
+        if ($e->getCode() === '42S21' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1060) {
+            return new DuplicateException('Attribute already exists', $e->getCode(), $e);
         }
 
-        switch ($type) {
-            case Database::VAR_POINT:
-                return "POINT($srid)$nullability";
+        // Duplicate index
+        if ($e->getCode() === '42000' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1061) {
+            return new DuplicateException('Index already exists', $e->getCode(), $e);
+        }
 
-            case Database::VAR_LINESTRING:
-                return "LINESTRING($srid)$nullability";
+        // Duplicate row
+        if ($e->getCode() === '23000' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1062) {
+            $message = $e->getMessage();
+            if (\str_contains($message, '_index1')) {
+                return new DuplicateException('Duplicate permissions for document', $e->getCode(), $e);
+            }
+            if (! \str_contains($message, '_uid')) {
+                return new DuplicateException('Document with the requested unique attributes already exists', $e->getCode(), $e);
+            }
 
-            case Database::VAR_POLYGON:
-                return "POLYGON($srid)$nullability";
+            return new DuplicateException('Document already exists', $e->getCode(), $e);
         }
 
-        return '';
-    }
-
-    /**
-     * Does the adapter support spatial axis order specification?
-     *
-     * @return bool
-     */
-    public function getSupportForSpatialAxisOrder(): bool
-    {
-        return false;
-    }
+        // 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);
+        }
 
-    /**
-     * Adapter supports optional spatial attributes with existing rows.
-     *
-     * @return bool
-     */
-    public function getSupportForOptionalSpatialAttributeWithExistingRows(): bool
-    {
-        return true;
-    }
+        // 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);
+        }
 
-    public function getSupportForAlterLocks(): bool
-    {
-        return true;
-    }
+        // 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);
+        }
 
-    public function getSupportNonUtfCharacters(): 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 getSupportForTrigramIndex(): bool
-    {
-        return false;
-    }
+        // 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 getSupportForPCRERegex(): 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 getSupportForPOSIXRegex(): 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 getSupportForTTLIndexes(): bool
-    {
-        return false;
+        return $e;
     }
 }
diff --git a/src/Database/Adapter/Mongo.php b/src/Database/Adapter/Mongo.php
index b462d1c28..62d7be677 100644
--- a/src/Database/Adapter/Mongo.php
+++ b/src/Database/Adapter/Mongo.php
@@ -2,26 +2,49 @@
 
 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\Duplicate as DuplicateException;
 use Utopia\Database\Exception\Timeout as TimeoutException;
 use Utopia\Database\Exception\Transaction as TransactionException;
 use Utopia\Database\Exception\Type as TypeException;
+use Utopia\Database\Hook\MongoPermissionFilter;
+use Utopia\Database\Hook\MongoTenantFilter;
+use Utopia\Database\Hook\Read;
+use Utopia\Database\Hook\Tenant;
+use Utopia\Database\Index;
+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\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>
@@ -45,11 +68,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
      */
@@ -57,10 +85,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;
 
     /**
@@ -68,7 +99,6 @@ class Mongo extends Adapter
      *
      * Set connection and settings
      *
-     * @param Client $client
      * @throws MongoException
      */
     public function __construct(Client $client)
@@ -77,97 +107,176 @@ public function __construct(Client $client)
         $this->client->connect();
     }
 
-    public function setTimeout(int $milliseconds, string $event = Database::EVENT_ALL): void
+    /**
+     * Get the list of capabilities supported by the MongoDB adapter.
+     *
+     * @return array<Capability>
+     */
+    public function capabilities(): array
     {
-        if (!$this->getSupportForTimeouts()) {
-            return;
-        }
+        return array_merge(parent::capabilities(), [
+            Capability::Objects,
+            Capability::Fulltext,
+            Capability::TTLIndexes,
+            Capability::Regex,
+            Capability::BatchCreateAttributes,
+            Capability::Hostname,
+            Capability::PCRE,
+        ]);
+    }
 
+    /**
+     * Set the maximum execution time for queries.
+     *
+     * @param int $milliseconds Timeout in milliseconds
+     * @param Event $event The event scope for the timeout
+     * @return void
+     */
+    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
+     */
+    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;
+
+        return $this->supportForAttributes;
+    }
+
+    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),
+            );
         }
 
-        // MongoDB doesn't support nested transactions/savepoints.
-        // If already in a transaction, just run the callback directly.
-        if ($this->inTransaction > 0) {
-            return $callback();
+        if ($this->hasPermissionHook()) {
+            $this->readHooks[] = new MongoPermissionFilter($this->authorization);
         }
+    }
 
-        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);
+        }
 
-            throw $action;
+        return $filters;
+    }
+
+    /**
+     * 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,
+        ]);
+
+        if ($result instanceof \stdClass && isset($result->ok)) {
+            return (bool) $result->ok;
         }
+
+        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;
         }
 
@@ -177,7 +286,7 @@ public function commitTransaction(): bool
             }
             $this->inTransaction--;
             if ($this->inTransaction === 0) {
-                if (!$this->session) {
+                if (! $this->session) {
                     return false;
                 }
                 try {
@@ -190,10 +299,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) {
@@ -204,24 +314,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;
         }
 
@@ -231,13 +351,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) {
@@ -254,85 +374,78 @@ 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>
-     */
-    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  callable(): T  $callback
+     * @return T
      *
-     * @param string $value The user input to escape
-     * @param string $pattern The pattern template (e.g., ".*%s.*" for contains)
-     * @return Regex
-     * @throws DatabaseException
+     * @throws Throwable
      */
-    private function createSafeRegex(string $value, string $pattern = '%s', string $flags = 'i'): Regex
+    public function withTransaction(callable $callback): mixed
     {
-        $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');
+        // If the database is not a replica set, we can't use transactions
+        if (! $this->client->isReplicaSet()) {
+            return $callback();
         }
 
-        $finalPattern = sprintf($pattern, $escaped);
+        // MongoDB doesn't support nested transactions/savepoints.
+        // If already in a transaction, just run the callback directly.
+        if ($this->inTransaction > 0) {
+            return $callback();
+        }
 
-        return new Regex($finalPattern, $flags);
-    }
+        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) {
+                // 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 {
+                        /** @var array<string, mixed> $session */
+                        $session = $this->session;
+                        $this->client->endSessions([$session]);
+                    } catch (Throwable $endSessionError) {
+                        // Ignore errors when ending session during error cleanup
+                    }
+                }
+                $this->inTransaction = 0;
+                $this->session = null;
+            }
 
-    public function reconnect(): void
-    {
-        $this->client->connect();
+            throw $action;
+        }
     }
 
     /**
      * Create Database
-     *
-     * @param string $name
-     *
-     * @return bool
      */
     public function create(string $name): bool
     {
@@ -343,25 +456,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;
             }
         }
@@ -373,13 +490,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;
         }
 
@@ -389,9 +512,7 @@ public function list(): array
     /**
      * Delete Database
      *
-     * @param string $name
      *
-     * @return bool
      * @throws Exception
      */
     public function delete(string $name): bool
@@ -404,20 +525,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;
         }
 
@@ -426,6 +546,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) {
                 return true;
@@ -445,7 +569,7 @@ public function createCollection(string $name, array $attributes = [], array $in
 
         $internalIndex = [
             [
-                'key' => ['_uid' => $this->getOrder(Database::ORDER_ASC)],
+                'key' => ['_uid' => $this->getOrder(OrderDirection::Asc)],
                 'name' => '_uid',
                 'unique' => true,
                 'collation' => [
@@ -454,22 +578,22 @@ public function createCollection(string $name, array $attributes = [], array $in
                 ],
             ],
             [
-                'key' => ['_createdAt' => $this->getOrder(Database::ORDER_ASC)],
+                'key' => ['_createdAt' => $this->getOrder(OrderDirection::Asc)],
                 'name' => '_createdAt',
             ],
             [
-                'key' => ['_updatedAt' => $this->getOrder(Database::ORDER_ASC)],
+                'key' => ['_updatedAt' => $this->getOrder(OrderDirection::Asc)],
                 'name' => '_updatedAt',
             ],
             [
-                'key' => ['_permissions' => $this->getOrder(Database::ORDER_ASC)],
+                'key' => ['_permissions' => $this->getOrder(OrderDirection::Asc)],
                 'name' => '_permissions',
-            ]
+            ],
         ];
 
         if ($this->sharedTables) {
             foreach ($internalIndex as &$index) {
-                $index['key'] = array_merge(['_tenant' => $this->getOrder(Database::ORDER_ASC)], $index['key']);
+                $index['key'] = array_merge(['_tenant' => $this->getOrder(OrderDirection::Asc)], $index['key']);
             }
             unset($index);
         }
@@ -477,18 +601,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]
              */
@@ -501,32 +625,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['_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(\strtoupper((string) ($orders[$j] ?? ''))) ?? 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(\strtoupper((string) ($orders[$j] ?? ''))) ?? 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(\strtoupper((string) ($orders[$j] ?? ''))) ?? OrderDirection::Asc);
                             break;
                         default:
                             // index not supported
@@ -538,34 +661,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;
                             }
                         }
@@ -575,10 +699,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;
                     }
                 }
@@ -586,12 +710,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;
             }
         }
@@ -603,79 +727,41 @@ 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;
         }
 
         return $list;
     }
 
-    /**
-     * Get Collection Size on disk
-     * @param string $collection
-     * @return int
-     * @throws DatabaseException
-     */
-    public function getSizeOfCollectionOnDisk(string $collection): int
-    {
-        return $this->getSizeOfCollection($collection);
-    }
-
-    /**
-     * Get Collection Size of raw data
-     * @param string $collection
-     * @return int
-     * @throws DatabaseException
-     */
-    public function getSizeOfCollection(string $collection): int
-    {
-        $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());
-        }
-    }
-
     /**
      * Delete Collection
      *
-     * @param string $id
-     * @return bool
      * @throws Exception
      */
     public function deleteCollection(string $id): bool
     {
-        $id = $this->getNamespace() . '_' . $this->filter($id);
-        return (!!$this->getClient()->dropCollection($id));
+        $id = $this->getNamespace().'_'.$this->filter($id);
+
+        return (bool) $this->getClient()->dropCollection($id);
     }
 
     /**
      * Analyze a collection updating it's metadata on the database engine
-     *
-     * @param string $collection
-     * @return bool
      */
     public function analyzeCollection(string $collection): bool
     {
@@ -684,16 +770,8 @@ 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
      */
-    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 true;
     }
@@ -701,9 +779,8 @@ 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
@@ -711,19 +788,28 @@ public function createAttributes(string $collection, array $attributes): bool
         return true;
     }
 
+    /**
+     * Update Attribute.
+     */
+    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,
@@ -738,19 +824,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(
@@ -765,100 +847,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:
+            case RelationType::ManyToMany:
                 $metadataCollection = new Document(['$id' => Database::METADATA]);
-                $collectionDoc = $this->getDocument($metadataCollection, $collection);
-                $relatedCollectionDoc = $this->getDocument($metadataCollection, $relatedCollection);
+                $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;
@@ -870,71 +933,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:
+            case RelationType::ManyToMany:
                 $metadataCollection = new Document(['$id' => Database::METADATA]);
-                $collectionDoc = $this->getDocument($metadataCollection, $collection);
-                $relatedCollectionDoc = $this->getDocument($metadataCollection, $relatedCollection);
+                $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;
@@ -948,34 +997,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
+    public function createIndex(string $collection, Index $index, array $indexAttributeTypes = [], array $collation = []): bool
     {
-        $name = $this->getNamespace() . '_' . $this->filter($collection);
-        $id = $this->filter($id);
+        $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['_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);
@@ -983,33 +1034,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(\strtoupper((string) ($orders[$i] ?? ''))) ?? 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,
@@ -1021,24 +1074,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 = ColumnType::tryFrom($indexAttributeTypes[$i] ?? '') ?? ColumnType::String;
                 $attrType = $this->getMongoTypeCode($attrType);
                 $partialFilter[$attr] = ['$exists' => true, '$type' => $attrType];
             }
-            if (!empty($partialFilter)) {
+            if (! empty($partialFilter)) {
                 $indexes['partialFilterExpression'] = $partialFilter;
             }
         }
@@ -1048,7 +1101,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
@@ -1056,26 +1109,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
                             );
@@ -1083,7 +1141,7 @@ public function createIndex(string $collection, string $id, string $type, array
                     }
 
                     $delay = \min($baseDelay * (2 ** $retryCount), $maxDelay);
-                    \usleep((int)$delay);
+                    \usleep((int) $delay);
                     $retryCount++;
                 }
 
@@ -1091,19 +1149,30 @@ 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
@@ -1113,11 +1182,17 @@ public function renameIndex(string $collection, string $old, string $new): bool
         $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['$id'] ?? $node['key'] ?? '';
+            $nodeIdStr = \is_string($nodeId) ? $nodeId : (\is_scalar($nodeId) ? (string) $nodeId : '');
+            if ($nodeIdStr === $old) {
                 $index = $node;
                 break;
             }
@@ -1125,14 +1200,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;
                         }
                     }
@@ -1141,12 +1224,29 @@ 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'] ?? [];
+            /** @var array<string> $indexOrders */
+            $indexOrders = $index['orders'] ?? [];
+            $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, new Index(
+                key: $new,
+                type: IndexType::from($indexTypeStr),
+                attributes: $indexAttributes,
+                lengths: $indexLengths,
+                orders: $indexOrders,
+                ttl: $indexTtlInt,
+            ), $indexAttributeTypes);
+        } catch (Exception $e) {
             throw $this->processException($e);
         }
 
@@ -1157,56 +1257,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());
-        }
-
+        $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);
         }
@@ -1215,13 +1296,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);
         }
 
@@ -1231,28 +1313,26 @@ 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();
+
+        $name = $this->getNamespace().'_'.$this->filter($collection->getId());
 
         $sequence = $document->getSequence();
 
         $document->removeAttribute('$sequence');
 
-        if ($this->sharedTables) {
-            $document->setAttribute('$tenant', $this->getTenant());
-        }
-
-        $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)) {
+        if (! empty($sequence)) {
             $record['_id'] = $sequence;
         }
         $options = $this->getTransactionOptions();
@@ -1266,186 +1346,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;
-            }
-
-            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:
-                        $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) {
-            return array_map($this->convertStdClassToArray(...), get_object_vars($value));
-        }
-
-        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;
-            }
-
-            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)) {
-                            $node = new UTCDateTime(new \DateTime($node));
-                        }
-                        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
@@ -1453,7 +1357,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 = [];
@@ -1464,14 +1370,17 @@ 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)) {
+            if (! empty($sequence)) {
                 $record['_id'] = $sequence;
             }
 
@@ -1485,74 +1394,32 @@ 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]);
         }
 
         return $documents;
     }
 
-    /**
-     *
-     * @param string $name
-     * @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 {
-            $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 = ['_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
@@ -1574,34 +1441,32 @@ 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('$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['_version']);
 
         $updateQuery = [
             '$set' => $record,
+            '$inc' => ['_version' => 1],
         ];
 
         try {
@@ -1618,10 +1483,9 @@ public function updateDocuments(Document $collection, Document $updates, array $
     }
 
     /**
-     * @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
@@ -1630,43 +1494,41 @@ 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 = [];
             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())) {
+                if (! empty($document->getSequence())) {
                     $attributes['_id'] = $document->getSequence();
                 }
 
-                if ($this->sharedTables) {
-                    $attributes['_tenant'] = $document->getTenant();
-                }
-
                 $record = $this->replaceChars('$', '_', $attributes);
+                $record = $this->decorateRow($record, $this->documentMetadata($document));
 
                 // Build filter for upsert
                 $filters = ['_uid' => $document->getId()];
-
-                if ($this->sharedTables) {
-                    $filters['_tenant'] = $this->getTenantFilters($collection->getId());
-                }
+                $filters = $this->applyReadFilters($filters, $collection->getId());
 
                 unset($record['_id']); // 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;
 
@@ -1680,26 +1542,26 @@ 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 {
                     // 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()
+                            '_id' => $this->client->createUuid(),
                         ];
                     }
                 }
@@ -1725,136 +1587,67 @@ 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 = [];
+        $name = $this->getNamespace().'_'.$this->filter($collection);
 
-        if ($this->getSupportForAttributes() || $oldDocument->isEmpty()) {
-            return $unsetFields;
-        }
-
-        $oldUserAttributes = $oldDocument->getAttributes();
-        $newUserAttributes = $newDocument->getAttributes();
-
-        $protectedFields = ['_uid', '_id', '_createdAt', '_updatedAt', '_permissions', '_tenant'];
-
-        foreach ($oldUserAttributes as $originalKey => $originalValue) {
-            if (in_array($originalKey, $protectedFields) || array_key_exists($originalKey, $newUserAttributes)) {
-                continue;
-            }
+        $filters = ['_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, '_id', $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
@@ -1864,24 +1657,25 @@ public function increaseDocumentAttribute(string $collection, string $id, string
         $attribute = $this->filter($attribute);
         $filters = ['_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],
@@ -1896,157 +1690,41 @@ public function increaseDocumentAttribute(string $collection, string $id, string
         return true;
     }
 
-    /**
-     * Delete Document
-     *
-     * @param string $collection
-     * @param string $id
-     *
-     * @return bool
-     * @throws Exception
-     */
-    public function deleteDocument(string $collection, string $id): bool
-    {
-        $name = $this->getNamespace() . '_' . $this->filter($collection);
-
-        $filters = [];
-        $filters['_uid'] = $id;
-
-        if ($this->sharedTables) {
-            $filters['_tenant'] = $this->getTenantFilters($collection);
-        }
-
-        $options = $this->getTransactionOptions();
-        $result = $this->client->delete($name, $filters, 1, [], $options);
-
-        return (!!$result);
-    }
-
-    /**
-     * 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);
-
-        foreach ($sequences as $index => $sequence) {
-            $sequences[$index] = $sequence;
-        }
-
-        $filters = $this->buildFilters([new Query(Query::TYPE_EQUAL, '_id', $sequences)]);
-
-        if ($this->sharedTables) {
-            $filters['_tenant'] = $this->getTenantFilters($collection);
-        }
-
-        $filters = $this->replaceInternalIdsKeys($filters, '$', '_', $this->operators);
-
-        $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',
-            '$permissions' => '_permissions',
-            default => $attribute
-        };
-    }
-
-
     /**
      * 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
-     *
+     * @param  array<Query>  $queries
+     * @param  array<string>  $orderAttributes
+     * @param  array<OrderDirection>  $orderTypes
+     * @param  array<string, mixed>  $cursor
      * @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
+    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->getId());
+        $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);
 
+        /** @var array<string, mixed> $filters */
         $filters = $this->buildFilters($queries);
 
-        if ($this->sharedTables) {
-            $filters['_tenant'] = $this->getTenantFilters($collection->getId());
-        }
-
-        // permissions
-        if ($this->authorization->getStatus()) {
-            $roles = \implode('|', $this->authorization->getRoles());
-            $filters['_permissions']['$in'] = [new Regex("{$forPermission}\\(\"(?:{$roles})\"\\)", 'i')];
-        }
+        $this->syncReadHooks();
+        $filters = $this->applyReadFilters($filters, $collection->getId(), $forPermission->value);
 
         $options = [];
 
-        if (!\is_null($limit)) {
+        if (! \is_null($limit)) {
             $options['limit'] = $limit;
         }
-        if (!\is_null($offset)) {
+        if (! \is_null($offset)) {
             $options['skip'] = $offset;
         }
 
@@ -2055,7 +1733,7 @@ public function find(Document $collection, array $queries = [], ?int $limit = 25
         }
 
         $selections = $this->getAttributeSelections($queries);
-        $hasProjection = !empty($selections) && !\in_array('*', $selections);
+        $hasProjection = ! empty($selections) && ! \in_array('*', $selections);
         if ($hasProjection) {
             $options['projection'] = $this->getAttributeProjection($selections);
         }
@@ -2064,31 +1742,34 @@ public function find(Document $collection, array $queries = [], ?int $limit = 25
         $options = $this->getTransactionOptions($options);
 
         $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++) {
@@ -2096,7 +1777,7 @@ public function find(Document $collection, array $queries = [], ?int $limit = 25
                     $prevAttr = $this->filter($this->getInternalKeyForAttribute($originalPrev));
                     $tmp = $cursor[$originalPrev];
                     $andConditions[] = [
-                        $prevAttr => $tmp
+                        $prevAttr => $tmp,
                     ];
                 }
 
@@ -2106,7 +1787,7 @@ public function find(Document $collection, array $queries = [], ?int $limit = 25
                     /** If there is only $sequence attribute in $orderAttributes skip Or And  operators **/
                     if (count($orderAttributes) === 1) {
                         $filters[$attribute] = [
-                            $operator => $tmp
+                            $operator => $tmp,
                         ];
                         break;
                     }
@@ -2114,24 +1795,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 {
@@ -2139,31 +1822,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);
@@ -2173,20 +1888,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);
             }
@@ -2195,83 +1910,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_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);
 
@@ -2281,7 +1929,7 @@ public function count(Document $collection, array $queries = [], ?int $max = nul
         $filters = [];
         $options = [];
 
-        if (!\is_null($max) && $max > 0) {
+        if (! \is_null($max) && $max > 0) {
             $options['limit'] = $max;
         }
 
@@ -2290,17 +1938,11 @@ public function count(Document $collection, array $queries = [], ?int $max = nul
         }
 
         // Build filters from queries
+        /** @var array<string, mixed> $filters */
         $filters = $this->buildFilters($queries);
 
-        if ($this->sharedTables) {
-            $filters['_tenant'] = $this->getTenantFilters($collection->getId());
-        }
-
-        // Add permissions filter if authorization is enabled
-        if ($this->authorization->getStatus()) {
-            $roles = \implode('|', $this->authorization->getRoles());
-            $filters['_permissions']['$in'] = [new Regex("read\\(\"(?:{$roles})\"\\)", 'i')];
-        }
+        $this->syncReadHooks();
+        $filters = $this->applyReadFilters($filters, $collection->getId());
 
         /**
          * Use MongoDB aggregation pipeline for accurate counting
@@ -2310,34 +1952,33 @@ 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();
         $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]]
+                    'total' => ['$sum' => 1]],
             ];
         } else {
             // When no limit is passed, use $count for better performance
             $pipeline[] = [
-                '$count' => 'total'
+                '$count' => 'total',
             ];
         }
 
@@ -2346,12 +1987,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);
+                    }
                 }
             }
 
@@ -2361,36 +2011,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
-            $roles = \implode('|', $this->authorization->getRoles());
-            $filters['_permissions']['$in'] = [new Regex("read\\(\"(?:{$roles})\"\\)", 'i')];
-        }
+        $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/
@@ -2401,1082 +2039,1225 @@ 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],
+                'total' => ['$sum' => '$'.$attribute],
             ],
         ];
 
         $options = $this->getTransactionOptions();
-        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;
     }
 
     /**
-     * @return Client
+     * Get sequences for documents that were created
      *
-     * @throws Exception
+     * @param  array<Document>  $documents
+     * @return array<Document>
+     *
+     * @throws DatabaseException
+     * @throws MongoException
      */
-    protected function getClient(): Client
+    public function getSequences(string $collection, array $documents): array
     {
-        return $this->client;
-    }
-
-    /**
-     * Escape a field name for MongoDB storage.
-     * MongoDB field names cannot start with $ or contain dots.
-     *
-     * @param string $name
-     * @return string
-     */
-    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;
-    }
+        $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;
-        }
-
-        foreach ($queries as $query) {
-            $attr = $query->getAttribute();
-            if (isset($dotAttributes[$attr])) {
-                $query->setAttribute($dotAttributes[$attr]);
-            }
+        if (empty($documentIds)) {
+            return $documents;
         }
-    }
 
-    /**
-     * 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'] ?? '';
+        $sequences = [];
+        $name = $this->getNamespace().'_'.$this->filter($collection);
 
-                // 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,
-                };
+        $filters = ['_uid' => ['$in' => $documentIds]];
 
-                if ($storesData) {
-                    $document->setAttribute($key, null);
-                }
-            }
+        if ($this->sharedTables) {
+            $filters['_tenant'] = $this->getTenantFilters($collection, $documentTenants);
         }
-    }
+        try {
+            // Use cursor paging for large result sets
+            $options = [
+                'projection' => ['_uid' => 1, '_id' => 1],
+                'batchSize' => self::DEFAULT_BATCH_SIZE,
+            ];
 
-    /**
-     * 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'
-        ];
+            $options = $this->getTransactionOptions($options);
+            $response = $this->client->find($name, $filters, $options);
+            /** @var \stdClass $responseCursor */
+            $responseCursor = $response->cursor;
+            /** @var array<\stdClass> $results */
+            $results = $responseCursor->firstBatch ?? [];
 
-        // 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);
+            // Process first batch
+            foreach ($results as $result) {
+                /** @var \stdClass $result */
+                /** @var mixed $uid */
+                $uid = $result->_uid;
+                /** @var mixed $oid */
+                $oid = $result->_id;
+                $uidStr = \is_string($uid) ? $uid : (\is_scalar($uid) ? (string) $uid : '');
+                $oidStr = \is_string($oid) ? $oid : (\is_scalar($oid) ? (string) $oid : '');
+                $sequences[$uidStr] = $oidStr;
             }
 
-            $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 (\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));
+            // 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;
+                }
             }
 
-            // 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);
-            }
+            // 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 ?? [];
 
-            if ($newKey !== $k) {
-                $keysToRename[$k] = $newKey;
-            }
-        }
+                if (empty($moreResults)) {
+                    break;
+                }
 
-        foreach ($keysToRename as $oldKey => $newKey) {
-            $array[$newKey] = $array[$oldKey];
-            unset($array[$oldKey]);
-        }
+                foreach ($moreResults as $result) {
+                    /** @var \stdClass $result */
+                    /** @var mixed $uid */
+                    $uid = $result->_uid;
+                    /** @var mixed $oid */
+                    $oid = $result->_id;
+                    $uidStr = \is_string($uid) ? $uid : (\is_scalar($uid) ? (string) $uid : '');
+                    $oidStr = \is_string($oid) ? $oid : (\is_scalar($oid) ? (string) $oid : '');
+                    $sequences[$uidStr] = $oidStr;
+                }
 
-        // 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']);
+                // 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;
+                }
             }
-            if (isset($array['$tenant'])) {
-                $array['_tenant'] = $array['$tenant'];
-                unset($array['$tenant']);
+        } catch (MongoException $e) {
+            throw $this->processException($e);
+        }
+
+        foreach ($documents as $document) {
+            if (isset($sequences[$document->getId()])) {
+                $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'];
+        return 2147483647;
+    }
 
-        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;
-                }
+    /**
+     * Get max INT limit
+     */
+    public function getLimitForInt(): int
+    {
+        // Mongo does not handle integers directly, so using MariaDB limit for now
+        return 4294967295;
+    }
 
-                $operator = $this->getQueryOperator($query->getMethod());
+    /**
+     * Get maximum column limit.
+     * Returns 0 to indicate no limit
+     */
+    public function getLimitForAttributes(): int
+    {
+        return 0;
+    }
 
-                $filters[$separator][] = $this->buildFilters($query->getValues(), $operator);
-            } else {
-                $filters[$separator][] = $this->buildFilter($query);
-            }
-        }
+    /**
+     * Get maximum index limit.
+     * https://docs.mongodb.com/manual/reference/limits/#mongodb-limit-Number-of-Indexes-per-Collection
+     */
+    public function getLimitForIndexes(): int
+    {
+        return 64;
+    }
 
-        return $filters;
+    /**
+     * Get the maximum combined index key length in bytes.
+     *
+     * @return int
+     */
+    public function getMaxIndexLength(): int
+    {
+        return 1024;
     }
 
     /**
-     * @param Query $query
-     * @return array<mixed>
-     * @throws Exception
+     * Get the maximum VARCHAR length. MongoDB has no distinction, so returns the same as string limit.
+     *
+     * @return int
      */
-    protected function buildFilter(Query $query): array
+    public function getMaxVarcharLength(): 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);
-        }
+        return 2147483647;
+    }
 
-        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;
-    }
+    /**
+     * Get the maximum length for unique document IDs.
+     *
+     * @return int
+     */
+    public function getMaxUIDLength(): int
+    {
+        return 255;
+    }
 
     /**
-     * @param Query $query
-     * @param array<string, mixed> $filter
-     * @return void
+     * Get the minimum supported datetime value for MongoDB.
+     *
+     * @return NativeDateTime
      */
-    private function handleObjectFilters(Query $query, array &$filter): void
+    public function getMinDateTime(): NativeDateTime
     {
-        $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 new NativeDateTime('-9999-01-01 00:00:00');
     }
 
     /**
-     * Flatten a nested associative array into Mongo-style dot notation.
-     *
-     * @param string $key
-     * @param mixed $value
-     * @param string $prefix
-     * @return array<string, mixed>
+     * Get current attribute count from collection document
      */
-    private function flattenWithDotNotation(string $key, mixed $value, string $prefix = ''): array
+    public function getCountOfAttributes(Document $collection): 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;
-            }
-        }
+        $rawAttrCount = $collection->getAttribute('attributes');
+        $attrArray = \is_array($rawAttrCount) ? $rawAttrCount : [];
+        $attributes = \count($attrArray);
 
-        return $result;
+        return $attributes + static::getCountOfDefaultAttributes();
     }
 
     /**
-     * Get Query Operator
-     *
-     * @param string $operator
-     *
-     * @return string
-     * @throws Exception
+     * Get current index count from collection document
      */
-    protected function getQueryOperator(string $operator): string
+    public function getCountOfIndexes(Document $collection): 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),
-        };
-    }
+        $rawIdxCount = $collection->getAttribute('indexes');
+        $idxArray = \is_array($rawIdxCount) ? $rawIdxCount : [];
+        $indexes = \count($idxArray);
 
-    protected function getQueryValue(string $method, mixed $value): mixed
-    {
-        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 $indexes + static::getCountOfDefaultIndexes();
     }
 
     /**
-     * Get Mongo Order
-     *
-     * @param string $order
-     *
-     * @return int
-     * @throws Exception
+     * Returns number of attributes used by default.
+     *p
      */
-    protected function getOrder(string $order): int
+    public function getCountOfDefaultAttributes(): 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 \count(Database::internalAttributes());
     }
 
     /**
-     * Check if tenant should be added to index
-     *
-     * @param Document|string $indexOrType Index document or index type string
-     * @return bool
+     * Returns number of indexes used by default.
      */
-    protected function shouldAddTenantToIndex(Document|string $indexOrType): bool
+    public function getCountOfDefaultIndexes(): int
     {
-        if (!$this->sharedTables) {
-            return false;
-        }
-
-        $indexType = $indexOrType instanceof Document
-            ? $indexOrType->getAttribute('type')
-            : $indexOrType;
-
-        return $indexType !== Database::INDEX_TTL;
+        return \count(Database::INTERNAL_INDEXES);
     }
 
     /**
-     * @param array<string> $selections
-     * @param string $prefix
-     * @return mixed
+     * Get maximum width, in bytes, allowed for a SQL row
+     * Return 0 when no restrictions apply
      */
-    protected function getAttributeProjection(array $selections, string $prefix = ''): mixed
+    public function getDocumentSizeLimit(): 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;
-
-        return $projection;
+        return 0;
     }
 
     /**
-     * Get max STRING limit
-     *
-     * @return int
+     * 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 getLimitForString(): int
+    public function getAttributeWidth(Document $collection): int
     {
-        return 2147483647;
+        return 0;
     }
 
     /**
-     * Get max VARCHAR limit
-     * MongoDB doesn't distinguish between string types, so using same as string limit
+     * Get reserved keywords that cannot be used as identifiers. MongoDB has none.
      *
-     * @return int
+     * @return array<string>
      */
-    public function getMaxVarcharLength(): int
+    public function getKeywords(): array
     {
-        return 2147483647;
+        return [];
     }
 
     /**
-     * Get max INT limit
+     * Get the keys of internally managed indexes. MongoDB has none exposed.
      *
-     * @return int
+     * @return array<string>
      */
-    public function getLimitForInt(): int
+    public function getInternalIndexesKeys(): array
     {
-        // Mongo does not handle integers directly, so using MariaDB limit for now
-        return 4294967295;
+        return [];
     }
 
     /**
-     * Get maximum column limit.
-     * Returns 0 to indicate no limit
+     * Get the internal ID attribute type used by MongoDB (UUID v7).
      *
-     * @return int
+     * @return string
      */
-    public function getLimitForAttributes(): int
+    public function getIdAttributeType(): string
     {
-        return 0;
+        return ColumnType::Uuid7->value;
     }
 
     /**
-     * Get maximum index limit.
-     * https://docs.mongodb.com/manual/reference/limits/#mongodb-limit-Number-of-Indexes-per-Collection
+     * Get the query to check for tenant when in shared tables mode
      *
-     * @return int
+     * @param  string  $collection  The collection being queried
+     * @param  string  $alias  The alias of the parent collection if in a subquery
      */
-    public function getLimitForIndexes(): int
-    {
-        return 64;
-    }
-
-    public function getMinDateTime(): \DateTime
+    public function getTenantQuery(string $collection, string $alias = ''): string
     {
-        return new \DateTime('-9999-01-01 00:00:00');
+        return '';
     }
 
     /**
-     * Is schemas supported?
+     * Check whether the adapter supports storing non-UTF characters. MongoDB does not.
      *
      * @return bool
      */
-    public function getSupportForSchemas(): bool
+    public function getSupportNonUtfCharacters(): bool
     {
         return false;
     }
 
     /**
-     * Is index supported?
+     * Get Collection Size of raw data
      *
-     * @return bool
+     * @throws DatabaseException
      */
-    public function getSupportForIndex(): bool
+    public function getSizeOfCollection(string $collection): int
     {
-        return true;
-    }
+        $namespace = $this->getNamespace();
+        $collection = $this->filter($collection);
+        $collection = $namespace.'_'.$collection;
 
-    public function getSupportForIndexArray(): bool
-    {
-        return true;
+        $command = [
+            'collStats' => $collection,
+            'scale' => 1,
+        ];
+
+        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());
+        }
     }
 
     /**
-     * Is internal casting supported?
+     * Get Collection Size on disk
      *
-     * @return bool
+     * @throws DatabaseException
      */
-    public function getSupportForInternalCasting(): bool
-    {
-        return true;
-    }
-
-    public function getSupportForUTCCasting(): bool
-    {
-        return true;
-    }
-
-    public function setUTCDatetime(string $value): mixed
+    public function getSizeOfCollectionOnDisk(string $collection): int
     {
-        return new UTCDateTime(new \DateTime($value));
+        return $this->getSizeOfCollection($collection);
     }
 
-
     /**
-     * Are attributes supported?
-     *
-     * @return bool
+     * @param  array<int|string>  $tenants
+     * @return int|string|null|array<string, array<int|string|null>>
      */
-    public function getSupportForAttributes(): bool
-    {
-        return $this->supportForAttributes;
-    }
+    public function getTenantFilters(
+        string $collection,
+        array $tenants = [],
+    ): int|string|null|array {
+        if (! $this->sharedTables) {
+            return null;
+        }
 
-    public function setSupportForAttributes(bool $support): bool
-    {
-        $this->supportForAttributes = $support;
-        return $this->supportForAttributes;
-    }
+        /** @var array<int|string> $values */
+        $values = [];
 
-    /**
-     * Is unique index supported?
-     *
-     * @return bool
-     */
-    public function getSupportForUniqueIndex(): bool
-    {
-        return true;
-    }
+        if (\count($tenants) === 0) {
+            $tenant = $this->getTenant();
+            if ($tenant !== null) {
+                $values[] = $tenant;
+            }
+        } else {
+            for ($index = 0; $index < \count($tenants); $index++) {
+                $values[] = $tenants[$index];
+            }
+        }
 
-    /**
-     * Is fulltext index supported?
-     *
-     * @return bool
-     */
-    public function getSupportForFulltextIndex(): bool
-    {
-        return true;
-    }
+        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]];
+        }
 
-    /**
-     * Is fulltext Wildcard index supported?
-     *
-     * @return bool
-     */
-    public function getSupportForFulltextWildcardIndex(): bool
-    {
-        return false;
+        if (empty($values)) {
+            return null;
+        }
+
+        if (\count($values) === 1) {
+            return $values[0];
+        }
+
+        return ['$in' => $values];
     }
 
     /**
-     * Does the adapter handle Query Array Contains?
+     * Returns the document after casting to
      *
-     * @return bool
+     * @throws Exception
      */
-    public function getSupportForQueryContains(): bool
+    public function castingBefore(Document $collection, Document $document): Document
     {
-        return false;
+        if ($document->isEmpty()) {
+            return $document;
+        }
+
+        $rawCbAttributes = $collection->getAttribute('attributes', []);
+        /** @var array<int, array<string, mixed>> $cbAttributes */
+        $cbAttributes = \is_array($rawCbAttributes) ? $rawCbAttributes : [];
+
+        $internalCbAttributeArrays = \array_map(
+            fn (Attribute $a) => ['$id' => $a->key, 'type' => $a->type, 'array' => $a->array],
+            Database::internalAttributes()
+        );
+
+        /** @var array<int, array<string, mixed>> $attributes */
+        $attributes = \array_merge($cbAttributes, $internalCbAttributeArrays);
+
+        foreach ($attributes as $attribute) {
+            /** @var array<string, mixed> $attribute */
+            $rawCbId = $attribute['$id'] ?? null;
+            $key = \is_string($rawCbId) ? $rawCbId : '';
+            $rawCbType = $attribute['type'] ?? null;
+            $type = $rawCbType instanceof ColumnType
+                ? $rawCbType
+                : (\is_string($rawCbType) ? ColumnType::tryFrom($rawCbType) : null);
+            $array = (bool) ($attribute['array'] ?? false);
+
+            $value = $document->getAttribute($key);
+            if (is_null($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::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;
     }
 
     /**
-     * Are timeouts supported?
-     *
-     * @return bool
+     * Returns the document after casting from
      */
-    public function getSupportForTimeouts(): bool
+    public function castingAfter(Document $collection, Document $document): Document
     {
-        return true;
-    }
+        if ($document->isEmpty()) {
+            return $document;
+        }
 
-    public function getSupportForRelationships(): bool
-    {
-        return true;
-    }
+        $rawCollectionAttributes = $collection->getAttribute('attributes', []);
+        /** @var array<int, array<string, mixed>> $collectionAttributes */
+        $collectionAttributes = \is_array($rawCollectionAttributes) ? $rawCollectionAttributes : [];
 
-    public function getSupportForUpdateLock(): bool
-    {
-        return false;
-    }
+        $internalAttributeArrays = \array_map(
+            fn (Attribute $a) => ['$id' => $a->key, 'type' => $a->type, 'array' => $a->array],
+            Database::internalAttributes()
+        );
 
-    public function getSupportForAttributeResizing(): bool
-    {
-        return false;
+        /** @var array<int, array<string, mixed>> $attributes */
+        $attributes = \array_merge($collectionAttributes, $internalAttributeArrays);
+
+        foreach ($attributes as $attribute) {
+            /** @var array<string, mixed> $attribute */
+            $rawId = $attribute['$id'] ?? null;
+            $key = \is_string($rawId) ? $rawId : '';
+            $rawType = $attribute['type'] ?? null;
+            $type = $rawType instanceof ColumnType
+                ? $rawType
+                : (\is_string($rawType) ? ColumnType::tryFrom($rawType) : null);
+            $array = (bool) ($attribute['array'] ?? false);
+            $value = $document->getAttribute($key);
+            if (is_null($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::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::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;
     }
 
     /**
-     * Are batch operations supported?
+     * Convert a datetime string to a MongoDB UTCDateTime object.
      *
-     * @return bool
+     * @param string $value The datetime string
+     * @return mixed
      */
-    public function getSupportForBatchOperations(): bool
+    public function setUTCDatetime(string $value): mixed
     {
-        return false;
+        return new UTCDateTime(new NativeDateTime($value));
     }
 
     /**
-     * Is get connection id supported?
-     *
-     * @return bool
+     * @return array<mixed>
      */
-    public function getSupportForGetConnectionId(): bool
+    public function decodePoint(string $wkb): array
     {
-        return false;
+        return [];
     }
 
     /**
-     * Is PCRE regex supported?
+     * Decode a WKB or textual LINESTRING into [[x1, y1], [x2, y2], ...]
      *
-     * @return bool
+     * @return float[][] Array of points, each as [x, y]
      */
-    public function getSupportForPCRERegex(): bool
+    public function decodeLinestring(string $wkb): array
     {
-        return true;
+        return [];
     }
 
     /**
-     * Is POSIX regex supported?
+     * Decode a WKB or textual POLYGON into [[[x1, y1], [x2, y2], ...], ...]
      *
-     * @return bool
+     * @return float[][][] Array of rings, each ring is an array of points [x, y]
      */
-    public function getSupportForPOSIXRegex(): bool
+    public function decodePolygon(string $wkb): array
     {
-        return false;
+        return [];
     }
 
     /**
-     * Is cache fallback supported?
-     *
-     * @return bool
+     * TODO Consider moving this to adapter.php
      */
-    public function getSupportForCacheSkipOnFailure(): bool
+    protected function getInternalKeyForAttribute(string $attribute): string
     {
-        return false;
+        return match ($attribute) {
+            '$id' => '_uid',
+            '$sequence' => '_id',
+            '$collection' => '_collection',
+            '$tenant' => '_tenant',
+            '$createdAt' => '_createdAt',
+            '$updatedAt' => '_updatedAt',
+            '$permissions' => '_permissions',
+            '$version' => '_version',
+            default => $attribute
+        };
     }
 
     /**
-     * Is hostname supported?
-     *
-     * @return bool
+     * Escape a field name for MongoDB storage.
+     * MongoDB field names cannot start with $ or contain dots.
      */
-    public function getSupportForHostname(): bool
+    protected function escapeMongoFieldName(string $name): string
     {
-        return true;
+        if (\str_starts_with($name, '$')) {
+            $name = '_'.\substr($name, 1);
+        }
+        if (\str_contains($name, '.')) {
+            $name = \str_replace('.', '__dot__', $name);
+        }
+
+        return $name;
     }
 
     /**
-     * Is get schema attributes supported?
+     * 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').
      *
-     * @return bool
+     * @param  array<Query>  $queries
      */
-    public function getSupportForSchemaAttributes(): bool
+    protected function escapeQueryAttributes(Document $collection, array $queries): void
     {
-        return false;
-    }
+        $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['$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);
+            }
+        }
 
-    public function getSupportForCastIndexArray(): bool
-    {
-        return false;
-    }
+        if (empty($dotAttributes)) {
+            return;
+        }
 
-    public function getSupportForUpserts(): bool
-    {
-        return true;
+        foreach ($queries as $query) {
+            $attr = $query->getAttribute();
+            if (isset($dotAttributes[$attr])) {
+                $query->setAttribute($dotAttributes[$attr]);
+            }
+        }
     }
 
-    public function getSupportForReconnection(): bool
+    /**
+     * 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.
+     */
+    protected function ensureRelationshipDefaults(Document $collection, Document $document): void
     {
-        return false;
-    }
+        $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['$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 : '');
 
-    public function getSupportForBatchCreateAttributes(): bool
-    {
-        return true;
-    }
+                // 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,
+                };
 
-    public function getSupportForObject(): bool
-    {
-        return true;
+                if ($storesData) {
+                    $document->setAttribute($key, null);
+                }
+            }
+        }
     }
 
     /**
-     * Are object (JSON) indexes supported?
+     * Keys cannot begin with $ in MongoDB
+     * Convert $ prefix to _ on $id, $permissions, and $collection
      *
-     * @return bool
+     * @param  array<string, mixed>  $array
+     * @return array<string, mixed>
      */
-    public function getSupportForObjectIndexes(): bool
+    protected function replaceChars(string $from, string $to, array $array): array
     {
-        return false;
-    }
+        $filter = [
+            'permissions',
+            'createdAt',
+            'updatedAt',
+            'collection',
+            'version',
+        ];
 
-    /**
-     * Get current attribute count from collection document
-     *
-     * @param Document $collection
-     * @return int
-     */
-    public function getCountOfAttributes(Document $collection): int
-    {
-        $attributes = \count($collection->getAttribute('attributes') ?? []);
+        // 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);
+            }
 
-        return $attributes + static::getCountOfDefaultAttributes();
-    }
+            $newKey = $k;
 
-    /**
-     * Get current index count from collection document
-     *
-     * @param Document $collection
-     * @return int
-     */
-    public function getCountOfIndexes(Document $collection): int
-    {
-        $indexes = \count($collection->getAttribute('indexes') ?? []);
+            // 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, ['$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));
+            }
 
-        return $indexes + static::getCountOfDefaultIndexes();
-    }
+            // 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);
+            }
 
-    /**
-     * Returns number of attributes used by default.
-     *p
-     * @return int
-     */
-    public function getCountOfDefaultAttributes(): int
-    {
-        return \count(Database::INTERNAL_ATTRIBUTES);
-    }
+            if ($newKey !== $k) {
+                $keysToRename[$k] = $newKey;
+            }
+        }
 
-    /**
-     * Returns number of indexes used by default.
-     *
-     * @return int
-     */
-    public function getCountOfDefaultIndexes(): int
-    {
-        return \count(Database::INTERNAL_INDEXES);
-    }
+        foreach ($keysToRename as $oldKey => $newKey) {
+            $array[$newKey] = $array[$oldKey];
+            unset($array[$oldKey]);
+        }
 
-    /**
-     * Get maximum width, in bytes, allowed for a SQL row
-     * Return 0 when no restrictions apply
-     *
-     * @return int
-     */
-    public function getDocumentSizeLimit(): int
-    {
-        return 0;
-    }
+        // Handle special attribute mappings
+        if ($from === '_') {
+            if (isset($array['_id'])) {
+                /** @var mixed $idVal */
+                $idVal = $array['_id'];
+                $array['$sequence'] = \is_string($idVal) ? $idVal : (\is_scalar($idVal) ? (string) $idVal : '');
+                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']);
+            }
+        }
 
-    /**
-     * 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
-     *
-     * @param Document $collection
-     * @return int
-     */
-    public function getAttributeWidth(Document $collection): int
-    {
-        return 0;
+        return $array;
     }
 
     /**
-     * Is casting supported?
+     * @param  array<Query>  $queries
+     * @return array<mixed>
      *
-     * @return bool
+     * @throws Exception
      */
-    public function getSupportForCasting(): bool
+    protected function buildFilters(array $queries, string $separator = '$and'): array
     {
-        return false;
+        $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;
     }
 
     /**
-     * Is spatial attributes supported?
+     * @return array<mixed>
      *
-     * @return bool
+     * @throws Exception
      */
-    public function getSupportForSpatialAttributes(): bool
+    protected function buildFilter(Query $query): array
     {
-        return false;
+        // 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(), ['$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()) {
+            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;
+        }
+
+        return $filter;
     }
 
     /**
-     * Get Support for Null Values in Spatial Indexes
+     * Get Query Operator
      *
-     * @return bool
-     */
-    public function getSupportForSpatialIndexNull(): bool
-    {
-        return false;
-    }
-
-    /**
-     * Does the adapter support operators?
      *
-     * @return bool
+     * @throws Exception
      */
-    public function getSupportForOperators(): 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 require booleans to be converted to integers (0/1)?
-     *
-     * @return bool
-     */
-    public function getSupportForIntegerBooleans(): bool
+    protected function getQueryValue(Method $method, mixed $value): mixed
     {
-        return false;
+        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 includes boundary during spatial contains?
+     * Get Mongo Order
      *
-     * @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['_uid'] = 1;
+        $projection['_id'] = 1;
+        $projection['_createdAt'] = 1;
+        $projection['_updatedAt'] = 1;
+        $projection['_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 = [];
@@ -3489,7 +3270,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
@@ -3505,223 +3286,62 @@ protected function removeNullKeys(array|Document $target): array
             $cleaned[$key] = $value;
         }
 
-
         return $cleaned;
     }
 
-    public function getKeywords(): array
-    {
-        return [];
-    }
-
-    protected function processException(\Throwable $e): \Throwable
-    {
-        // Timeout
-        if ($e->getCode() === 50 || $e->getCode() === 262) {
-            return new TimeoutException('Query timed out', $e->getCode(), $e);
-        }
-
-        // Duplicate key error
-        if ($e->getCode() === 11000 || $e->getCode() === 11001) {
-            $message = $e->getMessage();
-            if (!\str_contains($message, '_uid')) {
-                return new DuplicateException('Document with the requested unique attributes already exists', $e->getCode(), $e);
-            }
-            return new DuplicateException('Document already exists', $e->getCode(), $e);
-        }
-
-        // Collection already exists
-        if ($e->getCode() === 48) {
-            return new DuplicateException('Collection already exists', $e->getCode(), $e);
-        }
-
-        // Index already exists
-        if ($e->getCode() === 85) {
-            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);
-        }
-
-        return $e;
-    }
-
-    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 [];
-    }
-
-    /**
-     * 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 '';
-    }
-
-    public function getSupportForAlterLocks(): bool
-    {
-        return false;
-    }
-
-    public function getSupportNonUtfCharacters(): bool
+    protected function processException(Throwable $e): Throwable
     {
-        return false;
-    }
+        // Timeout
+        if ($e->getCode() === 50 || $e->getCode() === 262) {
+            return new TimeoutException('Query timed out', $e->getCode(), $e);
+        }
 
-    public function getSupportForTrigramIndex(): bool
-    {
-        return false;
-    }
+        // Duplicate key error
+        if ($e->getCode() === 11000 || $e->getCode() === 11001) {
+            $message = $e->getMessage();
+            if (! \str_contains($message, '_uid')) {
+                return new DuplicateException('Document with the requested unique attributes already exists', $e->getCode(), $e);
+            }
 
-    public function getSupportForTTLIndexes(): bool
-    {
-        return true;
+            return new DuplicateException('Document already exists', $e->getCode(), $e);
+        }
+
+        // Collection already exists
+        if ($e->getCode() === 48) {
+            return new DuplicateException('Collection already exists', $e->getCode(), $e);
+        }
+
+        // Index already exists
+        if ($e->getCode() === 85) {
+            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);
+        }
+
+        return $e;
     }
 
-    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
@@ -3735,7 +3355,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
@@ -3745,9 +3364,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] !== ':'
@@ -3764,7 +3383,7 @@ protected function isExtendedISODatetime(string $val): bool
             $val[$len - 3] === ':'
         );
 
-        if (!$hasZ && !$hasOffset) {
+        if (! $hasZ && ! $hasOffset) {
             return false;
         }
 
@@ -3777,12 +3396,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;
@@ -3805,7 +3424,7 @@ protected function isExtendedISODatetime(string $val): bool
         }
 
         foreach ($digitPositions as $i) {
-            if (!ctype_digit($val[$i])) {
+            if (! ctype_digit($val[$i])) {
                 return false;
             }
         }
@@ -3822,24 +3441,298 @@ 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 = ['_uid' => $document['_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::Integer => 'int',
+            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);
+            $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) {
+            return array_map($this->convertStdClassToArray(...), get_object_vars($value));
+        }
+
+        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 = ['_uid', '_id', '_createdAt', '_updatedAt', '_permissions', '_tenant', '_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 5aaa28107..f9453f5c3 100644
--- a/src/Database/Adapter/MySQL.php
+++ b/src/Database/Adapter/MySQL.php
@@ -2,71 +2,112 @@
 
 namespace Utopia\Database\Adapter;
 
+use Exception;
 use PDOException;
+use PDOStatement;
+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\Query;
-
+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
+    private bool $timeoutDirty = false;
+
+    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;
+        $this->timeoutDirty = true;
+    }
 
-        $this->before($event, 'timeout', function ($sql) use ($milliseconds) {
-            return \preg_replace(
-                pattern: '/SELECT/',
-                replacement: "SELECT /*+ max_execution_time({$milliseconds}) */",
-                subject: $sql,
-                limit: 1
-            );
-        });
+    public function clearTimeout(Event $event = Event::All): void
+    {
+        if ($this->timeout > 0) {
+            $this->timeoutDirty = true;
+        }
+        $this->timeout = 0;
+    }
+
+    protected function execute(mixed $stmt): bool
+    {
+        if ($this->timeoutDirty) {
+            $this->getPDO()->exec("SET SESSION MAX_EXECUTION_TIME = {$this->timeout}");
+            $this->timeoutDirty = false;
+        }
+        /** @var PDOStatement|\Swoole\Database\PDOStatementProxy $stmt */
+        return $stmt->execute();
     }
 
     /**
      * 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.'/'.$collection.'_perms';
 
-        $collectionSize = $this->getPDO()->prepare("
+        $collectionSize = $this->getPDO()->prepare('
              SELECT SUM(FS_BLOCK_SIZE + ALLOCATED_SIZE)  
              FROM INFORMATION_SCHEMA.INNODB_TABLESPACES
              WHERE NAME = :name
-        ");
+        ');
 
-        $permissionsSize = $this->getPDO()->prepare("
+        $permissionsSize = $this->getPDO()->prepare('
              SELECT SUM(FS_BLOCK_SIZE + ALLOCATED_SIZE)  
              FROM INFORMATION_SCHEMA.INNODB_TABLESPACES
              WHERE NAME = :permissions
-        ");
+        ');
 
         $collectionSize->bindParam(':name', $name);
         $permissionsSize->bindParam(':permissions', $permissions);
@@ -74,9 +115,11 @@ public function getSizeOfCollectionOnDisk(string $collection): int
         try {
             $collectionSize->execute();
             $permissionsSize->execute();
-            $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;
@@ -85,68 +128,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,140 +188,94 @@ 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 int &$bindIndex
-     * @return ?string
      */
-    protected function getOperatorSQL(string $column, \Utopia\Database\Operator $operator, int &$bindIndex): ?string
+    protected function getOperatorSQL(string $column, Operator $operator, int &$bindIndex): ?string
     {
         $quotedColumn = $this->quote($column);
         $method = $operator->getMethod();
 
         switch ($method) {
-            case Operator::TYPE_ARRAY_APPEND:
+            case OperatorType::ArrayAppend:
                 $bindKey = "op_{$bindIndex}";
                 $bindIndex++;
+
                 return "{$quotedColumn} = JSON_MERGE_PRESERVE(IFNULL({$quotedColumn}, JSON_ARRAY()), :$bindKey)";
 
-            case Operator::TYPE_ARRAY_PREPEND:
+            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 (
@@ -319,9 +288,4 @@ protected function getOperatorSQL(string $column, \Utopia\Database\Operator $ope
         // For all other operators, use parent implementation
         return parent::getOperatorSQL($column, $operator, $bindIndex);
     }
-
-    public function getSupportForTTLIndexes(): bool
-    {
-        return false;
-    }
 }
diff --git a/src/Database/Adapter/Pool.php b/src/Database/Adapter/Pool.php
index e89be89ac..3298ffdd5 100644
--- a/src/Database/Adapter/Pool.php
+++ b/src/Database/Adapter/Pool.php
@@ -2,14 +2,31 @@
 
 namespace Utopia\Database\Adapter;
 
+use DateTime;
+use Throwable;
 use Utopia\Database\Adapter;
+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\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;
-
-class Pool extends Adapter
+use Utopia\Query\CursorDirection;
+
+/**
+ * Connection pool adapter that delegates database operations to pooled adapter instances.
+ *
+ * Pool implements all Feature interfaces because it is a complete proxy — every method
+ * call is delegated to the underlying pooled adapter. If the pooled adapter does not
+ * actually support a feature, the delegated call will throw at runtime.
+ */
+class Pool extends Adapter implements Feature\ConnectionId, Feature\InternalCasting, Feature\Relationships, Feature\SchemaAttributes, Feature\Spatial, Feature\Timeouts, Feature\Upserts, Feature\UTCCasting
 {
     /**
      * @var UtopiaPool<covariant Adapter>
@@ -23,7 +40,7 @@ class Pool extends Adapter
     protected ?Adapter $pinnedAdapter = null;
 
     /**
-     * @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)
     {
@@ -35,9 +52,8 @@ 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
@@ -52,10 +68,13 @@ public function delegate(string $method, array $args): mixed
             $adapter->setNamespace($this->getNamespace());
             $adapter->setSharedTables($this->getSharedTables());
             $adapter->setTenant($this->getTenant());
+            $adapter->setTenantPerDocument($this->getTenantPerDocument());
             $adapter->setAuthorization($this->authorization);
 
             if ($this->getTimeout() > 0) {
                 $adapter->setTimeout($this->getTimeout());
+            } else {
+                $adapter->clearTimeout();
             }
             $adapter->resetDebug();
             foreach ($this->getDebug() as $key => $value) {
@@ -65,41 +84,125 @@ public function delegate(string $method, array $args): mixed
             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);
+            }
+            foreach ($this->writeHooks as $hook) {
+                if (empty(\array_filter($adapter->getWriteHooks(), fn ($h) => $h::class === $hook::class))) {
+                    $adapter->addWriteHook($hook);
+                }
+            }
             return $adapter->{$method}(...$args);
         });
     }
 
-    public function before(string $event, string $name = '', ?callable $callback = null): static
+    /**
+     * Check if a specific capability is supported by the pooled adapter.
+     *
+     * @param Capability $feature The capability to check
+     * @return bool
+     */
+    public function supports(Capability $feature): bool
     {
-        $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var bool $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
+    }
+
+    /**
+     * 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;
+    }
+
+    /**
+     * 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 addTransform(string $name, Transform $transform): static
+    {
+        $this->queryTransforms[$name] = $transform;
 
         return $this;
     }
 
-    protected function trigger(string $event, mixed $query): mixed
+    /**
+     * Remove a named query transform hook from the pooled adapter.
+     *
+     * @param string $name The transform name to remove
+     * @return static
+     */
+    public function removeTransform(string $name): static
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        unset($this->queryTransforms[$name]);
+
+        return $this;
     }
 
-    public function setTimeout(int $milliseconds, string $event = Database::EVENT_ALL): void
+    /**
+     * 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
+     */
+    public function setTimeout(int $milliseconds, Event $event = Event::All): void
     {
+        $this->timeout = $milliseconds;
         $this->delegate(__FUNCTION__, \func_get_args());
     }
 
+    /**
+     * 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;
     }
 
     /**
@@ -108,9 +211,11 @@ public function rollbackTransaction(): bool
      * 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
     {
@@ -125,10 +230,13 @@ public function withTransaction(callable $callback): mixed
             $adapter->setNamespace($this->getNamespace());
             $adapter->setSharedTables($this->getSharedTables());
             $adapter->setTenant($this->getTenant());
+            $adapter->setTenantPerDocument($this->getTenantPerDocument());
             $adapter->setAuthorization($this->authorization);
 
             if ($this->getTimeout() > 0) {
                 $adapter->setTimeout($this->getTimeout());
+            } else {
+                $adapter->clearTimeout();
             }
             $adapter->resetDebug();
             foreach ($this->getDebug() as $key => $value) {
@@ -138,6 +246,11 @@ public function withTransaction(callable $callback): mixed
             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->pinnedAdapter = $adapter;
             try {
@@ -150,392 +263,487 @@ 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;
     }
 
+    /**
+     * {@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->delegate(__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->delegate(__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->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 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;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function upsertDocuments(Document $collection, string $attribute, array $changes): array
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var array<Document> $result */
+        $result = $this->delegate(__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 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;
     }
 
+    /**
+     * {@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());
-    }
-
-    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());
+        /** @var int $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
-    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 getSupportForVectors(): bool
-    {
-        return $this->delegate(__FUNCTION__, \func_get_args());
-    }
-
-    public function getSupportForCacheSkipOnFailure(): 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
@@ -543,24 +751,44 @@ protected function getAttributeProjection(array $selections, string $prefix): mi
         return $this->delegate(__FUNCTION__, \func_get_args());
     }
 
+    /**
+     * {@inheritDoc}
+     */
     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
     {
-        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->delegate(__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;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function getSchemaAttributes(string $collection): array
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var array<Document> $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
     public function getSupportForSchemaIndexes(): bool
@@ -573,154 +801,163 @@ public function getSchemaIndexes(string $collection): array
         return $this->delegate(__FUNCTION__, \func_get_args());
     }
 
+    /**
+     * {@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->delegate(__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->delegate(__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->delegate(__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->delegate(__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->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritDoc}
+     */
     public function setUTCDatetime(string $value): mixed
     {
         return $this->delegate(__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
+    /**
+     * {@inheritDoc}
+     */
+    public function rawQuery(string $query, array $bindings = []): array
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var array<Document> $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
-    public function getSupportForTTLIndexes(): bool
+    public function rawMutation(string $query, array $bindings = []): int
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var int $result */
+        $result = $this->delegate(__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->delegate(__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->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
+
 }
diff --git a/src/Database/Adapter/Postgres.php b/src/Database/Adapter/Postgres.php
index 8dcf72025..b55b039fe 100644
--- a/src/Database/Adapter/Postgres.php
+++ b/src/Database/Adapter/Postgres.php
@@ -2,12 +2,17 @@
 
 namespace Utopia\Database\Adapter;
 
+use DateTime;
 use Exception;
 use PDO;
 use PDOException;
+use PDOStatement;
 use Swoole\Database\PDOStatementProxy;
+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;
@@ -17,8 +22,20 @@
 use Utopia\Database\Exception\Transaction as TransactionException;
 use Utopia\Database\Exception\Truncate as TruncateException;
 use Utopia\Database\Helpers\ID;
+use Utopia\Database\Index;
 use Utopia\Database\Operator;
+use Utopia\Database\OperatorType;
 use Utopia\Database\Query;
+use Utopia\Database\RelationSide;
+use Utopia\Database\RelationType;
+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\Blueprint;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\IndexType;
+use Utopia\Query\Schema\PostgreSQL as PostgreSQLSchema;
 
 /**
  * Differences between MariaDB and Postgres
@@ -28,11 +45,67 @@
  * 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\Relationships, Feature\Spatial, Feature\Timeouts, Feature\Upserts
 {
     public const MAX_IDENTIFIER_NAME = 63;
+
+    /**
+     * Get the list of capabilities supported by the PostgreSQL adapter.
+     *
+     * @return array<Capability>
+     */
+    public function capabilities(): array
+    {
+        return array_merge(parent::capabilities(), [
+            Capability::Vectors,
+            Capability::Objects,
+            Capability::SpatialIndexNull,
+            Capability::MultiDimensionDistance,
+            Capability::TrigramIndex,
+            Capability::POSIX,
+            Capability::ObjectIndexes,
+        ]);
+    }
+
+    /**
+     * Get the case-insensitive LIKE operator for PostgreSQL.
+     *
+     * @return string
+     */
+    public function getLikeOperator(): string
+    {
+        return 'ILIKE';
+    }
+
+    /**
+     * Get the POSIX regex matching operator for PostgreSQL.
+     *
+     * @return string
+     */
+    public function getRegexOperator(): string
+    {
+        return '~';
+    }
+
+    /**
+     * Get the PostgreSQL backend process ID as the connection identifier.
+     *
+     * @return string
+     */
+    public function getConnectionId(): string
+    {
+        $result = $this->createBuilder()->fromNone()->selectRaw('pg_backend_pid()')->build();
+        $stmt = $this->getPDO()->query($result->query);
+        if ($stmt === false) {
+            return '';
+        }
+        $col = $stmt->fetchColumn();
+
+        return \is_scalar($col) ? (string) $col : '';
+    }
+
     /**
-     * @inheritDoc
+     * {@inheritDoc}
      */
     public function startTransaction(): bool
     {
@@ -47,14 +120,14 @@ public function startTransaction(): bool
 
                 $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) {
+        if (! $result) {
             throw new TransactionException('Failed to start transaction');
         }
 
@@ -64,7 +137,7 @@ public function startTransaction(): bool
     }
 
     /**
-     * @inheritDoc
+     * {@inheritDoc}
      */
     public function rollbackTransaction(): bool
     {
@@ -74,8 +147,9 @@ 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--;
+
                 return true;
             }
 
@@ -83,65 +157,20 @@ public function rollbackTransaction(): bool
             $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);
         }
 
-        if (!$result) {
+        if (! $result) {
             throw new TransactionException('Failed to rollback transaction');
         }
 
         return $result;
     }
 
-    protected function execute(mixed $stmt): bool
-    {
-        $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");
-            }
-        }
-    }
-
-
-
-    /**
-     * Returns 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;
-    }
-
     /**
      * Create Database
      *
-     * @param string $name
      *
-     * @return bool
      * @throws DatabaseException
      */
     public function create(string $name): bool
@@ -152,203 +181,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->getPDO()
             ->prepare($sql)
             ->execute();
 
-        // 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();
-
-        $collation = "
-            CREATE COLLATION IF NOT EXISTS utf8_ci_ai (
-            provider = icu,
-            locale = 'und-u-ks-level1',
-            deterministic = false
-            )
-        ";
-        $this->getPDO()->prepare($collation)->execute();
+        // Enable extensions — wrap in try-catch to handle concurrent creation race conditions
+        foreach (['postgis', 'vector', 'pg_trgm'] as $ext) {
+            try {
+                $this->getPDO()->prepare($schema->createExtension($ext)->query)->execute();
+            } catch (PDOException) {
+                // Extension may already exist due to concurrent worker
+            }
+        }
+
+        try {
+            $collation = $schema->createCollation('utf8_ci_ai', [
+                'provider' => 'icu',
+                'locale' => 'und-u-ks-level1',
+            ], deterministic: false);
+            $this->getPDO()->prepare($collation->query)->execute();
+        } catch (PDOException) {
+            // Collation may already exist due to concurrent worker
+        }
+
         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
+    public function exists(string $database, ?string $collection = null): bool
     {
-        $name = $this->filter($name);
+        $database = $this->filter($database);
+
+        if ($collection !== null) {
+            $collection = $this->filter($collection);
+            $sql = 'SELECT "table_name" FROM information_schema.tables WHERE "table_schema" = ? AND "table_name" = ?';
+            $stmt = $this->getPDO()->prepare($sql);
+            $stmt->bindValue(1, $database);
+            $stmt->bindValue(2, "{$this->getNamespace()}_{$collection}");
+        } else {
+            $sql = 'SELECT "schema_name" FROM information_schema.schemata WHERE "schema_name" = ?';
+            $stmt = $this->getPDO()->prepare($sql);
+            $stmt->bindValue(1, $database);
+        }
 
-        $sql = "DROP SCHEMA IF EXISTS \"{$name}\" CASCADE";
-        $sql = $this->trigger(Database::EVENT_DATABASE_DELETE, $sql);
+        try {
+            $stmt->execute();
+            $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($id.'_perms');
+
+        $schema = $this->createSchemaBuilder();
+
+        // Build main collection table using schema builder
+        $collectionResult = $schema->create($tableRaw, function (Blueprint $table) use ($attributes) {
+            $table->id('_id');
+            $table->string('_uid', 255);
+
+            if ($this->sharedTables) {
+                $table->integer('_tenant')->nullable()->default(null);
+            }
 
-        /** @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)
-            );
-
-            // Ignore relationships with virtual attributes
-            if ($attribute->getAttribute('type') === Database::VAR_RELATIONSHIP) {
-                $options = $attribute->getAttribute('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)
-                ) {
-                    continue;
+            $table->datetime('_createdAt', 3)->nullable()->default(null);
+            $table->datetime('_updatedAt', 3)->nullable()->default(null);
+
+            foreach ($attributes as $attribute) {
+                // Ignore relationships with virtual attributes
+                if ($attribute->type === ColumnType::Relationship) {
+                    $options = $attribute->options ?? [];
+                    $relationType = $options['relationType'] ?? null;
+                    $twoWay = $options['twoWay'] ?? false;
+                    $side = $options['side'] ?? null;
+
+                    if (
+                        $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;
+                    }
                 }
+
+                $this->addBlueprintColumn(
+                    $table,
+                    $attribute->key,
+                    $attribute->type,
+                    $attribute->size,
+                    $attribute->signed,
+                    $attribute->array,
+                    $attribute->required
+                );
             }
 
-            $attributeStrings[] = "\"{$attrId}\" {$attrType}, ";
-        }
+            $table->text('_permissions')->nullable()->default(null);
+            $table->integer('_version')->nullable()->default(1);
+        });
 
-        $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 TEXT DEFAULT NULL
-            );
-        ";
+        // Build default indexes using schema builder
+        $indexStatements = [];
 
         if ($this->sharedTables) {
             $uidIndex = $this->getShortKey("{$namespace}_{$this->tenant}_{$id}_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");
-            $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);
-			";
+            $indexStatements[] = $schema->createIndex($tableRaw, $uidIndex, ['_uid', '_tenant'], unique: true, collations: ['_uid' => 'utf8_ci_ai'])->query;
+            $indexStatements[] = $schema->createIndex($tableRaw, $createdIndex, ['_tenant', '_createdAt'])->query;
+            $indexStatements[] = $schema->createIndex($tableRaw, $updatedIndex, ['_tenant', '_updatedAt'])->query;
+            $indexStatements[] = $schema->createIndex($tableRaw, $tenantIdIndex, ['_tenant', '_id'])->query;
         } else {
             $uidIndex = $this->getShortKey("{$namespace}_{$id}_uid");
             $createdIndex = $this->getShortKey("{$namespace}_{$id}_created");
             $updatedIndex = $this->getShortKey("{$namespace}_{$id}_updated");
-            $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\");
-			";
+            $indexStatements[] = $schema->createIndex($tableRaw, $uidIndex, ['_uid'], unique: true, collations: ['_uid' => 'utf8_ci_ai'])->query;
+            $indexStatements[] = $schema->createIndex($tableRaw, $createdIndex, ['_createdAt'])->query;
+            $indexStatements[] = $schema->createIndex($tableRaw, $updatedIndex, ['_updatedAt'])->query;
         }
 
-        $collection = $this->trigger(Database::EVENT_COLLECTION_CREATE, $collection);
+        $collectionSql = $collectionResult->query.'; '.implode('; ', $indexStatements);
 
-        $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
-            );
-        ";
+        // Build permissions table using schema builder
+        $permsResult = $schema->create($permsTableRaw, function (Blueprint $table) {
+            $table->id('_id');
+            $table->integer('_tenant')->nullable()->default(null);
+            $table->string('_type', 12);
+            $table->string('_permission', 255);
+            $table->string('_document', 255);
+        });
+
+        // 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, ['_tenant', '_document', '_type', '_permission'], unique: true, method: 'btree')->query;
+            $permsIndexStatements[] = $schema->createIndex($permsTableRaw, $permissionIndex, ['_tenant', '_permission', '_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, ['_document', '_type', '_permission'], unique: true, method: 'btree', collations: ['_document' => 'utf8_ci_ai'])->query;
+            $permsIndexStatements[] = $schema->createIndex($permsTableRaw, $permissionIndex, ['_permission', '_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->getPDO()->prepare($collectionSql)->execute();
+            $this->getPDO()->prepare($permsSql)->execute();
 
             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
                 );
             }
+        } 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->dropIfExists($tableRaw)->query.'; '.$dropSchema->dropIfExists($permsTableRaw)->query;
+                $this->execute($this->getPDO()->prepare($dropSql));
             }
 
             throw $e;
@@ -359,139 +403,170 @@ 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($collection.'_perms');
 
-        $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->getPDO()->prepare($collectionResult->query);
+        $permissionsSize = $this->getPDO()->prepare($permissionsResult->query);
+
+        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($collection.'_perms');
+
+        $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->getPDO()->prepare($collectionResult->query);
+        $permissionsSize = $this->getPDO()->prepare($permissionsResult->query);
 
-        $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();
+        $result = $schema->alter($this->getSQLTableRaw($collection), function (Blueprint $table) use ($attribute) {
+            $this->addBlueprintColumn($table, $attribute->key, $attribute->type, $attribute->size, $attribute->signed, $attribute->array, $attribute->required);
+        });
 
-        $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();
+            return $this->execute($this->getPDO()
+                ->prepare($sql));
         } 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);
 
-        $sql = "
-			ALTER TABLE {$this->getSQLTable($name)}
-			ADD COLUMN \"{$id}\" {$type}
-		";
+            $renameResult = $schema->alter($this->getSQLTableRaw($collection), function (Blueprint $table) use ($id, $newKey) {
+                $table->renameColumn($id, $newKey);
+            });
 
-        $sql = $this->trigger(Database::EVENT_ATTRIBUTE_CREATE, $sql);
+            $sql = $renameResult->query;
+
+            $result = $this->execute($this->getPDO()
+                ->prepare($sql));
+
+            if (! $result) {
+                return false;
+            }
+
+            $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) without time zone', "TO_TIMESTAMP(\"{$id}\", 'YYYY-MM-DD HH24:MI:SS.MS')");
+        } else {
+            $result = $schema->alterColumnType($tableRaw, $id, $sqlType);
+        }
+
+        $sql = $result->query;
 
         try {
             return $this->execute($this->getPDO()
@@ -504,30 +579,23 @@ 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);
+        $schema = $this->createSchemaBuilder();
+        $result = $schema->alter($this->getSQLTableRaw($collection), function (Blueprint $table) use ($id) {
+            $table->dropColumn($this->filter($id));
+        });
 
-        $sql = "
-			ALTER TABLE {$this->getSQLTable($name)}
-			DROP COLUMN \"{$id}\";
-		";
-
-        $sql = $this->trigger(Database::EVENT_ATTRIBUTE_DELETE, $sql);
+        $sql = $result->query;
 
         try {
             return $this->execute($this->getPDO()
                 ->prepare($sql));
         } catch (PDOException $e) {
-            if ($e->getCode() === "42703" && $e->errorInfo[1] === 7) {
+            if ($e->getCode() === '42703' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 7) {
                 return true;
             }
 
@@ -538,1199 +606,918 @@ 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();
+        $result = $schema->alter($this->getSQLTableRaw($collection), function (Blueprint $table) use ($old, $new) {
+            $table->renameColumn($this->filter($old), $this->filter($new));
+        });
 
-        $sql = "
-			ALTER TABLE {$this->getSQLTable($collection)} 
-			RENAME COLUMN \"{$old}\" TO \"{$new}\"
-		";
-
-        $sql = $this->trigger(Database::EVENT_ATTRIBUTE_UPDATE, $sql);
+        $sql = $result->query;
 
         return $this->execute($this->getPDO()
             ->prepare($sql));
     }
 
     /**
-     * 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
+    public function createIndex(string $collection, Index $index, array $indexAttributeTypes = [], array $collation = []): 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);
-            }
-        }
+        $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 = empty($orders[$i]) || $type === IndexType::Fulltext ? '' : $orders[$i];
+            $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 = match ($attr) {
+                    '$id' => '_uid',
+                    '$createdAt' => '_createdAt',
+                    '$updatedAt' => '_updatedAt',
+                    default => $this->filter($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, '_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->getPDO()->prepare($sql)->execute();
         } 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;
+
+        $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);
 
-                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');
-        }
+        return $this->execute($this->getPDO()
+            ->prepare($sql));
+    }
+
+    /**
+     * 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));
     }
 
     /**
-     * @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['_createdAt'] = $document->getCreatedAt();
+            $attributes['_updatedAt'] = $document->getUpdatedAt();
+            $attributes['_permissions'] = \json_encode($document->getPermissions());
+
+            $version = $document->getVersion();
+            if ($version !== null) {
+                $attributes['_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}\";";
-                    }
-                } 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());
-
-                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');
-        }
-
-        if (empty($sql)) {
-            return true;
-        }
+            $row = ['_uid' => $document->getId()];
+            if (! empty($document->getSequence())) {
+                $row['_id'] = $document->getSequence();
+            }
 
-        $sql = $this->trigger(Database::EVENT_ATTRIBUTE_UPDATE, $sql);
+            foreach ($spatialAttributes as $spatialCol) {
+                $builder->insertColumnExpression($spatialCol, $this->getSpatialGeomFromText('?'));
+            }
 
-        return $this->execute($this->getPDO()
-            ->prepare($sql));
-    }
+            foreach ($attributes as $attr => $value) {
+                $column = $this->filter($attr);
 
-    /**
-     * @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
-     */
-    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}\";";
+                if (\in_array($attr, $spatialAttributes, true)) {
+                    if (\is_array($value)) {
+                        $value = $this->convertArrayToWKT($value);
                     }
-                }
-                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}\";";
+                    $row[$column] = $value;
                 } else {
-                    $sql = "ALTER TABLE {$table} DROP COLUMN \"{$key}\";";
+                    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 = $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');
+            $row = $this->decorateRow($row, $this->documentMetadata($document));
+            $builder->set($row);
+            $result = $builder->insert();
+            $stmt = $this->executeResult($result, Event::DocumentCreate);
 
-                $sql = "DROP TABLE {$junction}; DROP TABLE {$perms}";
-                break;
-            default:
-                throw new DatabaseException('Invalid relationship type');
-        }
+            $this->execute($stmt);
+            $lastInsertedId = $this->getPDO()->lastInsertId();
+            $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_DELETE, $sql);
-
-        return $this->execute($this->getPDO()
-            ->prepare($sql));
+        return $document;
     }
 
     /**
-     * Create Index
+     * Update Document
+     *
      *
-     * @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
+     * @throws DatabaseException
+     * @throws DuplicateException
      */
-    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 updateDocument(Document $collection, string $id, Document $document, bool $skipPermissions): Document
     {
-        $collection = $this->filter($collection);
-        $id = $this->filter($id);
+        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());
+
+            $version = $document->getVersion();
+            if ($version !== null) {
+                $attributes['_version'] = $version;
+            }
 
-        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 = match ($attr) {
-                    '$id' => '_uid',
-                    '$createdAt' => '_createdAt',
-                    '$updatedAt' => '_updatedAt',
-                    default => $this->filter($attr),
-                };
+            $name = $this->filter($collection);
 
-                $attributes[$i] = "\"{$attr}\" {$order}";
+            $operators = [];
+            foreach ($attributes as $attribute => $value) {
+                if (Operator::isOperator($value)) {
+                    $operators[$attribute] = $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),
-        };
+            $builder = $this->newBuilder($name);
+            $row = ['_uid' => $document->getId()];
 
-        $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})",
-        };
+            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 (\in_array($attribute, $spatialAttributes, true)) {
+                    if (\is_array($value)) {
+                        $value = $this->convertArrayToWKT($value);
+                    }
+                    $builder->setRaw($column, $this->getSpatialGeomFromText('?'), [$value]);
+                } else {
+                    if (\is_array($value)) {
+                        $value = \json_encode($value);
+                    }
+                    $row[$column] = $value;
+                }
+            }
 
-        $sql = $this->trigger(Database::EVENT_INDEX_CREATE, $sql);
+            $builder->set($row);
+            $builder->filter([BaseQuery::equal('_id', [$document->getSequence()])]);
+            $result = $builder->update();
+            $stmt = $this->executeResult($result, Event::DocumentUpdate);
 
-        try {
-            return $this->getPDO()->prepare($sql)->execute();
+            $stmt->execute();
+
+            $ctx = $this->buildWriteContext($name);
+            $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}");
-
-        $sql = "DROP INDEX IF EXISTS \"{$schemaName}\".\"{$keyName}\"";
-        $sql = $this->trigger(Database::EVENT_INDEX_DELETE, $sql);
+        if ($milliseconds <= 0) {
+            throw new DatabaseException('Timeout must be greater than 0');
+        }
 
-        return $this->execute($this->getPDO()
-            ->prepare($sql));
+        $this->timeout = $milliseconds;
     }
 
     /**
-     * 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
+    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
+    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());
-
-        $name = $this->filter($collection);
-        $columns = '';
+        $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);
 
-        if (!$skipPermissions) {
-            $sql = "
-			SELECT _type, _permission
-			FROM {$this->getSQLTable($name . '_perms')}
-			WHERE _document = :_uid
-			{$this->getTenantQuery($collection)}
-		";
+            $points = explode(',', $inside);
 
-            $sql = $this->trigger(Database::EVENT_PERMISSIONS_READ, $sql);
+            return array_map(function ($point) {
+                $coords = explode(' ', trim($point));
 
-            /**
-             * Get current permissions from the database
-             */
-            $permissionsStmt = $this->getPDO()->prepare($sql);
-            $permissionsStmt->bindValue(':_uid', $document->getId());
+                return [(float) $coords[0], (float) $coords[1]];
+            }, $points);
+        }
 
-            if ($this->sharedTables) {
-                $permissionsStmt->bindValue(':_tenant', $this->tenant);
+        if (ctype_xdigit($wkb)) {
+            $wkb = hex2bin($wkb);
+            if ($wkb === false) {
+                throw new DatabaseException('Failed to convert hex WKB to binary.');
             }
+        }
 
-            $this->execute($permissionsStmt);
-            $permissions = $permissionsStmt->fetchAll();
-            $permissionsStmt->closeCursor();
+        if (strlen($wkb) < 9) {
+            throw new DatabaseException('WKB too short to be a valid geometry');
+        }
 
-            $initial = [];
-            foreach (Database::PERMISSIONS as $type) {
-                $initial[$type] = [];
-            }
+        $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');
+        }
 
-            $permissions = array_reduce($permissions, function (array $carry, array $item) {
-                $carry[$item['_type']][] = $item['_permission'];
+        // Type + SRID flag
+        $typeField = unpack('V', substr($wkb, 1, 4));
+        if ($typeField === false) {
+            throw new DatabaseException('Failed to unpack the type field from WKB.');
+        }
 
-                return $carry;
-            }, $initial);
+        $typeField = \is_numeric($typeField[1]) ? (int) $typeField[1] : 0;
+        $geomType = $typeField & 0xFF;
+        $hasSRID = ($typeField & 0x20000000) !== 0;
 
-            /**
-             * Get removed Permissions
-             */
-            $removals = [];
-            foreach (Database::PERMISSIONS as $type) {
-                $diff = \array_diff($permissions[$type], $document->getPermissionsByType($type));
-                if (!empty($diff)) {
-                    $removals[$type] = $diff;
-                }
-            }
+        if ($geomType !== 2) { // 2 = LINESTRING
+            throw new DatabaseException("Not a LINESTRING geometry type, got {$geomType}");
+        }
 
-            /**
-             * Get added Permissions
-             */
-            $additions = [];
-            foreach (Database::PERMISSIONS as $type) {
-                $diff = \array_diff($document->getPermissionsByType($type), $permissions[$type]);
-                if (!empty($diff)) {
-                    $additions[$type] = $diff;
-                }
-            }
+        $offset = 5;
+        if ($hasSRID) {
+            $offset += 4;
+        }
 
-            /**
-             * Query to remove permissions
-             */
-            $removeQuery = '';
-            if (!empty($removals)) {
-                $removeQuery = ' AND (';
-                foreach ($removals as $type => $permissions) {
-                    $removeQuery .= "(
-                    _type = '{$type}'
-                    AND _permission IN (" . implode(', ', \array_map(fn (string $i) => ":_remove_{$type}_{$i}", \array_keys($permissions))) . ")
-                )";
-                    if ($type !== \array_key_last($removals)) {
-                        $removeQuery .= ' OR ';
-                    }
-                }
-            }
-            if (!empty($removeQuery)) {
-                $removeQuery .= ')';
+        $numPoints = unpack('V', substr($wkb, $offset, 4));
+        if ($numPoints === false) {
+            throw new DatabaseException("Failed to unpack number of points at offset {$offset}.");
+        }
 
-                $sql = "
-				DELETE
-                FROM {$this->getSQLTable($name . '_perms')}
-                WHERE _document = :_uid
-                {$this->getTenantQuery($collection)}
-			";
+        $numPoints = \is_numeric($numPoints[1]) ? (int) $numPoints[1] : 0;
+        $offset += 4;
 
-                $removeQuery = $sql . $removeQuery;
+        $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}.");
+            }
 
-                $removeQuery = $this->trigger(Database::EVENT_PERMISSIONS_DELETE, $removeQuery);
-                $stmtRemovePermissions = $this->getPDO()->prepare($removeQuery);
-                $stmtRemovePermissions->bindValue(':_uid', $document->getId());
+            $x = \is_numeric($x[1]) ? (float) $x[1] : 0.0;
 
-                if ($this->sharedTables) {
-                    $stmtRemovePermissions->bindValue(':_tenant', $this->tenant);
-                }
+            $offset += 8;
 
-                foreach ($removals as $type => $permissions) {
-                    foreach ($permissions as $i => $permission) {
-                        $stmtRemovePermissions->bindValue(":_remove_{$type}_{$i}", $permission);
-                    }
-                }
+            $y = unpack('e', substr($wkb, $offset, 8));
+            if ($y === false) {
+                throw new DatabaseException("Failed to unpack Y coordinate at offset {$offset}.");
             }
 
-            /**
-             * Query to add permissions
-             */
-            if (!empty($additions)) {
-                $values = [];
-                foreach ($additions as $type => $permissions) {
-                    foreach ($permissions as $i => $_) {
-                        $sqlTenant = $this->sharedTables ? ', :_tenant' : '';
-                        $values[] = "( :_uid, '{$type}', :_add_{$type}_{$i} {$sqlTenant})";
-                    }
-                }
+            $y = \is_numeric($y[1]) ? (float) $y[1] : 0.0;
 
-                $sqlTenant = $this->sharedTables ? ', _tenant' : '';
-
-                $sql = "
-				INSERT INTO {$this->getSQLTable($name . '_perms')} (_document, _type, _permission {$sqlTenant})
-				VALUES" . \implode(', ', $values);
+            $offset += 8;
+            $points[] = [$x, $y];
+        }
 
-                $sql = $this->trigger(Database::EVENT_PERMISSIONS_CREATE, $sql);
+        return $points;
+    }
 
-                $stmtAddPermissions = $this->getPDO()->prepare($sql);
-                $stmtAddPermissions->bindValue(":_uid", $document->getId());
-                if ($this->sharedTables) {
-                    $stmtAddPermissions->bindValue(':_tenant', $this->tenant);
-                }
+    /**
+     * Decode a WKB or WKT POLYGON into an array of rings, each containing coordinate pairs.
+     *
+     * @param string $wkb The WKB hex or WKT string
+     * @return array<array<array<float>>>
+     *
+     * @throws DatabaseException If the input is invalid.
+     */
+    public function decodePolygon(string $wkb): array
+    {
+        // POLYGON((x1,y1),(x2,y2))
+        if (str_starts_with($wkb, 'POLYGON((')) {
+            $start = strpos($wkb, '((') + 2;
+            $end = strrpos($wkb, '))');
+            $inside = substr($wkb, $start, $end - $start);
 
-                foreach ($additions as $type => $permissions) {
-                    foreach ($permissions as $i => $permission) {
-                        $stmtAddPermissions->bindValue(":_add_{$type}_{$i}", $permission);
-                    }
-                }
-            }
-        }
+            $rings = explode('),(', $inside);
 
-        /**
-         * Update Attributes
-         */
+            return array_map(function ($ring) {
+                $points = explode(',', $ring);
 
-        $keyIndex = 0;
-        $opIndex = 0;
-        $operators = [];
+                return array_map(function ($point) {
+                    $coords = explode(' ', trim($point));
 
-        // Separate regular attributes from operators
-        foreach ($attributes as $attribute => $value) {
-            if (Operator::isOperator($value)) {
-                $operators[$attribute] = $value;
-            }
+                    return [(float) $coords[0], (float) $coords[1]];
+                }, $points);
+            }, $rings);
         }
 
-        foreach ($attributes as $attribute => $value) {
-            $column = $this->filter($attribute);
-
-            // Check if this is an operator, spatial attribute, or regular attribute
-            if (isset($operators[$attribute])) {
-                $operatorSQL = $this->getOperatorSQL($column, $operators[$attribute], $opIndex);
-                $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++;
+        // 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');
             }
         }
 
-        $sql = "
-			UPDATE {$this->getSQLTable($name)}
-			SET {$columns} _uid = :_newUid 
-			WHERE _id=:_sequence
-			{$this->getTenantQuery($collection)}
-		";
-
-        $sql = $this->trigger(Database::EVENT_DOCUMENT_UPDATE, $sql);
-
-        $stmt = $this->getPDO()->prepare($sql);
+        if (strlen($wkb) < 9) {
+            throw new DatabaseException('WKB too short');
+        }
 
-        $stmt->bindValue(':_sequence', $document->getSequence());
-        $stmt->bindValue(':_newUid', $document->getId());
+        $uInt32 = 'V'; // little-endian 32-bit unsigned
+        $uDouble = 'd'; // little-endian double
 
-        if ($this->sharedTables) {
-            $stmt->bindValue(':_tenant', $this->tenant);
+        $typeInt = unpack($uInt32, substr($wkb, 1, 4));
+        if ($typeInt === false) {
+            throw new DatabaseException('Failed to unpack type field from WKB.');
         }
 
-        $keyIndex = 0;
-        $opIndexForBinding = 0;
-        foreach ($attributes as $attribute => $value) {
-            // Handle operators separately
-            if (isset($operators[$attribute])) {
-                $this->bindOperatorParams($stmt, $operators[$attribute], $opIndexForBinding);
-            } else {
-                // 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);
-                }
+        $typeInt = \is_numeric($typeInt[1]) ? (int) $typeInt[1] : 0;
+        $hasSrid = ($typeInt & 0x20000000) !== 0;
+        $geomType = $typeInt & 0xFF;
 
-                $bindKey = 'key_' . $keyIndex;
-                $stmt->bindValue(':' . $bindKey, $value, $this->getPDOType($value));
-                $keyIndex++;
-            }
+        if ($geomType !== 3) { // 3 = POLYGON
+            throw new DatabaseException("Not a POLYGON geometry type, got {$geomType}");
         }
 
-        try {
-            $this->execute($stmt);
-            if (isset($stmtRemovePermissions)) {
-                $this->execute($stmtRemovePermissions);
-            }
-            if (isset($stmtAddPermissions)) {
-                $this->execute($stmtAddPermissions);
-            }
-        } catch (PDOException $e) {
-            throw $this->processException($e);
+        $offset = 5;
+        if ($hasSrid) {
+            $offset += 4;
         }
 
-        return $document;
-    }
+        // Number of rings
+        $numRings = unpack($uInt32, substr($wkb, $offset, 4));
+        if ($numRings === false) {
+            throw new DatabaseException('Failed to unpack number of rings from WKB.');
+        }
 
-    /**
-     * @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}";
-            }
+        $numRings = \is_numeric($numRings[1]) ? (int) $numRings[1] : 0;
+        $offset += 4;
 
-            if ($this->sharedTables) {
-                return "{$attribute} = CASE WHEN target._tenant = EXCLUDED._tenant THEN {$new} ELSE target.{$attribute} END";
+        $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.');
             }
 
-            return "{$attribute} = {$new}";
-        };
+            $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.');
+                }
 
-        $opIndex = 0;
+                $x = \is_numeric($x[1]) ? (float) $x[1] : 0.0;
 
-        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], $opIndex, useTargetPrefix: true);
-                    if ($operatorSQL !== null) {
-                        $updateColumns[] = $operatorSQL;
-                    }
-                } else {
-                    if (!in_array($attr, ['_uid', '_id', '_createdAt', '_tenant'])) {
-                        $updateColumns[] = $getUpdateClause($filteredAttr);
-                    }
+                $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;
         }
 
-        $conflictKeys = $this->sharedTables ? '("_uid", _tenant)' : '("_uid")';
+        return $rings; // array of rings, each ring is array of [x,y]
+    }
 
-        $stmt = $this->getPDO()->prepare(
-            "
-            INSERT INTO {$this->getSQLTable($tableName)} AS target {$columns}
-            VALUES " . implode(', ', $batchKeys) . "
-            ON CONFLICT {$conflictKeys} DO UPDATE
-                SET " . implode(', ', $updateColumns)
-        );
+    protected function execute(mixed $stmt): bool
+    {
+        $pdo = $this->getPDO();
 
-        foreach ($bindValues as $key => $binding) {
-            $stmt->bindValue($key, $binding, $this->getPDOType($binding));
-        }
+        // 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'";
 
-        $opIndexForBinding = 0;
+        // Apply timeout
+        $pdo->exec($sql);
 
-        // Bind operator parameters in the same order used to build SQL
-        foreach (array_keys($attributes) as $attr) {
-            if (isset($operators[$attr])) {
-                $this->bindOperatorParams($stmt, $operators[$attr], $opIndexForBinding);
+        /** @var PDOStatement|PDOStatementProxy $stmt */
+        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 $stmt;
     }
 
     /**
-     * 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
+     * {@inheritDoc}
      */
-    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
+    protected function insertRequiresAlias(): bool
     {
-        $name = $this->filter($collection);
-        $attribute = $this->filter($attribute);
-
-        $sqlMax = $max !== null ? " AND \"{$attribute}\" <= :max" : "";
-        $sqlMin = $min !== null ? " AND \"{$attribute}\" >= :min" : "";
+        return true;
+    }
 
-        $sql = "
-			UPDATE {$this->getSQLTable($name)}
-			SET
-			    \"{$attribute}\" = \"{$attribute}\" + :val,
-                \"_updatedAt\" = :updatedAt
-			WHERE _uid = :_uid
-			{$this->getTenantQuery($collection)}
-		";
+    /**
+     * {@inheritDoc}
+     */
+    protected function getConflictTenantExpression(string $column): string
+    {
+        $quoted = $this->quote($this->filter($column));
 
-        $sql .= $sqlMax . $sqlMin;
+        return "CASE WHEN target._tenant = EXCLUDED._tenant THEN EXCLUDED.{$quoted} ELSE target.{$quoted} END";
+    }
 
-        $sql = $this->trigger(Database::EVENT_DOCUMENT_UPDATE, $sql);
+    /**
+     * {@inheritDoc}
+     */
+    protected function getConflictIncrementExpression(string $column): string
+    {
+        $quoted = $this->quote($this->filter($column));
 
-        $stmt = $this->getPDO()->prepare($sql);
-        $stmt->bindValue(':_uid', $id);
-        $stmt->bindValue(':val', $value);
-        $stmt->bindValue(':updatedAt', $updatedAt);
+        return "target.{$quoted} + EXCLUDED.{$quoted}";
+    }
 
-        if ($max !== null) {
-            $stmt->bindValue(':max', $max);
-        }
-        if ($min !== null) {
-            $stmt->bindValue(':min', $min);
-        }
-        if ($this->sharedTables) {
-            $stmt->bindValue(':_tenant', $this->tenant);
-        }
+    /**
+     * {@inheritDoc}
+     */
+    protected function getConflictTenantIncrementExpression(string $column): string
+    {
+        $quoted = $this->quote($this->filter($column));
 
-        $this->execute($stmt) || throw new DatabaseException('Failed to update attribute');
-        return true;
+        return "CASE WHEN target._tenant = EXCLUDED._tenant THEN target.{$quoted} + EXCLUDED.{$quoted} ELSE target.{$quoted} END";
     }
 
     /**
-     * Delete Document
+     * 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") . ")";
+        $spatialGeomRaw = $query->getValues()[0];
+        $binds[":{$placeholder}_0"] = $this->convertArrayToWKT(\is_array($spatialGeomRaw) ? $spatialGeomRaw : []);
+        $geom = $this->getSpatialGeomFromText(":{$placeholder}_0");
 
-            default:
-                throw new DatabaseException('Unknown spatial query method: ' . $query->getMethod());
-        }
+        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];
 
@@ -1738,29 +1525,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
@@ -1780,62 +1566,71 @@ protected function getSQLCondition(Query $query, array &$binds): string
         $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);
                 }
 
-                $method = strtoupper($query->getMethod());
-                return empty($conditions) ? '' : ' ' . $method . ' (' . implode(' AND ', $conditions) . ')';
+                $method = strtoupper($query->getMethod()->value);
+
+                return empty($conditions) ? '' : ' '.$method.' ('.implode(' AND ', $conditions).')';
+
+            case Method::Search:
+                $searchVal = $query->getValue();
+                $binds[":{$placeholder}_0"] = $this->getFulltextValue(\is_string($searchVal) ? $searchVal : '');
 
-            case Query::TYPE_SEARCH:
-                $binds[":{$placeholder}_0"] = $this->getFulltextValue($query->getValue());
                 return "to_tsvector(regexp_replace({$attribute}, '[^\w]+',' ','g')) @@ websearch_to_tsquery(:{$placeholder}_0)";
 
-            case Query::TYPE_NOT_SEARCH:
-                $binds[":{$placeholder}_0"] = $this->getFulltextValue($query->getValue());
+            case Method::NotSearch:
+                $notSearchVal = $query->getValue();
+                $binds[":{$placeholder}_0"] = $this->getFulltextValue(\is_string($notSearchVal) ? $notSearchVal : '');
+
                 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 = '@>';
                 }
@@ -1845,19 +1640,20 @@ protected function getSQLCondition(Query $query, array &$binds): string
                 $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
                     };
 
@@ -1866,7 +1662,7 @@ protected function getSQLCondition(Query $query, array &$binds): string
                     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}";
@@ -1874,156 +1670,67 @@ protected function getSQLCondition(Query $query, array &$binds): string
                 }
 
                 $separator = $isNotQuery ? ' AND ' : ' OR ';
-                return empty($conditions) ? '' : '(' . implode($separator, $conditions) . ')';
+
+                return empty($conditions) ? '' : '('.implode($separator, $conditions).')';
         }
     }
 
     /**
-     * Get vector distance calculation for ORDER BY clause
-     *
-     * @param Query $query
-     * @param array<string, mixed> $binds
-     * @param string $alias
-     * @return string|null
-     * @throws DatabaseException
+     * Get SQL Type
      */
-    protected function getVectorDistanceOrder(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();
+    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::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 $value
-     * @return string
+     * Get SQL schema
      */
-    protected function getFulltextValue(string $value): string
+    protected function getSQLSchema(): string
     {
-        $exact = str_ends_with($value, '"') && str_starts_with($value, '"');
-        $value = str_replace(['@', '+', '-', '*', '.', "'", '"'], ' ', $value);
-        $value = preg_replace('/\s+/', ' ', $value); // Remove multiple whitespaces
-        $value = trim($value);
-
-        if (!$exact) {
-            $value = str_replace(' ', ' or ', $value);
+        if (! $this->supports(Capability::Schemas)) {
+            return '';
         }
 
-        return "'" . $value . "'";
+        return "\"{$this->getDatabase()}\".";
     }
 
     /**
-     * Get SQL Type
+     * Get PDO 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_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_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()}\".";
-    }
-
-    /**
-     * Get PDO Type
-     *
-     * @param mixed $value
-     *
-     * @return int
      * @throws DatabaseException
      */
     protected function getPDOType(mixed $value): int
@@ -2031,570 +1738,167 @@ 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)),
-        };
-    }
-
-    /**
-     * 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;
-    }
-
-    /**
-     * 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
-     */
-    public function getLikeOperator(): string
-    {
-        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) {
-            $message = $e->getMessage();
-            if (!\str_contains($message, '_uid')) {
-                return new DuplicateException('Document with the requested unique attributes already exists', $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);
-        }
-
-        // 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);
-        }
-
-        // Unknown column
-        if ($e->getCode() === "42703" && isset($e->errorInfo[1]) && $e->errorInfo[1] === 7) {
-            return new NotFoundException('Attribute not found', $e->getCode(), $e);
-        }
-
-        return $e;
-    }
-
-    /**
-     * @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;
-    }
-
-    /**
-     * 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
-    {
-        return false;
-    }
-
-    /**
-     * Adapter supports optional spatial attributes with existing rows.
-     *
-     * @return bool
-     */
-    public function getSupportForOptionalSpatialAttributeWithExistingRows(): bool
-    {
-        return false;
-    }
-
-    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.');
-        }
+            'integer' => PDO::PARAM_INT,
+            'NULL' => PDO::PARAM_NULL,
+            default => throw new DatabaseException('Unknown PDO Type for '.\gettype($value)),
+        };
+    }
 
-        $typeField = $typeField[1];
-        $geomType = $typeField & 0xFF;
-        $hasSRID = ($typeField & 0x20000000) !== 0;
+    /**
+     * Get vector distance calculation for ORDER BY clause
+     *
+     * @param  array<string, mixed>  $binds
+     *
+     * @throws DatabaseException
+     */
+    protected function getVectorDistanceOrder(Query $query, array &$binds, string $alias): ?string
+    {
+        $query->setAttribute($this->getInternalKeyForAttribute($query->getAttribute()));
 
-        if ($geomType !== 2) { // 2 = LINESTRING
-            throw new DatabaseException("Not a LINESTRING geometry type, got {$geomType}");
-        }
+        $attribute = $this->filter($query->getAttribute());
+        $attribute = $this->quote($attribute);
+        $alias = $this->quote($alias);
+        $placeholder = ID::unique();
 
-        $offset = 5;
-        if ($hasSRID) {
-            $offset += 4;
-        }
+        $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;
 
-        $numPoints = unpack('V', substr($wkb, $offset, 4));
-        if ($numPoints === false) {
-            throw new DatabaseException("Failed to unpack number of points at offset {$offset}.");
-        }
+        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,
+        };
+    }
 
-        $numPoints = $numPoints[1];
-        $offset += 4;
+    /**
+     * {@inheritDoc}
+     */
+    protected function getVectorOrderRaw(Query $query, string $alias): ?array
+    {
+        $query->setAttribute($this->getInternalKeyForAttribute($query->getAttribute()));
 
-        $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}.");
-            }
+        $attribute = $this->filter($query->getAttribute());
+        $attribute = $this->quote($attribute);
+        $quotedAlias = $this->quote($alias);
 
-            $x = (float) $x[1];
+        $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,
+        };
 
-            $offset += 8;
+        if ($expression === null) {
+            return null;
+        }
 
-            $y = unpack('e', substr($wkb, $offset, 8));
-            if ($y === false) {
-                throw new DatabaseException("Failed to unpack Y coordinate at offset {$offset}.");
-            }
+        return ['expression' => $expression, 'bindings' => [$vector]];
+    }
 
-            $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
+    {
+        $attribute = $this->filter($this->getInternalKeyForAttribute($query->getAttribute()));
+        $attribute = $this->quote($attribute);
+        $searchVal = $query->getValue();
+        $term = $this->getFulltextValue(\is_string($searchVal) ? $searchVal : '');
 
-        return $points;
+        return [
+            'expression' => "ts_rank(to_tsvector(regexp_replace({$attribute}, '[^\w]+',' ','g')), websearch_to_tsquery(?)) AS \"_relevance\"",
+            'order' => '"_relevance" DESC',
+            'bindings' => [$term],
+        ];
     }
 
-    public function decodePolygon(string $wkb): array
+    public function getSupportForSchemaIndexes(): bool
     {
-        // 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 false;
+    }
 
-            $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);
+    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);
         }
 
-        // 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 table
+        if ($e->getCode() === '42P07' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 7) {
+            return new DuplicateException('Collection already exists', $e->getCode(), $e);
         }
 
-        if (strlen($wkb) < 9) {
-            throw new DatabaseException("WKB too short");
+        // Duplicate column
+        if ($e->getCode() === '42701' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 7) {
+            return new DuplicateException('Attribute already exists', $e->getCode(), $e);
         }
 
-        $uInt32 = 'V'; // little-endian 32-bit unsigned
-        $uDouble = 'd'; // little-endian double
+        // Duplicate row
+        if ($e->getCode() === '23505' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 7) {
+            $message = $e->getMessage();
+            if (! \str_contains($message, '_uid')) {
+                return new DuplicateException('Document with the requested unique attributes already exists', $e->getCode(), $e);
+            }
 
-        $typeInt = unpack($uInt32, substr($wkb, 1, 4));
-        if ($typeInt === false) {
-            throw new DatabaseException('Failed to unpack type field from WKB.');
+            return new DuplicateException('Document already exists', $e->getCode(), $e);
         }
 
-        $typeInt = (int) $typeInt[1];
-        $hasSrid = ($typeInt & 0x20000000) !== 0;
-        $geomType = $typeInt & 0xFF;
-
-        if ($geomType !== 3) { // 3 = POLYGON
-            throw new DatabaseException("Not a POLYGON geometry type, got {$geomType}");
+        // 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);
         }
 
-        $offset = 5;
-        if ($hasSrid) {
-            $offset += 4;
+        // 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);
         }
 
-        // Number of rings
-        $numRings = unpack($uInt32, substr($wkb, $offset, 4));
-        if ($numRings === false) {
-            throw new DatabaseException('Failed to unpack number of rings from WKB.');
+        // Datetime field overflow
+        if ($e->getCode() === '22008' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 7) {
+            return new LimitException('Datetime field overflow', $e->getCode(), $e);
         }
 
-        $numRings = (int) $numRings[1];
-        $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 = (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.');
-                }
-
-                $x = (float) $x[1];
+        // Unknown table
+        if ($e->getCode() === '42P01' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 7) {
+            return new NotFoundException('Collection not found', $e->getCode(), $e);
+        }
 
-                $y = unpack($uDouble, substr($wkb, $offset + 8, 8));
-                if ($y === false) {
-                    throw new DatabaseException('Failed to unpack Y coordinate from WKB.');
-                }
+        // Unknown column
+        if ($e->getCode() === '42703' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 7) {
+            return new NotFoundException('Attribute not found', $e->getCode(), $e);
+        }
 
-                $y = (float) $y[1];
+        return $e;
+    }
 
-                $points[] = [$x, $y];
-                $offset += 16;
-            }
-            $rings[] = $points;
-        }
+    protected function quote(string $string): string
+    {
+        return "\"{$string}\"";
+    }
 
-        return $rings; // array of rings, each ring is array of [x,y]
+    protected function getIdentifierQuoteChar(): string
+    {
+        return '"';
     }
 
     /**
      * Get SQL expression for operator
-     *
-     * @param string $column
-     * @param Operator $operator
-     * @param int &$bindIndex
-     * @return ?string
      */
     protected function getOperatorSQL(string $column, Operator $operator, int &$bindIndex, bool $useTargetPrefix = false): ?string
     {
@@ -2605,40 +1909,45 @@ protected function getOperatorSQL(string $column, Operator $operator, int &$bind
 
         switch ($method) {
             // Numeric operators
-            case Operator::TYPE_INCREMENT:
+            case OperatorType::Increment:
                 $bindKey = "op_{$bindIndex}";
                 $bindIndex++;
                 if (isset($values[1])) {
                     $maxKey = "op_{$bindIndex}";
                     $bindIndex++;
+
                     return "{$quotedColumn} = CASE
                         WHEN COALESCE({$columnRef}, 0) >= CAST(:$maxKey AS NUMERIC) THEN CAST(:$maxKey AS NUMERIC)
                         WHEN COALESCE({$columnRef}, 0) > CAST(:$maxKey AS NUMERIC) - CAST(:$bindKey AS NUMERIC) THEN CAST(:$maxKey AS NUMERIC)
                         ELSE COALESCE({$columnRef}, 0) + CAST(:$bindKey AS NUMERIC)
                     END";
                 }
+
                 return "{$quotedColumn} = COALESCE({$columnRef}, 0) + :$bindKey";
 
-            case Operator::TYPE_DECREMENT:
+            case OperatorType::Decrement:
                 $bindKey = "op_{$bindIndex}";
                 $bindIndex++;
                 if (isset($values[1])) {
                     $minKey = "op_{$bindIndex}";
                     $bindIndex++;
+
                     return "{$quotedColumn} = CASE
                         WHEN COALESCE({$columnRef}, 0) <= CAST(:$minKey AS NUMERIC) THEN CAST(:$minKey AS NUMERIC)
                         WHEN COALESCE({$columnRef}, 0) < CAST(:$minKey AS NUMERIC) + CAST(:$bindKey AS NUMERIC) THEN CAST(:$minKey AS NUMERIC)
                         ELSE COALESCE({$columnRef}, 0) - CAST(:$bindKey AS NUMERIC)
                     END";
                 }
+
                 return "{$quotedColumn} = COALESCE({$columnRef}, 0) - :$bindKey";
 
-            case Operator::TYPE_MULTIPLY:
+            case OperatorType::Multiply:
                 $bindKey = "op_{$bindIndex}";
                 $bindIndex++;
                 if (isset($values[1])) {
                     $maxKey = "op_{$bindIndex}";
                     $bindIndex++;
+
                     return "{$quotedColumn} = CASE
                         WHEN COALESCE({$columnRef}, 0) >= CAST(:$maxKey AS NUMERIC) THEN CAST(:$maxKey AS NUMERIC)
                         WHEN CAST(:$bindKey AS NUMERIC) > 0 AND COALESCE({$columnRef}, 0) > CAST(:$maxKey AS NUMERIC) / CAST(:$bindKey AS NUMERIC) THEN CAST(:$maxKey AS NUMERIC)
@@ -2646,32 +1955,37 @@ protected function getOperatorSQL(string $column, Operator $operator, int &$bind
                         ELSE COALESCE({$columnRef}, 0) * CAST(:$bindKey AS NUMERIC)
                     END";
                 }
+
                 return "{$quotedColumn} = COALESCE({$columnRef}, 0) * :$bindKey";
 
-            case Operator::TYPE_DIVIDE:
+            case OperatorType::Divide:
                 $bindKey = "op_{$bindIndex}";
                 $bindIndex++;
                 if (isset($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 CAST(:$minKey AS NUMERIC)
                         ELSE COALESCE({$columnRef}, 0) / CAST(:$bindKey AS NUMERIC)
                     END";
                 }
+
                 return "{$quotedColumn} = COALESCE({$columnRef}, 0) / :$bindKey";
 
-            case Operator::TYPE_MODULO:
+            case OperatorType::Modulo:
                 $bindKey = "op_{$bindIndex}";
                 $bindIndex++;
+
                 return "{$quotedColumn} = MOD(COALESCE({$columnRef}::numeric, 0), :$bindKey::numeric)";
 
-            case Operator::TYPE_POWER:
+            case OperatorType::Power:
                 $bindKey = "op_{$bindIndex}";
                 $bindIndex++;
                 if (isset($values[1])) {
                     $maxKey = "op_{$bindIndex}";
                     $bindIndex++;
+
                     return "{$quotedColumn} = CASE
                         WHEN COALESCE({$columnRef}, 0) >= :$maxKey THEN :$maxKey
                         WHEN COALESCE({$columnRef}, 0) <= 1 THEN COALESCE({$columnRef}, 0)
@@ -2679,56 +1993,63 @@ protected function getOperatorSQL(string $column, Operator $operator, int &$bind
                         ELSE POWER(COALESCE({$columnRef}, 0), :$bindKey)
                     END";
                 }
+
                 return "{$quotedColumn} = POWER(COALESCE({$columnRef}, 0), :$bindKey)";
 
                 // String operators
-            case Operator::TYPE_STRING_CONCAT:
+            case OperatorType::StringConcat:
                 $bindKey = "op_{$bindIndex}";
                 $bindIndex++;
+
                 return "{$quotedColumn} = CONCAT(COALESCE({$columnRef}, ''), :$bindKey)";
 
-            case Operator::TYPE_STRING_REPLACE:
+            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:
+            case OperatorType::ArrayAppend:
                 $bindKey = "op_{$bindIndex}";
                 $bindIndex++;
+
                 return "{$quotedColumn} = COALESCE({$columnRef}, '[]'::jsonb) || :$bindKey::jsonb";
 
-            case Operator::TYPE_ARRAY_PREPEND:
+            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:
+            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:
+            case OperatorType::ArrayInsert:
                 $indexKey = "op_{$bindIndex}";
                 $bindIndex++;
                 $valueKey = "op_{$bindIndex}";
                 $bindIndex++;
+
                 return "{$quotedColumn} = (
                     SELECT jsonb_agg(value ORDER BY idx)
                     FROM (
@@ -2744,29 +2065,32 @@ protected function getOperatorSQL(string $column, Operator $operator, int &$bind
                     ) AS combined
                 )";
 
-            case Operator::TYPE_ARRAY_INTERSECT:
+            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:
+            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:
+            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
@@ -2784,60 +2108,57 @@ protected function getOperatorSQL(string $column, Operator $operator, int &$bind
                 ), '[]'::jsonb)";
 
                 // Date operators
-            case Operator::TYPE_DATE_ADD_DAYS:
+            case OperatorType::DateAddDays:
                 $bindKey = "op_{$bindIndex}";
                 $bindIndex++;
+
                 return "{$quotedColumn} = {$columnRef} + (:$bindKey || ' days')::INTERVAL";
 
-            case Operator::TYPE_DATE_SUB_DAYS:
+            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
-     *
-     * @param \PDOStatement|PDOStatementProxy $stmt
-     * @param Operator $operator
-     * @param int &$bindIndex
-     * @return void
      */
-    protected function bindOperatorParams(\PDOStatement|PDOStatementProxy $stmt, Operator $operator, int &$bindIndex): void
+    protected function bindOperatorParams(PDOStatement|PDOStatementProxy $stmt, Operator $operator, int &$bindIndex): void
     {
         $method = $operator->getMethod();
         $values = $operator->getValues();
 
         switch ($method) {
-            case Operator::TYPE_ARRAY_APPEND:
-            case Operator::TYPE_ARRAY_PREPEND:
+            case OperatorType::ArrayAppend:
+            case OperatorType::ArrayPrepend:
                 $arrayValue = json_encode($values);
                 $bindKey = "op_{$bindIndex}";
-                $stmt->bindValue(':' . $bindKey, $arrayValue, \PDO::PARAM_STR);
+                $stmt->bindValue(':'.$bindKey, $arrayValue, PDO::PARAM_STR);
                 $bindIndex++;
                 break;
 
-            case Operator::TYPE_ARRAY_REMOVE:
+            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);
+                $stmt->bindValue(':'.$bindKey, json_encode($value), PDO::PARAM_STR);
                 $bindIndex++;
                 break;
 
-            case Operator::TYPE_ARRAY_INTERSECT:
-            case Operator::TYPE_ARRAY_DIFF:
+            case OperatorType::ArrayIntersect:
+            case OperatorType::ArrayDiff:
                 $arrayValue = json_encode($values);
                 $bindKey = "op_{$bindIndex}";
-                $stmt->bindValue(':' . $bindKey, $arrayValue, \PDO::PARAM_STR);
+                $stmt->bindValue(':'.$bindKey, $arrayValue, PDO::PARAM_STR);
                 $bindIndex++;
                 break;
 
@@ -2848,16 +2169,72 @@ protected function bindOperatorParams(\PDOStatement|PDOStatementProxy $stmt, Ope
         }
     }
 
-    public function getSupportNonUtfCharacters(): bool
+    protected function getFulltextValue(string $value): string
     {
-        return false;
+        $exact = str_ends_with($value, '"') && str_starts_with($value, '"');
+        $value = str_replace(['@', '+', '-', '*', '.', "'", '"'], ' ', $value);
+        $value = preg_replace('/\s+/', ' ', $value); // Remove multiple whitespaces
+        $value = trim($value ?? '');
+
+        if (! $exact) {
+            $value = str_replace(' ', ' or ', $value);
+        }
+
+        return "'".$value."'";
+    }
+
+    protected function getOperatorBuilderExpression(string $column, Operator $operator): array
+    {
+        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
     {
@@ -2891,21 +2268,18 @@ protected function getSQLTable(string $name): string
         return "{$this->quote($this->getDatabase())}.{$this->quote($table)}";
     }
 
-    public function getSupportForTTLIndexes(): bool
-    {
-        return false;
-    }
     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 000000000..bc2c84ee6
--- /dev/null
+++ b/src/Database/Adapter/ReadWritePool.php
@@ -0,0 +1,143 @@
+<?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',
+        'getSizeOfCollection',
+        'getSizeOfCollectionOnDisk',
+        'ping',
+        'getConnectionId',
+        'getDocumentSizeLimit',
+        'getAttributeWidth',
+        'getCountOfAttributes',
+        'getCountOfIndexes',
+        'getCountOfDefaultAttributes',
+        'getCountOfDefaultIndexes',
+        'getLimitForString',
+        'getLimitForInt',
+        'getLimitForAttributes',
+        'getLimitForIndexes',
+        'getMaxIndexLength',
+        'getMaxVarcharLength',
+        'getMaxUIDLength',
+        'getIdAttributeType',
+        'getKeywords',
+        'getInternalIndexesKeys',
+        'supports',
+        'capabilities',
+    ];
+
+    /**
+     * @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
+    {
+        if ($this->pinnedAdapter !== null) {
+            return $this->pinnedAdapter->{$method}(...$args);
+        }
+
+        if ($this->isReadOperation($method) && ! $this->isSticky()) {
+            return $this->readPool->use(function (Adapter $adapter) use ($method, $args) {
+                $this->syncConfig($adapter);
+
+                return $adapter->{$method}(...$args);
+            });
+        }
+
+        if (! $this->isReadOperation($method)) {
+            $this->lastWriteTimestamp = \microtime(true);
+        }
+
+        return parent::delegate($method, $args);
+    }
+
+    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);
+
+        if ($this->getTimeout() > 0) {
+            $adapter->setTimeout($this->getTimeout());
+        }
+
+        $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/SQL.php b/src/Database/Adapter/SQL.php
index 8f0bd2db2..2a0426731 100644
--- a/src/Database/Adapter/SQL.php
+++ b/src/Database/Adapter/SQL.php
@@ -3,24 +3,60 @@
 namespace Utopia\Database\Adapter;
 
 use Exception;
+use PDO;
 use PDOException;
+use PDOStatement;
 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\PermissionFilter;
+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\PermissionType;
 use Utopia\Database\Query;
-
+use Utopia\Database\Relationship;
+use Utopia\Database\RelationSide;
+use Utopia\Database\RelationType;
+use Utopia\Query\Builder\Plan;
+use Utopia\Query\Builder\SQL as SQLBuilder;
+use Utopia\Query\CursorDirection;
+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\Blueprint;
+use Utopia\Query\Schema\Column;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\IndexType;
+use Utopia\Query\Schema\MySQL as MySQLSchema;
+
+/**
+ * Abstract base adapter for SQL-based database engines (MariaDB, MySQL, PostgreSQL, SQLite).
+ */
 abstract class SQL extends Adapter
 {
-    protected mixed $pdo;
+    protected object $pdo;
 
     /**
      * Maximum array size for array operations to prevent memory exhaustion.
@@ -28,11 +64,86 @@ abstract class SQL extends Adapter
      */
     protected const MAX_ARRAY_OPERATOR_SIZE = 10000;
 
+    private const COLUMN_RENAME_MAP = [
+        '_uid' => '$id',
+        '_id' => '$sequence',
+        '_tenant' => '$tenant',
+        '_createdAt' => '$createdAt',
+        '_updatedAt' => '$updatedAt',
+        '_version' => '$version',
+    ];
+
     /**
      * Controls how many fractional digits are used when binding float parameters.
      */
     protected int $floatPrecision = 17;
 
+    /**
+     * Accepts Utopia\Database\PDO or any PDO-compatible proxy (e.g. Swoole\Database\PDOProxy).
+     */
+    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::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
+     */
+    protected function getPDO(): object
+    {
+        return $this->pdo;
+    }
+
+    /**
+     * 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.
      */
@@ -46,23 +157,86 @@ public function setFloatPrecision(int $precision): void
      */
     protected function getFloatPrecision(float $value): string
     {
-        return sprintf('%.'. $this->floatPrecision . 'F', $value);
+        return sprintf('%.'.$this->floatPrecision.'F', $value);
     }
 
     /**
-     * Constructor.
+     * Get the hostname of the database connection.
      *
-     * Set connection and settings
+     * @return string
+     */
+    public function getHostname(): string
+    {
+        try {
+            return $this->pdo->getHostname();
+        } 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->getPDO()
+            ->prepare($result->query)
+            ->execute();
     }
 
     /**
-     * @inheritDoc
+     * Reconnect to the database and reset the transaction counter.
+     *
+     * @return void
+     */
+    public function reconnect(): void
+    {
+        $this->getPDO()->reconnect();
+        $this->inTransaction = 0;
+    }
+
+    /**
+     * {@inheritDoc}
      */
     public function startTransaction(): bool
     {
@@ -78,10 +252,10 @@ public function startTransaction(): bool
                 $this->getPDO()->beginTransaction();
 
             } else {
-                $this->getPDO()->exec('SAVEPOINT transaction' . $this->inTransaction);
+                $this->getPDO()->exec('SAVEPOINT transaction'.$this->inTransaction);
             }
         } 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);
         }
 
         $this->inTransaction++;
@@ -90,7 +264,7 @@ public function startTransaction(): bool
     }
 
     /**
-     * @inheritDoc
+     * {@inheritDoc}
      */
     public function commitTransaction(): bool
     {
@@ -98,13 +272,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;
         }
 
@@ -112,10 +288,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');
         }
 
@@ -123,7 +299,7 @@ public function commitTransaction(): bool
     }
 
     /**
-     * @inheritDoc
+     * {@inheritDoc}
      */
     public function rollbackTransaction(): bool
     {
@@ -133,7 +309,7 @@ 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--;
             } else {
                 $this->getPDO()->rollBack();
@@ -141,62 +317,48 @@ public function rollbackTransaction(): bool
             }
         } 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();
-    }
-
-    public function reconnect(): void
-    {
-        $this->getPDO()->reconnect();
-        $this->inTransaction = 0;
-    }
-
     /**
      * 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->getPDO()->prepare($result->query);
+            foreach ($result->bindings as $i => $v) {
+                $stmt->bindValue($i + 1, $v);
+            }
         } 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->getPDO()->prepare($result->query);
+            foreach ($result->bindings as $i => $v) {
+                $stmt->bindValue($i + 1, $v);
+            }
         }
 
         try {
@@ -233,22 +395,21 @@ 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
     {
-        $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();
+        $result = $schema->alter($this->getSQLTableRaw($collection), function (Blueprint $table) use ($attribute) {
+            $this->addBlueprintColumn($table, $attribute->key, $attribute->type, $attribute->size, $attribute->signed, $attribute->array, $attribute->required);
+        });
+
+        $sql = $result->query;
+        $lockType = $this->getLockType();
+        if (! empty($lockType)) {
+            $sql = rtrim($sql, ';').' '.$lockType;
+        }
 
         try {
             return $this->getPDO()
@@ -262,30 +423,32 @@ 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 = [];
-        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,
-            );
-            $parts[] = "{$id} {$type}";
-        }
-
-        $columns = \implode(', ADD COLUMN ', $parts);
+        $schema = $this->createSchemaBuilder();
+        $result = $schema->alter($this->getSQLTableRaw($collection), function (Blueprint $table) use ($attributes) {
+            foreach ($attributes as $attribute) {
+                $this->addBlueprintColumn(
+                    $table,
+                    $attribute->key,
+                    $attribute->type,
+                    $attribute->size,
+                    $attribute->signed,
+                    $attribute->array,
+                    $attribute->required,
+                );
+            }
+        });
 
-        $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()
@@ -297,24 +460,19 @@ public function createAttributes(string $collection, array $attributes): bool
     }
 
     /**
-     * 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();
+        $result = $schema->alter($this->getSQLTableRaw($collection), function (Blueprint $table) use ($id) {
+            $table->dropColumn($this->filter($id));
+        });
 
-        $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()
@@ -326,20 +484,19 @@ public function renameAttribute(string $collection, string $old, string $new): b
     }
 
     /**
-     * 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();
+        $result = $schema->alter($this->getSQLTableRaw($collection), function (Blueprint $table) use ($old, $new) {
+            $table->renameColumn($this->filter($old), $this->filter($new));
+        });
+
+        $sql = $result->query;
 
         try {
             return $this->getPDO()
@@ -353,11 +510,8 @@ 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
@@ -366,87 +520,115 @@ public function getDocument(Document $collection, string $id, array $queries = [
 
         $name = $this->filter($collection);
         $selections = $this->getAttributeSelections($queries);
-
-        $forUpdate = $forUpdate ? 'FOR UPDATE' : '';
-
         $alias = Query::DEFAULT_ALIAS;
 
-        $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)}
-		";
+        $builder = $this->newBuilder($name, $alias);
 
-        if ($this->getSupportForUpdateLock()) {
-            $sql .= " {$forUpdate}";
+        if (! empty($selections) && ! \in_array('*', $selections)) {
+            $builder->select($this->mapSelectionsToColumns($selections));
         }
 
-        $stmt = $this->getPDO()->prepare($sql);
+        $builder->filter([BaseQuery::equal('_uid', [$id])]);
+
+        if ($forUpdate && $this->supports(Capability::UpdateLock)) {
+            $builder->forUpdate();
+        }
 
-        $stmt->bindValue(':_uid', $id);
+        $result = $builder->build();
 
-        if ($this->sharedTables) {
-            $stmt->bindValue(':_tenant', $this->getTenant());
+        try {
+            $stmt = $this->executeResult($result);
+            $this->execute($stmt);
+        } catch (PDOException $e) {
+            throw $this->processException($e);
         }
 
-        $stmt->execute();
-        $document = $stmt->fetchAll();
+        /** @var array<int, array<string, mixed>> $rows */
+        $rows = $stmt->fetchAll();
         $stmt->closeCursor();
 
-        if (empty($document)) {
+        if (empty($rows)) {
             return new Document([]);
         }
 
-        $document = $document[0];
+        /** @var array<string, mixed> $document */
+        $document = $rows[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('_permissions', $document)) {
-            $document['$permissions'] = json_decode($document['_permissions'] ?? '[]', true);
-            unset($document['_permissions']);
-        }
+        $this->remapRow($document);
 
         return new Document($document);
     }
 
     /**
-     * Helper method to extract spatial type attributes from collection attributes
+     * Create Documents in batches
      *
-     * @param Document $collection
-     * @return array<int,string>
+     * @param  array<Document>  $documents
+     * @return array<Document>
+     *
+     * @throws DuplicateException
+     * @throws Throwable
      */
-    protected function getSpatialAttributes(Document $collection): array
+    public function createDocuments(Document $collection, array $documents): 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();
+        if (empty($documents)) {
+            return $documents;
+        }
+
+        $this->syncWriteHooks();
+
+        $spatialAttributes = $this->getSpatialAttributes($collection);
+        $collection = $collection->getId();
+        try {
+            $name = $this->filter($collection);
+
+            $attributeKeySet = [];
+            foreach (Database::INTERNAL_ATTRIBUTE_KEYS as $k) {
+                $attributeKeySet[$k] = true;
+            }
+
+            $hasSequence = null;
+            foreach ($documents as $document) {
+                foreach ($document->getAttributes() as $key => $value) {
+                    $attributeKeySet[$key] = true;
+                }
+
+                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');
                 }
             }
+
+            $attributeKeys = \array_keys($attributeKeySet);
+
+            if ($hasSequence) {
+                $attributeKeys[] = '_id';
+            }
+
+            $builder = $this->createBuilder()->into($this->getSQLTableRaw($name));
+
+            // Register spatial column expressions for ST_GeomFromText wrapping
+            foreach ($spatialAttributes as $spatialCol) {
+                $builder->insertColumnExpression($spatialCol, $this->getSpatialGeomFromText('?'));
+            }
+
+            foreach ($documents as $document) {
+                $row = $this->buildDocumentRow($document, $attributeKeys, $spatialAttributes);
+                $row = $this->decorateRow($row, $this->documentMetadata($document));
+                $builder->set($row);
+            }
+
+            $result = $builder->insert();
+            $stmt = $this->executeResult($result, Event::DocumentCreate);
+            $this->execute($stmt);
+
+            $ctx = $this->buildWriteContext($name);
+            $this->runWriteHooks(fn ($hook) => $hook->afterDocumentCreate($name, $documents, $ctx));
+        } catch (PDOException $e) {
+            throw $this->processException($e);
         }
-        return $spatialAttributes;
+
+        return $documents;
     }
 
     /**
@@ -454,11 +636,7 @@ protected function getSpatialAttributes(Document $collection): array
      *
      * 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
      */
@@ -467,16 +645,19 @@ public function updateDocuments(Document $collection, Document $updates, array $
         if (empty($documents)) {
             return 0;
         }
+
+        $this->syncWriteHooks();
+
         $spatialAttributes = $this->getSpatialAttributes($collection);
         $collection = $collection->getId();
 
         $attributes = $updates->getAttributes();
 
-        if (!empty($updates->getUpdatedAt())) {
+        if (! empty($updates->getUpdatedAt())) {
             $attributes['_updatedAt'] = $updates->getUpdatedAt();
         }
 
-        if (!empty($updates->getCreatedAt())) {
+        if (! empty($updates->getCreatedAt())) {
             $attributes['_createdAt'] = $updates->getCreatedAt();
         }
 
@@ -488,91 +669,76 @@ public function updateDocuments(Document $collection, Document $updates, array $
             return 0;
         }
 
-        $keyIndex = 0;
-        $opIndex = 0;
-        $columns = '';
-        $operators = [];
+        $name = $this->filter($collection);
 
         // Separate regular attributes from operators
+        $operators = [];
         foreach ($attributes as $attribute => $value) {
             if (Operator::isOperator($value)) {
                 $operators[$attribute] = $value;
             }
         }
 
-        foreach ($attributes as $attribute => $value) {
-            $column = $this->filter($attribute);
+        // Build the UPDATE using the query builder
+        $builder = $this->newBuilder($name);
 
-            // Check if this is an operator, spatial attribute, or regular attribute
+        // Regular (non-operator, non-spatial) attributes go into set()
+        $regularRow = [];
+        foreach ($attributes as $attribute => $value) {
             if (isset($operators[$attribute])) {
-                $columns .= $this->getOperatorSQL($column, $operators[$attribute], $opIndex);
-            } elseif (\in_array($attribute, $spatialAttributes)) {
-                $columns .= "{$this->quote($column)} = " . $this->getSpatialGeomFromText(":key_{$keyIndex}");
-                $keyIndex++;
-            } else {
-                $columns .= "{$this->quote($column)} = :key_{$keyIndex}";
-                $keyIndex++;
+                continue; // Handled via setRaw below
             }
-
-            if ($attribute !== \array_key_last($attributes)) {
-                $columns .= ',';
+            if (\in_array($attribute, $spatialAttributes)) {
+                continue; // Handled via setRaw below
             }
-        }
-
-        // Remove trailing comma if present
-        $columns = \rtrim($columns, ',');
-
-        if (empty($columns)) {
-            return 0;
-        }
-
-        $name = $this->filter($collection);
-        $sequences = \array_map(fn ($document) => $document->getSequence(), $documents);
 
-        $sql = "
-            UPDATE {$this->getSQLTable($name)}
-            SET {$columns}
-            WHERE _id IN (" . \implode(', ', \array_map(fn ($index) => ":_id_{$index}", \array_keys($sequences))) . ")
-            {$this->getTenantQuery($collection)}
-        ";
+            $column = $this->filter($attribute);
 
-        $sql = $this->trigger(Database::EVENT_DOCUMENTS_UPDATE, $sql);
-        $stmt = $this->getPDO()->prepare($sql);
+            if (\is_array($value)) {
+                $value = \json_encode($value);
+            }
+            if ($this->supports(Capability::IntegerBooleans)) {
+                $value = (\is_bool($value)) ? (int) $value : $value;
+            }
 
-        if ($this->sharedTables) {
-            $stmt->bindValue(':_tenant', $this->tenant);
+            $regularRow[$column] = $value;
         }
 
-        foreach ($sequences as $id => $value) {
-            $stmt->bindValue(":_id_{$id}", $value);
+        if (! empty($regularRow)) {
+            $builder->set($regularRow);
         }
 
-        $keyIndex = 0;
-        $opIndexForBinding = 0;
-        foreach ($attributes as $attributeName => $value) {
-            // Skip operators as they don't need value binding
-            if (isset($operators[$attributeName])) {
-                $this->bindOperatorParams($stmt, $operators[$attributeName], $opIndexForBinding);
+        // Spatial attributes use setRaw with ST_GeomFromText(?)
+        foreach ($attributes as $attribute => $value) {
+            if (! \in_array($attribute, $spatialAttributes)) {
                 continue;
             }
+            $column = $this->filter($attribute);
 
-            // 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 (\is_array($value)) {
+                $value = $this->convertArrayToWKT($value);
             }
 
-            $bindKey = 'key_' . $keyIndex;
-            if ($this->getSupportForIntegerBooleans()) {
-                $value = (\is_bool($value)) ? (int)$value : $value;
-            }
-            $stmt->bindValue(':' . $bindKey, $value, $this->getPDOType($value));
-            $keyIndex++;
+            $builder->setRaw($column, $this->getSpatialGeomFromText('?'), [$value]);
+        }
+
+        // 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']);
         }
 
+        $builder->setRaw('_version', $this->quote('_version') . ' + 1', []);
+
+        // WHERE _id IN (sequence values)
+        $sequences = \array_map(fn ($document) => $document->getSequence(), $documents);
+        $builder->filter([BaseQuery::equal('_id', \array_values($sequences))]);
+
+        $result = $builder->update();
+        $stmt = $this->executeResult($result, Event::DocumentsUpdate);
+
         try {
             $stmt->execute();
         } catch (PDOException $e) {
@@ -581,177 +747,112 @@ public function updateDocuments(Document $collection, Document $updates, array $
 
         $affected = $stmt->rowCount();
 
-        // Permissions logic
-        if ($updates->offsetExists('$permissions')) {
-            $removeQueries = [];
-            $removeBindValues = [];
-
-            $addQuery = '';
-            $addBindValues = [];
-
-            foreach ($documents as $index => $document) {
-                if ($document->getAttribute('$skipPermissionsUpdate', false)) {
-                    continue;
-                }
-
-                $sql = "
-                    SELECT _type, _permission
-                    FROM {$this->getSQLTable($name . '_perms')}
-                    WHERE _document = :_uid
-                    {$this->getTenantQuery($collection)}
-                ";
+        $ctx = $this->buildWriteContext($name);
+        $this->runWriteHooks(fn ($hook) => $hook->afterDocumentBatchUpdate($name, $updates, $documents, $ctx));
 
-                $sql = $this->trigger(Database::EVENT_PERMISSIONS_READ, $sql);
-
-                $permissionsStmt = $this->getPDO()->prepare($sql);
-                $permissionsStmt->bindValue(':_uid', $document->getId());
-
-                if ($this->sharedTables) {
-                    $permissionsStmt->bindValue(':_tenant', $this->tenant);
-                }
-
-                $permissionsStmt->execute();
-                $permissions = $permissionsStmt->fetchAll();
-                $permissionsStmt->closeCursor();
-
-                $initial = [];
-                foreach (Database::PERMISSIONS as $type) {
-                    $initial[$type] = [];
-                }
+        return $affected;
+    }
 
-                $permissions = \array_reduce($permissions, function (array $carry, array $item) {
-                    $carry[$item['_type']][] = $item['_permission'];
-                    return $carry;
-                }, $initial);
-
-                // Get removed Permissions
-                $removals = [];
-                foreach (Database::PERMISSIONS as $type) {
-                    $diff = array_diff($permissions[$type], $updates->getPermissionsByType($type));
-                    if (!empty($diff)) {
-                        $removals[$type] = $diff;
-                    }
-                }
-
-                // 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))) .
-                            ")
-                        )";
-                    }
-                }
-
-                // Get added Permissions
-                $additions = [];
-                foreach (Database::PERMISSIONS as $type) {
-                    $diff = \array_diff($updates->getPermissionsByType($type), $permissions[$type]);
-                    if (!empty($diff)) {
-                        $additions[$type] = $diff;
-                    }
-                }
-
-                // 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 ($this->sharedTables) {
-                                $addQuery .= ", :_tenant)";
-                            } else {
-                                $addQuery .= ")";
-                            }
+    /**
+     * @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);
 
-                            if ($i !== \array_key_last($permissionsToAdd) || $type !== \array_key_last($additions)) {
-                                $addQuery .= ', ';
-                            }
-                        }
-                    }
-                    if ($index !== \array_key_last($documents)) {
-                        $addQuery .= ', ';
-                    }
-                }
+            /** @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['$id'] ?? '';
+                $attrId = \is_scalar($attrIdRaw) ? (string) $attrIdRaw : '';
+                $attributeDefaults[$attrId] = $attr['default'] ?? null;
             }
 
-            if (!empty($removeQueries)) {
-                $removeQuery = \implode(' OR ', $removeQueries);
-
-                $stmtRemovePermissions = $this->getPDO()->prepare("
-                    DELETE
-                    FROM {$this->getSQLTable($name . '_perms')}
-                    WHERE ({$removeQuery})
-                ");
+            $collection = $collection->getId();
+            $name = $this->filter($collection);
 
-                foreach ($removeBindValues as $key => $value) {
-                    $stmtRemovePermissions->bindValue($key, $value, $this->getPDOType($value));
-                }
+            $hasOperators = false;
+            $firstChange = $changes[0];
+            $firstDoc = $firstChange->getNew();
+            $firstExtracted = Operator::extractOperators($firstDoc->getAttributes());
 
-                if ($this->sharedTables) {
-                    $stmtRemovePermissions->bindValue(':_tenant', $this->tenant);
+            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;
+                    }
                 }
-                $stmtRemovePermissions->execute();
             }
 
-            if (!empty($addQuery)) {
-                $sqlAddPermissions = "
-                    INSERT INTO {$this->getSQLTable($name . '_perms')} (_document, _type, _permission
-                ";
+            if (! $hasOperators) {
+                $this->executeUpsertBatch($name, $changes, $spatialAttributes, $attribute, [], $attributeDefaults, false);
+            } else {
+                $groups = [];
 
-                if ($this->sharedTables) {
-                    $sqlAddPermissions .= ', _tenant)';
-                } else {
-                    $sqlAddPermissions .= ')';
-                }
+                foreach ($changes as $change) {
+                    $document = $change->getNew();
+                    $extracted = Operator::extractOperators($document->getAttributes());
+                    $operators = $extracted['operators'];
 
-                $sqlAddPermissions .=  " VALUES {$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);
+                    }
 
-                $stmtAddPermissions = $this->getPDO()->prepare($sqlAddPermissions);
+                    if (! isset($groups[$signature])) {
+                        $groups[$signature] = [
+                            'documents' => [],
+                            'operators' => $operators,
+                        ];
+                    }
 
-                foreach ($addBindValues as $key => $value) {
-                    $stmtAddPermissions->bindValue($key, $value, $this->getPDOType($value));
+                    $groups[$signature]['documents'][] = $change;
                 }
 
-                if ($this->sharedTables) {
-                    $stmtAddPermissions->bindValue(':_tenant', $this->tenant);
+                foreach ($groups as $group) {
+                    $this->executeUpsertBatch($name, $group['documents'], $spatialAttributes, '', $group['operators'], $attributeDefaults, true);
                 }
-
-                $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
@@ -760,55 +861,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)}
-            ";
+            // Delete documents
+            $builder = $this->newBuilder($name);
+            $builder->filter([BaseQuery::equal('_id', \array_values($sequences))]);
+            $result = $builder->delete();
+            $stmt = $this->executeResult($result, Event::DocumentsDelete);
 
-            $sql = $this->trigger(Database::EVENT_DOCUMENTS_DELETE, $sql);
-
-            $stmt = $this->getPDO()->prepare($sql);
-
-            foreach ($sequences as $id => $value) {
-                $stmt->bindValue(":_id_{$id}", $value);
-            }
-
-            if ($this->sharedTables) {
-                $stmt->bindValue(':_tenant', $this->tenant);
-            }
-
-            if (!$stmt->execute()) {
+            if (! $stmt->execute()) {
                 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);
         }
 
@@ -818,29 +888,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();
-                }
             }
         }
 
@@ -848,23 +907,15 @@ 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(['_uid', '_id']);
+        $builder->filter([BaseQuery::equal('_uid', $documentIds)]);
 
+        $result = $builder->build();
+        $stmt = $this->executeResult($result);
         $stmt->execute();
-        $sequences = $stmt->fetchAll(\PDO::FETCH_KEY_PAIR); // Fetch as [documentId => sequence]
+        /** @var array<string, mixed> $sequences */
+        $sequences = $stmt->fetchAll(PDO::FETCH_KEY_PAIR); // Fetch as [documentId => sequence]
         $stmt->closeCursor();
 
         foreach ($documents as $document) {
@@ -876,198 +927,662 @@ public function getSequences(string $collection, array $documents): array
         return $documents;
     }
 
-    /**
-     * Get max STRING limit
-     *
-     * @return int
-     */
-    public function getLimitForString(): int
-    {
-        return 4294967295;
-    }
-
-    /**
-     * Get max INT limit
-     *
-     * @return int
-     */
-    public function getLimitForInt(): int
-    {
-        return 4294967295;
-    }
+    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);
 
-    /**
-     * 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
-     *
-     * @return int
-     */
-    public function getLimitForAttributes(): int
-    {
-        return 1017;
-    }
+        $builder = $this->newBuilder($name);
+        $builder->setRaw($attribute, $this->quote($attribute).' + ?', [$value]);
+        $builder->set(['_updatedAt' => $updatedAt]);
 
-    /**
-     * Get maximum index limit.
-     * https://mariadb.com/kb/en/innodb-limitations/#limitations-on-schema
-     *
-     * @return int
-     */
-    public function getLimitForIndexes(): int
-    {
-        return 64;
-    }
+        $filters = [BaseQuery::equal('_uid', [$id])];
+        if ($max !== null) {
+            $filters[] = BaseQuery::lessThanEqual($attribute, $max);
+        }
+        if ($min !== null) {
+            $filters[] = BaseQuery::greaterThanEqual($attribute, $min);
+        }
+        $builder->filter($filters);
 
-    /**
-     * Is schemas supported?
-     *
-     * @return bool
-     */
-    public function getSupportForSchemas(): bool
-    {
-        return true;
-    }
+        $result = $builder->update();
+        $stmt = $this->executeResult($result, Event::DocumentUpdate);
 
-    /**
-     * Is index supported?
-     *
-     * @return bool
-     */
-    public function getSupportForIndex(): bool
-    {
-        return true;
-    }
+        try {
+            $stmt->execute();
+        } catch (PDOException $e) {
+            throw $this->processException($e);
+        }
 
-    /**
-     * Are attributes supported?
-     *
-     * @return bool
-     */
-    public function getSupportForAttributes(): bool
-    {
         return true;
     }
 
-    /**
-     * Is unique index supported?
-     *
-     * @return bool
-     */
-    public function getSupportForUniqueIndex(): bool
+    public function deleteDocument(string $collection, string $id): bool
     {
-        return true;
-    }
+        try {
+            $this->syncWriteHooks();
 
-    /**
-     * Is fulltext index supported?
-     *
-     * @return bool
-     */
-    public function getSupportForFulltextIndex(): bool
-    {
-        return true;
-    }
+            $name = $this->filter($collection);
 
-    /**
-     * Are FOR UPDATE locks supported?
-     *
-     * @return bool
-     */
-    public function getSupportForUpdateLock(): bool
-    {
-        return true;
-    }
+            $builder = $this->newBuilder($name);
+            $builder->filter([BaseQuery::equal('_uid', [$id])]);
+            $result = $builder->delete();
+            $stmt = $this->executeResult($result, Event::DocumentDelete);
 
-    /**
-     * Is Attribute Resizing Supported?
-     *
-     * @return bool
-     */
-    public function getSupportForAttributeResizing(): bool
-    {
-        return true;
-    }
+            if (! $stmt->execute()) {
+                throw new DatabaseException('Failed to delete document');
+            }
 
-    /**
-     * Are batch operations supported?
-     *
-     * @return bool
-     */
-    public function getSupportForBatchOperations(): bool
-    {
-        return true;
-    }
+            $deleted = $stmt->rowCount();
 
-    /**
-     * Is get connection id supported?
-     *
-     * @return bool
-     */
-    public function getSupportForGetConnectionId(): bool
-    {
-        return true;
-    }
+            $ctx = $this->buildWriteContext($name);
+            $this->runWriteHooks(fn ($hook) => $hook->afterDocumentDelete($name, [$id], $ctx));
+        } catch (\Throwable $e) {
+            throw new DatabaseException($e->getMessage(), $e->getCode(), $e);
+        }
 
-    /**
-     * Is cache fallback supported?
-     *
-     * @return bool
-     */
-    public function getSupportForCacheSkipOnFailure(): bool
-    {
-        return true;
+        return $deleted > 0;
     }
 
     /**
-     * Is hostname supported?
+     * Find Documents
      *
-     * @return bool
-     */
-    public function getSupportForHostname(): bool
-    {
-        return true;
-    }
-
-    /**
-     * Get current attribute count from collection document
+     * @param  array<Query>  $queries
+     * @param  array<string>  $orderAttributes
+     * @param  array<OrderDirection>  $orderTypes
+     * @param  array<string, mixed>  $cursor
+     * @return array<Document>
      *
-     * @param Document $collection
-     * @return int
+     * @throws DatabaseException
+     * @throws TimeoutException
+     * @throws Exception
      */
-    public function getCountOfAttributes(Document $collection): 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
     {
-        $attributes = \count($collection->getAttribute('attributes') ?? []);
+        $collectionDoc = $collection;
+        $collection = $collection->getId();
+        $name = $this->filter($collection);
+        $roles = $this->authorization->getRoles();
+        $alias = Query::DEFAULT_ALIAS;
 
-        return $attributes + $this->getCountOfDefaultAttributes();
-    }
+        $queries = array_map(fn ($query) => clone $query, $queries);
 
-    /**
-     * Get current index count from collection document
+        // Extract vector queries for ORDER BY
+        $vectorQueries = [];
+        $otherQueries = [];
+        foreach ($queries as $query) {
+            if ($query->getMethod()->isVector()) {
+                $vectorQueries[] = $query;
+            } else {
+                $otherQueries[] = $query;
+            }
+        }
+
+        $queries = $otherQueries;
+
+        $hasAggregation = false;
+        $hasJoins = false;
+        foreach ($queries as $query) {
+            if ($query->getMethod()->isAggregate() || $query->getMethod() === Method::GroupBy) {
+                $hasAggregation = true;
+            }
+            if ($query->getMethod()->isJoin()) {
+                $hasJoins = true;
+            }
+        }
+
+        $builder = $this->newBuilder($name, $alias);
+
+        if (! $hasAggregation) {
+            $selections = $this->getAttributeSelections($queries);
+            if (! empty($selections) && ! \in_array('*', $selections)) {
+                $builder->select($this->mapSelectionsToColumns($selections));
+            }
+        }
+
+        $joinTablePrefixes = [];
+        $joinIndex = 0;
+
+        if ($hasJoins) {
+            foreach ($queries as $query) {
+                if ($query->getMethod()->isJoin()) {
+                    $joinTable = $query->getAttribute();
+                    $resolvedTable = $this->getSQLTableRaw($this->filter($joinTable));
+                    $joinAlias = 'j' . $joinIndex++;
+                    $query->setAttribute($resolvedTable);
+
+                    $values = $query->getValues();
+                    if (count($values) >= 3) {
+                        /** @var string $leftCol */
+                        $leftCol = $values[0];
+                        /** @var string $rightCol */
+                        $rightCol = $values[2];
+
+                        $leftInternal = $this->getInternalKeyForAttribute($leftCol);
+                        $rightInternal = $this->getInternalKeyForAttribute($rightCol);
+
+                        $values[0] = $alias . '.' . $leftInternal;
+                        $values[2] = $joinAlias . '.' . $rightInternal;
+                        $values[3] = $joinAlias;
+                        $query->setValues($values);
+
+                        $joinTablePrefixes[$joinTable] = $joinAlias;
+                    }
+                }
+            }
+        }
+
+        if ($hasAggregation && ! empty($joinTablePrefixes)) {
+            /** @var array<Document> $collectionAttrs */
+            $collectionAttrs = $collectionDoc->getAttribute('attributes', []);
+            $mainAttributeIds = \array_map(
+                fn (Document $attr) => $attr->getId(),
+                $collectionAttrs
+            );
+            $defaultJoinPrefix = \array_values($joinTablePrefixes)[0];
+
+            foreach ($queries as $query) {
+                if ($query->getMethod()->isAggregate()) {
+                    $attr = $query->getAttribute();
+                    if ($attr !== '*' && $attr !== '' && ! \str_contains($attr, '.') && ! \in_array($attr, $mainAttributeIds)) {
+                        $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, '.') && ! \in_array($col, $mainAttributeIds)) {
+                            $internalCol = $this->getInternalKeyForAttribute($col);
+                            $values[$i] = $defaultJoinPrefix . '.' . $internalCol;
+                            $qualified = true;
+                        }
+                    }
+                    if ($qualified) {
+                        $query->setValues($values);
+                    }
+                }
+            }
+        }
+
+        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
+                    ));
+                }
+            }
+        }
+
+        // Pass all queries (filters, aggregations, joins, groupBy, having) to the builder
+        $builder->filter($queries);
+
+        // Permission subquery for primary table
+        if ($this->authorization->getStatus()) {
+            $docCol = $hasJoins ? $alias . '._uid' : '_uid';
+            $builder->addHook($this->newPermissionHook($name, $roles, $forPermission->value, $docCol));
+
+            // Permission subquery for each joined table
+            foreach ($joinTablePrefixes as $joinTable => $joinAlias) {
+                $builder->addHook($this->newPermissionHook(
+                    $this->filter($joinTable),
+                    $roles,
+                    $forPermission->value,
+                    $joinAlias . '._uid'
+                ));
+            }
+        }
+
+        // Cursor pagination - build nested Query objects for complex multi-attribute cursor conditions
+        if (! empty($cursor)) {
+            $cursorConditions = [];
+
+            foreach ($orderAttributes as $i => $originalAttribute) {
+                $orderType = $orderTypes[$i] ?? OrderDirection::Asc;
+                if ($orderType === OrderDirection::Random) {
+                    continue;
+                }
+
+                $direction = $orderType;
+
+                if ($cursorDirection === CursorDirection::Before) {
+                    $direction = ($direction === OrderDirection::Asc)
+                        ? OrderDirection::Desc
+                        : OrderDirection::Asc;
+                }
+
+                $internalAttr = $this->filter($this->getInternalKeyForAttribute($originalAttribute));
+
+                // Special case: single attribute on unique primary key
+                if (count($orderAttributes) === 1 && $i === 0 && $originalAttribute === '$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;
+                }
+
+                // Multi-attribute cursor: (prev_attrs equal) AND (current_attr > or < cursor)
+                $andConditions = [];
+
+                for ($j = 0; $j < $i; $j++) {
+                    $prevOriginal = $orderAttributes[$j];
+                    $prevAttr = $this->filter($this->getInternalKeyForAttribute($prevOriginal));
+                    /** @var array<array<mixed>|bool|float|int|string|null> $prevCursorVals */
+                    $prevCursorVals = [$cursor[$prevOriginal]];
+                    $andConditions[] = BaseQuery::equal($prevAttr, $prevCursorVals);
+                }
+
+                /** @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 (count($andConditions) === 1) {
+                    $cursorConditions[] = $andConditions[0];
+                } else {
+                    $cursorConditions[] = BaseQuery::and($andConditions);
+                }
+            }
+
+            if (! empty($cursorConditions)) {
+                if (count($cursorConditions) === 1) {
+                    $builder->filter($cursorConditions);
+                } else {
+                    $builder->filter([BaseQuery::or($cursorConditions)]);
+                }
+            }
+        }
+
+        // Vector ordering (comes first for similarity search)
+        foreach ($vectorQueries as $query) {
+            $vectorRaw = $this->getVectorOrderRaw($query, $alias);
+            if ($vectorRaw !== null) {
+                $builder->orderByRaw($vectorRaw['expression'], $vectorRaw['bindings']);
+            }
+        }
+
+        // Full-text search relevance scoring
+        $searchQueries = $this->extractSearchQueries($queries);
+        if (! empty($searchQueries)) {
+            $builder->select(['*']);
+            foreach ($searchQueries as $searchQuery) {
+                $relevanceRaw = $this->getSearchRelevanceRaw($searchQuery, $alias);
+                if ($relevanceRaw !== null) {
+                    $builder->selectRaw($relevanceRaw['expression'], $relevanceRaw['bindings']);
+                    $builder->orderByRaw($relevanceRaw['order']);
+                }
+            }
+        }
+
+        // Regular ordering
+        foreach ($orderAttributes as $i => $originalAttribute) {
+            $orderType = $orderTypes[$i] ?? OrderDirection::Asc;
+
+            if ($orderType === OrderDirection::Random) {
+                $builder->sortRandom();
+
+                continue;
+            }
+
+            $internalAttr = $this->filter($this->getInternalKeyForAttribute($originalAttribute));
+            $direction = $orderType;
+
+            if ($cursorDirection === CursorDirection::Before) {
+                $direction = ($direction === OrderDirection::Asc)
+                    ? OrderDirection::Desc
+                    : OrderDirection::Asc;
+            }
+
+            if ($direction === OrderDirection::Desc) {
+                $builder->sortDesc($internalAttr);
+            } else {
+                $builder->sortAsc($internalAttr);
+            }
+        }
+
+        // Limit/offset
+        if (! \is_null($limit)) {
+            $builder->limit($limit);
+        }
+        if (! \is_null($offset)) {
+            $builder->offset($offset);
+        }
+
+        try {
+            $result = $builder->build();
+        } catch (ValidationException $e) {
+            throw new QueryException($e->getMessage(), $e->getCode(), $e);
+        }
+
+        $sql = $result->query;
+
+        try {
+            $stmt = $this->getPDO()->prepare($sql);
+            foreach ($result->bindings as $i => $value) {
+                if (\is_bool($value) && $this->supports(Capability::IntegerBooleans)) {
+                    $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));
+                }
+            }
+            $this->execute($stmt);
+        } catch (PDOException $e) {
+            throw $this->processException($e);
+        }
+
+        $results = $stmt->fetchAll();
+        $stmt->closeCursor();
+
+        $documents = [];
+
+        if ($hasAggregation) {
+            foreach ($results as $row) {
+                /** @var array<string, mixed> $row */
+                $documents[] = new Document($row);
+            }
+
+            return $documents;
+        }
+
+        foreach ($results as $row) {
+            /** @var array<string, mixed> $row */
+            $this->remapRow($row);
+            $documents[] = new Document($row);
+        }
+
+        if ($cursorDirection === CursorDirection::Before) {
+            $documents = \array_reverse($documents);
+        }
+
+        return $documents;
+    }
+
+    /**
+     * @param array<mixed> $bindings
+     * @return array<Document>
      *
-     * @param Document $collection
-     * @return int
+     * @throws DatabaseException
+     */
+    public function rawQuery(string $query, array $bindings = []): array
+    {
+        try {
+            $stmt = $this->getPDO()->prepare($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[] = new Document($row);
+        }
+
+        return $documents;
+    }
+
+    /**
+     * Count Documents
+     *
+     * @param  array<Query>  $queries
+     *
+     * @throws Exception
+     * @throws PDOException
+     */
+    public function count(Document $collection, array $queries = [], ?int $max = null): int
+    {
+        $collection = $collection->getId();
+        $name = $this->filter($collection);
+        $roles = $this->authorization->getRoles();
+        $alias = Query::DEFAULT_ALIAS;
+
+        $queries = array_map(fn ($query) => clone $query, $queries);
+
+        $otherQueries = [];
+        foreach ($queries as $query) {
+            if (! $query->getMethod()->isVector()) {
+                $otherQueries[] = $query;
+            }
+        }
+
+        // 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);
+        }
+
+        // Wrap in outer count: SELECT COUNT(1) as sum FROM (...) table_count
+        $outerBuilder = $this->createBuilder();
+        $outerBuilder->fromSub($innerBuilder, 'table_count');
+        $outerBuilder->count('1', 'sum');
+
+        $result = $outerBuilder->build();
+        $sql = $result->query;
+        $stmt = $this->getPDO()->prepare($sql);
+
+        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));
+            }
+        }
+
+        try {
+            $this->execute($stmt);
+        } catch (PDOException $e) {
+            throw $this->processException($e);
+        }
+
+        $result = $stmt->fetchAll();
+        $stmt->closeCursor();
+        if (! empty($result)) {
+            $result = $result[0];
+        }
+
+        if (\is_array($result)) {
+            $sumInt = $result['sum'] ?? 0;
+
+            return \is_numeric($sumInt) ? (int) $sumInt : 0;
+        }
+
+        return 0;
+    }
+
+    /**
+     * Sum an Attribute
+     *
+     * @param  array<Query>  $queries
+     *
+     * @throws Exception
+     * @throws PDOException
+     */
+    public function sum(Document $collection, string $attribute, array $queries = [], ?int $max = null): int|float
+    {
+        $collection = $collection->getId();
+        $name = $this->filter($collection);
+        $attribute = $this->filter($attribute);
+        $roles = $this->authorization->getRoles();
+        $alias = Query::DEFAULT_ALIAS;
+
+        $queries = array_map(fn ($query) => clone $query, $queries);
+
+        $otherQueries = [];
+        foreach ($queries as $query) {
+            if (! $query->getMethod()->isVector()) {
+                $otherQueries[] = $query;
+            }
+        }
+
+        // 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);
+        }
+
+        // Wrap in outer sum: SELECT SUM(attribute) as sum FROM (...) table_count
+        $outerBuilder = $this->createBuilder();
+        $outerBuilder->fromSub($innerBuilder, 'table_count');
+        $outerBuilder->sum($attribute, 'sum');
+
+        $result = $outerBuilder->build();
+        $sql = $result->query;
+        $stmt = $this->getPDO()->prepare($sql);
+
+        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));
+            }
+        }
+
+        try {
+            $this->execute($stmt);
+        } catch (PDOException $e) {
+            throw $this->processException($e);
+        }
+
+        $result = $stmt->fetchAll();
+        $stmt->closeCursor();
+        if (! empty($result)) {
+            $result = $result[0];
+        }
+
+        if (\is_array($result)) {
+            $sumVal = $result['sum'] ?? 0;
+
+            if (\is_numeric($sumVal)) {
+                return \str_contains((string) $sumVal, '.') ? (float) $sumVal : (int) $sumVal;
+            }
+
+            return 0;
+        }
+
+        return 0;
+    }
+
+    /**
+     * Get max STRING limit
+     */
+    public function getLimitForString(): int
+    {
+        return 4294967295;
+    }
+
+    /**
+     * Get max INT limit
+     */
+    public function getLimitForInt(): int
+    {
+        return 4294967295;
+    }
+
+    /**
+     * 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
+     */
+    public function getLimitForAttributes(): int
+    {
+        return 1017;
+    }
+
+    /**
+     * Get maximum index limit.
+     * https://mariadb.com/kb/en/innodb-limitations/#limitations-on-schema
+     */
+    public function getLimitForIndexes(): int
+    {
+        return 64;
+    }
+
+    /**
+     * Get current attribute count from collection document
+     */
+    public function getCountOfAttributes(Document $collection): int
+    {
+        /** @var array<mixed> $attrs */
+        $attrs = $collection->getAttribute('attributes') ?? [];
+        $attributes = \count($attrs);
+
+        return $attributes + $this->getCountOfDefaultAttributes();
+    }
+
+    /**
+     * Get current index count from collection document
      */
     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
     {
@@ -1077,8 +1592,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
     {
@@ -1090,8 +1603,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
@@ -1106,9 +1617,9 @@ public function getAttributeWidth(Document $collection): int
          * `_updatedAt` datetime(3) => 7 bytes
          * `_permissions` mediumtext => 20
          */
-
         $total = 1067;
 
+        /** @var array<int, array<string, mixed>> $attributes */
         $attributes = $collection->getAttributes()['attributes'] ?? [];
 
         foreach ($attributes as $attribute) {
@@ -1117,66 +1628,69 @@ public function getAttributeWidth(Document $collection): int
              * only the pointer contributes 20 bytes
              * data is stored externally
              */
-
             if ($attribute['array'] ?? false) {
                 $total += 20;
+
                 continue;
             }
 
-            switch ($attribute['type']) {
-                case Database::VAR_ID:
+            $attrSize = (int) (is_scalar($attribute['size'] ?? 0) ? ($attribute['size'] ?? 0) : 0);
+            $attrType = (string) (is_scalar($attribute['type'] ?? '') ? ($attribute['type'] ?? '') : '');
+
+            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_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
@@ -1186,7 +1700,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
@@ -1195,27 +1709,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/
@@ -1498,922 +2050,769 @@ 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
-    {
-        return true;
-    }
-
-    public function getSupportForNumericCasting(): bool
+    public function getInternalIndexesKeys(): array
     {
-        return false;
+        return ['primary', '_created_at', '_updated_at', '_tenant_id'];
     }
 
-
     /**
-     * Does the adapter handle Query Array Contains?
+     * Get the minimum supported datetime value.
      *
-     * @return bool
+     * @return \DateTime
      */
-    public function getSupportForQueryContains(): bool
+    public function getMinDateTime(): \DateTime
     {
-        return true;
+        return new \DateTime('1000-01-01 00:00:00');
     }
 
     /**
-     * Does the adapter handle array Overlaps?
+     * Analyze a collection, updating its metadata on the database engine.
      *
-     * @return bool
+     * @throws DatabaseException
      */
-    abstract public function getSupportForJSONOverlaps(): bool;
-
-    public function getSupportForIndexArray(): bool
-    {
-        return true;
-    }
-
-    public function getSupportForCastIndexArray(): bool
-    {
-        return false;
-    }
-
-    public function getSupportForRelationships(): bool
-    {
-        return true;
-    }
-
-    public function getSupportForReconnection(): bool
-    {
-        return true;
-    }
-
-    public function getSupportForBatchCreateAttributes(): bool
-    {
-        return true;
-    }
-
-    /**
-     * Are spatial attributes supported?
-     *
-     * @return bool
-    */
-    public function getSupportForSpatialAttributes(): bool
+    public function analyzeCollection(string $collection): bool
     {
         return false;
     }
 
     /**
-     * Does the adapter support null values in spatial indexes?
+     * Delete a database schema.
      *
-     * @return bool
+     * @throws Exception
+     * @throws PDOException
      */
-    public function getSupportForSpatialIndexNull(): bool
+    public function delete(string $name): bool
     {
-        return false;
+        $name = $this->filter($name);
+
+        $result = $this->createSchemaBuilder()->dropDatabase($name);
+        $sql = $result->query;
+
+        return $this->getPDO()
+            ->prepare($sql)
+            ->execute();
     }
 
     /**
-     * Does the adapter support operators?
+     * Delete a collection and its permissions table.
      *
-     * @return bool
+     * @throws DatabaseException
      */
-    public function getSupportForOperators(): bool
+    public function deleteCollection(string $id): bool
     {
-        return true;
-    }
+        $id = $this->filter($id);
 
-    /**
-     * Does the adapter support order attribute in spatial indexes?
-     *
-     * @return bool
-    */
-    public function getSupportForSpatialIndexOrder(): bool
-    {
-        return false;
-    }
+        $schema = $this->createSchemaBuilder();
+        $mainResult = $schema->drop($this->getSQLTableRaw($id));
+        $permsResult = $schema->drop($this->getSQLTableRaw($id . '_perms'));
 
-    /**
-    * Is internal casting supported?
-    *
-    * @return bool
-    */
-    public function getSupportForInternalCasting(): bool
-    {
-        return false;
-    }
+        $sql = $mainResult->query . '; ' . $permsResult->query;
 
-    /**
-     * Does the adapter support multiple fulltext indexes?
-     *
-     * @return bool
-     */
-    public function getSupportForMultipleFulltextIndexes(): bool
-    {
-        return true;
+        return $this->getPDO()->prepare($sql)->execute();
     }
 
     /**
-     * Does the adapter support identical indexes?
+     * Create a relationship between collections by adding foreign key columns.
      *
-     * @return bool
+     * @throws DatabaseException
      */
-    public function getSupportForIdenticalIndexes(): bool
+    public function createRelationship(Relationship $relationship): bool
     {
-        return true;
+        $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 {
+            $result = $schema->alter($this->getSQLTableRaw($tableName), function (Blueprint $table) use ($columnId) {
+                $table->string($columnId, 255)->nullable()->default(null);
+            });
+
+            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->getPDO()
+            ->prepare($sql)
+            ->execute();
     }
 
     /**
-     * Does the adapter support random order for queries?
+     * Update a relationship, optionally renaming its keys.
      *
-     * @return bool
+     * @throws DatabaseException
      */
-    public function getSupportForOrderRandom(): bool
-    {
-        return true;
-    }
+    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);
+        }
 
-    public function getSupportForUTCCasting(): bool
-    {
-        return false;
-    }
+        $schema = $this->createSchemaBuilder();
+        $renameCol = function (string $tableName, string $from, string $to) use ($schema): string {
+            $result = $schema->alter($this->getSQLTableRaw($tableName), function (Blueprint $table) use ($from, $to) {
+                $table->renameColumn($from, $to);
+            });
 
-    public function setUTCDatetime(string $value): mixed
-    {
-        return $value;
-    }
+            return $result->query;
+        };
 
-    public function castingBefore(Document $collection, Document $document): Document
-    {
-        return $document;
-    }
+        $sql = '';
 
-    public function castingAfter(Document $collection, Document $document): Document
-    {
-        return $document;
-    }
+        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(['$id' => Database::METADATA]);
+                $collection = $this->getDocument($metadataCollection, $collection);
+                $relatedCollection = $this->getDocument($metadataCollection, $relatedCollection);
 
-    /**
-     * Does the adapter support spatial axis order specification?
-     *
-     * @return bool
-     */
-    public function getSupportForSpatialAxisOrder(): bool
-    {
-        return false;
-    }
+                $junctionName = '_' . $collection->getSequence() . '_' . $relatedCollection->getSequence();
 
-    /**
-     * Is vector type supported?
-     *
-     * @return bool
-     */
-    public function getSupportForVectors(): bool
-    {
-        return false;
+                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->getPDO()
+            ->prepare($sql)
+            ->execute();
     }
 
     /**
-     * Generate ST_GeomFromText call with proper SRID and axis order support
+     * Delete a relationship between collections.
      *
-     * @param string $wktPlaceholder
-     * @param int|null $srid
-     * @return string
+     * @throws DatabaseException
      */
-    protected function getSpatialGeomFromText(string $wktPlaceholder, ?int $srid = null): string
+    public function deleteRelationship(Relationship $relationship): bool
     {
-        $srid = $srid ?? Database::DEFAULT_SRID;
-        $geomFromText = "ST_GeomFromText({$wktPlaceholder}, {$srid}";
+        $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 {
+            $result = $schema->alter($this->getSQLTableRaw($tableName), function (Blueprint $table) use ($columnId) {
+                $table->dropColumn($columnId);
+            });
+
+            return $result->query;
+        };
 
-        if ($this->getSupportForSpatialAxisOrder()) {
-            $geomFromText .= ", " . $this->getSpatialAxisOrderSpec();
-        }
+        $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(['$id' => Database::METADATA]);
+                $collection = $this->getDocument($metadataCollection, $collection);
+                $relatedCollection = $this->getDocument($metadataCollection, $relatedCollection);
 
-        $geomFromText .= ")";
+                $junctionName = $side === RelationSide::Parent
+                    ? '_' . $collection->getSequence() . '_' . $relatedCollection->getSequence()
+                    : '_' . $relatedCollection->getSequence() . '_' . $collection->getSequence();
 
-        return $geomFromText;
+                $junctionResult = $schema->drop($this->getSQLTableRaw($junctionName));
+                $permsResult = $schema->drop($this->getSQLTableRaw($junctionName . '_perms'));
+
+                $sql = $junctionResult->query . '; ' . $permsResult->query;
+                break;
+            default:
+                throw new DatabaseException('Invalid relationship type');
+        }
+
+        return $this->getPDO()
+            ->prepare($sql)
+            ->execute();
     }
 
     /**
-     * Get the spatial axis order specification string
+     * Convert a type string and size to the corresponding SQL column type definition.
      *
+     * @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
-     */
-    protected function getSpatialAxisOrderSpec(): string
-    {
-        return "'axis-order=long-lat'";
-    }
-
-    /**
-     * @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
-     */
-    abstract protected function getUpsertStatement(
-        string $tableName,
-        string $columns,
-        array $batchKeys,
-        array $attributes,
-        array $bindValues,
-        string $attribute = '',
-        array $operators = []
-    ): mixed;
-
-    /**
-     * Get vector distance calculation for ORDER BY clause
      *
-     * @param Query $query
-     * @param array<string, mixed> $binds
-     * @param string $alias
-     * @return string|null
+     * @throws DatabaseException For unknown type values.
      */
-    protected function getVectorDistanceOrder(Query $query, array &$binds, string $alias): ?string
+    public function getColumnType(string $type, int $size, bool $signed = true, bool $array = false, bool $required = false): string
     {
-        return null;
+        $columnType = ColumnType::tryFrom($type);
+        if ($columnType === null) {
+            throw new DatabaseException('Unknown column type: '.$type);
+        }
+
+        return $this->getSQLType($columnType, $size, $signed, $array, $required);
     }
 
-    /**
-     * @param string $value
-     * @return string
-     */
-    protected function getFulltextValue(string $value): string
+    protected function getSQLType(ColumnType $type, int $size, bool $signed = true, bool $array = false, bool $required = false): string
     {
-        $exact = str_ends_with($value, '"') && str_starts_with($value, '"');
+        if (in_array($type, [ColumnType::Point, ColumnType::Linestring, ColumnType::Polygon], true)) {
+            return $this->getSpatialSQLType($type->value, $required);
+        }
+        if ($array === true) {
+            return 'JSON';
+        }
 
-        /** Replace reserved chars with space. */
-        $specialChars = '@,+,-,*,),(,<,>,~,"';
-        $value = str_replace(explode(',', $specialChars), ' ', $value);
-        $value = preg_replace('/\s+/', ' ', $value); // Remove multiple whitespaces
-        $value = trim($value);
+        if ($type === ColumnType::String) {
+            if ($size > 16777215) {
+                return 'LONGTEXT';
+            }
+            if ($size > 65535) {
+                return 'MEDIUMTEXT';
+            }
+            if ($size > $this->getMaxVarcharLength()) {
+                return 'TEXT';
+            }
 
-        if (empty($value)) {
-            return '';
+            return "VARCHAR({$size})";
         }
 
-        if ($exact) {
-            $value = '"' . $value . '"';
-        } else {
-            /** Prepend wildcard by default on the back. */
-            $value .= '*';
+        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})";
         }
 
-        return $value;
-    }
+        if ($type === ColumnType::Integer) {
+            $suffix = $signed ? '' : ' UNSIGNED';
 
-    /**
-     * Get SQL Operator
-     *
-     * @param string $method
-     * @return string
-     * @throws Exception
-     */
-    protected function getSQLOperator(string $method): string
-    {
-        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 ($size >= 8 ? 'BIGINT' : 'INT') . $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),
+        };
     }
 
-    abstract protected function getSQLType(
-        string $type,
-        int $size,
-        bool $signed = true,
-        bool $array = false,
-        bool $required = false
-    ): string;
-
     /**
-     * @throws DatabaseException For unknown type values.
+     * Get the SQL type definition for spatial column types.
+     *
+     * @param string $type The spatial type (point, linestring, polygon)
+     * @param bool $required Whether the column is NOT NULL
+     * @return string
      */
-    public function getColumnType(string $type, int $size, bool $signed = true, bool $array = false, bool $required = false): string
+    protected function getSpatialSQLType(string $type, bool $required): string
     {
-        return $this->getSQLType($type, $size, $signed, $array, $required);
+        $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 => '',
+        };
     }
 
     /**
      * Get SQL Index Type
      *
-     * @param string $type
-     * @return string
      * @throws Exception
      */
-    protected function getSQLIndexType(string $type): string
+    protected function getSQLIndexType(IndexType $type): string
     {
         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),
+            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),
         };
     }
 
     /**
-     * Get SQL condition for permissions
+     * Extract the spatial geometry type name from a WKT string.
      *
-     * @param string $collection
-     * @param array<string> $roles
-     * @param string $alias
-     * @param string $type
-     * @return string
-     * @throws DatabaseException
+     * @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.
      */
-    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);
+    public function getSpatialTypeFromWKT(string $wkt): string
+    {
+        $wkt = trim($wkt);
+        $pos = strpos($wkt, '(');
+        if ($pos === false) {
+            throw new DatabaseException('Invalid spatial type');
         }
 
-        $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)}
-        )";
+        return strtolower(trim(substr($wkt, 0, $pos)));
     }
 
     /**
-     * Get SQL table
-     *
-     * @param string $name
-     * @return string
-     * @throws DatabaseException
+     * Generate ST_GeomFromText call with proper SRID and axis order support
      */
-    protected function getSQLTable(string $name): string
+    protected function getSpatialGeomFromText(string $wktPlaceholder, ?int $srid = null): string
     {
-        return "{$this->quote($this->getDatabase())}.{$this->quote($this->getNamespace() . '_' .$this->filter($name))}";
+        $srid = $srid ?? Database::DEFAULT_SRID;
+        $geomFromText = "ST_GeomFromText({$wktPlaceholder}, {$srid}";
+
+        if ($this->supports(Capability::SpatialAxisOrder)) {
+            $geomFromText .= ', '.$this->getSpatialAxisOrderSpec();
+        }
+
+        $geomFromText .= ')';
+
+        return $geomFromText;
     }
 
     /**
-     * Generate SQL expression for operator
-     * Each adapter must implement operators specific to their SQL dialect
-     *
-     * @param string $column
-     * @param Operator $operator
-     * @param int &$bindIndex
-     * @return string|null Returns null if operator can't be expressed in SQL
+     * Get the spatial axis order specification string
      */
-    abstract protected function getOperatorSQL(string $column, Operator $operator, int &$bindIndex): ?string;
+    protected function getSpatialAxisOrderSpec(): string
+    {
+        return "'axis-order=long-lat'";
+    }
 
     /**
-     * Bind operator parameters to prepared statement
+     * Build geometry WKT string from array input for spatial queries
      *
-     * @param \PDOStatement|PDOStatementProxy $stmt
-     * @param \Utopia\Database\Operator $operator
-     * @param int &$bindIndex
-     * @return void
+     * @param  array<mixed>  $geometry
+     *
+     * @throws DatabaseException
      */
-    protected function bindOperatorParams(\PDOStatement|PDOStatementProxy $stmt, Operator $operator, int &$bindIndex): void
+    protected function convertArrayToWKT(array $geometry): string
     {
-        $method = $operator->getMethod();
-        $values = $operator->getValues();
-
-        switch ($method) {
-            // Numeric operators with optional limits
-            case Operator::TYPE_INCREMENT:
-            case Operator::TYPE_DECREMENT:
-            case Operator::TYPE_MULTIPLY:
-            case Operator::TYPE_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 Operator::TYPE_MODULO:
-                $value = $values[0] ?? 1;
-                $bindKey = "op_{$bindIndex}";
-                $stmt->bindValue(':' . $bindKey, $value, $this->getPDOType($value));
-                $bindIndex++;
-                break;
-
-            case Operator::TYPE_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;
-
-                // String operators
-            case Operator::TYPE_STRING_CONCAT:
-                $value = $values[0] ?? '';
-                $bindKey = "op_{$bindIndex}";
-                $stmt->bindValue(':' . $bindKey, $value, \PDO::PARAM_STR);
-                $bindIndex++;
-                break;
-
-            case Operator::TYPE_STRING_REPLACE:
-                $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;
-
-                // Boolean operators
-            case Operator::TYPE_TOGGLE:
-                // No parameters to bind
-                break;
-
-                // Date operators
-            case Operator::TYPE_DATE_ADD_DAYS:
-            case Operator::TYPE_DATE_SUB_DAYS:
-                $days = $values[0] ?? 0;
-                $bindKey = "op_{$bindIndex}";
-                $stmt->bindValue(':' . $bindKey, $days, \PDO::PARAM_INT);
-                $bindIndex++;
-                break;
-
-            case Operator::TYPE_DATE_SET_NOW:
-                // No parameters to bind
-                break;
-
-                // Array operators
-            case Operator::TYPE_ARRAY_APPEND:
-            case Operator::TYPE_ARRAY_PREPEND:
-                // PERFORMANCE: Validate array size to prevent memory exhaustion
-                if (\count($values) > self::MAX_ARRAY_OPERATOR_SIZE) {
-                    throw new DatabaseException("Array size " . \count($values) . " exceeds maximum allowed size of " . self::MAX_ARRAY_OPERATOR_SIZE . " for array operations");
-                }
-
-                // Bind JSON array
-                $arrayValue = json_encode($values);
-                $bindKey = "op_{$bindIndex}";
-                $stmt->bindValue(':' . $bindKey, $arrayValue, \PDO::PARAM_STR);
-                $bindIndex++;
-                break;
+        // point [x, y]
+        if (count($geometry) === 2 && is_numeric($geometry[0]) && is_numeric($geometry[1])) {
+            return "POINT({$geometry[0]} {$geometry[1]})";
+        }
 
-            case Operator::TYPE_ARRAY_REMOVE:
-                $value = $values[0] ?? null;
-                $bindKey = "op_{$bindIndex}";
-                if (is_array($value)) {
-                    $value = json_encode($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');
                 }
-                $stmt->bindValue(':' . $bindKey, $value, \PDO::PARAM_STR);
-                $bindIndex++;
-                break;
-
-            case Operator::TYPE_ARRAY_UNIQUE:
-                // No parameters to bind
-                break;
+                $points[] = "{$point[0]} {$point[1]}";
+            }
 
-                // Complex array operators
-            case Operator::TYPE_ARRAY_INSERT:
-                $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;
+            return 'LINESTRING('.implode(', ', $points).')';
+        }
 
-            case Operator::TYPE_ARRAY_INTERSECT:
-            case Operator::TYPE_ARRAY_DIFF:
-                // PERFORMANCE: Validate array size to prevent memory exhaustion
-                if (\count($values) > self::MAX_ARRAY_OPERATOR_SIZE) {
-                    throw new DatabaseException("Array size " . \count($values) . " exceeds maximum allowed size of " . self::MAX_ARRAY_OPERATOR_SIZE . " for array operations");
+        // 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');
                 }
-
-                $arrayValue = json_encode($values);
-                $bindKey = "op_{$bindIndex}";
-                $stmt->bindValue(':' . $bindKey, $arrayValue, \PDO::PARAM_STR);
-                $bindIndex++;
-                break;
-
-            case Operator::TYPE_ARRAY_FILTER:
-                $condition = $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));
+                $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).')';
+            }
 
-                $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;
+            return 'POLYGON('.implode(', ', $rings).')';
         }
+
+        throw new DatabaseException('Unrecognized geometry array format');
     }
 
     /**
-     * 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.
+     * Decode a WKB or WKT POINT into a coordinate array [x, y].
      *
-     * @param Operator $operator
-     * @param mixed $value The current value (typically the attribute default)
-     * @return mixed The result after applying the operator
+     * @param string $wkb The WKB binary or WKT string
+     * @return array<float>
+     *
+     * @throws DatabaseException If the input is invalid.
      */
-    protected function applyOperatorToValue(Operator $operator, mixed $value): mixed
+    public function decodePoint(string $wkb): array
     {
-        $method = $operator->getMethod();
-        $values = $operator->getValues();
-
-        switch ($method) {
-            // Numeric operators
-            case Operator::TYPE_INCREMENT:
-                return ($value ?? 0) + ($values[0] ?? 1);
-
-            case Operator::TYPE_DECREMENT:
-                return ($value ?? 0) - ($values[0] ?? 1);
-
-            case Operator::TYPE_MULTIPLY:
-                return ($value ?? 0) * ($values[0] ?? 1);
+        if (str_starts_with(strtoupper($wkb), 'POINT(')) {
+            $start = strpos($wkb, '(') + 1;
+            $end = strrpos($wkb, ')');
+            $inside = substr($wkb, $start, $end - $start);
+            $coords = explode(' ', trim($inside));
 
-            case Operator::TYPE_DIVIDE:
-                $divisor = $values[0] ?? 1;
-                return (float)$divisor !== 0.0 ? ($value ?? 0) / $divisor : ($value ?? 0);
+            return [(float) $coords[0], (float) $coords[1]];
+        }
 
-            case Operator::TYPE_MODULO:
-                $divisor = $values[0] ?? 1;
-                return (float)$divisor !== 0.0 ? ($value ?? 0) % $divisor : ($value ?? 0);
+        /**
+         * [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');
+        }
 
-            case Operator::TYPE_POWER:
-                return pow($value ?? 0, $values[0] ?? 1);
+        // 4 bytes SRID first → skip to byteOrder at offset 4
+        $byteOrder = ord($wkb[4]);
+        $littleEndian = ($byteOrder === 1);
 
-                // Array operators
-            case Operator::TYPE_ARRAY_APPEND:
-                return array_merge($value ?? [], $values);
+        if (! $littleEndian) {
+            throw new DatabaseException('Only little-endian WKB supported');
+        }
 
-            case Operator::TYPE_ARRAY_PREPEND:
-                return array_merge($values, $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');
+        }
 
-            case Operator::TYPE_ARRAY_INSERT:
-                $arr = $value ?? [];
-                $index = $values[0] ?? 0;
-                $item = $values[1] ?? null;
-                array_splice($arr, $index, 0, [$item]);
-                return $arr;
+        // Unpack two doubles
+        $coords = unpack('d2', $coordsBin);
+        if ($coords === false || ! isset($coords[1], $coords[2])) {
+            throw new DatabaseException('Invalid WKB: failed to unpack coordinates');
+        }
 
-            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]));
+        return [(float) (is_numeric($coords[1]) ? $coords[1] : 0), (float) (is_numeric($coords[2]) ? $coords[2] : 0)];
+    }
 
-            case Operator::TYPE_ARRAY_UNIQUE:
-                return array_values(array_unique($value ?? []));
+    /**
+     * Decode a WKB or WKT LINESTRING into an array of coordinate pairs.
+     *
+     * @param string $wkb The WKB binary or WKT string
+     * @return array<array<float>>
+     *
+     * @throws DatabaseException If the input is invalid.
+     */
+    public function decodeLinestring(string $wkb): array
+    {
+        if (str_starts_with(strtoupper($wkb), 'LINESTRING(')) {
+            $start = strpos($wkb, '(') + 1;
+            $end = strrpos($wkb, ')');
+            $inside = substr($wkb, $start, $end - $start);
 
-            case Operator::TYPE_ARRAY_INTERSECT:
-                return array_values(array_intersect($value ?? [], $values));
+            $points = explode(',', $inside);
 
-            case Operator::TYPE_ARRAY_DIFF:
-                return array_values(array_diff($value ?? [], $values));
+            return array_map(function ($point) {
+                $coords = explode(' ', trim($point));
 
-            case Operator::TYPE_ARRAY_FILTER:
-                return $value ?? [];
+                return [(float) $coords[0], (float) $coords[1]];
+            }, $points);
+        }
 
-                // String operators
-            case Operator::TYPE_STRING_CONCAT:
-                return ($value ?? '') . ($values[0] ?? '');
+        // Skip 1 byte (endianness) + 4 bytes (type) + 4 bytes (SRID)
+        $offset = 9;
 
-            case Operator::TYPE_STRING_REPLACE:
-                $search = $values[0] ?? '';
-                $replace = $values[1] ?? '';
-                return str_replace($search, $replace, $value ?? '');
+        // 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');
+        }
 
-                // Boolean operators
-            case Operator::TYPE_TOGGLE:
-                return !($value ?? false);
+        $numPoints = $numPointsArr[1];
+        $offset += 4;
 
-                // Date operators
-            case Operator::TYPE_DATE_ADD_DAYS:
-            case Operator::TYPE_DATE_SUB_DAYS:
-                // For NULL dates, operators return NULL
-                return $value;
+        $points = [];
+        for ($i = 0; $i < $numPoints; $i++) {
+            $xArr = unpack('d', substr($wkb, $offset, 8));
+            $yArr = unpack('d', substr($wkb, $offset + 8, 8));
 
-            case Operator::TYPE_DATE_SET_NOW:
-                return DateTime::now();
+            if ($xArr === false || ! isset($xArr[1]) || $yArr === false || ! isset($yArr[1])) {
+                throw new DatabaseException('Invalid WKB: cannot unpack point coordinates');
+            }
 
-            default:
-                return $value;
+            $points[] = [(float) (is_numeric($xArr[1]) ? $xArr[1] : 0), (float) (is_numeric($yArr[1]) ? $yArr[1] : 0)];
+            $offset += 16;
         }
-    }
 
-    /**
-     * Returns the current PDO object
-     * @return mixed
-     */
-    protected function getPDO(): mixed
-    {
-        return $this->pdo;
+        return $points;
     }
 
     /**
-     * Get PDO Type
-     *
-     * @param mixed $value
-     * @return int
-     * @throws Exception
-     */
-    abstract protected function getPDOType(mixed $value): int;
-
-    /**
-     * Get the SQL function for random ordering
+     * Decode a WKB or WKT POLYGON into an array of rings, each containing coordinate pairs.
      *
-     * @return string
-     */
-    abstract protected function getRandomOrder(): string;
-
-    /**
-     * Returns default PDO configuration
+     * @param string $wkb The WKB binary or WKT string
+     * @return array<array<array<float>>>
      *
-     * @return array<int, mixed>
+     * @throws DatabaseException If the input is invalid.
      */
-    public static function getPDOAttributes(): array
+    public function decodePolygon(string $wkb): 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
-        ];
-    }
+        // POLYGON((x1,y1),(x2,y2))
+        if (str_starts_with($wkb, 'POLYGON((')) {
+            $start = strpos($wkb, '((') + 2;
+            $end = strrpos($wkb, '))');
+            $inside = substr($wkb, $start, $end - $start);
 
-    public function getHostname(): string
-    {
-        try {
-            return $this->pdo->getHostname();
-        } catch (\Throwable) {
-            return '';
+            $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);
         }
-    }
 
-    /**
-     * @return int
-     */
-    public function getMaxVarcharLength(): int
-    {
-        return 16381; // Floor value for Postgres:16383 | MySQL:16381 | MariaDB:16382
-    }
+        // 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');
+            }
+        }
 
-    /**
-     * Size of POINT spatial type
-     *
-     * @return int
-    */
-    abstract protected function getMaxPointSize(): int;
-    /**
-     * @return string
-     */
-    public function getIdAttributeType(): string
-    {
-        return Database::VAR_INTEGER;
-    }
+        if (strlen($wkb) < 21) {
+            throw new DatabaseException('WKB too short to be a POLYGON');
+        }
 
-    /**
-     * @return int
-     */
-    public function getMaxIndexLength(): int
-    {
-        /**
-         * $tenant int = 1
-         */
-        return $this->sharedTables ? 767 : 768;
-    }
+        // MySQL SRID-aware WKB layout: 4 bytes SRID prefix
+        $offset = 4;
 
-    /**
-     * @return int
-     */
-    public function getMaxUIDLength(): int
-    {
-        return 36;
-    }
+        $byteOrder = ord($wkb[$offset]);
+        if ($byteOrder !== 1) {
+            throw new DatabaseException('Only little-endian WKB supported');
+        }
+        $offset += 1;
 
-    /**
-     * @param Query $query
-     * @param array<string, mixed> $binds
-     * @return string
-     * @throws Exception
-     */
-    abstract protected function getSQLCondition(Query $query, array &$binds): string;
+        $typeArr = unpack('V', substr($wkb, $offset, 4));
+        if ($typeArr === false || ! isset($typeArr[1])) {
+            throw new DatabaseException('Invalid WKB: cannot unpack geometry type');
+        }
 
-    /**
-     * @param array<Query> $queries
-     * @param array<string, mixed> $binds
-     * @param string $separator
-     * @return string
-     * @throws Exception
-     */
-    public function getSQLConditions(array $queries, array &$binds, string $separator = 'AND'): string
-    {
-        $conditions = [];
-        foreach ($queries as $query) {
-            if ($query->getMethod() === Query::TYPE_SELECT) {
-                continue;
-            }
+        $type = \is_numeric($typeArr[1]) ? (int) $typeArr[1] : 0;
+        $hasSRID = ($type & 0x20000000) === 0x20000000;
+        $geomType = $type & 0xFF;
+        $offset += 4;
 
-            if ($query->isNested()) {
-                $conditions[] = $this->getSQLConditions($query->getValues(), $binds, $query->getMethod());
-            } else {
-                $conditions[] = $this->getSQLCondition($query, $binds);
-            }
+        if ($geomType !== 3) { // 3 = POLYGON
+            throw new DatabaseException("Not a POLYGON geometry type, got {$geomType}");
         }
 
-        $tmp = implode(' ' . $separator . ' ', $conditions);
-        return empty($tmp) ? '' : '(' . $tmp . ')';
-    }
+        // Skip SRID in type flag if present
+        if ($hasSRID) {
+            $offset += 4;
+        }
 
-    /**
-     * @return string
-     */
-    public function getLikeOperator(): string
-    {
-        return 'LIKE';
-    }
+        $numRingsArr = unpack('V', substr($wkb, $offset, 4));
 
-    /**
-     * @return string
-     */
-    public function getRegexOperator(): string
-    {
-        return 'REGEXP';
-    }
+        if ($numRingsArr === false || ! isset($numRingsArr[1])) {
+            throw new DatabaseException('Invalid WKB: cannot unpack number of rings');
+        }
 
-    public function getInternalIndexesKeys(): array
-    {
-        return [];
-    }
+        $numRings = $numRingsArr[1];
+        $offset += 4;
 
-    public function getSchemaAttributes(string $collection): array
-    {
-        return [];
-    }
+        $rings = [];
 
-    public function getSchemaIndexes(string $collection): array
-    {
-        return [];
-    }
+        for ($r = 0; $r < $numRings; $r++) {
+            $numPointsArr = unpack('V', substr($wkb, $offset, 4));
 
-    public function getSupportForSchemaIndexes(): bool
-    {
-        return false;
-    }
+            if ($numPointsArr === false || ! isset($numPointsArr[1])) {
+                throw new DatabaseException('Invalid WKB: cannot unpack number of points');
+            }
 
-    public function getTenantQuery(
-        string $collection,
-        string $alias = '',
-        int $tenantCount = 0,
-        string $condition = 'AND'
-    ): string {
-        if (!$this->sharedTables) {
-            return '';
-        }
+            $numPoints = $numPointsArr[1];
+            $offset += 4;
+            $ring = [];
 
-        $dot = '';
-        if ($alias !== '') {
-            $dot = '.';
-            $alias = $this->quote($alias);
-        }
+            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.');
+                }
 
-        $bindings = [];
-        if ($tenantCount === 0) {
-            $bindings[] = ':_tenant';
-        } else {
-            for ($index = 0; $index < $tenantCount; $index++) {
-                $bindings[] = ":_tenant_{$index}";
+                $x = (float) (is_numeric($xArr[1]) ? $xArr[1] : 0);
+
+                $yArr = unpack('d', substr($wkb, $offset + 8, 8));
+                if ($yArr === false) {
+                    throw new DatabaseException('Failed to unpack Y coordinate from WKB.');
+                }
+
+                $y = (float) (is_numeric($yArr[1]) ? $yArr[1] : 0);
+
+                $ring[] = [$x, $y];
+                $offset += 16;
             }
-        }
-        $bindings = \implode(',', $bindings);
 
-        $orIsNull = '';
-        if ($collection === Database::METADATA) {
-            $orIsNull = " OR {$alias}{$dot}_tenant IS NULL";
+            $rings[] = $ring;
         }
 
-        return "{$condition} ({$alias}{$dot}_tenant IN ({$bindings}) {$orIsNull})";
+        return $rings;
     }
 
     /**
-     * Get the SQL projection given the selected attributes
-     *
-     * @param array<string> $selections
-     * @param string $prefix
-     * @return mixed
-     * @throws Exception
-     */
-    protected function getAttributeProjection(array $selections, string $prefix): mixed
-    {
-        if (empty($selections) || \in_array('*', $selections)) {
-            return "{$this->quote($prefix)}.*";
-        }
-
-        // Handle specific selections with spatial conversion where needed
-        $internalKeys = [
-            '$id',
-            '$sequence',
-            '$permissions',
-            '$createdAt',
-            '$updatedAt',
-        ];
-
-        $selections = \array_diff($selections, [...$internalKeys, '$collection']);
+     * Get SQL table
+     *
+     * @throws DatabaseException
+     */
+    protected function getSQLTable(string $name): string
+    {
+        return "{$this->quote($this->getDatabase())}.{$this->quote($this->getNamespace().'_'.$this->filter($name))}";
+    }
 
-        foreach ($internalKeys as $internalKey) {
-            $selections[] = $this->getInternalKeyForAttribute($internalKey);
-        }
+    /**
+     * Get an unquoted qualified table name (the builder handles quoting).
+     *
+     * @throws DatabaseException
+     */
+    protected function getSQLTableRaw(string $name): string
+    {
+        return $this->getDatabase().'.'.$this->getNamespace().'_'.$this->filter($name);
+    }
 
-        $projections = [];
-        foreach ($selections as $selection) {
-            $filteredSelection = $this->filter($selection);
-            $quotedSelection = $this->quote($filteredSelection);
-            $projections[] = "{$this->quote($prefix)}.{$quotedSelection}";
-        }
+    /**
+     * Create a new query builder instance for this adapter's SQL dialect.
+     */
+    abstract protected function createBuilder(): SQLBuilder;
 
-        return \implode(',', $projections);
+    /**
+     * Create a new schema builder instance for this adapter's SQL dialect.
+     */
+    protected function createSchemaBuilder(): Schema
+    {
+        return new MySQLSchema();
     }
 
-    protected function getInternalKeyForAttribute(string $attribute): string
+    /**
+     * Create and configure a new query builder for a given table.
+     *
+     * Automatically applies tenant filtering when shared tables are enabled.
+     *
+     * @throws DatabaseException
+     */
+    protected function newBuilder(string $table, string $alias = ''): SQLBuilder
     {
-        return match ($attribute) {
+        $builder = $this->createBuilder()->from($this->getSQLTableRaw($table), $alias);
+        $builder->addHook(new AttributeMap([
             '$id' => '_uid',
             '$sequence' => '_id',
             '$collection' => '_collection',
@@ -2421,1196 +2820,1424 @@ protected function getInternalKeyForAttribute(string $attribute): string
             '$createdAt' => '_createdAt',
             '$updatedAt' => '_updatedAt',
             '$permissions' => '_permissions',
-            default => $attribute
-        };
+        ]));
+        if ($this->sharedTables && $this->tenant !== null) {
+            $builder->addHook(new TenantFilter($this->tenant, Database::METADATA, $table));
+        }
+
+        return $builder;
     }
 
-    protected function escapeWildcards(string $value): string
+    public function rawMutation(string $query, array $bindings = []): int
     {
-        $wildcards = ['%', '_', '[', ']', '^', '-', '.', '*', '+', '?', '(', ')', '{', '}', '|'];
-
-        foreach ($wildcards as $wildcard) {
-            $value = \str_replace($wildcard, "\\$wildcard", $value);
+        try {
+            $stmt = $this->getPDO()->prepare($query);
+            foreach ($bindings as $i => $value) {
+                $stmt->bindValue($i + 1, $value, $this->getPDOType($value));
+            }
+            $this->execute($stmt);
+        } catch (PDOException $e) {
+            throw $this->processException($e);
         }
 
-        return $value;
+        $count = $stmt->rowCount();
+        $stmt->closeCursor();
+
+        return $count;
     }
 
-    protected function processException(PDOException $e): \Exception
+    public function getBuilder(string $collection): SQLBuilder
     {
-        return $e;
+        return $this->newBuilder($this->filter($collection));
+    }
+
+    public function getSchema(): Schema
+    {
+        return $this->createSchemaBuilder();
+    }
+
+    protected function getIdentifierQuoteChar(): string
+    {
+        return '`';
     }
 
     /**
-     * @param mixed $stmt
-     * @return bool
+     * @param  array<string>  $roles
      */
-    protected function execute(mixed $stmt): bool
+    protected function newPermissionHook(string $collection, array $roles, string $type = PermissionType::Read->value, string $documentColumn = '_uid'): PermissionFilter
     {
-        return $stmt->execute();
+        return new PermissionFilter(
+            roles: \array_values($roles),
+            permissionsTable: fn (string $table) => $this->getSQLTableRaw($collection.'_perms'),
+            type: $type,
+            documentColumn: $documentColumn,
+            permDocumentColumn: '_document',
+            permRoleColumn: '_permission',
+            permTypeColumn: '_type',
+            subqueryFilter: $this->hasTenantHook() ? new TenantFilter($this->getTenantHook()->getTenant()) : null,
+            quoteChar: $this->getIdentifierQuoteChar(),
+        );
     }
 
     /**
-     * Create Documents in batches
-     *
-     * @param Document $collection
-     * @param array<Document> $documents
-     *
-     * @return array<Document>
+     * Synchronize write hooks with current adapter configuration.
      *
-     * @throws DuplicateException
-     * @throws \Throwable
+     * Ensures Permission is always registered and Tenant is registered
+     * when shared tables with a tenant are active.
      */
-    public function createDocuments(Document $collection, array $documents): array
+    protected function syncWriteHooks(): void
     {
-        if (empty($documents)) {
-            return $documents;
+        $this->removeWriteHook(Tenancy::class);
+        if ($this->sharedTables && $this->tenant !== null) {
+            $this->addWriteHook(new Tenancy($this->tenant));
         }
-        $spatialAttributes = $this->getSpatialAttributes($collection);
-        $collection = $collection->getId();
-        try {
-            $name = $this->filter($collection);
-
-            $attributeKeys = Database::INTERNAL_ATTRIBUTE_KEYS;
-
-            $hasSequence = null;
-            foreach ($documents as $document) {
-                $attributes = $document->getAttributes();
-                $attributeKeys = [...$attributeKeys, ...\array_keys($attributes)];
-
-                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');
-                }
-            }
-
-            $attributeKeys = array_unique($attributeKeys);
+    }
 
-            if ($hasSequence) {
-                $attributeKeys[] = '_id';
-            }
+    /**
+     * Build a WriteContext that delegates to this adapter's query infrastructure.
+     *
+     * @param  string  $collection  The filtered collection name
+     */
+    protected function buildWriteContext(string $collection): WriteContext
+    {
+        $name = $this->filter($collection);
 
-            if ($this->sharedTables) {
-                $attributeKeys[] = '_tenant';
-            }
+        return new WriteContext(
+            newBuilder: fn (string $table, string $alias = '') => $this->newBuilder($table, $alias),
+            executeResult: fn (Plan $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),
+        );
+    }
 
-            $columns = [];
-            foreach ($attributeKeys as $key => $attribute) {
-                $columns[$key] = $this->quote($this->filter($attribute));
+    /**
+     * Execute a Plan through the transformation system with positional bindings.
+     *
+     * Prepares the SQL statement and binds positional parameters from the Plan.
+     * Does NOT call execute() - the caller is responsible for that.
+     *
+     * @param  Event|null  $event  Optional event to run through transformation system
+     * @return PDOStatement|PDOStatementProxy
+     */
+    protected function executeResult(Plan $result, ?Event $event = null): PDOStatement|PDOStatementProxy
+    {
+        $sql = $result->query;
+        if ($event !== null) {
+            foreach ($this->queryTransforms as $transform) {
+                $sql = $transform->transform($event, $sql);
             }
-
-            $columns = '(' . \implode(', ', $columns) . ')';
-
-            $bindIndex = 0;
-            $batchKeys = [];
-            $bindValues = [];
-            $permissions = [];
-            $bindValuesPermissions = [];
-
-            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());
-
-                if (!empty($document->getSequence())) {
-                    $attributes['_id'] = $document->getSequence();
-                }
-
-                if ($this->sharedTables) {
-                    $attributes['_tenant'] = $document->getTenant();
-                }
-
-                $bindKeys = [];
-
-                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++;
-                }
-
-                $batchKeys[] = '(' . \implode(', ', $bindKeys) . ')';
-
-                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();
-                        }
-                    }
-                }
+        }
+        $stmt = $this->getPDO()->prepare($sql);
+        foreach ($result->bindings as $i => $value) {
+            if (\is_bool($value) && $this->supports(Capability::IntegerBooleans)) {
+                $value = (int) $value;
             }
-
-            $batchKeys = \implode(', ', $batchKeys);
-
-            $stmt = $this->getPDO()->prepare("
-                INSERT INTO {$this->getSQLTable($name)} {$columns}
-                VALUES {$batchKeys}
-            ");
-
-            foreach ($bindValues as $key => $value) {
-                $stmt->bindValue($key, $value, $this->getPDOType($value));
+            if (\is_float($value)) {
+                $stmt->bindValue($i + 1, $this->getFloatPrecision($value), PDO::PARAM_STR);
+            } else {
+                $stmt->bindValue($i + 1, $value, $this->getPDOType($value));
             }
+        }
 
-            $this->execute($stmt);
-
-            if (!empty($permissions)) {
-                $tenantColumn = $this->sharedTables ? ', _tenant' : '';
-                $permissions = \implode(', ', $permissions);
-
-                $sqlPermissions = "
-                    INSERT INTO {$this->getSQLTable($name . '_perms')} (_type, _permission, _document {$tenantColumn})
-                    VALUES {$permissions};
-                ";
-
-                $stmtPermissions = $this->getPDO()->prepare($sqlPermissions);
-
-                foreach ($bindValuesPermissions as $key => $value) {
-                    $stmtPermissions->bindValue($key, $value, $this->getPDOType($value));
-                }
+        return $stmt;
+    }
 
-                $this->execute($stmtPermissions);
-            }
+    protected function execute(mixed $stmt): bool
+    {
+        /** @var PDOStatement|PDOStatementProxy $stmt */
+        if ($this->profiler !== null && $this->profiler->isEnabled()) {
+            $start = \microtime(true);
+            $result = $stmt->execute();
+            $durationMs = (\microtime(true) - $start) * 1000;
+            $this->profiler->log(
+                $stmt->queryString ?? '',
+                [],
+                $durationMs,
+            );
 
-        } catch (PDOException $e) {
-            throw $this->processException($e);
+            return $result;
         }
 
-        return $documents;
+        return $stmt->execute();
     }
 
     /**
-     * @param Document $collection
-     * @param string $attribute
-     * @param array<Change> $changes
-     * @return array<Document>
+     * 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  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
      */
-    public function upsertDocuments(
-        Document $collection,
+    protected function executeUpsertBatch(
+        string $name,
+        array $changes,
+        array $spatialAttributes,
         string $attribute,
-        array $changes
-    ): array {
-        if (empty($changes)) {
-            return $changes;
+        array $operators,
+        array $attributeDefaults,
+        bool $hasOperators
+    ): void {
+        $builder = $this->createBuilder()->into($this->getSQLTableRaw($name));
+
+        // Register spatial column expressions for ST_GeomFromText wrapping
+        foreach ($spatialAttributes as $spatialCol) {
+            $builder->insertColumnExpression($spatialCol, $this->getSpatialGeomFromText('?'));
         }
-        try {
-            $spatialAttributes = $this->getSpatialAttributes($collection);
-
-            $attributeDefaults = [];
-            foreach ($collection->getAttribute('attributes', []) as $attr) {
-                $attributeDefaults[$attr['$id']] = $attr['default'] ?? null;
-            }
-
-            $collection = $collection->getId();
-            $name = $this->filter($collection);
 
-            $hasOperators = false;
-            $firstChange = $changes[0];
-            $firstDoc = $firstChange->getNew();
-            $firstExtracted = Operator::extractOperators($firstDoc->getAttributes());
-
-            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;
-                    }
-                }
-            }
-
-            if (!$hasOperators) {
-                $bindIndex = 0;
-                $batchKeys = [];
-                $bindValues = [];
-                $allColumnNames = [];
-                $documentsData = [];
+        // Postgres requires an alias on the INSERT target for conflict resolution
+        if ($this->insertRequiresAlias()) {
+            $builder->insertAs('target');
+        }
 
-                foreach ($changes as $change) {
-                    $document = $change->getNew();
-                    $currentRegularAttributes = $document->getAttributes();
+        // Collect all column names and build rows
+        $allColumnNames = [];
+        $documentsData = [];
 
-                    $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());
+        foreach ($changes as $change) {
+            $document = $change->getNew();
 
-                    if (!empty($document->getSequence())) {
-                        $currentRegularAttributes['_id'] = $document->getSequence();
-                    }
+            if ($hasOperators) {
+                $extracted = Operator::extractOperators($document->getAttributes());
+                $currentRegularAttributes = $extracted['updates'];
+                $extractedOperators = $extracted['operators'];
 
-                    if ($this->sharedTables) {
-                        $currentRegularAttributes['_tenant'] = $document->getTenant();
+                // 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);
                     }
+                }
 
-                    foreach (\array_keys($currentRegularAttributes) as $colName) {
-                        $allColumnNames[$colName] = true;
-                    }
+                $currentRegularAttributes['_uid'] = $document->getId();
+                $currentRegularAttributes['_createdAt'] = $document->getCreatedAt() ? $document->getCreatedAt() : null;
+                $currentRegularAttributes['_updatedAt'] = $document->getUpdatedAt() ? $document->getUpdatedAt() : null;
+            } else {
+                $currentRegularAttributes = $document->getAttributes();
+                $currentRegularAttributes['_uid'] = $document->getId();
+                $currentRegularAttributes['_createdAt'] = $document->getCreatedAt() ? DateTime::setTimezone($document->getCreatedAt()) : null;
+                $currentRegularAttributes['_updatedAt'] = $document->getUpdatedAt() ? DateTime::setTimezone($document->getUpdatedAt()) : null;
+            }
 
-                    $documentsData[] = ['regularAttributes' => $currentRegularAttributes];
-                }
+            $currentRegularAttributes['_permissions'] = \json_encode($document->getPermissions());
 
-                $allColumnNames = \array_keys($allColumnNames);
-                \sort($allColumnNames);
+            $version = $document->getVersion();
+            if ($version !== null) {
+                $currentRegularAttributes['_version'] = $version;
+            }
 
-                $columnsArray = [];
-                foreach ($allColumnNames as $attr) {
-                    $columnsArray[] = "{$this->quote($this->filter($attr))}";
-                }
-                $columns = '(' . \implode(', ', $columnsArray) . ')';
+            if (! empty($document->getSequence())) {
+                $currentRegularAttributes['_id'] = $document->getSequence();
+            }
 
-                foreach ($documentsData as $docData) {
-                    $currentRegularAttributes = $docData['regularAttributes'];
-                    $bindKeys = [];
+            if ($this->sharedTables) {
+                $currentRegularAttributes['_tenant'] = $document->getTenant();
+            }
 
-                    foreach ($allColumnNames as $attributeKey) {
-                        $attrValue = $currentRegularAttributes[$attributeKey] ?? null;
+            foreach (\array_keys($currentRegularAttributes) as $colName) {
+                $allColumnNames[$colName] = true;
+            }
 
-                        if (\is_array($attrValue)) {
-                            $attrValue = \json_encode($attrValue);
-                        }
+            $documentsData[] = $currentRegularAttributes;
+        }
 
-                        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++;
-                    }
+        // Include operator column names in the column set
+        foreach (\array_keys($operators) as $colName) {
+            $allColumnNames[$colName] = true;
+        }
 
-                    $batchKeys[] = '(' . \implode(', ', $bindKeys) . ')';
-                }
+        $allColumnNames = \array_keys($allColumnNames);
+        \sort($allColumnNames);
 
-                $regularAttributes = [];
-                foreach ($allColumnNames as $colName) {
-                    $regularAttributes[$colName] = null;
+        // Build rows for the builder, applying JSON/boolean/spatial conversions
+        foreach ($documentsData as $docAttrs) {
+            $row = [];
+            foreach ($allColumnNames as $key) {
+                $value = $docAttrs[$key] ?? null;
+                if (\is_array($value)) {
+                    $value = \json_encode($value);
                 }
-                foreach ($documentsData[0]['regularAttributes'] as $key => $value) {
-                    $regularAttributes[$key] = $value;
+                if (! \in_array($key, $spatialAttributes) && $this->supports(Capability::IntegerBooleans)) {
+                    $value = (\is_bool($value)) ? (int) $value : $value;
                 }
+                $row[$key] = $value;
+            }
+            $builder->set($row);
+        }
 
-                $stmt = $this->getUpsertStatement($name, $columns, $batchKeys, $regularAttributes, $bindValues, $attribute, []);
-                $stmt->execute();
-                $stmt->closeCursor();
-            } else {
-                $groups = [];
+        // Determine conflict keys
+        $conflictKeys = $this->sharedTables ? ['_uid', '_tenant'] : ['_uid'];
 
-                foreach ($changes as $change) {
-                    $document = $change->getNew();
-                    $extracted = Operator::extractOperators($document->getAttributes());
-                    $operators = $extracted['operators'];
+        // Determine which columns to update on conflict
+        $skipColumns = ['_uid', '_id', '_createdAt', '_tenant'];
 
-                    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 (! empty($attribute)) {
+            // Increment mode: only update the increment column and _updatedAt
+            $updateColumns = [$this->filter($attribute), '_updatedAt'];
+        } else {
+            // Normal mode: update all columns except the skip set
+            $updateColumns = \array_values(\array_filter(
+                $allColumnNames,
+                fn ($c) => ! \in_array($c, $skipColumns)
+            ));
+        }
 
-                    if (!isset($groups[$signature])) {
-                        $groups[$signature] = [
-                            'documents' => [],
-                            'operators' => $operators
-                        ];
-                    }
+        $builder->onConflict($conflictKeys, $updateColumns);
 
-                    $groups[$signature]['documents'][] = $change;
+        // 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('_updatedAt', $this->getConflictTenantExpression('_updatedAt'));
+            } 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));
+            }
+        }
 
-                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);
-                            }
-                        }
-
-                        $currentRegularAttributes['_uid'] = $document->getId();
-                        $currentRegularAttributes['_createdAt'] = $document->getCreatedAt() ? $document->getCreatedAt() : null;
-                        $currentRegularAttributes['_updatedAt'] = $document->getUpdatedAt() ? $document->getUpdatedAt() : null;
-                        $currentRegularAttributes['_permissions'] = \json_encode($document->getPermissions());
-
-                        if (!empty($document->getSequence())) {
-                            $currentRegularAttributes['_id'] = $document->getSequence();
-                        }
+        $result = $builder->upsert();
+        $stmt = $this->executeResult($result, Event::DocumentCreate);
+        $stmt->execute();
+        $stmt->closeCursor();
+    }
 
-                        if ($this->sharedTables) {
-                            $currentRegularAttributes['_tenant'] = $document->getTenant();
-                        }
+    /**
+     * 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
+     * @return array<string>
+     */
+    protected function mapSelectionsToColumns(array $selections): array
+    {
+        $internalKeys = [
+            '$id',
+            '$sequence',
+            '$permissions',
+            '$createdAt',
+            '$updatedAt',
+        ];
 
-                        foreach (\array_keys($currentRegularAttributes) as $colName) {
-                            $allColumnNames[$colName] = true;
-                        }
+        $selections = \array_diff($selections, [...$internalKeys, '$collection']);
 
-                        $documentsData[] = ['regularAttributes' => $currentRegularAttributes];
-                    }
+        foreach ($internalKeys as $internalKey) {
+            $selections[] = $this->getInternalKeyForAttribute($internalKey);
+        }
 
-                    foreach (\array_keys($operators) as $colName) {
-                        $allColumnNames[$colName] = true;
-                    }
+        $columns = [];
+        foreach ($selections as $selection) {
+            $columns[] = $this->filter($selection);
+        }
 
-                    $allColumnNames = \array_keys($allColumnNames);
-                    \sort($allColumnNames);
+        return $columns;
+    }
 
-                    $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++;
-                        }
+    /**
+     * Map Database type constants to Schema Blueprint column definitions.
+     *
+     * @throws DatabaseException
+     */
+    protected function addBlueprintColumn(
+        Blueprint $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();
+            }
 
-                        $batchKeys[] = '(' . \implode(', ', $bindKeys) . ')';
-                    }
+            return $col;
+        }
 
-                    $regularAttributes = [];
-                    foreach ($allColumnNames as $colName) {
-                        $regularAttributes[$colName] = null;
-                    }
-                    foreach ($documentsData[0]['regularAttributes'] as $key => $value) {
-                        $regularAttributes[$key] = $value;
-                    }
+        if ($array) {
+            // Arrays use JSON type and are nullable by default
+            return $table->json($filteredId)->nullable();
+        }
 
-                    $stmt = $this->getUpsertStatement(
-                        $name,
-                        $columns,
-                        $batchKeys,
-                        $regularAttributes,
-                        $bindValues,
-                        '',
-                        $operators
-                    );
-
-                    $stmt->execute();
-                    $stmt->closeCursor();
-                }
-            }
+        $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::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 => $table->vector($filteredId, $size),
+            default => throw new DatabaseException('Unknown type: '.$type->value),
+        };
 
-            $removeQueries = [];
-            $removeBindValues = [];
-            $addQueries = [];
-            $addBindValues = [];
+        // Apply unsigned for types that support it
+        if (! $signed && \in_array($type, [ColumnType::Integer, ColumnType::Float, ColumnType::Double])) {
+            $col->unsigned();
+        }
 
-            foreach ($changes as $index => $change) {
-                $old = $change->getOld();
-                $document = $change->getNew();
+        // Id type is always unsigned
+        if ($type === ColumnType::Id) {
+            $col->unsigned();
+        }
 
-                $current = [];
-                foreach (Database::PERMISSIONS as $type) {
-                    $current[$type] = $old->getPermissionsByType($type);
-                }
+        // Non-spatial columns are nullable by default to match existing behavior
+        $col->nullable();
 
-                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;
-                        }
-                    }
-                }
+        return $col;
+    }
 
-                foreach (Database::PERMISSIONS as $type) {
-                    $toAdd = \array_diff($document->getPermissionsByType($type), $current[$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  array<string>  $attributeKeys
+     * @param  array<string>  $spatialAttributes
+     * @return array<string, mixed>
+     */
+    /**
+     * @param array<string, mixed> $row
+     */
+    private function remapRow(array &$row): void
+    {
+        foreach (self::COLUMN_RENAME_MAP as $internal => $public) {
+            if (\array_key_exists($internal, $row)) {
+                $row[$public] = $row[$internal];
+                unset($row[$internal]);
+            }
+        }
+        if (\array_key_exists('_permissions', $row)) {
+            $row['$permissions'] = \json_decode(\is_string($row['_permissions']) ? $row['_permissions'] : '[]', true);
+            unset($row['_permissions']);
+        }
+    }
 
-                    foreach ($toAdd as $i => $permission) {
-                        $addQuery = "(:_uid_{$index}, '{$type}', :add_{$type}_{$index}_{$i}";
+    protected function buildDocumentRow(Document $document, array $attributeKeys, array $spatialAttributes = []): array
+    {
+        $attributes = $document->getAttributes();
+        $row = [
+            '_uid' => $document->getId(),
+            '_createdAt' => $document->getCreatedAt(),
+            '_updatedAt' => $document->getUpdatedAt(),
+            '_permissions' => \json_encode($document->getPermissions()),
+        ];
 
-                        if ($this->sharedTables) {
-                            $addQuery .= ", :_tenant_{$index}";
-                        }
+        $version = $document->getVersion();
+        if ($version !== null) {
+            $row['_version'] = $version;
+        }
 
-                        $addQuery .= ")";
-                        $addQueries[] = $addQuery;
-                        $addBindValues[":_uid_{$index}"] = $document->getId();
-                        $addBindValues[":add_{$type}_{$index}_{$i}"] = $permission;
+        if (! empty($document->getSequence())) {
+            $row['_id'] = $document->getSequence();
+        }
 
-                        if ($this->sharedTables) {
-                            $addBindValues[":_tenant_{$index}"] = $document->getTenant();
-                        }
-                    }
-                }
+        foreach ($attributeKeys as $key) {
+            if (isset($row[$key])) {
+                continue;
             }
-
-            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();
+            $value = $attributes[$key] ?? null;
+            if (\is_array($value)) {
+                $value = \json_encode($value);
             }
-
-            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();
+            if (! \in_array($key, $spatialAttributes) && $this->supports(Capability::IntegerBooleans)) {
+                $value = (\is_bool($value)) ? (int) $value : $value;
             }
-        } catch (PDOException $e) {
-            throw $this->processException($e);
+            $row[$key] = $value;
         }
 
-        return \array_map(fn ($change) => $change->getNew(), $changes);
+        return $row;
     }
 
     /**
-     * Build geometry WKT string from array input for spatial queries
+     * Helper method to extract spatial type attributes from collection attributes
      *
-     * @param array<mixed> $geometry
-     * @return string
-     * @throws DatabaseException
+     * @return array<int,string>
      */
-    protected function convertArrayToWKT(array $geometry): string
+    protected function getSpatialAttributes(Document $collection): array
     {
-        // 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]}";
+        /** @var array<mixed> $collectionAttributes */
+        $collectionAttributes = $collection->getAttribute('attributes', []);
+        $spatialAttributes = [];
+        foreach ($collectionAttributes as $attr) {
+            if ($attr instanceof Document) {
+                $attributeType = $attr->getAttribute('type');
+                if (in_array($attributeType, [ColumnType::Point->value, ColumnType::Linestring->value, ColumnType::Polygon->value])) {
+                    $spatialAttributes[] = $attr->getId();
                 }
-                $rings[] = '(' . implode(', ', $points) . ')';
             }
-            return 'POLYGON(' . implode(', ', $rings) . ')';
         }
 
-        throw new DatabaseException('Unrecognized geometry array format');
+        return $spatialAttributes;
     }
 
     /**
-     * Find Documents
+     * Generate SQL expression for operator
+     * Each adapter must implement operators specific to their SQL dialect
      *
-     * @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
+     * @return string|null Returns null if operator can't be expressed in SQL
      */
-    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
+    abstract protected function getOperatorSQL(string $column, Operator $operator, int &$bindIndex): ?string;
+
+    /**
+     * Bind operator parameters to prepared statement
+     */
+    protected function bindOperatorParams(PDOStatement|PDOStatementProxy $stmt, Operator $operator, int &$bindIndex): void
     {
-        $collection = $collection->getId();
-        $name = $this->filter($collection);
-        $roles = $this->authorization->getRoles();
-        $where = [];
-        $orders = [];
-        $alias = Query::DEFAULT_ALIAS;
-        $binds = [];
+        $method = $operator->getMethod();
+        $values = $operator->getValues();
 
-        $queries = array_map(fn ($query) => clone $query, $queries);
+        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++;
 
-        // 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;
-            }
-        }
+                // Bind limit if provided
+                if (isset($values[1])) {
+                    $limitKey = "op_{$bindIndex}";
+                    $stmt->bindValue(':'.$limitKey, $values[1], $this->getPDOType($values[1]));
+                    $bindIndex++;
+                }
+                break;
 
-        $queries = $otherQueries;
+            case OperatorType::Modulo:
+                $value = $values[0] ?? 1;
+                $bindKey = "op_{$bindIndex}";
+                $stmt->bindValue(':'.$bindKey, $value, $this->getPDOType($value));
+                $bindIndex++;
+                break;
 
-        $cursorWhere = [];
+            case OperatorType::Power:
+                $value = $values[0] ?? 1;
+                $bindKey = "op_{$bindIndex}";
+                $stmt->bindValue(':'.$bindKey, $value, $this->getPDOType($value));
+                $bindIndex++;
 
-        foreach ($orderAttributes as $i => $originalAttribute) {
-            $orderType = $orderTypes[$i] ?? Database::ORDER_ASC;
+                // Bind max limit if provided
+                if (isset($values[1])) {
+                    $maxKey = "op_{$bindIndex}";
+                    $stmt->bindValue(':'.$maxKey, $values[1], $this->getPDOType($values[1]));
+                    $bindIndex++;
+                }
+                break;
 
-            // Handle random ordering
-            if ($orderType === Database::ORDER_RANDOM) {
-                $orders[] = $this->getRandomOrder();
-                continue;
-            }
+                // String operators
+            case OperatorType::StringConcat:
+                $value = $values[0] ?? '';
+                $bindKey = "op_{$bindIndex}";
+                $stmt->bindValue(':'.$bindKey, $value, PDO::PARAM_STR);
+                $bindIndex++;
+                break;
 
-            $attribute = $this->getInternalKeyForAttribute($originalAttribute);
-            $attribute = $this->filter($attribute);
+            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;
 
-            $orderType = $this->filter($orderType);
-            $direction = $orderType;
+                // Boolean operators
+            case OperatorType::Toggle:
+                // No parameters to bind
+                break;
 
-            if ($cursorDirection === Database::CURSOR_BEFORE) {
-                $direction = ($direction === Database::ORDER_ASC)
-                    ? Database::ORDER_DESC
-                    : Database::ORDER_ASC;
-            }
+                // Date operators
+            case OperatorType::DateAddDays:
+            case OperatorType::DateSubDays:
+                $days = $values[0] ?? 0;
+                $bindKey = "op_{$bindIndex}";
+                $stmt->bindValue(':'.$bindKey, $days, PDO::PARAM_INT);
+                $bindIndex++;
+                break;
 
-            $orders[] = "{$this->quote($attribute)} {$direction}";
+            case OperatorType::DateSetNow:
+                // No parameters to bind
+                break;
 
-            // 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;
+                // Array operators
+            case OperatorType::ArrayAppend:
+            case OperatorType::ArrayPrepend:
+                // PERFORMANCE: Validate array size to prevent memory exhaustion
+                if (\count($values) > self::MAX_ARRAY_OPERATOR_SIZE) {
+                    throw new DatabaseException('Array size '.\count($values).' exceeds maximum allowed size of '.self::MAX_ARRAY_OPERATOR_SIZE.' for array operations');
+                }
 
-                    $bindName = ":cursor_pk";
-                    $binds[$bindName] = $cursor[$originalAttribute];
+                // Bind JSON array
+                $arrayValue = json_encode($values);
+                $bindKey = "op_{$bindIndex}";
+                $stmt->bindValue(':'.$bindKey, $arrayValue, PDO::PARAM_STR);
+                $bindIndex++;
+                break;
 
-                    $cursorWhere[] = "{$this->quote($alias)}.{$this->quote($attribute)} {$this->getSQLOperator($operator)} {$bindName}";
-                    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;
 
-                $conditions = [];
-
-                // Add equality conditions for previous attributes
-                for ($j = 0; $j < $i; $j++) {
-                    $prevOriginal = $orderAttributes[$j];
-                    $prevAttr = $this->filter($this->getInternalKeyForAttribute($prevOriginal));
+            case OperatorType::ArrayUnique:
+                // No parameters to bind
+                break;
 
-                    $bindName = ":cursor_{$j}";
-                    $binds[$bindName] = $cursor[$prevOriginal];
+                // 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;
 
-                    $conditions[] = "{$this->quote($alias)}.{$this->quote($prevAttr)} = {$bindName}";
+            case OperatorType::ArrayIntersect:
+            case OperatorType::ArrayDiff:
+                // PERFORMANCE: Validate array size to prevent memory exhaustion
+                if (\count($values) > self::MAX_ARRAY_OPERATOR_SIZE) {
+                    throw new DatabaseException('Array size '.\count($values).' exceeds maximum allowed size of '.self::MAX_ARRAY_OPERATOR_SIZE.' for array operations');
                 }
 
-                // Add comparison for current attribute
-                $operator = ($direction === Database::ORDER_DESC)
-                    ? Query::TYPE_LESSER
-                    : Query::TYPE_GREATER;
+                $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));
+                }
 
-                $bindName = ":cursor_{$i}";
-                $binds[$bindName] = $cursor[$originalAttribute];
+                $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->quote($alias)}.{$this->quote($attribute)} {$this->getSQLOperator($operator)} {$bindName}";
+    /**
+     * 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);
 
-                $cursorWhere[] = '(' . implode(' AND ', $conditions) . ')';
-            }
+        if ($fullExpression === null) {
+            throw new DatabaseException('Operator cannot be expressed in SQL: '.$operator->getMethod()->value);
         }
 
-        if (!empty($cursorWhere)) {
-            $where[] = '(' . implode(' OR ', $cursorWhere) . ')';
+        // 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));
         }
 
-        $conditions = $this->getSQLConditions($queries, $binds);
-        if (!empty($conditions)) {
-            $where[] = $conditions;
-        }
+        // Collect the named binding keys and their values in order
+        /** @var array<string, mixed> $namedBindings */
+        $namedBindings = [];
+        $method = $operator->getMethod();
+        $values = $operator->getValues();
+        $idx = 0;
+
+        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;
 
-        if ($this->authorization->getStatus()) {
-            $where[] = $this->getSQLPermissionsCondition($name, $roles, $alias, $forPermission);
-        }
+            case OperatorType::Power:
+                $namedBindings["op_{$idx}"] = $values[0] ?? 1;
+                $idx++;
+                if (isset($values[1])) {
+                    $namedBindings["op_{$idx}"] = $values[1];
+                    $idx++;
+                }
+                break;
 
-        if ($this->sharedTables) {
-            $binds[':_tenant'] = $this->tenant;
-            $where[] = "{$this->getTenantQuery($collection, $alias, condition: '')}";
-        }
+            case OperatorType::StringConcat:
+                $namedBindings["op_{$idx}"] = $values[0] ?? '';
+                $idx++;
+                break;
 
-        $sqlWhere = !empty($where) ? 'WHERE ' . implode(' AND ', $where) : '';
+            case OperatorType::StringReplace:
+                $namedBindings["op_{$idx}"] = $values[0] ?? '';
+                $idx++;
+                $namedBindings["op_{$idx}"] = $values[1] ?? '';
+                $idx++;
+                break;
 
-        // Add vector distance calculations to ORDER BY
-        $vectorOrders = [];
-        foreach ($vectorQueries as $query) {
-            $vectorOrder = $this->getVectorDistanceOrder($query, $binds, $alias);
-            if ($vectorOrder) {
-                $vectorOrders[] = $vectorOrder;
-            }
-        }
+            case OperatorType::Toggle:
+                // No bindings
+                break;
 
-        if (!empty($vectorOrders)) {
-            // Vector orders should come first for similarity search
-            $orders = \array_merge($vectorOrders, $orders);
-        }
+            case OperatorType::DateAddDays:
+            case OperatorType::DateSubDays:
+                $namedBindings["op_{$idx}"] = $values[0] ?? 0;
+                $idx++;
+                break;
 
-        $sqlOrder = !empty($orders) ? 'ORDER BY ' . implode(', ', $orders) : '';
+            case OperatorType::DateSetNow:
+                // No bindings
+                break;
 
-        $sqlLimit = '';
-        if (! \is_null($limit)) {
-            $binds[':limit'] = $limit;
-            $sqlLimit = 'LIMIT :limit';
-        }
+            case OperatorType::ArrayAppend:
+            case OperatorType::ArrayPrepend:
+                $namedBindings["op_{$idx}"] = json_encode($values);
+                $idx++;
+                break;
 
-        if (! \is_null($offset)) {
-            $binds[':offset'] = $offset;
-            $sqlLimit .= ' OFFSET :offset';
-        }
+            case OperatorType::ArrayRemove:
+                $value = $values[0] ?? null;
+                $namedBindings["op_{$idx}"] = is_array($value) ? json_encode($value) : $value;
+                $idx++;
+                break;
 
-        $selections = $this->getAttributeSelections($queries);
+            case OperatorType::ArrayUnique:
+                // No bindings
+                break;
 
-        $sql = "
-            SELECT {$this->getAttributeProjection($selections, $alias)}
-            FROM {$this->getSQLTable($name)} AS {$this->quote($alias)}
-            {$sqlWhere}
-            {$sqlOrder}
-            {$sqlLimit};
-        ";
+            case OperatorType::ArrayInsert:
+                $namedBindings["op_{$idx}"] = $values[0] ?? 0;
+                $idx++;
+                $namedBindings["op_{$idx}"] = json_encode($values[1] ?? null);
+                $idx++;
+                break;
 
-        $sql = $this->trigger(Database::EVENT_DOCUMENT_FIND, $sql);
+            case OperatorType::ArrayIntersect:
+            case OperatorType::ArrayDiff:
+                $namedBindings["op_{$idx}"] = json_encode($values);
+                $idx++;
+                break;
 
-        try {
-            $stmt = $this->getPDO()->prepare($sql);
+            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;
+        }
 
-            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));
-                }
+        // 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);
             }
-
-            $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']);
-            }
+        // Sort by position (ascending) to replace in order
+        usort($replacements, fn ($a, $b) => $a['pos'] - $b['pos']);
 
-            $results[$index] = new Document($results[$index]);
+        // 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']);
         }
 
-        if ($cursorDirection === Database::CURSOR_BEFORE) {
-            $results = \array_reverse($results);
+        // Collect bindings in positional order (left to right)
+        foreach ($replacements as $r) {
+            $positionalBindings[] = $namedBindings[$r['key']];
         }
 
-        return $results;
+        return ['expression' => $result, 'bindings' => $positionalBindings];
     }
 
     /**
-     * Count Documents
+     * Get a builder-compatible operator expression for use in upsert conflict resolution.
      *
-     * @param Document $collection
-     * @param array<Query> $queries
-     * @param int|null $max
-     * @return int
-     * @throws Exception
-     * @throws PDOException
+     * 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>}
      */
-    public function count(Document $collection, array $queries = [], ?int $max = null): int
+    protected function getOperatorUpsertExpression(string $column, Operator $operator): 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';
-        }
-
-        $queries = array_map(fn ($query) => clone $query, $queries);
-
-        $otherQueries = [];
-        foreach ($queries as $query) {
-            if (!in_array($query->getMethod(), Query::VECTOR_TYPES)) {
-                $otherQueries[] = $query;
-            }
-        }
+        return $this->getOperatorBuilderExpression($column, $operator);
+    }
 
-        $conditions = $this->getSQLConditions($otherQueries, $binds);
-        if (!empty($conditions)) {
-            $where[] = $conditions;
-        }
+    /**
+     * 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();
 
-        if ($this->authorization->getStatus()) {
-            $where[] = $this->getSQLPermissionsCondition($name, $roles, $alias);
-        }
+        $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]);
 
-        if ($this->sharedTables) {
-            $binds[':_tenant'] = $this->tenant;
-            $where[] = "{$this->getTenantQuery($collection, $alias, condition: '')}";
-        }
+                return $arr;
+            })(),
+            OperatorType::ArrayRemove => (function () use ($arrVal, $values) {
+                $arr = $arrVal;
+                $toRemove = $values[0] ?? null;
 
-        $sqlWhere = !empty($where)
-            ? 'WHERE ' . \implode(' AND ', $where)
-            : '';
+                return is_array($toRemove)
+                    ? array_values(array_diff($arr, $toRemove))
+                    : array_values(array_diff($arr, [$toRemove]));
+            })(),
+            OperatorType::ArrayUnique => array_values(array_unique($arrVal)),
+            OperatorType::ArrayIntersect => array_values(array_intersect($arrVal, $values)),
+            OperatorType::ArrayDiff => array_values(array_diff($arrVal, $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(),
+        };
+    }
 
-        $sql = "
-			SELECT COUNT(1) as sum FROM (
-				SELECT 1
-				FROM {$this->getSQLTable($name)} AS {$this->quote($alias)}
-                {$sqlWhere}
-                {$limit}
-			) table_count
-        ";
+    /**
+     * Quote an identifier (table name, column name) with the appropriate quoting character.
+     */
+    protected function quote(string $string): string
+    {
+        return "`{$string}`";
+    }
 
-        $sql = $this->trigger(Database::EVENT_DOCUMENT_COUNT, $sql);
+    /**
+     * 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;
+    }
 
-        $stmt = $this->getPDO()->prepare($sql);
+    /**
+     * 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;
 
-        foreach ($binds as $key => $value) {
-            $stmt->bindValue($key, $value, $this->getPDOType($value));
-        }
+    /**
+     * 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;
 
-        try {
-            $this->execute($stmt);
-        } catch (PDOException $e) {
-            throw $this->processException($e);
-        }
+    /**
+     * 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;
 
-        $result = $stmt->fetchAll();
-        $stmt->closeCursor();
-        if (!empty($result)) {
-            $result = $result[0];
-        }
+    /**
+     * 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)),
+        };
+    }
 
-        return $result['sum'] ?? 0;
+    /**
+     * Get the SQL function for random ordering
+     */
+    protected function getRandomOrder(): string
+    {
+        return 'RANDOM()';
     }
 
     /**
-     * Sum an Attribute
+     * Get SQL Operator
      *
-     * @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 getSQLOperator(Method $method): string
     {
-        $collection = $collection->getId();
-        $name = $this->filter($collection);
-        $attribute = $this->filter($attribute);
-        $roles = $this->authorization->getRoles();
-        $where = [];
-        $alias = Query::DEFAULT_ALIAS;
-        $binds = [];
-
-        $limit = '';
-        if (! \is_null($max)) {
-            $binds[':limit'] = $max;
-            $limit = 'LIMIT :limit';
-        }
+        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),
+        };
+    }
 
-        $queries = array_map(fn ($query) => clone $query, $queries);
+    /**
+     * 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');
+    }
 
-        $otherQueries = [];
-        foreach ($queries as $query) {
-            if (!in_array($query->getMethod(), Query::VECTOR_TYPES)) {
-                $otherQueries[] = $query;
-            }
-        }
+    /**
+     * 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');
+    }
 
-        $conditions = $this->getSQLConditions($otherQueries, $binds);
-        if (!empty($conditions)) {
-            $where[] = $conditions;
-        }
+    /**
+     * @param  array<string, mixed>  $binds
+     *
+     * @throws Exception
+     */
+    protected function getSQLCondition(Query $query, array &$binds): string
+    {
+        $query->setAttribute($this->getInternalKeyForAttribute($query->getAttribute()));
 
-        if ($this->authorization->getStatus()) {
-            $where[] = $this->getSQLPermissionsCondition($name, $roles, $alias);
-        }
+        $attribute = $query->getAttribute();
+        $attribute = $this->filter($attribute);
+        $attribute = $this->quote($attribute);
+        $alias = $this->quote(Query::DEFAULT_ALIAS);
+        $placeholder = ID::unique();
 
-        if ($this->sharedTables) {
-            $binds[':_tenant'] = $this->tenant;
-            $where[] = "{$this->getTenantQuery($collection, $alias, condition: '')}";
+        if ($query->isSpatialAttribute()) {
+            return $this->handleSpatialQueries($query, $binds, $attribute, $query->getAttributeType(), $alias, $placeholder);
         }
 
-        $sqlWhere = !empty($where)
-            ? 'WHERE ' . \implode(' AND ', $where)
-            : '';
-
-        $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
-        ";
-
-        $sql = $this->trigger(Database::EVENT_DOCUMENT_SUM, $sql);
-
-        $stmt = $this->getPDO()->prepare($sql);
-
-        foreach ($binds as $key => $value) {
-            $stmt->bindValue($key, $value, $this->getPDOType($value));
-        }
+        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);
+                }
 
-        try {
-            $this->execute($stmt);
-        } catch (PDOException $e) {
-            throw $this->processException($e);
-        }
+                $method = strtoupper($query->getMethod()->value);
 
-        $result = $stmt->fetchAll();
-        $stmt->closeCursor();
-        if (!empty($result)) {
-            $result = $result[0];
-        }
+                return empty($conditions) ? '' : ' ' . $method . ' (' . implode(' AND ', $conditions) . ')';
 
-        return $result['sum'] ?? 0;
-    }
+            case Method::Search:
+                $searchVal = $query->getValue();
+                $binds[":{$placeholder}_0"] = $this->getFulltextValue(\is_string($searchVal) ? $searchVal : '');
 
-    public function getSpatialTypeFromWKT(string $wkt): string
-    {
-        $wkt = trim($wkt);
-        $pos = strpos($wkt, '(');
-        if ($pos === false) {
-            throw new DatabaseException("Invalid spatial type");
-        }
-        return strtolower(trim(substr($wkt, 0, $pos)));
-    }
+                return "MATCH({$alias}.{$attribute}) AGAINST (:{$placeholder}_0 IN BOOLEAN MODE)";
 
-    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]];
-        }
+            case Method::NotSearch:
+                $notSearchVal = $query->getValue();
+                $binds[":{$placeholder}_0"] = $this->getFulltextValue(\is_string($notSearchVal) ? $notSearchVal : '');
 
-        /**
-         * [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.)
-         */
+                return "NOT (MATCH({$alias}.{$attribute}) AGAINST (:{$placeholder}_0 IN BOOLEAN MODE))";
 
-        if (strlen($wkb) < 25) {
-            throw new DatabaseException('Invalid WKB: too short for POINT');
-        }
+            case Method::Between:
+                $binds[":{$placeholder}_0"] = $query->getValues()[0];
+                $binds[":{$placeholder}_1"] = $query->getValues()[1];
 
-        // 4 bytes SRID first → skip to byteOrder at offset 4
-        $byteOrder = ord($wkb[4]);
-        $littleEndian = ($byteOrder === 1);
+                return "{$alias}.{$attribute} BETWEEN :{$placeholder}_0 AND :{$placeholder}_1";
 
-        if (!$littleEndian) {
-            throw new DatabaseException('Only little-endian WKB supported');
-        }
+            case Method::NotBetween:
+                $binds[":{$placeholder}_0"] = $query->getValues()[0];
+                $binds[":{$placeholder}_1"] = $query->getValues()[1];
 
-        // 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');
-        }
+                return "{$alias}.{$attribute} NOT BETWEEN :{$placeholder}_0 AND :{$placeholder}_1";
 
-        // Unpack two doubles
-        $coords = unpack('d2', $coordsBin);
-        if ($coords === false || !isset($coords[1], $coords[2])) {
-            throw new DatabaseException('Invalid WKB: failed to unpack coordinates');
-        }
+            case Method::IsNull:
+            case Method::IsNotNull:
 
-        return [(float)$coords[1], (float)$coords[2]];
-    }
+                return "{$alias}.{$attribute} {$this->getSQLOperator($query->getMethod())}";
+            case Method::ContainsAll:
+                if ($query->onArray()) {
+                    $binds[":{$placeholder}_0"] = json_encode($query->getValues());
 
-    public function decodeLinestring(string $wkb): array
-    {
-        if (str_starts_with(strtoupper($wkb), 'LINESTRING(')) {
-            $start = strpos($wkb, '(') + 1;
-            $end = strrpos($wkb, ')');
-            $inside = substr($wkb, $start, $end - $start);
+                    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
+                    };
 
-            $points = explode(',', $inside);
-            return array_map(function ($point) {
-                $coords = explode(' ', trim($point));
-                return [(float)$coords[0], (float)$coords[1]];
-            }, $points);
-        }
+                    $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}";
+                    }
+                }
 
-        // Skip 1 byte (endianness) + 4 bytes (type) + 4 bytes (SRID)
-        $offset = 9;
+                $separator = $isNotQuery ? ' AND ' : ' OR ';
 
-        // 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');
+                return empty($conditions) ? '' : '(' . implode($separator, $conditions) . ')';
         }
+    }
 
-        $numPoints = $numPointsArr[1];
-        $offset += 4;
-
-        $points = [];
-        for ($i = 0; $i < $numPoints; $i++) {
-            $xArr = unpack('d', substr($wkb, $offset, 8));
-            $yArr = unpack('d', substr($wkb, $offset + 8, 8));
-
-            if ($xArr === false || !isset($xArr[1]) || $yArr === false || !isset($yArr[1])) {
-                throw new DatabaseException('Invalid WKB: cannot unpack point coordinates');
+    /**
+     * 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)
+     * @return string
+     *
+     * @throws Exception
+     */
+    public function getSQLConditions(array $queries, array &$binds, string $separator = 'AND'): string
+    {
+        $conditions = [];
+        foreach ($queries as $query) {
+            if ($query->getMethod() === Method::Select) {
+                continue;
             }
 
-            $points[] = [(float)$xArr[1], (float)$yArr[1]];
-            $offset += 16;
+            if ($query->isNested()) {
+                /** @var array<Query> $nestedQueries */
+                $nestedQueries = $query->getValues();
+                $conditions[] = $this->getSQLConditions($nestedQueries, $binds, strtoupper($query->getMethod()->value));
+            } else {
+                $conditions[] = $this->getSQLCondition($query, $binds);
+            }
         }
 
-        return $points;
+        $tmp = implode(' '.$separator.' ', $conditions);
+
+        return empty($tmp) ? '' : '('.$tmp.')';
     }
 
-    public function decodePolygon(string $wkb): array
+    protected function getFulltextValue(string $value): 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);
+        $exact = str_ends_with($value, '"') && str_starts_with($value, '"');
 
-            $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);
-        }
+        /** Replace reserved chars with space. */
+        $specialChars = '@,+,-,*,),(,<,>,~,"';
+        $value = str_replace(explode(',', $specialChars), ' ', $value);
+        $value = (string) preg_replace('/\s+/', ' ', $value); // Remove multiple whitespaces
+        $value = trim($value);
 
-        // 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');
-            }
+        if (empty($value)) {
+            return '';
         }
 
-        if (strlen($wkb) < 21) {
-            throw new DatabaseException('WKB too short to be a POLYGON');
+        if ($exact) {
+            $value = '"'.$value.'"';
+        } else {
+            /** Prepend wildcard by default on the back. */
+            $value .= '*';
         }
 
-        // MySQL SRID-aware WKB layout: 4 bytes SRID prefix
-        $offset = 4;
+        return $value;
+    }
 
-        $byteOrder = ord($wkb[$offset]);
-        if ($byteOrder !== 1) {
-            throw new DatabaseException('Only little-endian WKB supported');
-        }
-        $offset += 1;
+    /**
+     * 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
+    {
+        return null;
+    }
 
-        $typeArr = unpack('V', substr($wkb, $offset, 4));
-        if ($typeArr === false || !isset($typeArr[1])) {
-            throw new DatabaseException('Invalid WKB: cannot unpack geometry type');
-        }
+    /**
+     * 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;
+    }
 
-        $type = $typeArr[1];
-        $hasSRID = ($type & 0x20000000) === 0x20000000;
-        $geomType = $type & 0xFF;
-        $offset += 4;
+    /**
+     * Get the SQL LIKE operator for this adapter.
+     *
+     * @return string
+     */
+    public function getLikeOperator(): string
+    {
+        return 'LIKE';
+    }
 
-        if ($geomType !== 3) { // 3 = POLYGON
-            throw new DatabaseException("Not a POLYGON geometry type, got {$geomType}");
-        }
+    /**
+     * Get the SQL regex matching operator for this adapter.
+     *
+     * @return string
+     */
+    public function getRegexOperator(): string
+    {
+        return 'REGEXP';
+    }
 
-        // Skip SRID in type flag if present
-        if ($hasSRID) {
-            $offset += 4;
-        }
+    public function getSchemaIndexes(string $collection): array
+    {
+        return [];
+    }
 
-        $numRingsArr = unpack('V', substr($wkb, $offset, 4));
+    public function getSupportForSchemaIndexes(): bool
+    {
+        return false;
+    }
 
-        if ($numRingsArr === false || !isset($numRingsArr[1])) {
-            throw new DatabaseException('Invalid WKB: cannot unpack number of rings');
+    /**
+     * 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 '';
         }
 
-        $numRings = $numRingsArr[1];
-        $offset += 4;
-
-        $rings = [];
-
-        for ($r = 0; $r < $numRings; $r++) {
-            $numPointsArr = unpack('V', substr($wkb, $offset, 4));
+        $dot = '';
+        if ($alias !== '') {
+            $dot = '.';
+            $alias = $this->quote($alias);
+        }
 
-            if ($numPointsArr === false || !isset($numPointsArr[1])) {
-                throw new DatabaseException('Invalid WKB: cannot unpack number of points');
+        $bindings = [];
+        if ($tenantCount === 0) {
+            $bindings[] = ':_tenant';
+        } else {
+            for ($index = 0; $index < $tenantCount; $index++) {
+                $bindings[] = ":_tenant_{$index}";
             }
+        }
+        $bindings = \implode(',', $bindings);
 
-            $numPoints = $numPointsArr[1];
-            $offset += 4;
-            $ring = [];
+        $orIsNull = '';
+        if ($collection === Database::METADATA) {
+            $orIsNull = " OR {$alias}{$dot}_tenant IS NULL";
+        }
 
-            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.');
-                }
+        return "{$condition} ({$alias}{$dot}_tenant IN ({$bindings}) {$orIsNull})";
+    }
 
-                $x = (float) $xArr[1];
+    /**
+     * 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)}.*";
+        }
 
-                $yArr = unpack('d', substr($wkb, $offset + 8, 8));
-                if ($yArr === false) {
-                    throw new DatabaseException('Failed to unpack Y coordinate from WKB.');
-                }
+        // Handle specific selections with spatial conversion where needed
+        $internalKeys = [
+            '$id',
+            '$sequence',
+            '$permissions',
+            '$createdAt',
+            '$updatedAt',
+        ];
 
-                $y = (float) $yArr[1];
+        $selections = \array_diff($selections, [...$internalKeys, '$collection']);
 
-                $ring[] = [$x, $y];
-                $offset += 16;
-            }
+        foreach ($internalKeys as $internalKey) {
+            $selections[] = $this->getInternalKeyForAttribute($internalKey);
+        }
 
-            $rings[] = $ring;
+        $projections = [];
+        foreach ($selections as $selection) {
+            $filteredSelection = $this->filter($selection);
+            $quotedSelection = $this->quote($filteredSelection);
+            $projections[] = "{$this->quote($prefix)}.{$quotedSelection}";
         }
 
-        return $rings;
+        return \implode(',', $projections);
     }
 
-    public function setSupportForAttributes(bool $support): bool
+    protected function getInternalKeyForAttribute(string $attribute): string
     {
-        return true;
+        return match ($attribute) {
+            '$id' => '_uid',
+            '$sequence' => '_id',
+            '$collection' => '_collection',
+            '$tenant' => '_tenant',
+            '$createdAt' => '_createdAt',
+            '$updatedAt' => '_updatedAt',
+            '$permissions' => '_permissions',
+            '$version' => '_version',
+            default => $attribute
+        };
     }
 
-    public function getSupportForAlterLocks(): bool
+    protected function escapeWildcards(string $value): string
     {
-        return false;
-    }
+        $wildcards = ['%', '_', '[', ']', '^', '-', '.', '*', '+', '?', '(', ')', '{', '}', '|'];
 
-    public function getLockType(): string
-    {
-        if ($this->getSupportForAlterLocks() && $this->alterLocks) {
-            return ',LOCK=SHARED';
+        foreach ($wildcards as $wildcard) {
+            $value = \str_replace($wildcard, "\\$wildcard", $value);
         }
 
-        return '';
+        return $value;
     }
 
-    public function getSupportForTransactionRetries(): bool
+    protected function processException(PDOException $e): Exception
     {
-        return true;
+        return $e;
     }
 
-    public function getSupportForNestedTransactions(): bool
+    /**
+     * Extract search queries from the query list (non-destructive).
+     *
+     * @param array<Query> $queries
+     * @return array<Query>
+     */
+    protected function extractSearchQueries(array $queries): array
     {
-        return true;
+        $searchQueries = [];
+        foreach ($queries as $query) {
+            if ($query->getMethod() === Method::Search) {
+                $searchQueries[] = $query;
+            }
+        }
+
+        return $searchQueries;
+    }
+
+    /**
+     * 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;
     }
 }
diff --git a/src/Database/Adapter/SQLite.php b/src/Database/Adapter/SQLite.php
index 3c25987eb..dfbf9fd29 100644
--- a/src/Database/Adapter/SQLite.php
+++ b/src/Database/Adapter/SQLite.php
@@ -5,9 +5,15 @@
 use Exception;
 use PDO;
 use PDOException;
+use PDOStatement;
 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;
@@ -16,7 +22,16 @@
 use Utopia\Database\Exception\Timeout as TimeoutException;
 use Utopia\Database\Exception\Transaction as TransactionException;
 use Utopia\Database\Helpers\ID;
+use Utopia\Database\Index;
 use Utopia\Database\Operator;
+use Utopia\Database\OperatorType;
+use Utopia\Database\Query;
+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:
@@ -32,10 +47,47 @@
  * 9. MODIFY COLUMN is not supported
  * 10. Can't rename an index directly
  */
-class SQLite extends MariaDB
+class SQLite extends SQL
 {
     /**
-     * @inheritDoc
+     * Get the list of capabilities supported by the SQLite adapter.
+     *
+     * @return array<Capability>
+     */
+    public function capabilities(): array
+    {
+        $remove = [
+            Capability::Schemas,
+            Capability::Fulltext,
+            Capability::MultipleFulltextIndexes,
+            Capability::Regex,
+            Capability::UpdateLock,
+            Capability::BatchCreateAttributes,
+            Capability::QueryContains,
+            Capability::Hostname,
+            Capability::AttributeResizing,
+        ];
+
+        return array_merge(
+            array_values(array_filter(
+                parent::capabilities(),
+                fn (Capability $c) => ! in_array($c, $remove, true)
+            )),
+            [
+                Capability::IntegerBooleans,
+                Capability::NumericCasting,
+            ]
+        );
+    }
+
+    protected function execute(mixed $stmt): bool
+    {
+        /** @var \PDOStatement|PDOStatementProxy $stmt */
+        return $stmt->execute();
+    }
+
+    /**
+     * {@inheritDoc}
      */
     public function startTransaction(): bool
     {
@@ -48,14 +100,14 @@ public function startTransaction(): bool
                 $result = $this->getPDO()->beginTransaction();
             } else {
                 $result = $this->getPDO()
-                    ->prepare('SAVEPOINT transaction' . $this->inTransaction)
+                    ->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');
         }
 
@@ -64,13 +116,21 @@ public function startTransaction(): bool
         return $result;
     }
 
+    /**
+     * 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
@@ -84,12 +144,10 @@ 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->bindValue(':table', "{$this->getNamespace()}_{$collection}", PDO::PARAM_STR);
@@ -98,31 +156,20 @@ public function exists(string $database, ?string $collection = null): bool
 
         $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
      */
@@ -134,10 +181,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
      */
@@ -149,14 +195,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}, ";
@@ -171,15 +217,14 @@ public function createCollection(string $name, array $attributes = [], array $in
 				{$tenantQuery}
 				`_createdAt` DATETIME(3) DEFAULT NULL,
 				`_updatedAt` DATETIME(3) DEFAULT NULL,
-				`_permissions` MEDIUMTEXT DEFAULT NULL".(!empty($attributes) ? ',' : '')."
-				" . \substr(\implode(' ', $attributeStrings), 0, -2) . "
+				`_permissions` MEDIUMTEXT DEFAULT NULL,
+				`_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')} (
+			CREATE TABLE {$this->getSQLTable($id.'_perms')} (
 				`_id` INTEGER PRIMARY KEY AUTOINCREMENT,
 				{$tenantQuery}
 				`_type` VARCHAR(12) NOT NULL,
@@ -188,8 +233,6 @@ public function createCollection(string $name, array $attributes = [], array $in
 			)
 		";
 
-        $permissions = $this->trigger(Database::EVENT_COLLECTION_CREATE, $permissions);
-
         try {
             $this->getPDO()
                 ->prepare($collection)
@@ -199,63 +242,86 @@ public function createCollection(string $name, array $attributes = [], array $in
                 ->prepare($permissions)
                 ->execute();
 
-            $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, new Index(key: '_index1', type: IndexType::Unique, attributes: ['_uid']));
+            $this->createIndex($id, new Index(key: '_created_at', type: IndexType::Key, attributes: ['_createdAt']));
+            $this->createIndex($id, new Index(key: '_updated_at', type: IndexType::Key, attributes: ['_updatedAt']));
 
-            $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("{$id}_perms", new Index(key: '_index_1', type: IndexType::Unique, attributes: ['_document', '_type', '_permission']));
+            $this->createIndex("{$id}_perms", new Index(key: '_index_2', type: IndexType::Key, attributes: ['_permission', '_type']));
 
             if ($this->sharedTables) {
-                $this->createIndex($id, '_tenant_id', Database::INDEX_KEY, [ '_id'], [], []);
+                $this->createIndex($id, new Index(key: '_tenant_id', type: IndexType::Key, attributes: ['_id']));
             }
 
             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,
+                ));
             }
 
-            $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("{$id}_perms", new Index(key: '_index_1', type: IndexType::Unique, attributes: ['_document', '_type', '_permission']));
+            $this->createIndex("{$id}_perms", new Index(key: '_index_2', type: IndexType::Key, attributes: ['_permission', '_type']));
 
         } catch (PDOException $e) {
             throw $this->processException($e);
         }
+
         return true;
     }
 
+    /**
+     * Delete Collection
+     *
+     * @throws Exception
+     * @throws PDOException
+     */
+    public function deleteCollection(string $id): bool
+    {
+        $id = $this->filter($id);
+
+        $sql = "DROP TABLE IF EXISTS {$this->getSQLTable($id)}";
+
+        $this->getPDO()
+            ->prepare($sql)
+            ->execute();
+
+        $sql = "DROP TABLE IF EXISTS {$this->getSQLTable($id.'_perms')}";
+
+        $this->getPDO()
+            ->prepare($sql)
+            ->execute();
+
+        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';
+        $name = $namespace.'_'.$collection;
+        $permissions = $namespace.'_'.$collection.'_perms';
 
-        $collectionSize = $this->getPDO()->prepare("
-             SELECT SUM(\"pgsize\") 
-             FROM \"dbstat\" 
+        $collectionSize = $this->getPDO()->prepare('
+             SELECT SUM("pgsize")
+             FROM "dbstat"
              WHERE name = :name;
-        ");
+        ');
 
-        $permissionsSize = $this->getPDO()->prepare("
-             SELECT SUM(\"pgsize\") 
-             FROM \"dbstat\"
+        $permissionsSize = $this->getPDO()->prepare('
+             SELECT SUM("pgsize")
+             FROM "dbstat"
              WHERE name = :name;
-        ");
+        ');
 
         $collectionSize->bindParam(':name', $name);
         $permissionsSize->bindParam(':name', $permissions);
@@ -263,9 +329,11 @@ public function getSizeOfCollection(string $collection): int
         try {
             $collectionSize->execute();
             $permissionsSize->execute();
-            $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;
@@ -273,8 +341,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
@@ -282,64 +349,16 @@ public function getSizeOfCollectionOnDisk(string $collection): int
         return $this->getSizeOfCollection($collection);
     }
 
-    /**
-     * Delete Collection
-     * @param string $id
-     * @return bool
-     * @throws Exception
-     * @throws PDOException
-     */
-    public function deleteCollection(string $id): bool
-    {
-        $id = $this->filter($id);
-
-        $sql = "DROP TABLE IF EXISTS {$this->getSQLTable($id)}";
-        $sql = $this->trigger(Database::EVENT_COLLECTION_DELETE, $sql);
-
-        $this->getPDO()
-            ->prepare($sql)
-            ->execute();
-
-        $sql = "DROP TABLE IF EXISTS {$this->getSQLTable($id . '_perms')}";
-        $sql = $this->trigger(Database::EVENT_COLLECTION_DELETE, $sql);
-
-        $this->getPDO()
-            ->prepare($sql)
-            ->execute();
-
-        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);
         }
 
         return true;
@@ -348,14 +367,10 @@ 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);
@@ -366,22 +381,31 @@ public function deleteAttribute(string $collection, string $id, bool $array = fa
             throw new NotFoundException('Collection not found');
         }
 
-        $indexes = \json_decode($collection->getAttribute('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['$id'] ?? null) ? (string) $index['$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);
+            } elseif (\in_array($id, \is_array($attributes) ? $attributes : [])) {
+                $this->deleteIndex($name, $indexId);
+                $this->createIndex($name, new Index(
+                    key: $indexId,
+                    type: IndexType::from($indexType),
+                    attributes: \array_map(fn (mixed $v): string => \is_scalar($v) ? (string) $v : '', \is_array($attributes) ? \array_values(\array_diff($attributes, [$id])) : []),
+                    lengths: \array_map(fn (mixed $v): int => \is_numeric($v) ? (int) $v : 0, \is_array($index['lengths'] ?? null) ? $index['lengths'] : []),
+                    orders: \array_map(fn (mixed $v): string => \is_scalar($v) ? (string) $v : '', \is_array($index['orders'] ?? null) ? $index['orders'] : []),
+                ));
             }
         }
 
         $sql = "ALTER TABLE {$this->getSQLTable($name)} DROP COLUMN `{$id}`";
 
-        $sql = $this->trigger(Database::EVENT_COLLECTION_DELETE, $sql);
-
         try {
             return $this->getPDO()
                 ->prepare($sql)
@@ -395,89 +419,37 @@ 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 = \json_decode($collection->getAttribute('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 = []): bool
     {
         $name = $this->filter($collection);
-        $id = $this->filter($id);
+        $id = $this->filter($index->key);
+        $type = $index->type;
+        $attributes = $index->attributes;
 
         // Workaround for no support for CREATE INDEX IF NOT EXISTS
         $stmt = $this->getPDO()->prepare("
-			SELECT name 
-			FROM sqlite_master 
+			SELECT name
+			FROM sqlite_master
 			WHERE type='index' AND name=:_index;
 		");
         $stmt->bindValue(':_index', "{$this->getNamespace()}_{$this->tenant}_{$name}_{$id}");
         $stmt->execute();
-        $index = $stmt->fetch();
-        if (!empty($index)) {
+        $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();
@@ -486,9 +458,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
      */
@@ -498,7 +467,6 @@ public function deleteIndex(string $collection, string $id): bool
         $id = $this->filter($id);
 
         $sql = "DROP INDEX `{$this->getNamespace()}_{$this->tenant}_{$name}_{$id}`";
-        $sql = $this->trigger(Database::EVENT_INDEX_DELETE, $sql);
 
         try {
             return $this->getPDO()
@@ -514,372 +482,190 @@ public function deleteIndex(string $collection, string $id): bool
     }
 
     /**
-     * Create Document
+     * Rename Index
      *
-     * @param Document $collection
-     * @param Document $document
-     * @return Document
      * @throws Exception
      * @throws PDOException
-     * @throws DuplicateException
      */
-    public function createDocument(Document $collection, Document $document): Document
+    public function renameIndex(string $collection, string $old, string $new): bool
     {
-        $collection = $collection->getId();
-        $attributes = $document->getAttributes();
-        $attributes['_createdAt'] = $document->getCreatedAt();
-        $attributes['_updatedAt'] = $document->getUpdatedAt();
-        $attributes['_permissions'] = json_encode($document->getPermissions());
+        $metadataCollection = new Document(['$id' => Database::METADATA]);
+        $collection = $this->getDocument($metadataCollection, $collection);
 
-        if ($this->sharedTables) {
-            $attributes['_tenant'] = $this->tenant;
+        if ($collection->isEmpty()) {
+            throw new NotFoundException('Collection not found');
         }
 
-        $name = $this->filter($collection);
-        $columns = ['_uid'];
-        $values = ['_uid'];
+        $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;
 
-        /**
-         * Insert Attributes
-         */
-        $bindIndex = 0;
-        foreach ($attributes as $attribute => $value) { // Parse statement
-            $column = $this->filter($attribute);
-            $values[] = 'value_' . $bindIndex;
-            $columns[] = "`{$column}`";
-            $bindIndex++;
+        foreach ($indexes as $node) {
+            /** @var array<string, mixed> $node */
+            if (($node['key'] ?? null) === $old) {
+                $index = $node;
+                break;
+            }
         }
 
-        // Insert manual id if set
-        if (!empty($document->getSequence())) {
-            $values[] = '_id';
-            $columns[] = "_id";
+        if ($index
+            && $this->deleteIndex($collection->getId(), $old)
+            && $this->createIndex(
+                $collection->getId(),
+                new Index(
+                    key: $new,
+                    type: IndexType::from(\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: \array_map(fn (mixed $v): string => \is_scalar($v) ? (string) $v : '', \is_array($index['orders'] ?? null) ? $index['orders'] : []),
+                ),
+            )) {
+            return true;
         }
 
-        $sql = "
-			INSERT INTO `{$this->getNamespace()}_{$name}` (".\implode(', ', $columns).") 
-			VALUES (:".\implode(', :', $values).");
-		";
-
-        $sql = $this->trigger(Database::EVENT_DOCUMENT_CREATE, $sql);
-
-        $stmt = $this->getPDO()->prepare($sql);
-
-        $stmt->bindValue(':_uid', $document->getId(), PDO::PARAM_STR);
-
-        // Bind internal id if set
-        if (!empty($document->getSequence())) {
-            $stmt->bindValue(':_id', $document->getSequence(), PDO::PARAM_STR);
-        }
+        return false;
+    }
 
-        $attributeIndex = 0;
-        foreach ($attributes as $attribute => $value) {
-            if (is_array($value)) { // arrays & objects should be saved as strings
-                $value = json_encode($value);
-            }
+    /**
+     * Create Document
+     *
+     * @throws Exception
+     * @throws PDOException
+     * @throws DuplicateException
+     */
+    public function createDocument(Document $collection, Document $document): Document
+    {
+        try {
+            $this->syncWriteHooks();
 
-            $bindKey = 'value_' . $attributeIndex;
-            $attribute = $this->filter($attribute);
-            $value = (is_bool($value)) ? (int)$value : $value;
-            $stmt->bindValue(':' . $bindKey, $value, $this->getPDOType($value));
-            $attributeIndex++;
-        }
+            $collection = $collection->getId();
+            $attributes = $document->getAttributes();
+            $attributes['_createdAt'] = $document->getCreatedAt();
+            $attributes['_updatedAt'] = $document->getUpdatedAt();
+            $attributes['_permissions'] = json_encode($document->getPermissions());
 
-        $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})";
+            $version = $document->getVersion();
+            if ($version !== null) {
+                $attributes['_version'] = $version;
             }
-        }
 
-        if (!empty($permissions)) {
-            $tenantQuery = $this->sharedTables ? ', _tenant' : '';
+            $name = $this->filter($collection);
 
-            $queryPermissions = "
-				INSERT INTO `{$this->getNamespace()}_{$name}_perms` (_type, _permission, _document {$tenantQuery})
-				VALUES " . \implode(', ', $permissions);
+            $builder = $this->createBuilder()->into($this->getSQLTableRaw($name));
+            $row = ['_uid' => $document->getId()];
 
-            $queryPermissions = $this->trigger(Database::EVENT_PERMISSIONS_CREATE, $queryPermissions);
+            if (! empty($document->getSequence())) {
+                $row['_id'] = $document->getSequence();
+            }
 
-            $stmtPermissions = $this->getPDO()->prepare($queryPermissions);
+            foreach ($attributes as $attr => $value) {
+                $column = $this->filter($attr);
 
-            if ($this->sharedTables) {
-                $stmtPermissions->bindValue(':_tenant', $this->tenant);
+                if (is_array($value)) {
+                    $value = json_encode($value);
+                }
+                $value = (is_bool($value)) ? (int) $value : $value;
+                $row[$column] = $value;
             }
-        }
 
-        try {
+            $row = $this->decorateRow($row, $this->documentMetadata($document));
+            $builder->set($row);
+            $result = $builder->insert();
+            $stmt = $this->executeResult($result, Event::DocumentCreate);
+
             $stmt->execute();
 
-            $statment = $this->getPDO()->prepare("SELECT last_insert_rowid() AS id");
+            $statment = $this->getPDO()->prepare('SELECT last_insert_rowid() AS id');
             $statment->execute();
             $last = $statment->fetch();
 
-            $document['$sequence'] = $last['id'];
-
-            if (isset($stmtPermissions)) {
-                $stmtPermissions->execute();
+            if (\is_array($last)) {
+                /** @var array<string, mixed> $last */
+                $document['$sequence'] = $last['id'] ?? null;
             }
+
+            $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());
-
-        if ($this->sharedTables) {
-            $attributes['_tenant'] = $this->tenant;
-        }
-
-        $name = $this->filter($collection);
-        $columns = '';
-
-        if (!$skipPermissions) {
-            $sql = "
-			SELECT _type, _permission
-			FROM `{$this->getNamespace()}_{$name}_perms`
-			WHERE _document = :_uid
-			{$this->getTenantQuery($collection)}
-		";
-
-            $sql = $this->trigger(Database::EVENT_PERMISSIONS_READ, $sql);
-
-            /**
-             * Get current permissions from the database
-             */
-            $permissionsStmt = $this->getPDO()->prepare($sql);
-            $permissionsStmt->bindValue(':_uid', $document->getId());
-
-            if ($this->sharedTables) {
-                $permissionsStmt->bindValue(':_tenant', $this->tenant);
-            }
-
-            $permissionsStmt->execute();
-            $permissions = $permissionsStmt->fetchAll();
-            $permissionsStmt->closeCursor();
-
-            $initial = [];
-            foreach (Database::PERMISSIONS as $type) {
-                $initial[$type] = [];
+        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());
+
+            $version = $document->getVersion();
+            if ($version !== null) {
+                $attributes['_version'] = $version;
             }
 
-            $permissions = array_reduce($permissions, function (array $carry, array $item) {
-                $carry[$item['_type']][] = $item['_permission'];
-
-                return $carry;
-            }, $initial);
+            $name = $this->filter($collection);
 
-            /**
-             * Get removed Permissions
-             */
-            $removals = [];
-            foreach (Database::PERMISSIONS as $type) {
-                $diff = \array_diff($permissions[$type], $document->getPermissionsByType($type));
-                if (!empty($diff)) {
-                    $removals[$type] = $diff;
+            $operators = [];
+            foreach ($attributes as $attribute => $value) {
+                if (Operator::isOperator($value)) {
+                    $operators[$attribute] = $value;
                 }
             }
 
-            /**
-             * Get added Permissions
-             */
-            $additions = [];
-            foreach (Database::PERMISSIONS as $type) {
-                $diff = \array_diff($document->getPermissionsByType($type), $permissions[$type]);
-                if (!empty($diff)) {
-                    $additions[$type] = $diff;
-                }
-            }
+            $builder = $this->newBuilder($name);
+            $regularRow = ['_uid' => $document->getId()];
 
-            /**
-             * Query to remove permissions
-             */
-            $removeQuery = '';
-            if (!empty($removals)) {
-                $removeQuery = ' AND (';
-                foreach ($removals as $type => $permissions) {
-                    $removeQuery .= "(
-                    _type = '{$type}'
-                    AND _permission IN (" . implode(', ', \array_map(fn (string $i) => ":_remove_{$type}_{$i}", \array_keys($permissions))) . ")
-                )";
-                    if ($type !== \array_key_last($removals)) {
-                        $removeQuery .= ' OR ';
-                    }
-                }
-            }
-            if (!empty($removeQuery)) {
-                $removeQuery .= ')';
-                $sql = "
-				DELETE
-                FROM `{$this->getNamespace()}_{$name}_perms`
-                WHERE _document = :_uid
-                {$this->getTenantQuery($collection)}
-			";
-
-                $removeQuery = $sql . $removeQuery;
-                $removeQuery = $this->trigger(Database::EVENT_PERMISSIONS_DELETE, $removeQuery);
-
-                $stmtRemovePermissions = $this->getPDO()->prepare($removeQuery);
-                $stmtRemovePermissions->bindValue(':_uid', $document->getId());
-
-                if ($this->sharedTables) {
-                    $stmtRemovePermissions->bindValue(':_tenant', $this->tenant);
-                }
+            foreach ($attributes as $attribute => $value) {
+                $column = $this->filter($attribute);
 
-                foreach ($removals as $type => $permissions) {
-                    foreach ($permissions as $i => $permission) {
-                        $stmtRemovePermissions->bindValue(":_remove_{$type}_{$i}", $permission);
+                if (isset($operators[$attribute])) {
+                    $op = $operators[$attribute];
+                    if ($op instanceof Operator) {
+                        $opResult = $this->getOperatorBuilderExpression($column, $op);
+                        $builder->setRaw($column, $opResult['expression'], $opResult['bindings']);
                     }
-                }
-            }
-
-            /**
-             * Query to add permissions
-             */
-            if (!empty($additions)) {
-                $values = [];
-                foreach ($additions as $type => $permissions) {
-                    foreach ($permissions as $i => $_) {
-                        $tenantQuery = $this->sharedTables ? ', :_tenant' : '';
-                        $values[] = "(:_uid, '{$type}', :_add_{$type}_{$i} {$tenantQuery})";
+                } elseif ($this instanceof Feature\Spatial && \in_array($attribute, $spatialAttributes, true)) {
+                    if (\is_array($value)) {
+                        $value = $this->convertArrayToWKT($value);
                     }
-                }
-
-                $tenantQuery = $this->sharedTables ? ', _tenant' : '';
-
-                $sql = "
-			   INSERT INTO `{$this->getNamespace()}_{$name}_perms` (_document, _type, _permission {$tenantQuery})
-			   VALUES " . \implode(', ', $values);
-
-                $sql = $this->trigger(Database::EVENT_PERMISSIONS_CREATE, $sql);
-
-                $stmtAddPermissions = $this->getPDO()->prepare($sql);
-
-                $stmtAddPermissions->bindValue(":_uid", $document->getId());
-                if ($this->sharedTables) {
-                    $stmtAddPermissions->bindValue(":_tenant", $this->tenant);
-                }
-
-                foreach ($additions as $type => $permissions) {
-                    foreach ($permissions as $i => $permission) {
-                        $stmtAddPermissions->bindValue(":_add_{$type}_{$i}", $permission);
+                    $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;
                 }
             }
-        }
 
-        /**
-         * Update Attributes
-         */
-        $keyIndex = 0;
-        $opIndex = 0;
-        $operators = [];
+            $builder->set($regularRow);
+            $builder->filter([BaseQuery::equal('_uid', [$id])]);
+            $result = $builder->update();
+            $stmt = $this->executeResult($result, Event::DocumentUpdate);
 
-        // Separate regular attributes from operators
-        foreach ($attributes as $attribute => $value) {
-            if (Operator::isOperator($value)) {
-                $operators[$attribute] = $value;
-            }
-        }
-
-        foreach ($attributes as $attribute => $value) {
-            $column = $this->filter($attribute);
-
-            // Check if this is an operator, spatial attribute, or regular attribute
-            if (isset($operators[$attribute])) {
-                $operatorSQL = $this->getOperatorSQL($column, $operators[$attribute], $opIndex);
-                $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}, _uid = :_newUid
-			WHERE _uid = :_existingUid
-			{$this->getTenantQuery($collection)}
-		";
-
-        $sql = $this->trigger(Database::EVENT_DOCUMENT_UPDATE, $sql);
-
-        $stmt = $this->getPDO()->prepare($sql);
-
-        $stmt->bindValue(':_existingUid', $id);
-        $stmt->bindValue(':_newUid', $document->getId());
-
-        if ($this->sharedTables) {
-            $stmt->bindValue(':_tenant', $this->tenant);
-        }
-
-        // Bind values for non-operator attributes and operator parameters
-        $keyIndex = 0;
-        $opIndexForBinding = 0;
-        foreach ($attributes as $attribute => $value) {
-            // Handle operators separately
-            if (isset($operators[$attribute])) {
-                $this->bindOperatorParams($stmt, $operators[$attribute], $opIndexForBinding);
-                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++;
-        }
-
-        try {
             $stmt->execute();
-            if (isset($stmtRemovePermissions)) {
-                $stmtRemovePermissions->execute();
-            }
-            if (isset($stmtAddPermissions)) {
-                $stmtAddPermissions->execute();
-            }
+
+            $ctx = $this->buildWriteContext($name);
+            $this->runWriteHooks(fn ($hook) => $hook->afterDocumentUpdate($name, $document, $skipPermissions, $ctx));
         } catch (PDOException $e) {
             throw $this->processException($e);
         }
@@ -887,270 +673,15 @@ public function updateDocument(Document $collection, string $id, Document $docum
         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 false;
-    }
-
-    /**
-     * Is fulltext Wildcard index supported?
-     *
-     * @return bool
-     */
-    public function getSupportForFulltextWildcardIndex(): bool
-    {
-        return false;
-    }
-
-    /**
-     * Are timeouts supported?
-     *
-     * @return bool
-     */
-    public function getSupportForTimeouts(): bool
-    {
-        return false;
-    }
-
-    public function getSupportForRelationships(): bool
-    {
-        return false;
-    }
-
-    public function getSupportForUpdateLock(): bool
-    {
-        return false;
-    }
-
-    /**
-     * Is attribute resizing supported?
-     *
-     * @return bool
-     */
-    public function getSupportForAttributeResizing(): bool
-    {
-        return false;
-    }
-
-    /**
-     * 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 false;
-    }
-
     public function getSupportForSchemaIndexes(): bool
     {
         return false;
     }
 
     /**
-     * Is upsert supported?
-     *
-     * @return bool
-     */
-    public function getSupportForUpserts(): 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 false;
-    }
-
-    public function getSupportForSpatialAttributes(): bool
-    {
-        return false; // SQLite doesn't have native spatial support
-    }
-
-    public function getSupportForObject(): 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';
-
-            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) => match ($attribute) {
-            '$id' => ID::custom('_uid'),
-            '$createdAt' => '_createdAt',
-            '$updatedAt' => '_updatedAt',
-            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 = "`_tenant` {$postfix}, {$attributes}";
-        }
-
-        return "CREATE {$type} {$key} ON `{$this->getNamespace()}_{$collection}` ({$attributes})";
-    }
-
-    /**
-     * Get SQL condition for permissions
+     * Get the maximum length for unique document IDs.
      *
-     * @param string $collection
-     * @param array<string> $roles
-     * @return string
-     * @throws Exception
-     */
-    protected function getSQLPermissionsCondition(string $collection, array $roles, string $alias, string $type = Database::PERMISSION_READ): string
-    {
-        $roles = array_map(fn (string $role) => $this->getPDO()->quote($role), $roles);
-
-        return "{$this->quote($alias)}.{$this->quote('_uid')} IN (
-                    SELECT distinct(_document)
-                    FROM `{$this->getNamespace()}_{$collection}_perms`
-                    WHERE _permission IN (" . implode(', ', $roles) . ")
-                    AND _type = '{$type}'
-                )";
-    }
-
-    /**
-     * Get SQL table
-     *
-     * @param string $name
-     * @return string
-     */
-    protected function getSQLTable(string $name): string
-    {
-        return $this->quote("{$this->getNamespace()}_{$this->filter($name)}");
-    }
-
+     * SQLite uses VARCHAR(36) for the _uid column, unlike other SQL adapters
     /**
      * Get list of keywords that cannot be used
      *  Refference: https://www.sqlite.org/lang_keywords.html
@@ -1310,154 +841,354 @@ public function getKeywords(): array
         ];
     }
 
-    protected function processException(PDOException $e): \Exception
+    protected function createBuilder(): SQLBuilder
     {
-        // Timeout
-        if ($e->getCode() === 'HY000' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 3024) {
-            return new TimeoutException('Query timed out', $e->getCode(), $e);
+        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';
         }
 
-        // Table/index already exists (SQLITE_ERROR with "already exists" message)
-        if ($e->getCode() === 'HY000' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1 && stripos($e->getMessage(), 'already exists') !== false) {
-            return new DuplicateException('Collection already exists', $e->getCode(), $e);
+        if ($type === ColumnType::String) {
+            if ($size > 16777215) {
+                return 'LONGTEXT';
+            }
+            if ($size > 65535) {
+                return 'MEDIUMTEXT';
+            }
+            if ($size > $this->getMaxVarcharLength()) {
+                return 'TEXT';
+            }
+
+            return "VARCHAR({$size})";
         }
 
-        // Table not found (SQLITE_ERROR with "no such table" message)
-        if ($e->getCode() === 'HY000' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1 && stripos($e->getMessage(), 'no such table') !== false) {
-            return new NotFoundException('Collection not found', $e->getCode(), $e);
+        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})";
         }
 
-        // Duplicate - SQLite uses various error codes for constraint violations:
-        // - Error code 19 is SQLITE_CONSTRAINT (includes UNIQUE violations)
-        // - Error code 1 is also used for some duplicate cases
-        // - SQL state '23000' is integrity constraint violation
-        if (
-            ($e->getCode() === 'HY000' && isset($e->errorInfo[1]) && ($e->errorInfo[1] === 1 || $e->errorInfo[1] === 19)) ||
-            $e->getCode() === '23000'
-        ) {
-            $message = $e->getMessage();
-            if (
-                (isset($e->errorInfo[1]) && $e->errorInfo[1] === 19) ||
-                $e->getCode() === '23000' ||
-                stripos($message, 'unique') !== false ||
-                stripos($message, 'duplicate') !== false
-            ) {
-                if (!\str_contains($message, '_uid')) {
-                    return new DuplicateException('Document with the requested unique attributes already exists', $e->getCode(), $e);
+        if ($type === ColumnType::Integer) {
+            $suffix = $signed ? '' : ' UNSIGNED';
+
+            return ($size >= 8 ? 'BIGINT' : 'INT').$suffix;
+        }
+
+        if ($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;
+    }
+
+    /**
+     * @param  array<string, mixed>  $binds
+     *
+     * @throws Exception
+     */
+    protected function getSQLCondition(Query $query, array &$binds): 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();
+
+        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);
+                }
+
+                $method = strtoupper($query->getMethod()->value);
+
+                return empty($conditions) ? '' : ' '.$method.' ('.implode(' AND ', $conditions).')';
+
+            case Method::Search:
+                $searchVal = $query->getValue();
+                $binds[":{$placeholder}_0"] = $this->getFulltextValue(\is_string($searchVal) ? $searchVal : '');
+
+                return "MATCH({$alias}.{$attribute}) AGAINST (:{$placeholder}_0 IN BOOLEAN MODE)";
+
+            case Method::NotSearch:
+                $notSearchVal = $query->getValue();
+                $binds[":{$placeholder}_0"] = $this->getFulltextValue(\is_string($notSearchVal) ? $notSearchVal : '');
+
+                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];
+
+                return "{$alias}.{$attribute} BETWEEN :{$placeholder}_0 AND :{$placeholder}_1";
+
+            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 Method::IsNull:
+            case Method::IsNotNull:
+
+                return "{$alias}.{$attribute} {$this->getSQLOperator($query->getMethod())}";
+            case Method::ContainsAll:
+                if ($query->onArray()) {
+                    $binds[":{$placeholder}_0"] = json_encode($query->getValues());
+
+                    return "JSON_CONTAINS({$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
+                    };
+
+                    $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}";
+                    }
                 }
-                return new DuplicateException('Document already exists', $e->getCode(), $e);
-            }
-        }
 
-        // String or BLOB exceeds size limit
-        if ($e->getCode() === 'HY000' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 18) {
-            return new LimitException('Value too large', $e->getCode(), $e);
-        }
+                $separator = $isNotQuery ? ' AND ' : ' OR ';
 
-        return $e;
+                return empty($conditions) ? '' : '('.implode($separator, $conditions).')';
+        }
     }
 
-    public function getSupportForSpatialIndexOrder(): bool
-    {
-        return false;
-    }
-    public function getSupportForBoundaryInclusiveContains(): bool
+    /**
+     * 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 false;
+        return $wktPlaceholder;
     }
 
     /**
-     * Does the adapter support calculating distance(in meters) between multidimension geometry(line, polygon,etc)?
+     * Get SQL Index Type
      *
-     * @return bool
+     * @throws Exception
      */
-    public function getSupportForDistanceBetweenMultiDimensionGeometryInMeters(): bool
+    protected function getSQLIndexType(IndexType $type): string
     {
-        return false;
+        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),
+        };
     }
 
     /**
-     * Does the adapter support spatial axis order specification?
+     * Get SQL Index
      *
-     * @return bool
+     * @param  array<string>  $attributes
+     *
+     * @throws Exception
      */
-    public function getSupportForSpatialAxisOrder(): bool
+    protected function getSQLIndex(string $collection, string $id, IndexType $type, array $attributes): string
     {
-        return false;
+        [$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) {
+            '$id' => ID::custom('_uid'),
+            '$createdAt' => '_createdAt',
+            '$updatedAt' => '_updatedAt',
+            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 = "`_tenant` {$postfix}, {$attributes}";
+        }
+
+        return "CREATE {$sqlType} {$key} ON `{$this->getNamespace()}_{$collection}` ({$attributes})";
     }
 
     /**
-     * Adapter supports optional spatial attributes with existing rows.
-     *
-     * @return bool
+     * Get SQL table
      */
-    public function getSupportForOptionalSpatialAttributeWithExistingRows(): bool
+    protected function getSQLTable(string $name): string
     {
-        return true;
+        return $this->quote("{$this->getNamespace()}_{$this->filter($name)}");
     }
 
     /**
-     * Get the SQL function for random ordering
-     *
-     * @return string
+     * SQLite doesn't use database-qualified table names.
      */
-    protected function getRandomOrder(): string
+    protected function getSQLTableRaw(string $name): string
     {
-        return 'RANDOM()';
+        return $this->getNamespace().'_'.$this->filter($name);
     }
 
     /**
      * Check if SQLite math functions (like POWER) are available
      * SQLite must be compiled with -DSQLITE_ENABLE_MATH_FUNCTIONS
-     *
-     * @return bool
      */
     private function getSupportForMathFunctions(): bool
     {
         static $available = null;
 
         if ($available !== null) {
-            return $available;
+            return (bool) $available;
         }
 
         try {
             // Test if POWER function exists by attempting to use it
             $stmt = $this->getPDO()->query('SELECT POWER(2, 3) as test');
+            if ($stmt === false) {
+                $available = false;
+
+                return false;
+            }
             $result = $stmt->fetch();
-            $available = ($result['test'] == 8);
+            /** @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;
+    }
+
+    protected function processException(PDOException $e): Exception
+    {
+        // Timeout
+        if ($e->getCode() === 'HY000' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 3024) {
+            return new TimeoutException('Query timed out', $e->getCode(), $e);
+        }
+
+        // Table/index already exists (SQLITE_ERROR with "already exists" message)
+        if ($e->getCode() === 'HY000' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1 && stripos($e->getMessage(), 'already exists') !== false) {
+            return new DuplicateException('Collection already exists', $e->getCode(), $e);
+        }
+
+        // Table not found (SQLITE_ERROR with "no such table" message)
+        if ($e->getCode() === 'HY000' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 1 && stripos($e->getMessage(), 'no such table') !== false) {
+            return new NotFoundException('Collection not found', $e->getCode(), $e);
+        }
+
+        // Duplicate - SQLite uses various error codes for constraint violations:
+        // - Error code 19 is SQLITE_CONSTRAINT (includes UNIQUE violations)
+        // - Error code 1 is also used for some duplicate cases
+        // - SQL state '23000' is integrity constraint violation
+        if (
+            ($e->getCode() === 'HY000' && isset($e->errorInfo[1]) && ($e->errorInfo[1] === 1 || $e->errorInfo[1] === 19)) ||
+            $e->getCode() === '23000'
+        ) {
+            $message = $e->getMessage();
+            if (
+                (isset($e->errorInfo[1]) && $e->errorInfo[1] === 19) ||
+                $e->getCode() === '23000' ||
+                stripos($message, 'unique') !== false ||
+                stripos($message, 'duplicate') !== false
+            ) {
+                if (! \str_contains($message, '_uid')) {
+                    return new DuplicateException('Document with the requested unique attributes already exists', $e->getCode(), $e);
+                }
+
+                return new DuplicateException('Document already exists', $e->getCode(), $e);
+            }
+        }
+
+        // String or BLOB exceeds size limit
+        if ($e->getCode() === 'HY000' && isset($e->errorInfo[1]) && $e->errorInfo[1] === 18) {
+            return new LimitException('Value too large', $e->getCode(), $e);
+        }
+
+        return $e;
+    }
+
     /**
      * Bind operator parameters to statement
      * Override to handle SQLite-specific operator bindings
-     *
-     * @param \PDOStatement|PDOStatementProxy $stmt
-     * @param Operator $operator
-     * @param int &$bindIndex
-     * @return void
      */
-    protected function bindOperatorParams(\PDOStatement|PDOStatementProxy $stmt, Operator $operator, int &$bindIndex): void
+    protected function bindOperatorParams(PDOStatement|PDOStatementProxy $stmt, Operator $operator, int &$bindIndex): void
     {
         $method = $operator->getMethod();
 
         // 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, [Operator::TYPE_TOGGLE, Operator::TYPE_DATE_SET_NOW, Operator::TYPE_ARRAY_UNIQUE])) {
+        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 === Operator::TYPE_ARRAY_FILTER) {
+        if ($method === OperatorType::ArrayFilter) {
             $values = $operator->getValues();
-            if (!empty($values) && count($values) >= 2) {
+            if (! empty($values) && count($values) >= 2) {
                 $filterType = $values[0];
                 $filterValue = $values[1];
 
@@ -1465,11 +1196,12 @@ protected function bindOperatorParams(\PDOStatement|PDOStatementProxy $stmt, Ope
                 $comparisonTypes = ['equal', 'notEqual', 'greaterThan', 'greaterThanEqual', 'lessThan', 'lessThanEqual'];
                 if (in_array($filterType, $comparisonTypes)) {
                     $bindKey = "op_{$bindIndex}";
-                    $value = (is_bool($filterValue)) ? (int)$filterValue : $filterValue;
+                    $value = (is_bool($filterValue)) ? (int) $filterValue : $filterValue;
                     $stmt->bindValue(":{$bindKey}", $value, $this->getPDOType($value));
                     $bindIndex++;
                 }
             }
+
             return;
         }
 
@@ -1477,11 +1209,68 @@ protected function bindOperatorParams(\PDOStatement|PDOStatementProxy $stmt, Ope
         parent::bindOperatorParams($stmt, $operator, $bindIndex);
     }
 
+    /**
+     * {@inheritDoc}
+     */
+    protected function getOperatorBuilderExpression(string $column, Operator $operator): array
+    {
+        if ($operator->getMethod() === OperatorType::ArrayFilter) {
+            $bindIndex = 0;
+            $fullExpression = $this->getOperatorSQL($column, $operator, $bindIndex);
+
+            if ($fullExpression === null) {
+                throw new DatabaseException('Operator cannot be expressed in SQL: '.$operator->getMethod()->value);
+            }
+
+            $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)
@@ -1490,11 +1279,6 @@ protected function bindOperatorParams(\PDOStatement|PDOStatementProxy $stmt, Ope
      *
      * 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 int &$bindIndex
-     * @return ?string
      */
     protected function getOperatorSQL(string $column, Operator $operator, int &$bindIndex): ?string
     {
@@ -1503,7 +1287,7 @@ protected function getOperatorSQL(string $column, Operator $operator, int &$bind
 
         switch ($method) {
             // Numeric operators
-            case Operator::TYPE_INCREMENT:
+            case OperatorType::Increment:
                 $values = $operator->getValues();
                 $bindKey = "op_{$bindIndex}";
                 $bindIndex++;
@@ -1511,15 +1295,17 @@ protected function getOperatorSQL(string $column, Operator $operator, int &$bind
                 if (isset($values[1])) {
                     $maxKey = "op_{$bindIndex}";
                     $bindIndex++;
+
                     return "{$quotedColumn} = CASE
                         WHEN COALESCE({$quotedColumn}, 0) >= :$maxKey THEN :$maxKey
                         WHEN COALESCE({$quotedColumn}, 0) > :$maxKey - :$bindKey THEN :$maxKey
                         ELSE COALESCE({$quotedColumn}, 0) + :$bindKey
                     END";
                 }
+
                 return "{$quotedColumn} = COALESCE({$quotedColumn}, 0) + :$bindKey";
 
-            case Operator::TYPE_DECREMENT:
+            case OperatorType::Decrement:
                 $values = $operator->getValues();
                 $bindKey = "op_{$bindIndex}";
                 $bindIndex++;
@@ -1527,15 +1313,17 @@ protected function getOperatorSQL(string $column, Operator $operator, int &$bind
                 if (isset($values[1])) {
                     $minKey = "op_{$bindIndex}";
                     $bindIndex++;
+
                     return "{$quotedColumn} = CASE
                         WHEN COALESCE({$quotedColumn}, 0) <= :$minKey THEN :$minKey
                         WHEN COALESCE({$quotedColumn}, 0) < :$minKey + :$bindKey THEN :$minKey
                         ELSE COALESCE({$quotedColumn}, 0) - :$bindKey
                     END";
                 }
+
                 return "{$quotedColumn} = COALESCE({$quotedColumn}, 0) - :$bindKey";
 
-            case Operator::TYPE_MULTIPLY:
+            case OperatorType::Multiply:
                 $values = $operator->getValues();
                 $bindKey = "op_{$bindIndex}";
                 $bindIndex++;
@@ -1543,6 +1331,7 @@ protected function getOperatorSQL(string $column, Operator $operator, int &$bind
                 if (isset($values[1])) {
                     $maxKey = "op_{$bindIndex}";
                     $bindIndex++;
+
                     return "{$quotedColumn} = CASE
                         WHEN COALESCE({$quotedColumn}, 0) >= :$maxKey THEN :$maxKey
                         WHEN :$bindKey > 0 AND COALESCE({$quotedColumn}, 0) > :$maxKey / :$bindKey THEN :$maxKey
@@ -1550,9 +1339,10 @@ protected function getOperatorSQL(string $column, Operator $operator, int &$bind
                         ELSE COALESCE({$quotedColumn}, 0) * :$bindKey
                     END";
                 }
+
                 return "{$quotedColumn} = COALESCE({$quotedColumn}, 0) * :$bindKey";
 
-            case Operator::TYPE_DIVIDE:
+            case OperatorType::Divide:
                 $values = $operator->getValues();
                 $bindKey = "op_{$bindIndex}";
                 $bindIndex++;
@@ -1560,22 +1350,25 @@ protected function getOperatorSQL(string $column, Operator $operator, int &$bind
                 if (isset($values[1])) {
                     $minKey = "op_{$bindIndex}";
                     $bindIndex++;
+
                     return "{$quotedColumn} = CASE
                         WHEN :$bindKey != 0 AND COALESCE({$quotedColumn}, 0) / :$bindKey <= :$minKey THEN :$minKey
                         ELSE COALESCE({$quotedColumn}, 0) / :$bindKey
                     END";
                 }
+
                 return "{$quotedColumn} = COALESCE({$quotedColumn}, 0) / :$bindKey";
 
-            case Operator::TYPE_MODULO:
+            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.'
                     );
                 }
@@ -1587,6 +1380,7 @@ protected function getOperatorSQL(string $column, Operator $operator, int &$bind
                 if (isset($values[1])) {
                     $maxKey = "op_{$bindIndex}";
                     $bindIndex++;
+
                     return "{$quotedColumn} = CASE
                         WHEN COALESCE({$quotedColumn}, 0) >= :$maxKey THEN :$maxKey
                         WHEN COALESCE({$quotedColumn}, 0) <= 1 THEN COALESCE({$quotedColumn}, 0)
@@ -1594,30 +1388,34 @@ protected function getOperatorSQL(string $column, Operator $operator, int &$bind
                         ELSE POWER(COALESCE({$quotedColumn}, 0), :$bindKey)
                     END";
                 }
+
                 return "{$quotedColumn} = POWER(COALESCE({$quotedColumn}, 0), :$bindKey)";
 
                 // String operators
-            case Operator::TYPE_STRING_CONCAT:
+            case OperatorType::StringConcat:
                 $bindKey = "op_{$bindIndex}";
                 $bindIndex++;
+
                 return "{$quotedColumn} = IFNULL({$quotedColumn}, '') || :$bindKey";
 
-            case Operator::TYPE_STRING_REPLACE:
+            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:
+            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} = (
@@ -1629,9 +1427,10 @@ protected function getOperatorSQL(string $column, Operator $operator, int &$bind
                     )
                 )";
 
-            case Operator::TYPE_ARRAY_PREPEND:
+            case OperatorType::ArrayPrepend:
                 $bindKey = "op_{$bindIndex}";
                 $bindIndex++;
+
                 // SQLite: prepend by extracting and recombining with new elements first
                 return "{$quotedColumn} = (
                     SELECT json_group_array(value)
@@ -1642,16 +1441,17 @@ protected function getOperatorSQL(string $column, Operator $operator, int &$bind
                     )
                 )";
 
-            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:
+            case OperatorType::ArrayRemove:
                 $bindKey = "op_{$bindIndex}";
                 $bindIndex++;
+
                 // SQLite: remove specific value from array
                 return "{$quotedColumn} = (
                     SELECT json_group_array(value)
@@ -1659,11 +1459,12 @@ protected function getOperatorSQL(string $column, Operator $operator, int &$bind
                     WHERE value != :$bindKey
                 )";
 
-            case Operator::TYPE_ARRAY_INSERT:
+            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
@@ -1693,9 +1494,10 @@ protected function getOperatorSQL(string $column, Operator $operator, int &$bind
                     )
                 )";
 
-            case Operator::TYPE_ARRAY_INTERSECT:
+            case OperatorType::ArrayIntersect:
                 $bindKey = "op_{$bindIndex}";
                 $bindIndex++;
+
                 // SQLite: keep only values that exist in both arrays
                 return "{$quotedColumn} = (
                     SELECT json_group_array(value)
@@ -1703,9 +1505,10 @@ protected function getOperatorSQL(string $column, Operator $operator, int &$bind
                     WHERE value IN (SELECT value FROM json_each(:$bindKey))
                 )";
 
-            case Operator::TYPE_ARRAY_DIFF:
+            case OperatorType::ArrayDiff:
                 $bindKey = "op_{$bindIndex}";
                 $bindIndex++;
+
                 // SQLite: remove values that exist in the comparison array
                 return "{$quotedColumn} = (
                     SELECT json_group_array(value)
@@ -1713,7 +1516,7 @@ protected function getOperatorSQL(string $column, Operator $operator, int &$bind
                     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
@@ -1759,7 +1562,7 @@ protected function getOperatorSQL(string $column, Operator $operator, int &$bind
                             '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
@@ -1785,48 +1588,182 @@ protected function getOperatorSQL(string $column, Operator $operator, int &$bind
 
                 // Date operators
                 // no break
-            case Operator::TYPE_DATE_ADD_DAYS:
+            case OperatorType::DateAddDays:
                 $bindKey = "op_{$bindIndex}";
                 $bindIndex++;
 
                 return "{$quotedColumn} = datetime({$quotedColumn}, :$bindKey || ' days')";
 
-            case Operator::TYPE_DATE_SUB_DAYS:
+            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, $bindIndex);
+                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 _tenant = excluded._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 _tenant = excluded._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
+     * @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
      */
-    public function getUpsertStatement(
-        string $tableName,
-        string $columns,
-        array $batchKeys,
-        array $attributes,
-        array $bindValues,
-        string $attribute = '',
-        array $operators = [],
-    ): mixed {
+    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['_uid'] = $document->getId();
+                $currentRegularAttributes['_createdAt'] = $document->getCreatedAt() ? $document->getCreatedAt() : null;
+                $currentRegularAttributes['_updatedAt'] = $document->getUpdatedAt() ? $document->getUpdatedAt() : null;
+            } else {
+                $currentRegularAttributes = $document->getAttributes();
+                $currentRegularAttributes['_uid'] = $document->getId();
+                $currentRegularAttributes['_createdAt'] = $document->getCreatedAt() ? DatabaseDateTime::setTimezone($document->getCreatedAt()) : null;
+                $currentRegularAttributes['_updatedAt'] = $document->getUpdatedAt() ? DatabaseDateTime::setTimezone($document->getUpdatedAt()) : null;
+            }
+
+            $currentRegularAttributes['_permissions'] = \json_encode($document->getPermissions());
+
+            $version = $document->getVersion();
+            if ($version !== null) {
+                $currentRegularAttributes['_version'] = $version;
+            }
+
+            if (! empty($document->getSequence())) {
+                $currentRegularAttributes['_id'] = $document->getSequence();
+            }
+
+            if ($this->sharedTables) {
+                $currentRegularAttributes['_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) {
@@ -1845,28 +1782,23 @@ public function getUpsertStatement(
         $updateColumns = [];
         $opIndex = 0;
 
-        if (!empty($attribute)) {
-            // Increment specific column by its new value in place
+        if (! empty($attribute)) {
             $updateColumns = [
                 $getUpdateClause($attribute, increment: true),
                 $getUpdateClause('_updatedAt'),
             ];
         } 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], $opIndex);
                     if ($operatorSQL !== null) {
                         $updateColumns[] = $operatorSQL;
                     }
                 } else {
-                    if (!in_array($attr, ['_uid', '_id', '_createdAt', '_tenant'])) {
+                    if (! in_array($attr, ['_uid', '_id', '_createdAt', '_tenant'])) {
                         $updateColumns[] = $getUpdateClause($filteredAttr);
                     }
                 }
@@ -1876,64 +1808,24 @@ public function getUpsertStatement(
         $conflictKeys = $this->sharedTables ? '(_uid, _tenant)' : '(_uid)';
 
         $stmt = $this->getPDO()->prepare(
-            "
-            INSERT INTO {$this->getSQLTable($tableName)} {$columns}
-            VALUES " . \implode(', ', $batchKeys) . "
+            "INSERT INTO {$this->getSQLTable($name)} {$columns}
+            VALUES ".\implode(', ', $batchKeys)."
             ON CONFLICT {$conflictKeys} DO UPDATE
-                SET " . \implode(', ', $updateColumns)
+                SET ".\implode(', ', $updateColumns)
         );
 
-        // Bind regular attribute values
         foreach ($bindValues as $key => $binding) {
             $stmt->bindValue($key, $binding, $this->getPDOType($binding));
         }
 
         $opIndexForBinding = 0;
-
-        // Bind operator parameters in the same order used to build SQL
-        foreach (array_keys($attributes) as $attr) {
+        foreach (array_keys($regularAttributes) as $attr) {
             if (isset($operators[$attr])) {
                 $this->bindOperatorParams($stmt, $operators[$attr], $opIndexForBinding);
             }
         }
 
-        return $stmt;
-    }
-
-    public function getSupportForAlterLocks(): bool
-    {
-        return false;
-    }
-
-    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 false;
-    }
-
-    /**
-     * 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
-    {
-        return false;
-    }
-
-    public function getSupportForTTLIndexes(): bool
-    {
-        return false;
+        $stmt->execute();
+        $stmt->closeCursor();
     }
 }
diff --git a/src/Database/Attribute.php b/src/Database/Attribute.php
new file mode 100644
index 000000000..dfc984a2c
--- /dev/null
+++ b/src/Database/Attribute.php
@@ -0,0 +1,154 @@
+<?php
+
+namespace Utopia\Database;
+
+use Utopia\Database\Helpers\ID;
+use Utopia\Query\Schema\ColumnType;
+
+/**
+ * Represents a database collection attribute with its type, constraints, and formatting options.
+ */
+class Attribute
+{
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     * @param  array<string, mixed>|null  $options
+     */
+    public function __construct(
+        public string $key = '',
+        public ColumnType $type = ColumnType::String,
+        public int $size = 0,
+        public bool $required = false,
+        public mixed $default = null,
+        public bool $signed = true,
+        public bool $array = false,
+        public ?string $format = null,
+        public array $formatOptions = [],
+        public array $filters = [],
+        public ?string $status = null,
+        public ?array $options = null,
+    ) {
+    }
+
+    /**
+     * Convert this attribute to a Document representation.
+     *
+     * @return Document
+     */
+    public function toDocument(): Document
+    {
+        $data = [
+            '$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 new self(
+            key: $key,
+            type: $type instanceof ColumnType ? $type : ColumnType::from($type),
+            size: $size,
+            required: $required,
+            default: $document->getAttribute('default'),
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+            status: $status,
+            options: $options,
+        );
+    }
+
+    /**
+     * 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['$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'] ?? [];
+
+        return new self(
+            key: $key,
+            type: $type instanceof ColumnType ? $type : ColumnType::from((string) $type),
+            size: $size,
+            required: $required,
+            default: $data['default'] ?? null,
+            signed: $signed,
+            array: $array,
+            format: $format,
+            formatOptions: $formatOptions,
+            filters: $filters,
+        );
+    }
+}
diff --git a/src/Database/Cache/CacheInvalidator.php b/src/Database/Cache/CacheInvalidator.php
new file mode 100644
index 000000000..e670fc795
--- /dev/null
+++ b/src/Database/Cache/CacheInvalidator.php
@@ -0,0 +1,55 @@
+<?php
+
+namespace Utopia\Database\Cache;
+
+use Utopia\Database\Document;
+use Utopia\Database\Event;
+use Utopia\Database\Hook\Lifecycle;
+
+class CacheInvalidator implements Lifecycle
+{
+    public function __construct(
+        private QueryCache $queryCache,
+    ) {
+    }
+
+    public function handle(Event $event, mixed $data): void
+    {
+        $collection = $this->extractCollection($event, $data);
+
+        if ($collection === null) {
+            return;
+        }
+
+        $writeEvents = [
+            Event::DocumentCreate,
+            Event::DocumentsCreate,
+            Event::DocumentUpdate,
+            Event::DocumentsUpdate,
+            Event::DocumentsUpsert,
+            Event::DocumentDelete,
+            Event::DocumentsDelete,
+            Event::DocumentIncrease,
+            Event::DocumentDecrease,
+        ];
+
+        if (\in_array($event, $writeEvents, true)) {
+            $this->queryCache->invalidateCollection($collection);
+        }
+    }
+
+    private function extractCollection(Event $event, mixed $data): ?string
+    {
+        if ($data instanceof Document) {
+            $collection = $data->getCollection();
+
+            return $collection !== '' ? $collection : null;
+        }
+
+        if (\is_string($data) && $data !== '') {
+            return $data;
+        }
+
+        return null;
+    }
+}
diff --git a/src/Database/Cache/CacheRegion.php b/src/Database/Cache/CacheRegion.php
new file mode 100644
index 000000000..cbd16a990
--- /dev/null
+++ b/src/Database/Cache/CacheRegion.php
@@ -0,0 +1,12 @@
+<?php
+
+namespace Utopia\Database\Cache;
+
+class CacheRegion
+{
+    public function __construct(
+        public int $ttl = 3600,
+        public bool $enabled = true,
+    ) {
+    }
+}
diff --git a/src/Database/Cache/QueryCache.php b/src/Database/Cache/QueryCache.php
new file mode 100644
index 000000000..6de8793ac
--- /dev/null
+++ b/src/Database/Cache/QueryCache.php
@@ -0,0 +1,92 @@
+<?php
+
+namespace Utopia\Database\Cache;
+
+use Utopia\Cache\Cache;
+use Utopia\Database\Document;
+
+class QueryCache
+{
+    /** @var array<string, CacheRegion> */
+    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, CacheRegion $region): void
+    {
+        $this->regions[$collection] = $region;
+    }
+
+    public function getRegion(string $collection): CacheRegion
+    {
+        return $this->regions[$collection] ?? new CacheRegion();
+    }
+
+    /**
+     * @param  array<\Utopia\Database\Query>  $queries
+     */
+    public function buildQueryKey(string $collection, array $queries, string $namespace, ?int $tenant): string
+    {
+        $queriesHash = \md5(\serialize($queries));
+
+        return "{$this->cacheName}:qcache:{$namespace}:{$tenant}:{$collection}:{$queriesHash}";
+    }
+
+    /**
+     * @return array<Document>|null
+     */
+    public function get(string $key): ?array
+    {
+        /** @var mixed $data */
+        $data = $this->cache->load($key, 0, 0);
+
+        if ($data === false || $data === null || ! \is_array($data)) {
+            return null;
+        }
+
+        return \array_map(function (mixed $item): Document {
+            if ($item instanceof Document) {
+                return $item;
+            }
+            if (\is_array($item)) {
+                return new Document($item);
+            }
+
+            return new Document();
+        }, $data);
+    }
+
+    /**
+     * @param  array<Document>  $results
+     */
+    public function set(string $key, array $results): void
+    {
+        $data = \array_map(fn (Document $doc) => $doc->getArrayCopy(), $results);
+        $this->cache->save($key, $data);
+    }
+
+    public function invalidateCollection(string $collection): void
+    {
+        $this->cache->purge("{$this->cacheName}:qcache:*:{$collection}:*");
+    }
+
+    public function isEnabled(string $collection): bool
+    {
+        $region = $this->getRegion($collection);
+
+        return $region->enabled;
+    }
+
+    public function flush(): void
+    {
+        $this->cache->flush();
+    }
+}
diff --git a/src/Database/Capability.php b/src/Database/Capability.php
new file mode 100644
index 000000000..2b433bff7
--- /dev/null
+++ b/src/Database/Capability.php
@@ -0,0 +1,59 @@
+<?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 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 Vectors;
+    case Joins;
+    case Aggregations;
+    case Subqueries;
+    case CTEs;
+    case WindowFunctions;
+}
diff --git a/src/Database/Change.php b/src/Database/Change.php
index e57dd16cf..718278587 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 000000000..9dc539900
--- /dev/null
+++ b/src/Database/Collection.php
@@ -0,0 +1,84 @@
+<?php
+
+namespace Utopia\Database;
+
+use Utopia\Database\Helpers\ID;
+
+/**
+ * Represents a database collection with its attributes, indexes, permissions, and configuration.
+ */
+class Collection
+{
+    /**
+     * @param  array<Attribute>  $attributes
+     * @param  array<Index>  $indexes
+     * @param  array<string>  $permissions
+     */
+    public function __construct(
+        public string $id = '',
+        public string $name = '',
+        public array $attributes = [],
+        public array $indexes = [],
+        public array $permissions = [],
+        public bool $documentSecurity = true,
+    ) {
+    }
+
+    /**
+     * Convert this collection to a Document representation.
+     *
+     * @return Document
+     */
+    public function toDocument(): Document
+    {
+        return new Document([
+            '$id' => ID::custom($this->id),
+            'name' => $this->name ?: $this->id,
+            'attributes' => \array_map(fn (Attribute $attr) => $attr->toDocument(), $this->attributes),
+            'indexes' => \array_map(fn (Index $idx) => $idx->toDocument(), $this->indexes),
+            '$permissions' => $this->permissions,
+            'documentSecurity' => $this->documentSecurity,
+        ]);
+    }
+
+    /**
+     * Create a Collection instance from a Document.
+     *
+     * @param  Document  $document  The document to convert
+     * @return self
+     */
+    public static function fromDocument(Document $document): self
+    {
+        /** @var string $id */
+        $id = $document->getId();
+        /** @var string $name */
+        $name = $document->getAttribute('name', $id);
+        /** @var bool $documentSecurity */
+        $documentSecurity = $document->getAttribute('documentSecurity', true);
+        /** @var array<string> $permissions */
+        $permissions = $document->getPermissions();
+
+        /** @var array<Document> $rawAttributes */
+        $rawAttributes = $document->getAttribute('attributes', []);
+        $attributes = \array_map(
+            fn (Document $attr) => Attribute::fromDocument($attr),
+            $rawAttributes
+        );
+
+        /** @var array<Document> $rawIndexes */
+        $rawIndexes = $document->getAttribute('indexes', []);
+        $indexes = \array_map(
+            fn (Document $idx) => Index::fromDocument($idx),
+            $rawIndexes
+        );
+
+        return new self(
+            id: $id,
+            name: $name,
+            attributes: $attributes,
+            indexes: $indexes,
+            permissions: $permissions,
+            documentSecurity: $documentSecurity,
+        );
+    }
+}
diff --git a/src/Database/Connection.php b/src/Database/Connection.php
index 474d10a7f..024aecc26 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 ac58d72f0..529ee643b 100644
--- a/src/Database/Database.php
+++ b/src/Database/Database.php
@@ -2,115 +2,58 @@
 
 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\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\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\Spatial as SpatialValidator;
 use Utopia\Database\Validator\Structure;
+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_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';
-
-    // 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\Entities;
+    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 MAX_ARRAY_INDEX_LENGTH = 255;
+
     public const MAX_UID_DEFAULT_LENGTH = 36;
 
     // Min limits
@@ -118,102 +61,23 @@ 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,
-    ];
+    public const RELATION_QUERY_CHUNK_SIZE = 5000;
 
-    // Collections
     public const METADATA = '_metadata';
 
-    // Cursor
-    public const CURSOR_BEFORE = 'before';
-    public const CURSOR_AFTER = 'after';
-
     // Lengths
     public const LENGTH_KEY = 255;
 
     // Cache
     public const TTL = 60 * 60 * 24; // 24 hours
 
-    // 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;
 
     /**
@@ -224,7 +88,7 @@ class Database
     public const INTERNAL_ATTRIBUTES = [
         [
             '$id' => '$id',
-            'type' => self::VAR_STRING,
+            'type' => 'string',
             'size' => Database::LENGTH_KEY,
             'required' => true,
             'signed' => true,
@@ -233,7 +97,7 @@ class Database
         ],
         [
             '$id' => '$sequence',
-            'type' => self::VAR_ID,
+            'type' => 'id',
             'size' => 0,
             'required' => true,
             'signed' => true,
@@ -242,7 +106,7 @@ class Database
         ],
         [
             '$id' => '$collection',
-            'type' => self::VAR_STRING,
+            'type' => 'string',
             'size' => Database::LENGTH_KEY,
             'required' => true,
             'signed' => true,
@@ -251,7 +115,7 @@ class Database
         ],
         [
             '$id' => '$tenant',
-            'type' => self::VAR_ID,
+            'type' => 'id',
             'size' => 0,
             'required' => false,
             'default' => null,
@@ -261,35 +125,45 @@ class Database
         ],
         [
             '$id' => '$createdAt',
-            'type' => Database::VAR_DATETIME,
+            'type' => 'datetime',
             'format' => '',
             'size' => 0,
             'signed' => false,
             'required' => false,
             'default' => null,
             'array' => false,
-            'filters' => ['datetime']
+            'filters' => ['datetime'],
         ],
         [
             '$id' => '$updatedAt',
-            'type' => Database::VAR_DATETIME,
+            'type' => 'datetime',
             'format' => '',
             'size' => 0,
             'signed' => false,
             'required' => false,
             'default' => null,
             'array' => false,
-            'filters' => ['datetime']
+            'filters' => ['datetime'],
         ],
         [
             '$id' => '$permissions',
-            'type' => Database::VAR_STRING,
+            'type' => 'string',
             'size' => 1_000_000,
             'signed' => true,
             'required' => false,
             'default' => [],
             'array' => false,
-            'filters' => ['json']
+            'filters' => ['json'],
+        ],
+        [
+            '$id' => '$version',
+            'type' => 'integer',
+            'size' => 0,
+            'required' => false,
+            'default' => null,
+            'signed' => false,
+            'array' => false,
+            'filters' => [],
         ],
     ];
 
@@ -298,6 +172,7 @@ class Database
         '_createdAt',
         '_updatedAt',
         '_permissions',
+        '_version',
     ];
 
     public const INTERNAL_INDEXES = [
@@ -323,7 +198,7 @@ class Database
             [
                 '$id' => 'name',
                 'key' => 'name',
-                'type' => self::VAR_STRING,
+                'type' => 'string',
                 'size' => 256,
                 'required' => true,
                 'signed' => true,
@@ -333,7 +208,7 @@ class Database
             [
                 '$id' => 'attributes',
                 'key' => 'attributes',
-                'type' => self::VAR_STRING,
+                'type' => 'string',
                 'size' => 1000000,
                 'required' => false,
                 'signed' => true,
@@ -343,7 +218,7 @@ class Database
             [
                 '$id' => 'indexes',
                 'key' => 'indexes',
-                'type' => self::VAR_STRING,
+                'type' => 'string',
                 'size' => 1000000,
                 'required' => false,
                 'signed' => true,
@@ -353,13 +228,24 @@ class Database
             [
                 '$id' => 'documentSecurity',
                 'key' => 'documentSecurity',
-                'type' => self::VAR_BOOLEAN,
+                'type' => 'boolean',
                 'size' => 0,
                 'required' => true,
                 'signed' => true,
                 'array' => false,
-                'filters' => []
-            ]
+                'filters' => [],
+            ],
+            [
+                '$id' => 'externalId',
+                'key' => 'externalId',
+                'type' => 'string',
+                'size' => 255,
+                'required' => false,
+                'default' => null,
+                'signed' => true,
+                'array' => false,
+                'filters' => [],
+            ],
         ],
         'indexes' => [],
     ];
@@ -381,30 +267,23 @@ class Database
     protected array $instanceFilters = [];
 
     /**
-     * @var array<string, array<string, callable>>
+     * @var array<Lifecycle>
      */
-    protected array $listeners = [
-        '*' => [],
-    ];
+    protected array $lifecycleHooks = [];
 
     /**
-     * Array in which the keys are the names of database listeners that
-     * should be skipped when dispatching events. null $silentListeners
-     * will skip all listeners.
-     *
-     * @var ?array<string, bool>
+     * @var array<Hook\Decorator>
      */
-    protected ?array $silentListeners = [];
-
-    protected ?\DateTime $timestamp = null;
+    protected array $decorators = [];
 
-    protected bool $resolveRelationships = true;
-
-    protected bool $checkRelationshipsExist = true;
+    /**
+     * When true, lifecycle hooks are not fired.
+     */
+    protected bool $eventsSilenced = false;
 
-    protected int $relationshipFetchDepth = 0;
+    protected ?NativeDateTime $timestamp = null;
 
-    protected bool $inBatchRelationshipPopulation = false;
+    protected ?Relationships $relationshipHook = null;
 
     protected bool $filter = true;
 
@@ -430,38 +309,27 @@ 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 ?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,
@@ -481,65 +349,72 @@ public function __construct(
         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)) {
+                if (! is_string($value)) {
                     return $value;
                 }
 
-                $value = json_decode($value, true) ?? [];
+                $decoded = json_decode($value, true) ?? [];
+                if (! is_array($decoded)) {
+                    return $decoded;
+                }
 
-                if (array_key_exists('$id', $value)) {
-                    return new Document($value);
+                /** @var array<string, mixed> $decoded */
+                if (array_key_exists('$id', $decoded)) {
+                    return new Document($decoded);
                 } else {
-                    $value = array_map(function ($item) {
+                    $decoded = array_map(function ($item) {
                         if (is_array($item) && array_key_exists('$id', $item)) { // if `$id` exists, create a Document instance
+                            /** @var array<string, mixed> $item */
                             return new Document($item);
                         }
+
                         return $item;
-                    }, $value);
+                    }, $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) {
@@ -548,141 +423,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 instanceof Feature\Spatial) {
+                    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 instanceof Feature\Spatial) {
+                    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 instanceof Feature\Spatial) {
+                    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 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;
             }
         );
 
         self::addFilter(
-            Database::VAR_OBJECT,
+            ColumnType::Object->value,
             /**
-             * @param mixed $value
              * @return mixed
              */
             function (mixed $value) {
-                if (!\is_array($value)) {
+                if (! \is_array($value)) {
                     return $value;
                 }
 
                 return \json_encode($value);
             },
             /**
-             * @param mixed $value
              * @return array|null
              */
             function (mixed $value) {
@@ -690,292 +566,200 @@ 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 = json_decode($value, true);
+
                 return is_array($decoded) ? $decoded : $value;
             }
         );
     }
 
     /**
-     * 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.
      *
-     * @param string $event
-     * @param string $name
-     * @param callable $callback
-     * @return $this
+     * Get Database from current scope
+     *
+     * @throws DatabaseException
      */
-    public function before(string $event, string $name, callable $callback): static
+    public function getDatabase(): string
     {
-        $this->adapter->before($event, $name, $callback);
-
-        return $this;
+        return $this->adapter->getDatabase();
     }
 
     /**
-     * Silent event generation for calls inside the callback
+     * Set 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
+     * Set namespace to divide different scope of data sets
+     *
+     *
+     * @return $this
+     *
+     * @throws DatabaseException
      */
-    public function silent(callable $callback, ?array $listeners = null): mixed
+    public function setNamespace(string $namespace): static
     {
-        $previous = $this->silentListeners;
-
-        if (is_null($listeners)) {
-            $this->silentListeners = null;
-        } else {
-            $silentListeners = [];
-            foreach ($listeners as $listener) {
-                $silentListeners[$listener] = true;
-            }
-            $this->silentListeners = $silentListeners;
-        }
+        $this->adapter->setNamespace($namespace);
 
-        try {
-            return $callback();
-        } finally {
-            $this->silentListeners = $previous;
-        }
+        return $this;
     }
 
     /**
-     * Get getConnection Id
+     * Get Namespace.
      *
-     * @return string
-     * @throws Exception
+     * Get namespace of current set scope
      */
-    public function getConnectionId(): string
+    public function getNamespace(): string
     {
-        return $this->adapter->getConnectionId();
+        return $this->adapter->getNamespace();
     }
 
     /**
-     * Skip relationships for all the calls inside the callback
+     * Get ID Attribute Type.
      *
-     * @template T
-     * @param callable(): T $callback
-     * @return T
+     * Returns the type of the internal ID attribute (e.g. integer for SQL, uuid7 for MongoDB)
      */
-    public function skipRelationships(callable $callback): mixed
+    public function getIdAttributeType(): string
     {
-        $previous = $this->resolveRelationships;
-        $this->resolveRelationships = false;
-
-        try {
-            return $callback();
-        } finally {
-            $this->resolveRelationships = $previous;
-        }
+        return $this->adapter->getIdAttributeType();
     }
 
     /**
-     * Refetch documents after operator updates to get computed values
-     *
-     * @param Document $collection
-     * @param array<Document> $documents
-     * @return array<Document>
+     * Get Database Adapter
      */
-    protected function refetchDocuments(Document $collection, array $documents): array
+    public function getAdapter(): Adapter
     {
-        if (empty($documents)) {
-            return $documents;
-        }
-
-        $docIds = array_map(fn ($doc) => $doc->getId(), $documents);
-
-        // Fetch fresh copies with computed operator values
-        $refetched = $this->getAuthorization()->skip(fn () => $this->silent(
-            fn () => $this->find($collection->getId(), [Query::equal('$id', $docIds)])
-        ));
-
-        $refetchedMap = [];
-        foreach ($refetched as $doc) {
-            $refetchedMap[$doc->getId()] = $doc;
-        }
-
-        $result = [];
-        foreach ($documents as $doc) {
-            $result[] = $refetchedMap[$doc->getId()] ?? $doc;
-        }
-
-        return $result;
+        return $this->adapter;
     }
 
-    public function skipRelationshipsExistCheck(callable $callback): mixed
+    /**
+     * 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
     {
-        $previous = $this->checkRelationshipsExist;
-        $this->checkRelationshipsExist = false;
+        $builder = $this->adapter->getBuilder($collection);
+        $builder->setExecutor(fn (\Utopia\Query\Builder\Plan $plan) => $this->execute($plan));
 
-        try {
-            return $callback();
-        } finally {
-            $this->checkRelationshipsExist = $previous;
-        }
+        return $builder;
     }
 
     /**
-     * Trigger callback for events
-     *
-     * @param string $event
-     * @param mixed $args
-     * @return void
+     * Get a utopia-php/query Schema builder for DDL operations.
      */
-    protected function trigger(string $event, mixed $args = null): void
+    public function schema(): \Utopia\Query\Schema
     {
-        if (\is_null($this->silentListeners)) {
-            return;
-        }
-        foreach ($this->listeners[self::EVENT_ALL] as $name => $callback) {
-            if (isset($this->silentListeners[$name])) {
-                continue;
-            }
-            $callback($event, $args);
-        }
+        $schema = $this->adapter->getSchema();
+        $schema->setExecutor(fn (\Utopia\Query\Builder\Plan $plan) => $this->execute($plan));
 
-        foreach (($this->listeners[$event] ?? []) as $name => $callback) {
-            if (isset($this->silentListeners[$name])) {
-                continue;
-            }
-            $callback($event, $args);
-        }
+        return $schema;
     }
 
     /**
-     * Executes $callback with $timestamp set to $requestTimestamp
-     *
-     * @template T
-     * @param ?\DateTime $requestTimestamp
-     * @param callable(): T $callback
-     * @return T
+     * @return array<Document>|int
      */
-    public function withRequestTimestamp(?\DateTime $requestTimestamp, callable $callback): mixed
+    public function execute(\Utopia\Query\Builder|\Utopia\Query\Builder\Plan $query): array|int
     {
-        $previous = $this->timestamp;
-        $this->timestamp = $requestTimestamp;
-        try {
-            $result = $callback();
-        } finally {
-            $this->timestamp = $previous;
+        $result = $query instanceof \Utopia\Query\Builder\Plan ? $query : $query->build();
+
+        if ($result->readOnly) {
+            return $this->adapter->rawQuery($result->query, $result->bindings);
         }
-        return $result;
+
+        return $this->adapter->rawMutation($result->query, $result->bindings);
     }
 
-    /**
-     * Set Namespace.
-     *
-     * Set namespace to divide different scope of data sets
-     *
-     * @param string $namespace
-     *
-     * @return $this
-     *
-     * @throws DatabaseException
-     */
-    public function setNamespace(string $namespace): static
+    public function setTypeRegistry(?TypeRegistry $typeRegistry): static
     {
-        $this->adapter->setNamespace($namespace);
+        $this->typeRegistry = $typeRegistry;
 
         return $this;
     }
 
-    /**
-     * Get Namespace.
-     *
-     * Get namespace of current set scope
-     *
-     * @return string
-     */
-    public function getNamespace(): string
+    public function getTypeRegistry(): ?TypeRegistry
     {
-        return $this->adapter->getNamespace();
+        return $this->typeRegistry;
     }
 
-    /**
-     * Get ID Attribute Type.
-     *
-     * Returns the type of the internal ID attribute (e.g. VAR_INTEGER for SQL, VAR_UUID7 for MongoDB)
-     *
-     * @return string
-     */
-    public function getIdAttributeType(): string
+    public function setQueryCache(?QueryCache $queryCache): static
     {
-        return $this->adapter->getIdAttributeType();
+        $this->queryCache = $queryCache;
+
+        return $this;
     }
 
-    /**
-     * Set database to use for current scope
-     *
-     * @param string $name
-     *
-     * @return static
-     * @throws DatabaseException
-     */
-    public function setDatabase(string $name): static
+    public function getQueryCache(): ?QueryCache
     {
-        $this->adapter->setDatabase($name);
+        return $this->queryCache;
+    }
+
+    public function enableProfiling(): static
+    {
+        if ($this->profiler === null) {
+            $this->profiler = new QueryProfiler();
+        }
+
+        $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;
+    }
+
     /**
-     * Get Database.
-     *
-     * Get Database from current scope
+     * Get list of keywords that cannot be used
      *
-     * @return string
-     * @throws DatabaseException
+     * @return string[]
      */
-    public function getDatabase(): string
+    public function getKeywords(): array
     {
-        return $this->adapter->getDatabase();
+        return $this->adapter->getKeywords();
     }
 
     /**
      * Set the cache instance
      *
-     * @param Cache $cache
      *
      * @return $this
      */
     public function setCache(Cache $cache): static
     {
         $this->cache = $cache;
+
         return $this;
     }
 
     /**
      * Get the cache instance
-     *
-     * @return Cache
      */
     public function getCache(): Cache
     {
@@ -985,7 +769,6 @@ public function getCache(): Cache
     /**
      * Set the name to use for cache
      *
-     * @param string $name
      * @return $this
      */
     public function setCacheName(string $name): static
@@ -997,8 +780,6 @@ public function setCacheName(string $name): static
 
     /**
      * Get the cache name
-     *
-     * @return string
      */
     public function getCacheName(): string
     {
@@ -1006,334 +787,310 @@ public function getCacheName(): string
     }
 
     /**
-     * Set a metadata value to be printed in the query comments
+     * Set shard tables
      *
-     * @param string $key
-     * @param mixed $value
-     * @return static
+     * Set whether to share tables between tenants
      */
-    public function setMetadata(string $key, mixed $value): static
+    public function setSharedTables(bool $sharedTables): static
     {
-        $this->adapter->setMetadata($key, $value);
+        $this->adapter->setSharedTables($sharedTables);
 
         return $this;
     }
 
     /**
-     * Get metadata
+     * Get shared tables
      *
-     * @return array<string, mixed>
+     * Get whether to share tables between tenants
      */
-    public function getMetadata(): array
+    public function getSharedTables(): bool
     {
-        return $this->adapter->getMetadata();
+        return $this->adapter->getSharedTables();
     }
 
     /**
-     * Sets instance of authorization for permission checks
+     * Set Tenant
      *
-     * @param Authorization $authorization
-     * @return self
+     * Set tenant to use if tables are shared
      */
-    public function setAuthorization(Authorization $authorization): self
+    public function setTenant(int|string|null $tenant): static
     {
-        $this->adapter->setAuthorization($authorization);
-        $this->authorization = $authorization;
+        $this->adapter->setTenant($tenant);
+
         return $this;
     }
 
     /**
-     * Get Authorization
+     * Get Tenant
      *
-     * @return Authorization
+     * Get tenant to use if tables are shared
      */
-    public function getAuthorization(): Authorization
+    public function getTenant(): int|string|null
     {
-        return $this->authorization;
+        return $this->adapter->getTenant();
     }
 
     /**
-     * Clear metadata
+     * With Tenant
      *
-     * @return void
+     * Execute a callback with a specific tenant
      */
-    public function resetMetadata(): void
+    public function withTenant(int|string|null $tenant, callable $callback): mixed
     {
-        $this->adapter->resetMetadata();
+        $previous = $this->adapter->getTenant();
+        $this->adapter->setTenant($tenant);
+
+        try {
+            return $callback();
+        } finally {
+            $this->adapter->setTenant($previous);
+        }
     }
 
     /**
-     * Set maximum query execution time
-     *
-     * @param int $milliseconds
-     * @param string $event
-     * @return static
-     * @throws Exception
+     * Set whether to allow creating documents with tenant set per document.
      */
-    public function setTimeout(int $milliseconds, string $event = Database::EVENT_ALL): static
+    public function setTenantPerDocument(bool $enabled): static
     {
-        $this->adapter->setTimeout($milliseconds, $event);
+        $this->adapter->setTenantPerDocument($enabled);
 
         return $this;
     }
 
     /**
-     * Clear maximum query execution time
-     *
-     * @param string $event
-     * @return void
+     * Get whether to allow creating documents with tenant set per document.
      */
-    public function clearTimeout(string $event = Database::EVENT_ALL): void
+    public function getTenantPerDocument(): bool
     {
-        $this->adapter->clearTimeout($event);
+        return $this->adapter->getTenantPerDocument();
     }
 
     /**
-     * Enable filters
-     *
-     * @return $this
+     * Sets instance of authorization for permission checks
      */
-    public function enableFilters(): static
+    public function setAuthorization(Authorization $authorization): self
     {
-        $this->filter = true;
+        $this->adapter->setAuthorization($authorization);
+        $this->authorization = $authorization;
+
         return $this;
     }
 
     /**
-     * Disable filters
-     *
-     * @return $this
+     * Get Authorization
      */
-    public function disableFilters(): static
+    public function getAuthorization(): Authorization
     {
-        $this->filter = false;
-        return $this;
+        return $this->authorization;
     }
 
     /**
-     * Skip filters
-     *
-     * Execute a callback without filters
+     * Set maximum query execution time
      *
-     * @template T
-     * @param callable(): T $callback
-     * @param array<string>|null $filters
-     * @return T
+     * @throws Exception
      */
-    public function skipFilters(callable $callback, ?array $filters = null): mixed
+    public function setTimeout(int $milliseconds, Event $event = Event::All): static
     {
-        if (empty($filters)) {
-            $initial = $this->filter;
-            $this->disableFilters();
-
-            try {
-                return $callback();
-            } finally {
-                $this->filter = $initial;
-            }
-        }
+        $this->adapter->setTimeout($milliseconds, $event);
 
-        $previous = $this->filter;
-        $previousDisabled = $this->disabledFilters;
-        $disabled = [];
-        foreach ($filters as $name) {
-            $disabled[$name] = true;
-        }
-        $this->disabledFilters = $disabled;
+        return $this;
+    }
 
-        try {
-            return $callback();
-        } finally {
-            $this->filter = $previous;
-            $this->disabledFilters = $previousDisabled;
-        }
+    /**
+     * Clear maximum query execution time
+     */
+    public function clearTimeout(Event $event = Event::All): void
+    {
+        $this->adapter->clearTimeout($event);
     }
 
     /**
-     * Get instance filters
+     * Get the current relationship hook.
      *
-     * @return array<string, array{encode: callable, decode: callable, signature: string}>
+     * @return Relationships|null The relationship hook, or null if not set.
      */
-    public function getInstanceFilters(): array
+    public function getRelationshipHook(): ?Relationships
     {
-        return $this->instanceFilters;
+        return $this->relationshipHook;
     }
 
     /**
-     * Enable validation
+     * 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 enableValidation(): static
+    public function setPreserveDates(bool $preserve): static
     {
-        $this->validate = true;
+        $this->preserveDates = $preserve;
 
         return $this;
     }
 
     /**
-     * Disable validation
+     * Get whether date preservation is enabled.
      *
-     * @return $this
+     * @return bool True if dates are being preserved.
      */
-    public function disableValidation(): static
+    public function getPreserveDates(): bool
     {
-        $this->validate = false;
-
-        return $this;
+        return $this->preserveDates;
     }
 
     /**
-     * Skip Validation
-     *
-     * Execute a callback without validation
+     * Execute a callback with date 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 withPreserveDates(callable $callback): mixed
     {
-        $initial = $this->validate;
-        $this->disableValidation();
+        $previous = $this->preserveDates;
+        $this->preserveDates = true;
 
         try {
             return $callback();
         } finally {
-            $this->validate = $initial;
+            $this->preserveDates = $previous;
         }
     }
 
     /**
-     * Get shared tables
+     * Set whether to preserve original sequence values instead of auto-generating them.
      *
-     * Get whether to share tables between tenants
-     * @return bool
+     * @param bool $preserve True to preserve sequence values on write operations.
+     * @return $this
      */
-    public function getSharedTables(): bool
+    public function setPreserveSequence(bool $preserve): static
     {
-        return $this->adapter->getSharedTables();
+        $this->preserveSequence = $preserve;
+
+        return $this;
     }
 
     /**
-     * Set shard tables
-     *
-     * Set whether to share tables between tenants
+     * Get whether sequence preservation is enabled.
      *
-     * @param bool $sharedTables
-     * @return static
+     * @return bool True if sequence values are being preserved.
      */
-    public function setSharedTables(bool $sharedTables): static
+    public function getPreserveSequence(): bool
     {
-        $this->adapter->setSharedTables($sharedTables);
-
-        return $this;
+        return $this->preserveSequence;
     }
 
     /**
-     * Set Tenant
+     * Execute a callback with sequence preservation enabled, restoring the previous state afterward.
      *
-     * Set tenant to use if tables are shared
-     *
-     * @param int|string|null $tenant
-     * @return static
+     * @param callable $callback The callback to execute.
+     * @return mixed The callback's return value.
      */
-    public function setTenant(int|string|null $tenant): static
+    public function withPreserveSequence(callable $callback): mixed
     {
-        $this->adapter->setTenant($tenant);
+        $previous = $this->preserveSequence;
+        $this->preserveSequence = true;
 
-        return $this;
+        try {
+            return $callback();
+        } finally {
+            $this->preserveSequence = $previous;
+        }
     }
 
     /**
-     * Get Tenant
-     *
-     * Get tenant to use if tables are shared
+     * Set the migration mode flag, which relaxes certain constraints during data migrations.
      *
-     * @return int|string|null
+     * @param bool $migrating True to enable migration mode.
+     * @return $this
      */
-    public function getTenant(): int|string|null
+    public function setMigrating(bool $migrating): self
     {
-        return $this->adapter->getTenant();
+        $this->migrating = $migrating;
+
+        return $this;
     }
 
     /**
-     * With Tenant
+     * Check whether the database is currently in migration mode.
      *
-     * Execute a callback with a specific tenant
-     *
-     * @param int|string|null $tenant
-     * @param callable $callback
-     * @return mixed
+     * @return bool True if migration mode is active.
      */
-    public function withTenant(int|string|null $tenant, callable $callback): mixed
+    public function isMigrating(): bool
     {
-        $previous = $this->adapter->getTenant();
-        $this->adapter->setTenant($tenant);
-
-        try {
-            return $callback();
-        } finally {
-            $this->adapter->setTenant($previous);
-        }
+        return $this->migrating;
     }
 
     /**
-     * Set whether to allow creating documents with tenant set per document.
+     * Set the maximum number of values allowed in a single query (e.g., IN clauses).
      *
-     * @param bool $enabled
-     * @return static
+     * @param int $max The maximum number of query values.
+     * @return $this
      */
-    public function setTenantPerDocument(bool $enabled): static
+    public function setMaxQueryValues(int $max): self
     {
-        $this->adapter->setTenantPerDocument($enabled);
+        $this->maxQueryValues = $max;
 
         return $this;
     }
 
     /**
-     * Get whether to allow creating documents with tenant set per document.
+     * Get the maximum number of values allowed in a single query.
      *
-     * @return bool
+     * @return int The current maximum query values limit.
      */
-    public function getTenantPerDocument(): bool
+    public function getMaxQueryValues(): int
     {
-        return $this->adapter->getTenantPerDocument();
+        return $this->maxQueryValues;
     }
 
     /**
-     * Enable or disable LOCK=SHARED during ALTER TABLE operation
-     *
-     * Set lock mode when altering tables
+     * Set list of collections which are globally accessible
      *
-     * @param bool $enabled
-     * @return static
+     * @param  array<string>  $collections
+     * @return $this
      */
-    public function enableLocks(bool $enabled): static
+    public function setGlobalCollections(array $collections): static
     {
-        if ($this->adapter->getSupportForAlterLocks()) {
-            $this->adapter->enableAlterLocks($enabled);
+        foreach ($collections as $collection) {
+            $this->globalCollections[$collection] = true;
         }
 
         return $this;
     }
 
+    /**
+     * Get list of collections which are globally accessible
+     *
+     * @return array<string>
+     */
+    public function getGlobalCollections(): array
+    {
+        return \array_keys($this->globalCollections);
+    }
+
+    /**
+     * Clear global collections
+     */
+    public function resetGlobalCollections(): void
+    {
+        $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;
@@ -1344,7 +1101,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
@@ -1355,8 +1112,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
     {
@@ -1367,8 +1123,6 @@ public function clearDocumentType(string $collection): static
 
     /**
      * Clear all document type mappings
-     *
-     * @return static
      */
     public function clearAllDocumentTypes(): static
     {
@@ -1378,7330 +1132,282 @@ public function clearAllDocumentTypes(): static
     }
 
     /**
-     * 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;
+        if ($this->adapter->supports(Capability::AlterLock)) {
+            $this->adapter->enableAlterLocks($enabled);
+        }
 
-        return new $className($data);
+        return $this;
     }
 
-    public function getPreserveDates(): bool
+    /**
+     * Enable validation
+     *
+     * @return $this
+     */
+    public function enableValidation(): static
     {
-        return $this->preserveDates;
+        $this->validate = true;
+
+        return $this;
     }
 
-    public function setPreserveDates(bool $preserve): static
+    /**
+     * Disable validation
+     *
+     * @return $this
+     */
+    public function disableValidation(): static
     {
-        $this->preserveDates = $preserve;
+        $this->validate = false;
 
         return $this;
     }
 
-    public function setMigrating(bool $migrating): self
-    {
-        $this->migrating = $migrating;
-
-        return $this;
-    }
-
-    public function isMigrating(): bool
-    {
-        return $this->migrating;
-    }
-
-    public function withPreserveDates(callable $callback): mixed
-    {
-        $previous = $this->preserveDates;
-        $this->preserveDates = true;
-
-        try {
-            return $callback();
-        } finally {
-            $this->preserveDates = $previous;
-        }
-    }
-
-    public function getPreserveSequence(): bool
-    {
-        return $this->preserveSequence;
-    }
-
-    public function setPreserveSequence(bool $preserve): static
-    {
-        $this->preserveSequence = $preserve;
-
-        return $this;
-    }
-
-    public function withPreserveSequence(callable $callback): mixed
-    {
-        $previous = $this->preserveSequence;
-        $this->preserveSequence = true;
-
-        try {
-            return $callback();
-        } finally {
-            $this->preserveSequence = $previous;
-        }
-    }
-
-    public function setMaxQueryValues(int $max): self
-    {
-        $this->maxQueryValues = $max;
-
-        return $this;
-    }
-
-    public function getMaxQueryValues(): int
-    {
-        return $this->maxQueryValues;
-    }
-
-    /**
-     * Set list of collections which are globally accessible
-     *
-     * @param array<string> $collections
-     * @return $this
-     */
-    public function setGlobalCollections(array $collections): static
-    {
-        foreach ($collections as $collection) {
-            $this->globalCollections[$collection] = true;
-        }
-
-        return $this;
-    }
-
-    /**
-     * Get list of collections which are globally accessible
-     *
-     * @return array<string>
-     */
-    public function getGlobalCollections(): array
-    {
-        return \array_keys($this->globalCollections);
-    }
-
-    /**
-     * Clear global collections
-     *
-     * @return void
-     */
-    public function resetGlobalCollections(): void
-    {
-        $this->globalCollections = [];
-    }
-
-    /**
-     * Get list of keywords that cannot be used
-     *
-     * @return string[]
-     */
-    public function getKeywords(): array
-    {
-        return $this->adapter->getKeywords();
-    }
-
     /**
-     * Get Database Adapter
+     * Skip Validation
      *
-     * @return Adapter
-     */
-    public function getAdapter(): Adapter
-    {
-        return $this->adapter;
-    }
-
-    /**
-     * Run a callback inside a transaction.
+     * Execute a callback without validation
      *
      * @template T
-     * @param callable(): T $callback
-     * @return T
-     * @throws \Throwable
-     */
-    public function withTransaction(callable $callback): mixed
-    {
-        return $this->adapter->withTransaction($callback);
-    }
-
-    /**
-     * Ping Database
-     *
-     * @return bool
-     */
-    public function ping(): bool
-    {
-        return $this->adapter->ping();
-    }
-
-    public function reconnect(): void
-    {
-        $this->adapter->reconnect();
-    }
-
-    /**
-     * Create the database
-     *
-     * @param string|null $database
-     * @return bool
-     * @throws DuplicateException
-     * @throws LimitException
-     * @throws Exception
-     */
-    public function create(?string $database = null): bool
-    {
-        $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']);
-
-        $this->silent(fn () => $this->createCollection(self::METADATA, $attributes));
-
-        try {
-            $this->trigger(self::EVENT_DATABASE_CREATE, $database);
-        } catch (\Throwable $e) {
-            // Ignore
-        }
-
-        return true;
-    }
-
-    /**
-     * 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
-     *
-     * @return bool
-     */
-    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();
-
-        try {
-            $this->trigger(self::EVENT_DATABASE_LIST, $databases);
-        } catch (\Throwable $e) {
-            // Ignore
-        }
-
-        return $databases;
-    }
-
-    /**
-     * Delete Database
-     *
-     * @param string|null $database
-     * @return bool
-     * @throws DatabaseException
-     */
-    public function delete(?string $database = null): bool
-    {
-        $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
+     * @param  callable(): T  $callback
+     * @return T
      */
-    public function createCollection(string $id, array $attributes = [], array $indexes = [], ?array $permissions = null, bool $documentSecurity = true): Document
+    public function skipValidation(callable $callback): mixed
     {
-        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 {
-                // Metadata check (above) already verified collection is absent
-                // from metadata. A DuplicateException from the adapter means
-                // the collection exists only in physical schema — an orphan
-                // from a prior partial failure. Drop and recreate to ensure
-                // schema matches.
-                try {
-                    $this->adapter->deleteCollection($id);
-                } catch (NotFoundException) {
-                    // Already removed by a concurrent reconciler.
-                }
-                $this->adapter->createCollection($id, $attributes, $indexes);
-                $createdPhysicalTable = true;
-            }
-        }
-
-        if ($id === self::METADATA) {
-            return new Document(self::COLLECTION);
-        }
-
-        try {
-            $createdCollection = $this->silent(fn () => $this->createDocument(self::METADATA, $collection));
-        } 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);
-        }
+        $initial = $this->validate;
+        $this->disableValidation();
 
         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);
-        }
-
-        $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'] = [];
-            }
-
-            $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;
-    }
-
-    /**
-     * @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 {
-        $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(),
-            supportForSchemaAttributes: $this->adapter->getSupportForSchemaAttributes(),
-            supportForVectors: $this->adapter->getSupportForVectors(),
-            supportForSpatialAttributes: $this->adapter->getSupportForSpatialAttributes(),
-            supportForObject: $this->adapter->getSupportForObject(),
-            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 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_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');
-
-        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_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_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,
-                $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
-        );
-
-        try {
-            $cached = $this->cache->load($documentKey, self::TTL, $hashKey);
-        } catch (Exception $e) {
-            Console::warning('Warning: Failed to get document from cache: ' . $e->getMessage());
-            $cached = null;
-        }
-
-        if ($cached) {
-            $document = $this->createDocumentInstance($collection->getId(), $cached);
-
-            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;
-        }
-
-        $document = $this->adapter->getDocument(
-            $collection,
-            $id,
-            $queries,
-            $forUpdate
-        );
-
-        if ($document->isEmpty()) {
-            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
-        if (empty($relationships)) {
-            try {
-                $this->cache->save($documentKey, $document->getArrayCopy(), $hashKey);
-                $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()
-            );
-            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);
-        });
-
-        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()
-                );
-                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) {
-            $batch = $this->withTransaction(function () use ($collection, $chunk) {
-                return $this->adapter->createDocuments($collection, $chunk);
-            });
-
-            $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);
-
-                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();
-        $document = $this->withTransaction(function () use ($collection, $id, $document, $newUpdatedAt) {
-            $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);
-            }
-            $createdAt = $document->getCreatedAt();
-
-            $document = \array_merge($old->getArrayCopy(), $document->getArrayCopy());
-            $document['$collection'] = $old->getAttribute('$collection'); // Make sure user doesn't switch collection ID
-            $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);
-
-            $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 ($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(),
-                    $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 document to get computed values
-            $hasOperators = false;
-            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;
-        }
-
-        if (!$this->inBatchRelationshipPopulation && $this->resolveRelationships) {
-            $documents = $this->silent(fn () => $this->populateDocumentsRelationships([$document], $collection, $this->relationshipFetchDepth));
-            $document = $documents[0];
-        }
-
-        $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()
-            );
-
-            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(),
-                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);
-            }
-
-            foreach ($batch as $index => $doc) {
-                $doc = $this->adapter->castingAfter($collection, $doc);
-                $doc->removeAttribute('$skipPermissionsUpdate');
-                $this->purgeCachedDocument($collection->getId(), $doc->getId());
-                $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 = [];
-        foreach ($documents as $key => $document) {
-            if ($this->getSharedTables() && $this->getTenantPerDocument()) {
-                $old = $this->authorization->skip(fn () => $this->withTenant($document->getTenant(), fn () => $this->silent(fn () => $this->getDocument(
-                    $collection->getId(),
-                    $document->getId(),
-                ))));
-            } else {
-                $old = $this->authorization->skip(fn () => $this->silent(fn () => $this->getDocument(
-                    $collection->getId(),
-                    $document->getId(),
-                )));
-            }
-
-            // 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(),
-                    $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[] = $document->getId();
-            $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);
-                }
-
-                if ($this->getSharedTables() && $this->getTenantPerDocument()) {
-                    $this->withTenant($doc->getTenant(), function () use ($collection, $doc) {
-                        $this->purgeCachedDocument($collection->getId(), $doc->getId());
-                    });
-                } else {
-                    $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_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_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) {
-            $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()
-            );
-
-            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) {
-                if ($this->getSharedTables() && $this->getTenantPerDocument()) {
-                    $this->withTenant($document->getTenant(), function () use ($collection, $document) {
-                        $this->purgeCachedDocument($collection->getId(), $document->getId());
-                    });
-                } else {
-                    $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;
-    }
-
-    /**
-     * 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;
+            return $callback();
+        } finally {
+            $this->validate = $initial;
+        }
     }
 
     /**
-     * Find Documents
+     * Register a hook into the database pipeline.
      *
-     * @param string $collection
-     * @param array<Query> $queries
-     * @param string $forPermission
-     * @return array<Document>
-     * @throws DatabaseException
-     * @throws QueryException
-     * @throws TimeoutException
-     * @throws Exception
+     * 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 find(string $collection, array $queries = [], string $forPermission = Database::PERMISSION_READ): array
+    public function addHook(\Utopia\Query\Hook $hook): static
     {
-        $collection = $this->silent(fn () => $this->getCollection($collection));
-
-        if ($collection->isEmpty()) {
-            throw new NotFoundException('Collection not found');
+        if ($hook instanceof Lifecycle) {
+            $this->lifecycleHooks[] = $hook;
         }
 
-        $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()
-            );
-            if (!$validator->isValid($queries)) {
-                throw new QueryException($validator->getDescription());
-            }
+        if ($hook instanceof Hook\Decorator) {
+            $this->decorators[] = $hook;
         }
 
-        $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());
+        if ($hook instanceof Relationships) {
+            $this->relationshipHook = $hook;
         }
 
-        $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;
-            }
+        if ($hook instanceof Hook\Write) {
+            $this->adapter->addWriteHook($hook);
         }
 
-        if ($uniqueOrderBy === false) {
-            $orderAttributes[] = '$sequence';
+        if ($hook instanceof Transform) {
+            $this->adapter->addTransform($hook::class, $hook);
         }
 
-        if (!empty($cursor)) {
-            foreach ($orderAttributes as $order) {
-                if ($cursor->getAttribute($order) === null) {
-                    throw new OrderException(
-                        message: "Order attribute '{$order}' is empty",
-                        attribute: $order
-                    );
-                }
-            }
-        }
+        return $this;
+    }
 
-        if (!empty($cursor) && $cursor->getCollection() !== $collection->getId()) {
-            throw new DatabaseException("cursor Document must be from the same Collection.");
+    /**
+     * Apply all registered decorators to a single document.
+     */
+    protected function decorateDocument(Event $event, Document $collection, Document $document): Document
+    {
+        if ($this->eventsSilenced) {
+            return $document;
         }
 
-        if (!empty($cursor)) {
-            $cursor = $this->encode($collection, $cursor);
-            $cursor = $this->adapter->castingBefore($collection, $cursor);
-            $cursor = $cursor->getArrayCopy();
-        } else {
-            $cursor = [];
+        foreach ($this->decorators as $decorator) {
+            $document = $decorator->decorate($event, $collection, $document);
         }
 
-        /**  @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
-            );
+        return $document;
+    }
 
-            $results = $skipAuth ? $this->authorization->skip($getResults) : $getResults();
+    /**
+     * Apply all registered document decorators to an array of documents.
+     *
+     * @param  array<Document>  $documents
+     * @return array<Document>
+     */
+    protected function decorateDocuments(Event $event, Document $collection, array $documents): array
+    {
+        if (empty($this->decorators)) {
+            return $documents;
         }
 
-        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 ($documents as $i => $document) {
+            $documents[$i] = $this->decorateDocument($event, $collection, $document);
         }
 
-        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());
-            }
+        return $documents;
+    }
 
-            $results[$index] = $node;
-        }
 
-        $this->trigger(self::EVENT_DOCUMENT_FIND, $results);
+    /**
+     * Remove a query transform hook from the adapter.
+     */
+    public function removeTransform(string $name): static
+    {
+        $this->adapter->removeTransform($name);
 
-        return $results;
+        return $this;
     }
 
     /**
-     * Helper method to iterate documents in collection using callback pattern
-     * Alterative is
+     * Silence lifecycle hooks for calls inside the callback.
      *
-     * @param string $collection
-     * @param callable $callback
-     * @param array<Query> $queries
-     * @param string $forPermission
-     * @return void
-     * @throws \Utopia\Database\Exception
+     * @template T
+     *
+     * @param  callable(): T  $callback
+     * @return T
      */
-    public function foreach(string $collection, callable $callback, array $queries = [], string $forPermission = Database::PERMISSION_READ): void
+    public function silent(callable $callback): mixed
     {
-        foreach ($this->iterate($collection, $queries, $forPermission) as $document) {
-            $callback($document);
+        $previous = $this->eventsSilenced;
+        $this->eventsSilenced = true;
+
+        try {
+            return $callback();
+        } finally {
+            $this->eventsSilenced = $previous;
         }
     }
 
     /**
-     * Return each document of the given collection
-     * that matches the given queries
+     * Register a global attribute filter with encode and decode callbacks for data transformation.
      *
-     * @param string $collection
-     * @param array<Query> $queries
-     * @param string $forPermission
-     * @return \Generator
-     * @throws \Utopia\Database\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 iterate(string $collection, array $queries = [], string $forPermission = Database::PERMISSION_READ): \Generator
+    public static function addFilter(string $name, callable $encode, callable $decode): void
     {
-        $grouped = Query::groupByType($queries);
-        $limitExists = $grouped['limit'] !== null;
-        $limit = $grouped['limit'] ?? 25;
-        $offset = $grouped['offset'];
-
-        $cursor = $grouped['cursor'];
-        $cursorDirection = $grouped['cursorDirection'];
+        self::$filters[$name] = [
+            'encode' => $encode,
+            'decode' => $decode,
+            'signature' => self::computeCallableSignature($encode) . ':' . self::computeCallableSignature($decode),
+        ];
+    }
 
-        // Cursor before is not supported
-        if ($cursor !== null && $cursorDirection === Database::CURSOR_BEFORE) {
-            throw new DatabaseException('Cursor ' . Database::CURSOR_BEFORE . ' not supported in this method.');
+    private static function computeCallableSignature(callable $callable): string
+    {
+        if (\is_string($callable)) {
+            return $callable;
         }
 
-        $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)];
+        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 string $collection
-     * @param array<Query> $queries
-     * @return Document
-     * @throws DatabaseException
+     * Enable filters
+     *
+     * @return $this
      */
-    public function findOne(string $collection, array $queries = []): Document
+    public function enableFilters(): static
     {
-        $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();
-        }
+        $this->filter = true;
 
-        return $found;
+        return $this;
     }
 
     /**
-     * Count Documents
-     *
-     * Count the number of documents.
-     *
-     * @param string $collection
-     * @param array<Query> $queries
-     * @param int|null $max
+     * Disable filters
      *
-     * @return int
-     * @throws DatabaseException
+     * @return $this
      */
-    public function count(string $collection, array $queries = [], ?int $max = null): int
+    public function disableFilters(): static
     {
-        $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()
-            );
-            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);
+        $this->filter = false;
 
-        return $count;
+        return $this;
     }
 
     /**
-     * Sum an attribute
+     * Skip filters
      *
-     * Sum an attribute for all the documents. Pass $max=0 for unlimited count
+     * Execute a callback without filters
      *
-     * @param string $collection
-     * @param string $attribute
-     * @param array<Query> $queries
-     * @param int|null $max
+     * @template T
      *
-     * @return int|float
-     * @throws DatabaseException
+     * @param  callable(): T  $callback
+     * @param  array<string>|null  $filters
+     * @return T
      */
-    public function sum(string $collection, string $attribute, array $queries = [], ?int $max = null): float|int
+    public function skipFilters(callable $callback, ?array $filters = null): mixed
     {
-        $collection = $this->silent(fn () => $this->getCollection($collection));
-
-        if ($collection->isEmpty()) {
-            throw new NotFoundException('Collection not found');
-        }
+        if (empty($filters)) {
+            $initial = $this->filter;
+            $this->disableFilters();
 
-        $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()
-            );
-            if (!$validator->isValid($queries)) {
-                throw new QueryException($validator->getDescription());
+            try {
+                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
+     * Get instance filters
      *
-     * @return void
+     * @return array<string, array{encode: callable, decode: callable, signature: string}>
      */
-    public static function addFilter(string $name, callable $encode, callable $decode): void
+    public function getInstanceFilters(): array
     {
-        self::$filters[$name] = [
-            'encode' => $encode,
-            'decode' => $decode,
-            'signature' => self::computeCallableSignature($encode) . ':' . self::computeCallableSignature($decode),
-        ];
+        return $this->instanceFilters;
     }
 
     /**
      * Encode Document
      *
-     * @param Document $collection
-     * @param Document $document
-     * @param bool $applyDefaults Whether to apply default values to null attributes
+     * @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
     {
+        /** @var array<array<string, mixed>> $attributes */
         $attributes = $collection->getAttribute('attributes', []);
         $internalDateAttributes = ['$createdAt', '$updatedAt'];
         foreach ($this->getInternalAttributes() as $attribute) {
@@ -8709,14 +1415,17 @@ public function encode(Document $collection, Document $document, bool $applyDefa
         }
 
         foreach ($attributes as $attribute) {
+            /** @var string $key */
             $key = $attribute['$id'] ?? '';
             $array = $attribute['array'] ?? false;
             $default = $attribute['default'] ?? null;
+            /** @var array<string> $filters */
             $filters = $attribute['filters'] ?? [];
             $value = $document->getAttribute($key);
 
             if (in_array($key, $internalDateAttributes) && is_string($value) && empty($value)) {
                 $document->setAttribute($key, null);
+
                 continue;
             }
 
@@ -8735,11 +1444,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 (is_null($value) && ! is_null($default)) {
                 // Skip applying defaults during updates to avoid resetting unspecified attributes
-                if (!$applyDefaults) {
+                if (! $applyDefaults) {
                     continue;
                 }
                 $value = ($array) ? $default : [$default];
@@ -8747,6 +1454,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) {
@@ -8756,7 +1464,7 @@ public function encode(Document $collection, Document $document, bool $applyDefa
                 }
             }
 
-            if (!$array) {
+            if (! $array) {
                 $value = $value[0];
             }
             $document->setAttribute($key, $value);
@@ -8768,32 +1476,33 @@ public function encode(Document $collection, Document $document, bool $applyDefa
     /**
      * 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
     {
+        /** @var array<array<string, mixed>|Document> $allAttributes */
+        $allAttributes = $collection->getAttribute('attributes', []);
         $attributes = \array_filter(
-            $collection->getAttribute('attributes', []),
-            fn ($attribute) => $attribute['type'] !== self::VAR_RELATIONSHIP
+            $allAttributes,
+            fn (array|Document $attribute) => $attribute['type'] !== ColumnType::Relationship->value
         );
 
         $relationships = \array_filter(
-            $collection->getAttribute('attributes', []),
-            fn ($attribute) => $attribute['type'] === self::VAR_RELATIONSHIP
+            $allAttributes,
+            fn (array|Document $attribute) => $attribute['type'] === ColumnType::Relationship->value
         );
 
         $filteredValue = [];
 
         foreach ($relationships as $relationship) {
+            /** @var string $key */
             $key = $relationship['$id'] ?? '';
 
             if (
-                \array_key_exists($key, (array)$document)
-                || \array_key_exists($this->adapter->filter($key), (array)$document)
+                \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));
@@ -8807,9 +1516,11 @@ public function decode(Document $collection, Document $document, array $selectio
         }
 
         foreach ($attributes as $attribute) {
+            /** @var string $key */
             $key = $attribute['$id'] ?? '';
             $type = $attribute['type'] ?? '';
             $array = $attribute['array'] ?? false;
+            /** @var array<string> $filters */
             $filters = $attribute['filters'] ?? [];
             $value = $document->getAttribute($key);
 
@@ -8820,7 +1531,7 @@ public function decode(Document $collection, Document $document, array $selectio
             if (\is_null($value)) {
                 $value = $document->getAttribute($this->adapter->filter($key));
 
-                if (!\is_null($value)) {
+                if (! \is_null($value)) {
                     $document->removeAttribute($this->adapter->filter($key));
                 }
             }
@@ -8833,6 +1544,7 @@ public function decode(Document $collection, Document $document, array $selectio
             $value = ($array) ? $value : [$value];
             $value = (is_null($value)) ? [] : $value;
 
+            /** @var array<int|string, mixed> $value */
             foreach ($value as $index => $node) {
                 foreach (\array_reverse($filters) as $filter) {
                     $node = $this->decodeAttribute($filter, $node, $document, $key);
@@ -8852,7 +1564,7 @@ public function decode(Document $collection, Document $document, array $selectio
         }
 
         $hasRelationshipSelections = false;
-        if (!empty($selections)) {
+        if (! empty($selections)) {
             foreach ($selections as $selection) {
                 if (\str_contains($selection, '.')) {
                     $hasRelationshipSelections = true;
@@ -8861,36 +1573,38 @@ public function decode(Document $collection, Document $document, array $selectio
             }
         }
 
-        if ($hasRelationshipSelections && !empty($selections) && !\in_array('*', $selections)) {
-            foreach ($collection->getAttribute('attributes', []) as $attribute) {
+        if ($hasRelationshipSelections && ! empty($selections) && ! \in_array('*', $selections)) {
+            foreach ($allAttributes as $attribute) {
+                /** @var string $key */
                 $key = $attribute['$id'] ?? '';
 
-                if ($attribute['type'] === self::VAR_RELATIONSHIP || $key === '$permissions') {
+                if ($attribute['type'] === ColumnType::Relationship->value || $key === '$permissions') {
                     continue;
                 }
 
-                if (!in_array($key, $selections) && isset($filteredValue[$key])) {
+                if (! in_array($key, $selections) && isset($filteredValue[$key])) {
                     $document->setAttribute($key, $filteredValue[$key]);
                 }
             }
         }
+
         return $document;
     }
 
     /**
-     * Casting
-     *
-     * @param Document $collection
-     * @param Document $document
+     * Cast document attribute values to their proper PHP types based on the collection schema.
      *
-     * @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) {
@@ -8898,6 +1612,7 @@ public function casting(Document $collection, Document $document): Document
         }
 
         foreach ($attributes as $attribute) {
+            /** @var string $key */
             $key = $attribute['$id'] ?? '';
             $type = $attribute['type'] ?? '';
             $array = $attribute['array'] ?? false;
@@ -8911,33 +1626,22 @@ public function casting(Document $collection, Document $document): Document
             }
 
             if ($array) {
-                $value = !is_string($value)
+                $value = ! is_string($value)
                     ? $value
                     : 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_FLOAT:
-                        $node = (float)$node;
-                        break;
-                    default:
-                        break;
-                }
+                $node = match ($type) {
+                    ColumnType::Id->value => (string) $node,
+                    ColumnType::Boolean->value => (bool) $node,
+                    ColumnType::Integer->value => (int) $node,
+                    ColumnType::Double->value => (float) $node,
+                    default => $node,
+                };
 
                 $value[$index] = $node;
             }
@@ -8948,140 +1652,84 @@ public function casting(Document $collection, Document $document): Document
         return $document;
     }
 
+    /**
+     * Set a metadata value to be printed in the query comments
+     */
+    public function setMetadata(string $key, mixed $value): static
+    {
+        $this->adapter->setMetadata($key, $value);
+
+        return $this;
+    }
 
     /**
-     * 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
+     * Get metadata
      *
-     * @return mixed
-     * @throws DatabaseException
+     * @return array<string, mixed>
      */
-    protected function encodeAttribute(string $name, mixed $value, Document $document): mixed
+    public function getMetadata(): array
     {
-        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);
-        }
+        return $this->adapter->getMetadata();
+    }
 
-        return $value;
+    /**
+     * Clear metadata
+     */
+    public function resetMetadata(): void
+    {
+        $this->adapter->resetMetadata();
     }
 
     /**
-     * Decode Attribute
+     * Executes $callback with $timestamp set to $requestTimestamp
      *
-     * Passes the attribute $value, and $document context to a predefined filter
-     *  that allow you to manipulate the output format of the given attribute.
+     * @template T
      *
-     * @param string $filter
-     * @param mixed $value
-     * @param Document $document
-     * @param string $attribute
-     * @return mixed
-     * @throws NotFoundException
+     * @param  callable(): T  $callback
+     * @return T
      */
-    protected function decodeAttribute(string $filter, mixed $value, Document $document, string $attribute): mixed
+    public function withRequestTimestamp(?NativeDateTime $requestTimestamp, callable $callback): mixed
     {
-        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);
+        $previous = $this->timestamp;
+        $this->timestamp = $requestTimestamp;
+        try {
+            $result = $callback();
+        } finally {
+            $this->timestamp = $previous;
         }
 
-        return $value;
+        return $result;
     }
 
     /**
-     * Validate if a set of attributes can be selected from the collection
+     * Get getConnection Id
      *
-     * @param Document $collection
-     * @param array<Query> $queries
-     * @return array<string>
-     * @throws QueryException
+     * @throws Exception
      */
-    private function validateSelections(Document $collection, array $queries): array
+    public function getConnectionId(): string
     {
-        if (empty($queries)) {
-            return [];
-        }
-
-        $selections = [];
-        $relationshipSelections = [];
-
-        foreach ($queries as $query) {
-            if ($query->getMethod() == Query::TYPE_SELECT) {
-                foreach ($query->getValues() as $value) {
-                    if (\str_contains($value, '.')) {
-                        $relationshipSelections[] = $value;
-                        continue;
-                    }
-                    $selections[] = $value;
-                }
-            }
-        }
-
-        // Allow querying internal attributes
-        $keys = \array_map(
-            fn ($attribute) => $attribute['$id'],
-            $this->getInternalAttributes()
-        );
-
-        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));
-            }
-        }
-
-        $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
     {
@@ -9094,8 +1742,6 @@ public function getLimitForAttributes(): int
 
     /**
      * Get adapter index limit
-     *
-     * @return int
      */
     public function getLimitForIndexes(): int
     {
@@ -9103,9 +1749,9 @@ public function getLimitForIndexes(): int
     }
 
     /**
-     * @param Document $collection
-     * @param array<Query> $queries
+     * @param  array<Query>  $queries
      * @return array<Query>
+     *
      * @throws QueryException
      * @throws \Utopia\Database\Exception
      */
@@ -9113,7 +1759,9 @@ public function convertQueries(Document $collection, array $queries): array
     {
         foreach ($queries as $index => $query) {
             if ($query->isNested()) {
-                $values = $this->convertQueries($collection, $query->getValues());
+                /** @var array<Query> $nestedQueries */
+                $nestedQueries = $query->getValues();
+                $values = $this->convertQueries($collection, $nestedQueries);
                 $query->setValues($values);
             }
 
@@ -9126,49 +1774,13 @@ 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
      */
-    /**
-     * Check if values are compatible with object attribute type (hashmap/multi-dimensional array)
-     *
-     * @param array<mixed> $values
-     * @return bool
-     */
-    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;
-    }
-
     public function convertQuery(Document $collection, Query $query): Query
     {
         /**
@@ -9181,7 +1793,7 @@ public function convertQuery(Document $collection, Query $query): Query
         }
 
         $queryAttribute = $query->getAttribute();
-        $isNestedQueryAttribute = $this->getAdapter()->getSupportForAttributes() && $this->getAdapter()->getSupportForObject() && \str_contains($queryAttribute, '.');
+        $isNestedQueryAttribute = $this->getAdapter()->supports(Capability::DefinedAttributes) && $this->adapter->supports(Capability::Objects) && \str_contains($queryAttribute, '.');
 
         $attribute = new Document();
 
@@ -9191,34 +1803,39 @@ public function convertQuery(Document $collection, Query $query): Query
             } 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);
+                if ($baseAttribute === $attr->getId() && $attr->getAttribute('type') === ColumnType::Object->value) {
+                    $query->setAttributeType(ColumnType::Object->value);
                 }
             }
         }
 
-        if (!$attribute->isEmpty()) {
-            $query->setOnArray($attribute->getAttribute('array', false));
-            $query->setAttributeType($attribute->getAttribute('type'));
+        if (! $attribute->isEmpty()) {
+            /** @var bool $isArray */
+            $isArray = $attribute->getAttribute('array', false);
+            /** @var string $attrType */
+            $attrType = $attribute->getAttribute('type');
+            $query->setOnArray($isArray);
+            $query->setAttributeType($attrType);
 
-            if ($attribute->getAttribute('type') == Database::VAR_DATETIME) {
+            if ($attrType == ColumnType::Datetime->value) {
                 $values = $query->getValues();
                 foreach ($values as $valueIndex => $value) {
                     try {
-                        $values[$valueIndex] = $this->adapter->getSupportForUTCCasting()
+                        /** @var string $value */
+                        $values[$valueIndex] = $this->adapter instanceof Feature\UTCCasting
                             ? $this->adapter->setUTCDatetime($value)
                             : DateTime::setTimezone($value);
-                    } catch (\Throwable $e) {
+                    } catch (Throwable $e) {
                         throw new QueryException($e->getMessage(), $e->getCode(), $e);
                     }
                 }
                 $query->setValues($values);
             }
-        } elseif (!$this->adapter->getSupportForAttributes()) {
+        } elseif (! $this->adapter->supports(Capability::DefinedAttributes)) {
             $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);
+            if ($this->adapter->supports(Capability::Objects) && $this->isCompatibleObjectValue($values)) {
+                $query->setAttributeType(ColumnType::Object->value);
             }
         }
 
@@ -9226,771 +1843,265 @@ public function convertQuery(Document $collection, Query $query): Query
     }
 
     /**
-     * @return  array<array<string, mixed>>
-     */
-    public function getInternalAttributes(): array
-    {
-        $attributes = self::INTERNAL_ATTRIBUTES;
-
-        if (!$this->adapter->getSharedTables()) {
-            $attributes = \array_filter(Database::INTERNAL_ATTRIBUTES, function ($attribute) {
-                return $attribute['$id'] !== '$tenant';
-            });
-        }
-
-        return $attributes;
-    }
-
-    /**
-     * Get Schema Attributes
-     *
-     * @param string $collection
-     * @return array<Document>
-     * @throws DatabaseException
-     */
-    public function getSchemaAttributes(string $collection): array
-    {
-        return $this->adapter->getSchemaAttributes($collection);
-    }
-
-    /**
-     * @param string $collection
-     * @return array<Document>
+     * @return array<array<string, mixed>>
      */
-    public function getSchemaIndexes(string $collection): array
-    {
-        return $this->adapter->getSchemaIndexes($collection);
-    }
-
     /**
-     * @param string $collectionId
-     * @param string|null $documentId
-     * @param array<string> $selects
-     * @return array{0: string, 1: string, 2: string}
+     * @return array<string, mixed>
      */
-    public function getCacheKeys(string $collectionId, ?string $documentId = null, array $selects = []): array
+    protected static function collectionMeta(): array
     {
-        if ($this->adapter->getSupportForHostname()) {
-            $hostname = $this->adapter->getHostname();
-        }
-
-        $tenantSegment = $this->adapter->getTenant();
-
-        if ($collectionId === self::METADATA && isset($this->globalCollections[$documentId])) {
-            $tenantSegment = null;
-        }
-
-        $collectionKey = \sprintf(
-            '%s-cache-%s:%s:%s:collection:%s',
-            $this->cacheName,
-            $hostname ?? '',
-            $this->getNamespace(),
-            $tenantSegment,
-            $collectionId
+        $collection = self::COLLECTION;
+        $collection['attributes'] = \array_map(
+            fn (array $attr) => new Document($attr),
+            $collection['attributes']
         );
 
-        if ($documentId) {
-            $documentKey = $documentHashKey = "{$collectionKey}:{$documentId}";
-
-            $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' => $filterSignatures,
-            ]) ?: '';
-            $documentHashKey = $documentKey . ':' . \md5($payload);
-        }
-
-        return [
-            $collectionKey,
-            $documentKey ?? '',
-            $documentHashKey ?? ''
-        ];
-    }
-
-    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 (!\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;
+        return $collection;
     }
 
     /**
-     * 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.
+     * Get the list of internal attribute definitions (e.g., $id, $createdAt, $permissions) as typed Attribute objects.
      *
-     * 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);
-                }
+     * @return array<Attribute>
+     */
+    public static function internalAttributes(): array
+    {
+        return \array_map(
+            fn (array $attr): Attribute => Attribute::fromDocument(new Document($attr)),
+            self::INTERNAL_ATTRIBUTES
+        );
+    }
 
-                if (empty($matchingIds)) {
-                    return null;
-                }
-            }
+    /**
+     * 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;
 
-            $allMatchingIds = \array_merge($allMatchingIds, $matchingIds);
+        if (! $this->adapter->getSharedTables()) {
+            $attributes = \array_filter(Database::INTERNAL_ATTRIBUTES, function ($attribute) {
+                return $attribute['$id'] !== '$tenant';
+            });
         }
 
-        return \array_unique($allMatchingIds);
+        return $attributes;
     }
 
     /**
-     * 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
+     * Get Schema Attributes
      *
-     * 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
+     * @return array<Document>
      *
-     * @param array<Document> $relationships
-     * @param array<Query> $queries
-     * @return array<Query>|null Returns null if relationship filters cannot match any documents
+     * @throws DatabaseException
      */
-    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;
-            }
-        }
+    public function getSchemaAttributes(string $collection): array
+    {
+        return $this->adapter->getSchemaAttributes($collection);
+    }
 
-        if (!$hasRelationshipQuery) {
-            return $queries;
-        }
+    /**
+     * 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
+    {
+        return $this->adapter->getSchemaIndexes($collection);
+    }
 
-        $relationshipsByKey = [];
-        foreach ($relationships as $relationship) {
-            $relationshipsByKey[$relationship->getAttribute('key')] = $relationship;
+    /**
+     * @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->supports(Capability::Hostname)) {
+            $hostname = $this->adapter->getHostname();
         }
 
-        $additionalQueries = [];
-        $groupedQueries = [];
-        $indicesToRemove = [];
-
-        // Handle containsAll queries first
-        foreach ($queries as $index => $query) {
-            if ($query->getMethod() !== Query::TYPE_CONTAINS_ALL) {
-                continue;
-            }
+        $tenantSegment = $this->adapter->getTenant();
 
-            $attribute = $query->getAttribute();
+        if ($collectionId === self::METADATA && isset($this->globalCollections[$documentId])) {
+            $tenantSegment = null;
+        }
 
-            if (!\str_contains($attribute, '.')) {
-                continue; // Non-relationship containsAll handled by adapter
-            }
+        $collectionKey = \sprintf(
+            '%s-cache-%s:%s:%s:collection:%s',
+            $this->cacheName,
+            $hostname ?? '',
+            $this->getNamespace(),
+            $tenantSegment,
+            $collectionId
+        );
 
-            $parts = \explode('.', $attribute);
-            $relationshipKey = \array_shift($parts);
-            $nestedAttribute = \implode('.', $parts);
-            $relationship = $relationshipsByKey[$relationshipKey] ?? null;
+        if ($documentId) {
+            $documentKey = $documentHashKey = "{$collectionKey}:{$documentId}";
 
-            if (!$relationship) {
-                continue;
-            }
+            $sortedSelects = $selects;
+            \sort($sortedSelects);
 
-            // 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);
+            $filterSignatures = [];
+            if ($this->filter) {
+                $disabled = $this->disabledFilters ?? [];
 
-                if ($result === null) {
-                    return null;
+                foreach (self::$filters as $name => $callbacks) {
+                    if (isset($disabled[$name])) {
+                        continue;
+                    }
+                    if (\array_key_exists($name, $this->instanceFilters)) {
+                        continue;
+                    }
+                    $filterSignatures[$name] = $callbacks['signature'];
                 }
 
-                $resolvedAttribute = $result['attribute'];
-                $parentIdSets[] = $result['ids'];
-            }
-
-            $ids = \count($parentIdSets) > 1
-                ? \array_values(\array_intersect(...$parentIdSets))
-                : ($parentIdSets[0] ?? []);
+                foreach ($this->instanceFilters as $name => $callbacks) {
+                    if (isset($disabled[$name])) {
+                        continue;
+                    }
+                    $filterSignatures[$name] = $callbacks['signature'];
+                }
 
-            if (empty($ids)) {
-                return null;
+                \ksort($filterSignatures);
             }
 
-            $additionalQueries[] = Query::equal($resolvedAttribute, $ids);
-            $indicesToRemove[] = $index;
+            $payload = \json_encode([
+                'selects' => $sortedSelects,
+                'filters' => $filterSignatures,
+            ]) ?: '';
+            $documentHashKey = $documentKey . ':' . \md5($payload);
         }
 
-        // 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();
-
-            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()
-            ];
+        return [
+            $collectionKey,
+            $documentKey ?? '',
+            $documentHashKey ?? '',
+        ];
+    }
 
-            $groupedQueries[$relationshipKey]['indices'][] = $index;
+    /**
+     * Fire an event to all registered lifecycle hooks.
+     * Exceptions from hooks are silently caught.
+     */
+    protected function trigger(Event $event, mixed $data = null): void
+    {
+        if ($this->eventsSilenced) {
+            return;
         }
 
-        // 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;
-                }
-            }
-
-            $relatedQueries = [];
-            foreach ($group['queries'] as $queryData) {
-                $relatedQueries[] = new Query(
-                    $queryData['method'],
-                    $queryData['attribute'],
-                    $queryData['values']
-                );
-            }
-
+        foreach ($this->lifecycleHooks as $hook) {
             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;
+                $hook->handle($event, $data);
+            } catch (Throwable) {
+                // Lifecycle hooks must not break business logic
             }
         }
+    }
 
-        // Remove the original queries
-        foreach ($indicesToRemove as $index) {
-            unset($queries[$index]);
-        }
+    /**
+     * Create a document instance of the appropriate type
+     *
+     * @param  string  $collection  Collection ID
+     * @param  array<string, mixed>  $data  Document data
+     */
+    protected function createDocumentInstance(string $collection, array $data): Document
+    {
+        $className = $this->documentTypes[$collection] ?? Document::class;
 
-        // Merge additional queries
-        return \array_merge(\array_values($queries), $additionalQueries);
+        return new $className($data);
     }
 
     /**
-     * Resolve a group of relationship queries to matching document IDs.
+     * 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 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
+     * @throws DatabaseException
      */
-    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 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");
         }
 
-        if ($hasNestedPaths) {
-            $matchingIds = $this->processNestedRelationshipPath(
-                $relatedCollection,
-                $relatedQueries
-            );
-
-            if ($matchingIds === null || empty($matchingIds)) {
-                return null;
+        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);
             }
-
-            $relatedQueries = \array_values(\array_merge(
-                \array_filter($relatedQueries, fn (Query $q) => !\str_contains($q->getAttribute(), '.')),
-                [Query::equal('$id', $matchingIds)]
-            ));
+        } catch (Throwable $th) {
+            throw new DatabaseException($th->getMessage(), $th->getCode(), $th);
         }
 
-        $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);
+        return $value;
+    }
 
-            $junctionDocs = $this->silent(fn () => $this->skipRelationships(fn () => $this->find($junction, [
-                Query::equal($relationshipKey, $matchingIds),
-                Query::limit(PHP_INT_MAX),
-            ])));
+    /**
+     * 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;
+        }
 
-            $parentIds = [];
-            foreach ($junctionDocs as $jDoc) {
-                $pId = $jDoc->getAttribute($twoWayKey);
-                if ($pId && !\in_array($pId, $parentIds)) {
-                    $parentIds[] = $pId;
-                }
-            }
+        if (! \is_null($this->disabledFilters) && isset($this->disabledFilters[$filter])) {
+            return $value;
+        }
 
-            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),
-                ])
-            ));
-
-            $twoWayKey = $relationship->getAttribute('options')['twoWayKey'];
-            $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 ($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);
         } 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);
         }
+
+        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]);
@@ -10001,29 +2112,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,
@@ -10033,13 +2183,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++;
 
@@ -10053,7 +2204,7 @@ private function withRetries(
                     \usleep($delayMs * 1000);
                 }
 
-                $delayMs = (int)($delayMs * $multiplier);
+                $delayMs = (int) ($delayMs * $multiplier);
             }
         }
 
@@ -10063,11 +2214,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(
@@ -10078,34 +2229,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
      *
@@ -10114,13 +2243,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(
@@ -10134,18 +2263,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
                         );
                     }
@@ -10153,16 +2282,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
                         );
                     }
@@ -10170,26 +2299,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 e5c8850fb..d3eed24d1 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,34 +22,41 @@ 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
+     * 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');
+        $interval = DateInterval::createFromDateString($seconds.' seconds');
 
-        if (!$interval) {
+        if (! $interval) {
             throw new DatabaseException('Invalid interval');
         }
 
@@ -51,24 +66,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 +97,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 d50a957ca..f60f4cbd1 100644
--- a/src/Database/Document.php
+++ b/src/Database/Document.php
@@ -7,46 +7,67 @@
 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';
+    /** @var array<string, true>|null */
+    private static ?array $internalKeySet = null;
 
+    private ?array $parsedPermissions = null;
+
+    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'])) {
+        if (array_key_exists('$id', $input) && ! \is_string($input['$id'])) {
             throw new StructureException('$id must be of type string');
         }
 
-        if (array_key_exists('$permissions', $input) && !is_array($input['$permissions'])) {
+        if (array_key_exists('$permissions', $input) && ! is_array($input['$permissions'])) {
             throw new StructureException('$permissions must be of type array');
         }
 
+        if (array_key_exists('$permissions', $input) && is_array($input['$permissions'])) {
+            $input['$permissions'] = \array_values(\array_unique($input['$permissions']));
+        }
+
         foreach ($input as $key => $value) {
-            if (!\is_array($value)) {
+            if (! \is_array($value)) {
                 continue;
             }
 
             if (isset($value['$id']) || isset($value['$collection'])) {
+                /** @var array<string, mixed> $value */
                 $input[$key] = new self($value);
+
                 continue;
             }
 
             foreach ($value as $childKey => $child) {
-                if ((isset($child['$id']) || isset($child['$collection'])) && (!$child instanceof self)) {
+                if (\is_array($child) && (isset($child['$id']) || isset($child['$collection']))) {
+                    /** @var array<string, mixed> $child */
                     $value[$childKey] = new self($child);
                 }
             }
@@ -58,15 +79,21 @@ public function __construct(array $input = [])
     }
 
     /**
-     * @return string
+     * 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('$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
     {
@@ -76,58 +103,77 @@ public function getSequence(): ?string
             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('$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('$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
@@ -140,52 +186,90 @@ public function getWrite(): array
     }
 
     /**
+     * Get roles for a specific permission type from this document's permissions.
+     *
+     * @param string $type The permission type (e.g., 'read', 'create', 'update', 'delete').
      * @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 (['read', 'create', 'update', 'delete', 'write'] as $t) {
+                    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('$createdAt');
+        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('$updatedAt');
+        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');
 
-        if (\is_numeric($tenant)) {
+        if (\is_string($tenant) && \ctype_digit($tenant)) {
             return (int) $tenant;
         }
 
         return $tenant;
     }
 
+    /**
+     * 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('$version');
+
+        if ($version === null) {
+            return null;
+        }
+
+        /** @var int $version */
+        return $version;
+    }
+
     /**
      * Get Document Attributes
      *
@@ -194,14 +278,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;
             }
 
@@ -215,11 +295,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,27 +309,24 @@ public function getAttribute(string $name, mixed $default = null): mixed
      * 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
+    public function setAttribute(string $key, mixed $value, SetType $type = SetType::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;
+        if ($type !== SetType::Assign) {
+            $this[$key] = (! isset($this[$key]) || ! \is_array($this[$key])) ? [] : $this[$key];
+        }
+
+        match ($type) {
+            SetType::Assign => $this[$key] = $value,
+            SetType::Append => $this[$key] = [...(array) $this[$key], $value],
+            SetType::Prepend => $this[$key] = [$value, ...(array) $this[$key]],
+        };
+
+        if ($key === '$permissions') {
+            if (\is_array($this[$key])) {
+                $this[$key] = \array_values(\array_unique($this[$key]));
+            }
+            $this->parsedPermissions = null;
         }
 
         return $this;
@@ -263,8 +335,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
     {
@@ -279,45 +350,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;
     }
 
@@ -326,32 +394,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;
     }
 
@@ -360,50 +441,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
     {
@@ -415,9 +503,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
@@ -427,27 +514,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;
@@ -457,6 +546,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 000000000..2c8605fa5
--- /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/CollectionCreated.php b/src/Database/Event/CollectionCreated.php
new file mode 100644
index 000000000..abfd4fde7
--- /dev/null
+++ b/src/Database/Event/CollectionCreated.php
@@ -0,0 +1,16 @@
+<?php
+
+namespace Utopia\Database\Event;
+
+use Utopia\Database\Document;
+use Utopia\Database\Event;
+
+class CollectionCreated extends DomainEvent
+{
+    public function __construct(
+        string $collection,
+        public readonly Document $document,
+    ) {
+        parent::__construct($collection, Event::CollectionCreate);
+    }
+}
diff --git a/src/Database/Event/CollectionDeleted.php b/src/Database/Event/CollectionDeleted.php
new file mode 100644
index 000000000..2e889847c
--- /dev/null
+++ b/src/Database/Event/CollectionDeleted.php
@@ -0,0 +1,14 @@
+<?php
+
+namespace Utopia\Database\Event;
+
+use Utopia\Database\Event;
+
+class CollectionDeleted extends DomainEvent
+{
+    public function __construct(
+        string $collection,
+    ) {
+        parent::__construct($collection, Event::CollectionDelete);
+    }
+}
diff --git a/src/Database/Event/DocumentCreated.php b/src/Database/Event/DocumentCreated.php
new file mode 100644
index 000000000..4d5f2e68d
--- /dev/null
+++ b/src/Database/Event/DocumentCreated.php
@@ -0,0 +1,16 @@
+<?php
+
+namespace Utopia\Database\Event;
+
+use Utopia\Database\Document;
+use Utopia\Database\Event;
+
+class DocumentCreated extends DomainEvent
+{
+    public function __construct(
+        string $collection,
+        public readonly Document $document,
+    ) {
+        parent::__construct($collection, Event::DocumentCreate);
+    }
+}
diff --git a/src/Database/Event/DocumentDeleted.php b/src/Database/Event/DocumentDeleted.php
new file mode 100644
index 000000000..045ef18ef
--- /dev/null
+++ b/src/Database/Event/DocumentDeleted.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace Utopia\Database\Event;
+
+use Utopia\Database\Event;
+
+class DocumentDeleted extends DomainEvent
+{
+    public function __construct(
+        string $collection,
+        public readonly string $documentId,
+    ) {
+        parent::__construct($collection, Event::DocumentDelete);
+    }
+}
diff --git a/src/Database/Event/DocumentUpdated.php b/src/Database/Event/DocumentUpdated.php
new file mode 100644
index 000000000..f09959599
--- /dev/null
+++ b/src/Database/Event/DocumentUpdated.php
@@ -0,0 +1,17 @@
+<?php
+
+namespace Utopia\Database\Event;
+
+use Utopia\Database\Document;
+use Utopia\Database\Event;
+
+class DocumentUpdated extends DomainEvent
+{
+    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/DomainEvent.php b/src/Database/Event/DomainEvent.php
new file mode 100644
index 000000000..637b291b0
--- /dev/null
+++ b/src/Database/Event/DomainEvent.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace Utopia\Database\Event;
+
+use Utopia\Database\Event;
+
+class DomainEvent
+{
+    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/Event/EventDispatcherHook.php b/src/Database/Event/EventDispatcherHook.php
new file mode 100644
index 000000000..6bf8e08b5
--- /dev/null
+++ b/src/Database/Event/EventDispatcherHook.php
@@ -0,0 +1,73 @@
+<?php
+
+namespace Utopia\Database\Event;
+
+use Utopia\Database\Document;
+use Utopia\Database\Event;
+use Utopia\Database\Hook\Lifecycle;
+
+class EventDispatcherHook 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): ?DomainEvent
+    {
+        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 && isset($data->collection, $data->id)
+                    ? 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/Exception.php b/src/Database/Exception.php
index d86e94c2b..f9bd10a9f 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 a7ab33a7c..1689f8844 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 bf184803a..e308ca36d 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 8803bf902..b0a8d6746 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 5c58ef63c..b7a33dd9a 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 9fc1e907e..2f15a0689 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 65524c926..70dd72db6 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 7a5bc0f6b..25228b68c 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 a7e7168f6..2794a744c 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 781afcb86..fb26941f4 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 0ab49094e..e356766ce 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 58f699d12..ba1ebcfef 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 bcb296579..ff831e50a 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 1ef9fefd7..b6c23d127 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 26e9ce1fd..47901cf2a 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 613e74e55..3079baa53 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 3a3ddf0af..2abe9ebfb 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 9bd0ffb12..d567876f7 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 045ec5af9..28226a3a2 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/Helpers/ID.php b/src/Database/Helpers/ID.php
index 3a690a7b1..90a406ebd 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 18c4fe5a9..962065be5 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 1682cb547..951271443 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/Decorator.php b/src/Database/Hook/Decorator.php
new file mode 100644
index 000000000..5b19b437b
--- /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 000000000..18ac1b941
--- /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 000000000..45d13115e
--- /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/MongoPermissionFilter.php b/src/Database/Hook/MongoPermissionFilter.php
new file mode 100644
index 000000000..94eb7a751
--- /dev/null
+++ b/src/Database/Hook/MongoPermissionFilter.php
@@ -0,0 +1,56 @@
+<?php
+
+namespace Utopia\Database\Hook;
+
+use MongoDB\BSON\Regex;
+use Utopia\Database\Database;
+use Utopia\Database\Validator\Authorization;
+
+/**
+ * MongoDB read hook that injects permission-based regex 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 MongoPermissionFilter implements Read
+{
+    /**
+     * @param Authorization $authorization The authorization instance providing current user roles
+     */
+    public function __construct(
+        private Authorization $authorization,
+    ) {
+    }
+
+    /**
+     * Inject a regex filter matching the current user's roles against the _permissions field.
+     *
+     * @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;
+        }
+
+        $roles = \implode('|', $this->authorization->getRoles());
+        /** @var array<string, mixed> $permissionsFilter */
+        $permissionsFilter = isset($filters['_permissions']) && \is_array($filters['_permissions'])
+            ? $filters['_permissions']
+            : [];
+        $permissionsFilter['$in'] = [new Regex("{$forPermission}\\(\".*(?:{$roles}).*\"\\)", 'i')];
+        $filters['_permissions'] = $permissionsFilter;
+
+        return $filters;
+    }
+}
diff --git a/src/Database/Hook/MongoTenantFilter.php b/src/Database/Hook/MongoTenantFilter.php
new file mode 100644
index 000000000..cdfd63d12
--- /dev/null
+++ b/src/Database/Hook/MongoTenantFilter.php
@@ -0,0 +1,47 @@
+<?php
+
+namespace Utopia\Database\Hook;
+
+use Closure;
+
+/**
+ * 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 MongoTenantFilter 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['_tenant'] = ($this->getTenantFilters)($collection);
+
+        return $filters;
+    }
+}
diff --git a/src/Database/Hook/PermissionFilter.php b/src/Database/Hook/PermissionFilter.php
new file mode 100644
index 000000000..e3bc93af2
--- /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/Permissions.php b/src/Database/Hook/Permissions.php
new file mode 100644
index 000000000..c7615a585
--- /dev/null
+++ b/src/Database/Hook/Permissions.php
@@ -0,0 +1,369 @@
+<?php
+
+namespace Utopia\Database\Hook;
+
+use PDOStatement;
+use Utopia\Database\Document;
+use Utopia\Database\Event;
+use Utopia\Database\Exception as DatabaseException;
+use Utopia\Database\PermissionType;
+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)($collection.'_perms'));
+        $hasPermissions = false;
+
+        foreach ($documents as $document) {
+            foreach ($this->buildPermissionRows($document, $context) as $row) {
+                $permBuilder->set($row);
+                $hasPermissions = true;
+            }
+        }
+
+        if ($hasPermissions) {
+            $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;
+        }
+
+        $permissions = $this->readCurrentPermissions($collection, $document, $context);
+
+        /** @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 = \array_values(\array_diff($document->getPermissionsByType($type), $permissions[$type->value]));
+            if (! empty($added)) {
+                $additions[$type->value] = $added;
+            }
+        }
+
+        $this->deletePermissions($collection, $document, $removals, $context);
+        $this->insertPermissions($collection, $document, $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('$permissions')) {
+            return;
+        }
+
+        $removeConditions = [];
+        $addBuilder = ($context->createBuilder)()->into(($context->getTableRaw)($collection.'_perms'));
+        $hasAdditions = false;
+
+        foreach ($documents as $document) {
+            if ($document->getAttribute('$skipPermissionsUpdate', false)) {
+                continue;
+            }
+
+            $permissions = $this->readCurrentPermissions($collection, $document, $context);
+
+            foreach (self::PERM_TYPES as $type) {
+                $diff = \array_diff($permissions[$type->value], $updates->getPermissionsByType($type));
+                if (! empty($diff)) {
+                    $removeConditions[] = Query::and([
+                        Query::equal('_document', [$document->getId()]),
+                        Query::equal('_type', [$type->value]),
+                        Query::equal('_permission', \array_values($diff)),
+                    ]);
+                }
+            }
+
+            $metadata = $this->documentMetadata($document);
+            foreach (self::PERM_TYPES as $type) {
+                $diff = \array_diff($updates->getPermissionsByType($type), $permissions[$type->value]);
+                if (! empty($diff)) {
+                    foreach ($diff as $permission) {
+                        $row = ($context->decorateRow)([
+                            '_document' => $document->getId(),
+                            '_type' => $type->value,
+                            '_permission' => $permission,
+                        ], $metadata);
+                        $addBuilder->set($row);
+                        $hasAdditions = true;
+                    }
+                }
+            }
+        }
+
+        if (! empty($removeConditions)) {
+            $removeBuilder = ($context->newBuilder)($collection.'_perms');
+            $removeBuilder->filter([Query::or($removeConditions)]);
+            $deleteResult = $removeBuilder->delete();
+            /** @var PDOStatement $deleteStmt */
+            $deleteStmt = ($context->executeResult)($deleteResult, Event::PermissionsDelete);
+            $deleteStmt->execute();
+        }
+
+        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)($collection.'_perms'));
+        $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('_document', [$document->getId()]),
+                        Query::equal('_type', [$type->value]),
+                        Query::equal('_permission', \array_values($toRemove)),
+                    ]);
+                }
+            }
+
+            foreach (self::PERM_TYPES as $type) {
+                $toAdd = \array_diff($document->getPermissionsByType($type), $current[$type->value]);
+                foreach ($toAdd as $permission) {
+                    $row = ($context->decorateRow)([
+                        '_document' => $document->getId(),
+                        '_type' => $type->value,
+                        '_permission' => $permission,
+                    ], $metadata);
+                    $addBuilder->set($row);
+                    $hasAdditions = true;
+                }
+            }
+        }
+
+        if (! empty($removeConditions)) {
+            $removeBuilder = ($context->newBuilder)($collection.'_perms');
+            $removeBuilder->filter([Query::or($removeConditions)]);
+            $deleteResult = $removeBuilder->delete();
+            /** @var PDOStatement $deleteStmt */
+            $deleteStmt = ($context->executeResult)($deleteResult, Event::PermissionsDelete);
+            $deleteStmt->execute();
+        }
+
+        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)($collection.'_perms');
+        $permsBuilder->filter([Query::equal('_document', $documentIds)]);
+        $permsResult = $permsBuilder->delete();
+        /** @var PDOStatement $stmtPermissions */
+        $stmtPermissions = ($context->executeResult)($permsResult, Event::PermissionsDelete);
+
+        if (! $stmtPermissions->execute()) {
+            throw new DatabaseException('Failed to delete permissions');
+        }
+    }
+
+    /**
+     * @return array<string, list<string>>
+     */
+    private function readCurrentPermissions(string $collection, Document $document, WriteContext $context): array
+    {
+        $readBuilder = ($context->newBuilder)($collection.'_perms');
+        $readBuilder->select(['_type', '_permission']);
+        $readBuilder->filter([Query::equal('_document', [$document->getId()])]);
+
+        $readResult = $readBuilder->build();
+        /** @var PDOStatement $readStmt */
+        $readStmt = ($context->executeResult)($readResult, Event::PermissionsRead);
+        $readStmt->execute();
+        /** @var array<array<string, string>> $rows */
+        $rows = (array) $readStmt->fetchAll();
+        $readStmt->closeCursor();
+
+        /** @var array<string, list<string>> $initial */
+        $initial = [];
+        foreach (self::PERM_TYPES as $type) {
+            $initial[$type->value] = [];
+        }
+
+        /** @var array<string, list<string>> $result */
+        $result = \array_reduce($rows, function (array $carry, array $item) {
+            /** @var array<string, list<string>> $carry */
+            $carry[$item['_type']][] = $item['_permission'];
+
+            return $carry;
+        }, $initial);
+
+        return $result;
+    }
+
+    /**
+     * @param  array<string, list<string>>  $removals
+     */
+    private function deletePermissions(string $collection, Document $document, array $removals, WriteContext $context): void
+    {
+        if (empty($removals)) {
+            return;
+        }
+
+        $removeConditions = [];
+        foreach ($removals as $type => $perms) {
+            $removeConditions[] = Query::and([
+                Query::equal('_document', [$document->getId()]),
+                Query::equal('_type', [$type]),
+                Query::equal('_permission', $perms),
+            ]);
+        }
+
+        $removeBuilder = ($context->newBuilder)($collection.'_perms');
+        $removeBuilder->filter([Query::or($removeConditions)]);
+        $deleteResult = $removeBuilder->delete();
+        /** @var PDOStatement $deleteStmt */
+        $deleteStmt = ($context->executeResult)($deleteResult, Event::PermissionsDelete);
+        $deleteStmt->execute();
+    }
+
+    /**
+     * @param  array<string, list<string>>  $additions
+     */
+    private function insertPermissions(string $collection, Document $document, array $additions, WriteContext $context): void
+    {
+        if (empty($additions)) {
+            return;
+        }
+
+        $addBuilder = ($context->createBuilder)()->into(($context->getTableRaw)($collection.'_perms'));
+        $metadata = $this->documentMetadata($document);
+
+        foreach ($additions as $type => $perms) {
+            foreach ($perms as $permission) {
+                $row = ($context->decorateRow)([
+                    '_document' => $document->getId(),
+                    '_type' => $type,
+                    '_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 = [
+                    '_document' => $document->getId(),
+                    '_type' => $type->value,
+                    '_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 000000000..746e4ae42
--- /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 000000000..db2c0bc69
--- /dev/null
+++ b/src/Database/Hook/Relationships.php
@@ -0,0 +1,2363 @@
+<?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,
+    ) {
+    }
+
+    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,
+            fn (Document $attribute): bool => Attribute::fromDocument($attribute)->type === ColumnType::Relationship
+        );
+
+        $stackCount = \count($this->writeStack);
+
+        foreach ($relationships as $relationship) {
+            $typedRelAttr = Attribute::fromDocument($relationship);
+            $key = $typedRelAttr->key;
+            $value = $document->getAttribute($key);
+            $rel = RelationshipVO::fromDocument($collection->getId(), $relationship);
+            $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,
+            fn (Document $attribute): bool => Attribute::fromDocument($attribute)->type === ColumnType::Relationship
+        );
+
+        $stackCount = \count($this->writeStack);
+
+        foreach ($relationships as $index => $relationship) {
+            $typedRelAttr = Attribute::fromDocument($relationship);
+            $key = $typedRelAttr->key;
+            $value = $document->getAttribute($key);
+
+            $value = $this->coerceToDocument($document, $key, $value);
+
+            $oldValue = $old->getAttribute($key);
+            $rel = RelationshipVO::fromDocument($collection->getId(), $relationship);
+            $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(['$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(['$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(['$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(['$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['$permissions'])) {
+                                    $value->setAttribute('$permissions', $document->getAttribute('$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_diff($oldIds, $newIds);
+
+                            foreach ($removedDocuments as $relation) {
+                                $this->db->getAuthorization()->skip(fn () => $this->db->skipRelationships(fn () => $this->db->updateDocument(
+                                    $relatedCollection->getId(),
+                                    $relation,
+                                    new Document([$twoWayKey => null])
+                                )));
+                            }
+
+                            foreach ($value as $relation) {
+                                if (\is_string($relation)) {
+                                    $related = $this->db->skipRelationships(
+                                        fn () => $this->db->getDocument($relatedCollection->getId(), $relation, [Query::select(['$id'])])
+                                    );
+
+                                    if ($related->isEmpty()) {
+                                        continue;
+                                    }
+
+                                    $this->db->skipRelationships(fn () => $this->db->updateDocument(
+                                        $relatedCollection->getId(),
+                                        $related->getId(),
+                                        $related->setAttribute($twoWayKey, $document->getId())
+                                    ));
+                                } elseif ($relation instanceof Document) {
+                                    $related = $this->db->skipRelationships(
+                                        fn () => $this->db->getDocument($relatedCollection->getId(), $relation->getId(), [Query::select(['$id'])])
+                                    );
+
+                                    if ($related->isEmpty()) {
+                                        if (! isset($relation['$permissions'])) {
+                                            $relation->setAttribute('$permissions', $document->getAttribute('$permissions'));
+                                        }
+                                        $this->db->createDocument(
+                                            $relatedCollection->getId(),
+                                            $relation->setAttribute($twoWayKey, $document->getId())
+                                        );
+                                    } else {
+                                        $this->db->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->db->skipRelationships(
+                                fn () => $this->db->getDocument($relatedCollection->getId(), $value, [Query::select(['$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 $id.');
+                            }
+
+                            $related = $this->db->skipRelationships(
+                                fn () => $this->db->getDocument($relatedCollection->getId(), $value->getId(), [Query::select(['$id'])])
+                            );
+
+                            if ($related->isEmpty()) {
+                                if (! isset($value['$permissions'])) {
+                                    $value->setAttribute('$permissions', $document->getAttribute('$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_diff($oldIds, $newIds);
+
+                        foreach ($removedDocuments as $relation) {
+                            $junction = $this->getJunctionCollection($collection, $relatedCollection, $side);
+
+                            $junctions = $this->db->find($junction, [
+                                Query::equal($key, [$relation]),
+                                Query::equal($twoWayKey, [$document->getId()]),
+                                Query::limit(PHP_INT_MAX),
+                            ]);
+
+                            foreach ($junctions as $junction) {
+                                $this->db->getAuthorization()->skip(fn () => $this->db->deleteDocument($junction->getCollection(), $junction->getId()));
+                            }
+                        }
+
+                        foreach ($value as $relation) {
+                            if (\is_string($relation)) {
+                                if (\in_array($relation, $oldIds) || $this->db->getDocument($relatedCollection->getId(), $relation, [Query::select(['$id'])])->isEmpty()) {
+                                    continue;
+                                }
+                            } elseif ($relation instanceof Document) {
+                                $related = $this->db->getDocument($relatedCollection->getId(), $relation->getId(), [Query::select(['$id'])]);
+
+                                if ($related->isEmpty()) {
+                                    if (! isset($value['$permissions'])) {
+                                        $relation->setAttribute('$permissions', $document->getAttribute('$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(),
+                                    '$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,
+            fn (Document $attribute): bool => Attribute::fromDocument($attribute)->type === ColumnType::Relationship
+        );
+
+        foreach ($relationships as $relationship) {
+            $typedRelAttr = Attribute::fromDocument($relationship);
+            $key = $typedRelAttr->key;
+            $value = $document->getAttribute($key);
+            $rel = RelationshipVO::fromDocument($collection->getId(), $relationship);
+            $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::fromDocument($existingCollection, $processedRelationship);
+                        $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;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    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) {
+                        $typedPopAttr = Attribute::fromDocument($attribute);
+                        if ($typedPopAttr->type === ColumnType::Relationship) {
+                            if ($typedPopAttr->key === $skipKey) {
+                                continue;
+                            }
+
+                            if (! $parentHasExplicitSelects || \array_key_exists($typedPopAttr->key, $sels)) {
+                                $relationships[] = $attribute;
+                            }
+                        }
+                    }
+
+                    foreach ($relationships as $relationship) {
+                        $typedRelAttr = Attribute::fromDocument($relationship);
+                        $key = $typedRelAttr->key;
+                        $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::fromDocument($coll->getId(), $relationship);
+
+                        $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,
+                                    fn (Document $attr): bool => Attribute::fromDocument($attr)->type === ColumnType::Relationship
+                                );
+
+                                $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;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function processQueries(array $relationships, array $queries): array
+    {
+        $nestedSelections = [];
+
+        foreach ($queries as $query) {
+            if ($query->getMethod() !== Method::Select) {
+                continue;
+            }
+
+            $values = $query->getValues();
+            foreach ($values as $valueIndex => $value) {
+                /** @var string $value */
+                if (! \str_contains($value, '.')) {
+                    continue;
+                }
+
+                $nesting = \explode('.', $value);
+                $selectedKey = \array_shift($nesting);
+
+                $relationship = \array_values(\array_filter(
+                    $relationships,
+                    fn (Document $relationship) => Attribute::fromDocument($relationship)->key === $selectedKey,
+                ))[0] ?? null;
+
+                if (! $relationship) {
+                    continue;
+                }
+
+                $nestingPath = \implode('.', $nesting);
+
+                if (empty($nestingPath)) {
+                    $nestedSelections[$selectedKey][] = Query::select(['*']);
+                } else {
+                    $nestedSelections[$selectedKey][] = Query::select([$nestingPath]);
+                }
+
+                $relVO = RelationshipVO::fromDocument('', $relationship);
+
+                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;
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @throws QueryException If a relationship query references an invalid attribute
+     */
+    public function convertQueries(array $relationships, array $queries, ?Document $collection = null): ?array
+    {
+        $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::fromDocument($collectionId, $relationship);
+            $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 = '$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['$permissions'])) {
+                $relation->setAttribute('$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(),
+                '$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,
+                    '$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, Database::RELATION_QUERY_CHUNK_SIZE);
+
+        if (\count($chunks) > 1) {
+            $collectionId = $relatedCollection->getId();
+            $tasks = \array_map(
+                fn (array $chunk) => fn () => $this->db->find($collectionId, [
+                    Query::equal('$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('$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, Database::RELATION_QUERY_CHUNK_SIZE);
+
+        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, Database::RELATION_QUERY_CHUNK_SIZE);
+
+        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, Database::RELATION_QUERY_CHUNK_SIZE);
+
+        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, Database::RELATION_QUERY_CHUNK_SIZE);
+
+            if (\count($relatedChunks) > 1) {
+                $relatedCollectionId = $relatedCollection->getId();
+                $tasks = \array_map(
+                    fn (array $chunk) => fn () => $this->db->find($relatedCollectionId, [
+                        Query::equal('$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('$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(['$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(['$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(['$id']),
+                            Query::equal($twoWayKey, [$document->getId()]),
+                        ]);
+                    } else {
+                        if (empty($value)) {
+                            return;
+                        }
+                        /** @var Document $value */
+                        $related = $this->db->getDocument($relatedCollection->getId(), $value->getId(), [Query::select(['$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 */
+                foreach ($value as $relation) {
+                    $this->db->getAuthorization()->skip(function () use ($relatedCollection, $twoWayKey, $relation) {
+                        $this->db->skipRelationships(fn () => $this->db->updateDocument(
+                            $relatedCollection->getId(),
+                            $relation->getId(),
+                            new Document([
+                                $twoWayKey => null,
+                            ]),
+                        ));
+                    });
+                }
+                break;
+
+            case RelationType::ManyToOne:
+                if ($side === RelationSide::Parent) {
+                    break;
+                }
+
+                if (! $twoWay) {
+                    $value = $this->db->find($relatedCollection->getId(), [
+                        Query::select(['$id']),
+                        Query::equal($twoWayKey, [$document->getId()]),
+                        Query::limit(PHP_INT_MAX),
+                    ]);
+                }
+
+                /** @var array<Document> $value */
+                foreach ($value as $relation) {
+                    $this->db->getAuthorization()->skip(function () use ($relatedCollection, $twoWayKey, $relation) {
+                        $this->db->skipRelationships(fn () => $this->db->updateDocument(
+                            $relatedCollection->getId(),
+                            $relation->getId(),
+                            new Document([
+                                $twoWayKey => null,
+                            ])
+                        ));
+                    });
+                }
+                break;
+
+            case RelationType::ManyToMany:
+                $junction = $this->getJunctionCollection($collection, $relatedCollection, $side);
+
+                $junctions = $this->db->find($junction, [
+                    Query::select(['$id']),
+                    Query::equal($twoWayKey, [$document->getId()]),
+                    Query::limit(PHP_INT_MAX),
+                ]);
+
+                foreach ($junctions as $document) {
+                    $this->db->skipRelationships(fn () => $this->db->deleteDocument(
+                        $junction,
+                        $document->getId()
+                    ));
+                }
+                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 */
+                foreach ($value as $relation) {
+                    $this->db->deleteDocument(
+                        $relatedCollection->getId(),
+                        $relation->getId()
+                    );
+                }
+
+                \array_pop($this->deleteStack);
+
+                break;
+            case RelationType::ManyToOne:
+                if ($side === RelationSide::Parent) {
+                    break;
+                }
+
+                $value = $this->db->find($relatedCollection->getId(), [
+                    Query::select(['$id']),
+                    Query::equal($twoWayKey, [$document->getId()]),
+                    Query::limit(PHP_INT_MAX),
+                ]);
+
+                $this->deleteStack[] = $relationship;
+
+                foreach ($value as $relation) {
+                    $this->db->deleteDocument(
+                        $relatedCollection->getId(),
+                        $relation->getId()
+                    );
+                }
+
+                \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(['$id', $key]),
+                    Query::equal($twoWayKey, [$document->getId()]),
+                    Query::limit(PHP_INT_MAX),
+                ]));
+
+                $this->deleteStack[] = $relationship;
+
+                foreach ($junctions as $document) {
+                    if ($side === RelationSide::Parent) {
+                        $relatedAttr = $document->getAttribute($key);
+                        $relatedId = $relatedAttr instanceof Document ? $relatedAttr->getId() : (\is_string($relatedAttr) ? $relatedAttr : null);
+                        if ($relatedId !== null) {
+                            $this->db->deleteDocument(
+                                $relatedCollection->getId(),
+                                $relatedId
+                            );
+                        }
+                    }
+                    $this->db->deleteDocument(
+                        $junction,
+                        $document->getId()
+                    );
+                }
+
+                \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::fromDocument($currentCollection, $relationship);
+                $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(['$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('$id', $matchingIds),
+                                Query::select(['$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(['$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('$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(['$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' => '$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' => '$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(['$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 000000000..bd3455fc6
--- /dev/null
+++ b/src/Database/Hook/Tenancy.php
@@ -0,0 +1,34 @@
+<?php
+
+namespace Utopia\Database\Hook;
+
+/**
+ * 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 = '_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 000000000..5e12ae2c7
--- /dev/null
+++ b/src/Database/Hook/TenantFilter.php
@@ -0,0 +1,56 @@
+<?php
+
+namespace Utopia\Database\Hook;
+
+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)
+     */
+    public function __construct(
+        private int|string $tenant,
+        private string $metadataCollection = '',
+        private string $collection = ''
+    ) {
+    }
+
+    public function filter(string $table): Condition
+    {
+        // Only qualify with table/alias when it looks like a simple alias (no dots/backticks)
+        // This avoids breaking subqueries where $table is a fully-qualified raw table name
+        $prefix = (!\str_contains($table, '.') && !\str_contains($table, '`')) ? "{$table}." : '';
+
+        // Check the actual collection name against the metadata collection, not the alias
+        $name = $this->collection !== '' ? $this->collection : $table;
+
+        if (! empty($this->metadataCollection) && \str_contains($name, $this->metadataCollection)) {
+            return new Condition("({$prefix}_tenant IN (?) OR {$prefix}_tenant IS NULL)", [$this->tenant]);
+        }
+
+        return new Condition("{$prefix}_tenant IN (?)", [$this->tenant]);
+    }
+
+    public function filterJoin(string $table, JoinType $joinType): ?JoinCondition
+    {
+        $condition = new Condition("{$table}._tenant IN (?)", [$this->tenant]);
+
+        $placement = match ($joinType) {
+            JoinType::Left, JoinType::Right => 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 000000000..1271b00aa
--- /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 000000000..bfe71319f
--- /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 000000000..c9ce6eff6
--- /dev/null
+++ b/src/Database/Hook/WriteContext.php
@@ -0,0 +1,31 @@
+<?php
+
+namespace Utopia\Database\Hook;
+
+use Closure;
+use Utopia\Database\Event;
+use Utopia\Query\Builder\Plan;
+
+/**
+ * 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(Plan, Event=): mixed  $executeResult  Prepare a Plan with optional event trigger, returns PDO statement
+     * @param  Closure(mixed): 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
+     */
+    public function __construct(
+        public Closure $newBuilder,
+        public Closure $executeResult,
+        public Closure $execute,
+        public Closure $decorateRow,
+        public Closure $createBuilder,
+        public Closure $getTableRaw,
+    ) {
+    }
+}
diff --git a/src/Database/Index.php b/src/Database/Index.php
new file mode 100644
index 000000000..1731edb08
--- /dev/null
+++ b/src/Database/Index.php
@@ -0,0 +1,96 @@
+<?php
+
+namespace Utopia\Database;
+
+use Utopia\Database\Helpers\ID;
+use Utopia\Query\Schema\IndexType;
+
+/**
+ * Represents a database index with its type, target attributes, and configuration.
+ */
+class Index
+{
+    /**
+     * @param  array<string>  $attributes
+     * @param  array<int|null>  $lengths
+     * @param  array<string|null>  $orders
+     */
+    public function __construct(
+        public string $key,
+        public IndexType $type,
+        public array $attributes = [],
+        public array $lengths = [],
+        public array $orders = [],
+        public int $ttl = 1,
+    ) {
+    }
+
+    /**
+     * Convert this index to a Document representation.
+     *
+     * @return Document
+     */
+    public function toDocument(): Document
+    {
+        return new Document([
+            '$id' => ID::custom($this->key),
+            'key' => $this->key,
+            'type' => $this->type->value,
+            'attributes' => $this->attributes,
+            'lengths' => $this->lengths,
+            'orders' => $this->orders,
+            'ttl' => $this->ttl,
+        ]);
+    }
+
+    /**
+     * Create an Index instance from a Document.
+     *
+     * @param Document $document The document to convert
+     * @return self
+     */
+    /**
+     * 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';
+
+        return new self(
+            key: $data['$id'] ?? $data['key'] ?? '',
+            type: $type instanceof IndexType ? $type : IndexType::from((string) $type),
+            attributes: $data['attributes'] ?? [],
+            lengths: $data['lengths'] ?? [],
+            orders: $data['orders'] ?? [],
+            ttl: $data['ttl'] ?? 1,
+        );
+    }
+
+    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<string> $orders */
+        $orders = $document->getAttribute('orders', []);
+        /** @var int $ttl */
+        $ttl = $document->getAttribute('ttl', 1);
+
+        return new self(
+            key: $key,
+            type: IndexType::from($type),
+            attributes: $attributes,
+            lengths: $lengths,
+            orders: $orders,
+            ttl: $ttl,
+        );
+    }
+}
diff --git a/src/Database/Loading/BatchLoader.php b/src/Database/Loading/BatchLoader.php
new file mode 100644
index 000000000..d67e53e76
--- /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('$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 000000000..5756f71a5
--- /dev/null
+++ b/src/Database/Loading/LazyProxy.php
@@ -0,0 +1,92 @@
+<?php
+
+namespace Utopia\Database\Loading;
+
+use Utopia\Database\Document;
+
+class LazyProxy extends Document
+{
+    private bool $resolved = false;
+
+    private ?Document $realDocument = null;
+
+    private ?BatchLoader $batchLoader;
+
+    private string $targetCollection;
+
+    private string $targetId;
+
+    public function __construct(BatchLoader $batchLoader, string $targetCollection, string $targetId)
+    {
+        parent::__construct(['$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;
+        $this->realDocument = $document;
+
+        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);
+
+        if (! $this->resolved) {
+            $this->resolved = true;
+        }
+    }
+}
diff --git a/src/Database/Loading/LoadingStrategy.php b/src/Database/Loading/LoadingStrategy.php
new file mode 100644
index 000000000..e9614d382
--- /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 000000000..d36b970ff
--- /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/Migration/Migration.php b/src/Database/Migration/Migration.php
new file mode 100644
index 000000000..b3ae3332d
--- /dev/null
+++ b/src/Database/Migration/Migration.php
@@ -0,0 +1,19 @@
+<?php
+
+namespace Utopia\Database\Migration;
+
+use Utopia\Database\Database;
+
+abstract class Migration
+{
+    abstract public function version(): string;
+
+    abstract public function up(Database $db): void;
+
+    abstract public function down(Database $db): void;
+
+    public function name(): string
+    {
+        return static::class;
+    }
+}
diff --git a/src/Database/Migration/MigrationGenerator.php b/src/Database/Migration/MigrationGenerator.php
new file mode 100644
index 000000000..bfa34a5d8
--- /dev/null
+++ b/src/Database/Migration/MigrationGenerator.php
@@ -0,0 +1,141 @@
+<?php
+
+namespace Utopia\Database\Migration;
+
+use Utopia\Database\Schema\DiffResult;
+use Utopia\Database\Schema\SchemaChange;
+use Utopia\Database\Schema\SchemaChangeType;
+
+class MigrationGenerator
+{
+    public function generate(DiffResult $diff, string $className, string $namespace = 'App\\Migration'): string
+    {
+        $version = $this->extractVersion($className);
+        $upLines = [];
+        $downLines = [];
+
+        foreach ($diff->changes as $change) {
+            $up = $this->generateUpStatement($change);
+            $down = $this->generateDownStatement($change);
+
+            if ($up !== null) {
+                $upLines[] = "        {$up}";
+            }
+
+            if ($down !== null) {
+                $downLines[] = "        {$down}";
+            }
+        }
+
+        $upBody = $upLines !== [] ? \implode("\n", $upLines) : '        // No changes';
+        $downBody = $downLines !== [] ? \implode("\n", $downLines) : '        // No changes';
+
+        return <<<PHP
+        <?php
+
+        namespace {$namespace};
+
+        use Utopia\Database\Database;
+        use Utopia\Database\Migration\Migration;
+
+        class {$className} extends Migration
+        {
+            public function version(): string
+            {
+                return '{$version}';
+            }
+
+            public function up(Database \$db): void
+            {
+        {$upBody}
+            }
+
+            public function down(Database \$db): void
+            {
+        {$downBody}
+            }
+        }
+
+        PHP;
+    }
+
+    public function generateEmpty(string $className, string $namespace = 'App\\Migration'): string
+    {
+        $version = $this->extractVersion($className);
+
+        return <<<PHP
+        <?php
+
+        namespace {$namespace};
+
+        use Utopia\Database\Database;
+        use Utopia\Database\Migration\Migration;
+
+        class {$className} extends Migration
+        {
+            public function version(): string
+            {
+                return '{$version}';
+            }
+
+            public function up(Database \$db): void
+            {
+                //
+            }
+
+            public function down(Database \$db): void
+            {
+                //
+            }
+        }
+
+        PHP;
+    }
+
+    private function extractVersion(string $className): string
+    {
+        if (\preg_match('/^V(\d+)_/', $className, $matches)) {
+            return $matches[1];
+        }
+
+        return $className;
+    }
+
+    private function generateUpStatement(SchemaChange $change): ?string
+    {
+        return match ($change->type) {
+            SchemaChangeType::AddAttribute => $change->attribute !== null
+                ? "\$db->createAttribute('{collectionId}', new \\Utopia\\Database\\Attribute(key: '{$change->attribute->key}', type: \\Utopia\\Query\\Schema\\ColumnType::" . \ucfirst($change->attribute->type->value) . ", size: {$change->attribute->size}));"
+                : null,
+            SchemaChangeType::DropAttribute => $change->attribute !== null
+                ? "\$db->deleteAttribute('{collectionId}', '{$change->attribute->key}');"
+                : null,
+            SchemaChangeType::AddIndex => $change->index !== null
+                ? "\$db->createIndex('{collectionId}', new \\Utopia\\Database\\Index(key: '{$change->index->key}', type: \\Utopia\\Query\\Schema\\IndexType::" . \ucfirst($change->index->type->value) . ", attributes: " . \var_export($change->index->attributes, true) . '));\\'
+                : null,
+            SchemaChangeType::DropIndex => $change->index !== null
+                ? "\$db->deleteIndex('{collectionId}', '{$change->index->key}');"
+                : null,
+            default => null,
+        };
+    }
+
+    private function generateDownStatement(SchemaChange $change): ?string
+    {
+        return match ($change->type) {
+            SchemaChangeType::AddAttribute => $change->attribute !== null
+                ? "\$db->deleteAttribute('{collectionId}', '{$change->attribute->key}');"
+                : null,
+            SchemaChangeType::DropAttribute => $change->attribute !== null
+                ? "\$db->createAttribute('{collectionId}', new \\Utopia\\Database\\Attribute(key: '{$change->attribute->key}', type: \\Utopia\\Query\\Schema\\ColumnType::" . \ucfirst($change->attribute->type->value) . ", size: {$change->attribute->size}));"
+                : null,
+            SchemaChangeType::AddIndex => $change->index !== null
+                ? "\$db->deleteIndex('{collectionId}', '{$change->index->key}');"
+                : null,
+            SchemaChangeType::DropIndex => $change->index !== null
+                ? "\$db->createIndex('{collectionId}', new \\Utopia\\Database\\Index(key: '{$change->index->key}', type: \\Utopia\\Query\\Schema\\IndexType::" . \ucfirst($change->index->type->value) . ", attributes: " . \var_export($change->index->attributes, true) . '));\\'
+                : null,
+            default => null,
+        };
+    }
+}
diff --git a/src/Database/Migration/MigrationRunner.php b/src/Database/Migration/MigrationRunner.php
new file mode 100644
index 000000000..4a6eb3987
--- /dev/null
+++ b/src/Database/Migration/MigrationRunner.php
@@ -0,0 +1,128 @@
+<?php
+
+namespace Utopia\Database\Migration;
+
+use Utopia\Database\Database;
+
+class MigrationRunner
+{
+    private Database $db;
+
+    private MigrationTracker $tracker;
+
+    public function __construct(Database $db, ?MigrationTracker $tracker = null)
+    {
+        $this->db = $db;
+        $this->tracker = $tracker ?? new MigrationTracker($db);
+    }
+
+    /**
+     * @param  array<Migration>  $migrations
+     */
+    public function migrate(array $migrations): int
+    {
+        $this->tracker->setup();
+        $executed = $this->tracker->getAppliedVersions();
+        $batch = $this->tracker->getLastBatch() + 1;
+
+        $pending = \array_filter(
+            $migrations,
+            fn (Migration $m) => ! \in_array($m->version(), $executed, true)
+        );
+
+        \usort($pending, fn (Migration $a, Migration $b) => \strcmp($a->version(), $b->version()));
+
+        $count = 0;
+
+        foreach ($pending as $migration) {
+            $this->db->withTransaction(function () use ($migration, $batch): void {
+                $migration->up($this->db);
+                $this->tracker->markApplied($migration->version(), $migration->name(), $batch);
+            });
+            $count++;
+        }
+
+        return $count;
+    }
+
+    /**
+     * @param  array<Migration>  $migrations
+     */
+    public function rollback(array $migrations, int $steps = 1): int
+    {
+        $this->tracker->setup();
+        $lastBatch = $this->tracker->getLastBatch();
+        $count = 0;
+
+        $migrationsByVersion = [];
+        foreach ($migrations as $migration) {
+            $migrationsByVersion[$migration->version()] = $migration;
+        }
+
+        for ($batch = $lastBatch; $batch > $lastBatch - $steps && $batch > 0; $batch--) {
+            $applied = $this->tracker->getByBatch($batch);
+
+            foreach ($applied as $doc) {
+                $version = $doc->getAttribute('version', '');
+
+                if (isset($migrationsByVersion[$version])) {
+                    $this->db->withTransaction(function () use ($migrationsByVersion, $version): void {
+                        $migrationsByVersion[$version]->down($this->db);
+                        $this->tracker->markRolledBack($version);
+                    });
+                    $count++;
+                }
+            }
+        }
+
+        return $count;
+    }
+
+    /**
+     * @param  array<Migration>  $migrations
+     * @return array<array{version: string, name: string, applied: bool}>
+     */
+    public function status(array $migrations): array
+    {
+        $this->tracker->setup();
+        $executed = $this->tracker->getAppliedVersions();
+        $status = [];
+
+        \usort($migrations, fn (Migration $a, Migration $b) => \strcmp($a->version(), $b->version()));
+
+        foreach ($migrations as $migration) {
+            $status[] = [
+                'version' => $migration->version(),
+                'name' => $migration->name(),
+                'applied' => \in_array($migration->version(), $executed, true),
+            ];
+        }
+
+        return $status;
+    }
+
+    /**
+     * @param  array<Migration>  $migrations
+     */
+    public function fresh(array $migrations): int
+    {
+        $collections = $this->db->listCollections();
+
+        foreach ($collections as $collection) {
+            $id = $collection->getId();
+            if ($id !== '_metadata' && $id !== '') {
+                try {
+                    $this->db->deleteCollection($id);
+                } catch (\Throwable) {
+                }
+            }
+        }
+
+        return $this->migrate($migrations);
+    }
+
+    public function getTracker(): MigrationTracker
+    {
+        return $this->tracker;
+    }
+}
diff --git a/src/Database/Migration/MigrationTracker.php b/src/Database/Migration/MigrationTracker.php
new file mode 100644
index 000000000..be3ead79c
--- /dev/null
+++ b/src/Database/Migration/MigrationTracker.php
@@ -0,0 +1,128 @@
+<?php
+
+namespace Utopia\Database\Migration;
+
+use Utopia\Database\Attribute;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Helpers\ID;
+use Utopia\Database\Query;
+use Utopia\Query\Schema\ColumnType;
+
+class MigrationTracker
+{
+    private const COLLECTION = '_migrations';
+
+    private Database $db;
+
+    private bool $initialized = false;
+
+    public function __construct(Database $db)
+    {
+        $this->db = $db;
+    }
+
+    public function setup(): void
+    {
+        if ($this->initialized) {
+            return;
+        }
+
+        if ($this->db->exists($this->db->getAdapter()->getDatabase(), self::COLLECTION)) {
+            $this->initialized = true;
+
+            return;
+        }
+
+        $this->db->createCollection(
+            id: self::COLLECTION,
+            attributes: [
+                new Attribute(key: 'version', type: ColumnType::String, size: 255, required: true),
+                new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true),
+                new Attribute(key: 'batch', type: ColumnType::Integer, size: 0, required: true),
+                new Attribute(key: 'appliedAt', type: ColumnType::Datetime, size: 0, required: false, filters: ['datetime']),
+            ],
+        );
+
+        $this->initialized = true;
+    }
+
+    /**
+     * @return array<Document>
+     */
+    public function getApplied(): array
+    {
+        $this->setup();
+
+        return $this->db->find(self::COLLECTION, [
+            Query::orderAsc('version'),
+        ]);
+    }
+
+    /**
+     * @return array<string>
+     */
+    public function getAppliedVersions(): array
+    {
+        return \array_map(
+            fn (Document $doc) => $doc->getAttribute('version', ''),
+            $this->getApplied()
+        );
+    }
+
+    public function markApplied(string $version, string $name, int $batch): void
+    {
+        $this->setup();
+
+        $this->db->createDocument(self::COLLECTION, new Document([
+            '$id' => ID::unique(),
+            'version' => $version,
+            'name' => $name,
+            'batch' => $batch,
+            'appliedAt' => \date('Y-m-d H:i:s'),
+        ]));
+    }
+
+    public function markRolledBack(string $version): void
+    {
+        $this->setup();
+
+        $docs = $this->db->find(self::COLLECTION, [
+            Query::equal('version', [$version]),
+            Query::limit(1),
+        ]);
+
+        if ($docs !== []) {
+            $this->db->deleteDocument(self::COLLECTION, $docs[0]->getId());
+        }
+    }
+
+    public function getLastBatch(): int
+    {
+        $this->setup();
+
+        $docs = $this->db->find(self::COLLECTION, [
+            Query::orderDesc('batch'),
+            Query::limit(1),
+        ]);
+
+        if ($docs === []) {
+            return 0;
+        }
+
+        return (int) $docs[0]->getAttribute('batch', 0);
+    }
+
+    /**
+     * @return array<Document>
+     */
+    public function getByBatch(int $batch): array
+    {
+        $this->setup();
+
+        return $this->db->find(self::COLLECTION, [
+            Query::equal('batch', [$batch]),
+            Query::orderDesc('version'),
+        ]);
+    }
+}
diff --git a/src/Database/Migration/Strategy/ExpandContract.php b/src/Database/Migration/Strategy/ExpandContract.php
new file mode 100644
index 000000000..03227d1f8
--- /dev/null
+++ b/src/Database/Migration/Strategy/ExpandContract.php
@@ -0,0 +1,61 @@
+<?php
+
+namespace Utopia\Database\Migration\Strategy;
+
+use Utopia\Database\Attribute;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Query;
+
+class ExpandContract
+{
+    public function expand(Database $db, string $collection, Attribute $newAttribute): void
+    {
+        $db->createAttribute($collection, $newAttribute);
+    }
+
+    public function migrate(Database $db, string $collection, string $oldKey, string $newKey, callable $transform, int $batchSize = 100): int
+    {
+        $count = 0;
+        $lastDocument = null;
+
+        while (true) {
+            $queries = [Query::limit($batchSize)];
+
+            if ($lastDocument !== null) {
+                $queries[] = Query::cursorAfter($lastDocument);
+            }
+
+            $documents = $db->find($collection, $queries);
+
+            if ($documents === []) {
+                break;
+            }
+
+            foreach ($documents as $doc) {
+                $oldValue = $doc->getAttribute($oldKey);
+                $newValue = $transform($oldValue);
+
+                $db->updateDocument($collection, $doc->getId(), new Document([
+                    '$id' => $doc->getId(),
+                    $newKey => $newValue,
+                ]));
+
+                $count++;
+            }
+
+            $lastDocument = \end($documents);
+
+            if (\count($documents) < $batchSize) {
+                break;
+            }
+        }
+
+        return $count;
+    }
+
+    public function contract(Database $db, string $collection, string $oldKey): void
+    {
+        $db->deleteAttribute($collection, $oldKey);
+    }
+}
diff --git a/src/Database/Migration/Strategy/OnlineSchemaChange.php b/src/Database/Migration/Strategy/OnlineSchemaChange.php
new file mode 100644
index 000000000..1dfb52c97
--- /dev/null
+++ b/src/Database/Migration/Strategy/OnlineSchemaChange.php
@@ -0,0 +1,28 @@
+<?php
+
+namespace Utopia\Database\Migration\Strategy;
+
+use Utopia\Database\Database;
+
+class OnlineSchemaChange
+{
+    public function alter(Database $db, string $collection, callable $changes): void
+    {
+        $adapter = $db->getAdapter();
+
+        $hadLocks = true;
+
+        if (\method_exists($adapter, 'enableAlterLocks')) {
+            $hadLocks = true;
+            $adapter->enableAlterLocks(false);
+        }
+
+        try {
+            $changes($db, $collection);
+        } finally {
+            if (\method_exists($adapter, 'enableAlterLocks') && $hadLocks) {
+                $adapter->enableAlterLocks(true);
+            }
+        }
+    }
+}
diff --git a/src/Database/Mirror.php b/src/Database/Mirror.php
index f740cab3e..250fc5bb2 100644
--- a/src/Database/Mirror.php
+++ b/src/Database/Mirror.php
@@ -2,15 +2,29 @@
 
 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\OrderDirection;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\ForeignKeyAction;
+use Utopia\Query\Schema\IndexType;
+
+/**
+ * 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 +37,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 +49,37 @@ 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;
     }
 
+    /**
+     * Get the destination database instance, if configured.
+     *
+     * @return Database|null
+     */
     public function getDestination(): ?Database
     {
         return $this->destination;
@@ -72,8 +94,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,27 +102,28 @@ 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());
@@ -109,6 +131,9 @@ public function setDatabase(string $name): static
         return $this;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function setNamespace(string $namespace): static
     {
         $this->delegate(__FUNCTION__, \func_get_args());
@@ -116,6 +141,9 @@ public function setNamespace(string $namespace): static
         return $this;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function setSharedTables(bool $sharedTables): static
     {
         $this->delegate(__FUNCTION__, \func_get_args());
@@ -123,6 +151,9 @@ public function setSharedTables(bool $sharedTables): static
         return $this;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function setTenant(int|string|null $tenant): static
     {
         $this->delegate(__FUNCTION__, \func_get_args());
@@ -130,6 +161,9 @@ public function setTenant(int|string|null $tenant): static
         return $this;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function setPreserveDates(bool $preserve): static
     {
         $this->delegate(__FUNCTION__, \func_get_args());
@@ -139,6 +173,9 @@ public function setPreserveDates(bool $preserve): static
         return $this;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function setPreserveSequence(bool $preserve): static
     {
         $this->delegate(__FUNCTION__, \func_get_args());
@@ -148,6 +185,9 @@ public function setPreserveSequence(bool $preserve): static
         return $this;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function enableValidation(): static
     {
         $this->delegate(__FUNCTION__);
@@ -157,6 +197,9 @@ public function enableValidation(): static
         return $this;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function disableValidation(): static
     {
         $this->delegate(__FUNCTION__);
@@ -166,43 +209,70 @@ public function disableValidation(): static
         return $this;
     }
 
-    public function on(string $event, string $name, ?callable $callback): static
+    /**
+     * {@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());
+        /** @var bool $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        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;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function createCollection(string $id, array $attributes = [], array $indexes = [], ?array $permissions = null, bool $documentSecurity = true): Document
     {
         $result = $this->source->createCollection(
@@ -219,12 +289,15 @@ 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,
                     collection: $result,
                 );
+                if ($filtered !== null) {
+                    $result = $filtered;
+                }
             }
 
             $this->destination->createCollection(
@@ -241,15 +314,19 @@ public function createCollection(string $id, array $attributes = [], array $inde
                 $this->source->createDocument('upgrades', new Document([
                     '$id' => $id,
                     'collectionId' => $id,
-                    'status' => 'upgraded'
+                    'status' => 'upgraded',
                 ]));
             });
-        } catch (\Throwable $err) {
+        } catch (Throwable $err) {
             $this->logError('createCollection', $err);
         }
+
         return $result;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function updateCollection(string $id, array $permissions, bool $documentSecurity): Document
     {
         $result = $this->source->updateCollection($id, $permissions, $documentSecurity);
@@ -260,22 +337,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);
@@ -294,77 +377,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);
@@ -374,32 +436,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,
@@ -422,36 +499,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);
@@ -471,56 +556,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);
@@ -540,13 +623,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);
@@ -587,13 +673,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,
@@ -621,50 +710,55 @@ public function createDocuments(
             return $modified;
         }
 
-        try {
-            $clones = [];
-
-            foreach ($documents as $document) {
-                $clone = clone $document;
+        $clones = [];
+        $destination = $this->destination;
 
-                foreach ($this->writeFilters as $filter) {
-                    $clone = $filter->beforeCreateDocument(
-                        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->beforeCreateDocument(
+                    source: $this->source,
+                    destination: $destination,
+                    collectionId: $collection,
+                    document: $clone,
+                );
             }
 
-            $this->destination->withPreserveDates(
-                fn () =>
-                $this->destination->createDocuments(
-                    $collection,
-                    $clones,
-                    $batchSize,
-                )
-            );
+            $clones[] = $clone;
+        }
 
-            foreach ($clones as $clone) {
-                foreach ($this->writeFilters as $filter) {
-                    $filter->afterCreateDocument(
-                        source: $this->source,
-                        destination: $this->destination,
-                        collectionId: $collection,
-                        document: $clone,
-                    );
+        Promise::async(function () use ($destination, $collection, $clones, $batchSize) {
+            try {
+                $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);
@@ -706,13 +800,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,
@@ -742,45 +839,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,
@@ -808,50 +910,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);
@@ -868,33 +975,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 = [],
@@ -922,112 +1035,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;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function increaseDocumentAttribute(string $collection, string $id, string $attribute, int|float $value = 1, int|float|null $max = null): Document
     {
-        return $this->delegate(__FUNCTION__, \func_get_args());
+        /** @var Document $result */
+        $result = $this->delegate(__FUNCTION__, \func_get_args());
+        return $result;
     }
 
+    /**
+     * {@inheritdoc}
+     */
     public function decreaseDocumentAttribute(string $collection, string $id, string $attribute, int|float $value = 1, int|float|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
@@ -1036,51 +1207,40 @@ 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' => ''
-                ]),
+                new Attribute(
+                    key: 'collectionId',
+                    type: ColumnType::String,
+                    size: Database::LENGTH_KEY,
+                    required: true,
+                ),
+                new Attribute(
+                    key: 'status',
+                    type: ColumnType::String,
+                    size: Database::LENGTH_KEY,
+                    required: false,
+                ),
             ],
             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],
-                ]),
+                new Index(
+                    key: '_unique_collection',
+                    type: IndexType::Unique,
+                    attributes: ['collectionId'],
+                    lengths: [Database::LENGTH_KEY],
+                ),
+                new Index(
+                    key: '_status_index',
+                    type: IndexType::Key,
+                    attributes: ['status'],
+                    lengths: [Database::LENGTH_KEY],
+                    orders: [OrderDirection::Asc->value],
+                ),
             ],
         );
     }
@@ -1097,53 +1257,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
     {
@@ -1155,8 +1335,6 @@ public function clearDocumentType(string $collection): static
 
     /**
      * Clear all document type mappings
-     *
-     * @return static
      */
     public function clearAllDocumentTypes(): static
     {
@@ -1165,5 +1343,4 @@ public function clearAllDocumentTypes(): static
 
         return $this;
     }
-
 }
diff --git a/src/Database/Mirroring/Filter.php b/src/Database/Mirroring/Filter.php
index 2da00534b..b1e61b271 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/ORM/ColumnMapping.php b/src/Database/ORM/ColumnMapping.php
new file mode 100644
index 000000000..bd9d8b27b
--- /dev/null
+++ b/src/Database/ORM/ColumnMapping.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace Utopia\Database\ORM;
+
+use Utopia\Database\ORM\Mapping\Column;
+
+class ColumnMapping
+{
+    public function __construct(
+        public readonly string $propertyName,
+        public readonly string $documentKey,
+        public readonly Column $column,
+    ) {
+    }
+}
diff --git a/src/Database/ORM/EmbeddableMapping.php b/src/Database/ORM/EmbeddableMapping.php
new file mode 100644
index 000000000..f6d74d468
--- /dev/null
+++ b/src/Database/ORM/EmbeddableMapping.php
@@ -0,0 +1,13 @@
+<?php
+
+namespace Utopia\Database\ORM;
+
+class EmbeddableMapping
+{
+    public function __construct(
+        public readonly string $propertyName,
+        public readonly string $typeName,
+        public readonly string $prefix,
+    ) {
+    }
+}
diff --git a/src/Database/ORM/EntityManager.php b/src/Database/ORM/EntityManager.php
new file mode 100644
index 000000000..1f44335e9
--- /dev/null
+++ b/src/Database/ORM/EntityManager.php
@@ -0,0 +1,212 @@
+<?php
+
+namespace Utopia\Database\ORM;
+
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Query;
+
+class EntityManager
+{
+    private UnitOfWork $unitOfWork;
+
+    private IdentityMap $identityMap;
+
+    private MetadataFactory $metadataFactory;
+
+    private EntityMapper $entityMapper;
+
+    private Database $db;
+
+    public function __construct(Database $db)
+    {
+        $this->db = $db;
+        $this->identityMap = new IdentityMap();
+        $this->metadataFactory = new MetadataFactory();
+        $this->entityMapper = new EntityMapper($this->metadataFactory);
+        $this->unitOfWork = new UnitOfWork(
+            $this->identityMap,
+            $this->metadataFactory,
+            $this->entityMapper,
+        );
+    }
+
+    public function persist(object $entity): void
+    {
+        $this->unitOfWork->persist($entity);
+    }
+
+    public function remove(object $entity): void
+    {
+        $this->unitOfWork->remove($entity);
+    }
+
+    public function forceRemove(object $entity): void
+    {
+        $this->unitOfWork->forceRemove($entity);
+    }
+
+    public function restore(object $entity): void
+    {
+        $this->unitOfWork->restore($entity);
+    }
+
+    public function flush(): void
+    {
+        $this->unitOfWork->flush($this->db);
+    }
+
+    /**
+     * @template T of object
+     * @param  class-string<T>  $className
+     * @return T|null
+     */
+    public function find(string $className, string $id): ?object
+    {
+        $metadata = $this->metadataFactory->getMetadata($className);
+
+        $existing = $this->identityMap->get($metadata->collection, $id);
+        if ($existing !== null) {
+            /** @var T $existing */
+            return $existing;
+        }
+
+        $document = $this->db->getDocument($metadata->collection, $id);
+
+        if ($document->isEmpty()) {
+            return null;
+        }
+
+        /** @var T $entity */
+        $entity = $this->entityMapper->toEntity($document, $metadata, $this->identityMap);
+        $this->unitOfWork->registerManaged($entity, $metadata);
+
+        return $entity;
+    }
+
+    /**
+     * @template T of object
+     * @param  class-string<T>  $className
+     * @param  array<Query>  $queries
+     * @return array<T>
+     */
+    public function findMany(string $className, array $queries = [], bool $withTrashed = false): array
+    {
+        $metadata = $this->metadataFactory->getMetadata($className);
+
+        if (! $withTrashed && $metadata->softDeleteColumn !== null) {
+            $queries[] = Query::isNull($metadata->softDeleteColumn);
+        }
+
+        $documents = $this->db->find($metadata->collection, $queries);
+        $entities = [];
+
+        foreach ($documents as $document) {
+            /** @var T $entity */
+            $entity = $this->entityMapper->toEntity($document, $metadata, $this->identityMap);
+            $this->unitOfWork->registerManaged($entity, $metadata);
+            $entities[] = $entity;
+        }
+
+        return $entities;
+    }
+
+    /**
+     * @template T of object
+     * @param  class-string<T>  $className
+     * @param  array<Query>  $queries
+     * @return T|null
+     */
+    public function findOne(string $className, array $queries = []): ?object
+    {
+        $queries[] = Query::limit(1);
+        $results = $this->findMany($className, $queries);
+
+        if ($results === []) {
+            return null;
+        }
+
+        /** @var T */
+        return $results[0];
+    }
+
+    public function createCollectionFromEntity(string $className): Document
+    {
+        $metadata = $this->metadataFactory->getMetadata($className);
+        $defs = $this->entityMapper->toCollectionDefinitions($metadata);
+
+        /** @var \Utopia\Database\Collection $collection */
+        $collection = $defs['collection'];
+        /** @var array<\Utopia\Database\Relationship> $relationships */
+        $relationships = $defs['relationships'];
+
+        $doc = $this->db->createCollection(
+            id: $collection->id,
+            attributes: $collection->attributes,
+            indexes: $collection->indexes,
+            permissions: $collection->permissions !== [] ? $collection->permissions : null,
+            documentSecurity: $collection->documentSecurity,
+        );
+
+        foreach ($relationships as $relationship) {
+            $this->db->createRelationship($relationship);
+        }
+
+        return $doc;
+    }
+
+    public function syncCollectionFromEntity(string $className): void
+    {
+        $metadata = $this->metadataFactory->getMetadata($className);
+        $defs = $this->entityMapper->toCollectionDefinitions($metadata);
+
+        /** @var \Utopia\Database\Collection $desired */
+        $desired = $defs['collection'];
+
+        if (! $this->db->exists($this->db->getAdapter()->getDatabase(), $metadata->collection)) {
+            $this->createCollectionFromEntity($className);
+
+            return;
+        }
+
+        $currentDoc = $this->db->getCollection($metadata->collection);
+        $current = \Utopia\Database\Collection::fromDocument($currentDoc);
+
+        $differ = new \Utopia\Database\Schema\SchemaDiff();
+        $diff = $differ->diff($current, $desired);
+
+        if ($diff->hasChanges()) {
+            $diff->apply($this->db, $metadata->collection);
+        }
+    }
+
+    public function detach(object $entity): void
+    {
+        $this->unitOfWork->detach($entity);
+    }
+
+    public function clear(): void
+    {
+        $this->unitOfWork->clear();
+    }
+
+    public function getUnitOfWork(): UnitOfWork
+    {
+        return $this->unitOfWork;
+    }
+
+    public function getIdentityMap(): IdentityMap
+    {
+        return $this->identityMap;
+    }
+
+    public function getMetadataFactory(): MetadataFactory
+    {
+        return $this->metadataFactory;
+    }
+
+    public function getEntityMapper(): EntityMapper
+    {
+        return $this->entityMapper;
+    }
+}
diff --git a/src/Database/ORM/EntityMapper.php b/src/Database/ORM/EntityMapper.php
new file mode 100644
index 000000000..e4673eea7
--- /dev/null
+++ b/src/Database/ORM/EntityMapper.php
@@ -0,0 +1,373 @@
+<?php
+
+namespace Utopia\Database\ORM;
+
+use Utopia\Database\Attribute;
+use Utopia\Database\Collection;
+use Utopia\Database\Document;
+use Utopia\Database\Index;
+use Utopia\Database\Relationship as RelationshipModel;
+use Utopia\Database\RelationSide;
+
+class EntityMapper
+{
+    /** @var array<string, array<string, \ReflectionProperty>> */
+    private static array $reflectionPropertyCache = [];
+
+    /** @var array<string, \ReflectionClass<object>> */
+    private static array $reflectionClassCache = [];
+
+    private MetadataFactory $metadataFactory;
+
+    public function __construct(MetadataFactory $metadataFactory)
+    {
+        $this->metadataFactory = $metadataFactory;
+    }
+
+    private function getReflectionProperty(string $class, string $property): \ReflectionProperty
+    {
+        if (!isset(self::$reflectionPropertyCache[$class][$property])) {
+            self::$reflectionPropertyCache[$class][$property] = new \ReflectionProperty($class, $property);
+        }
+        return self::$reflectionPropertyCache[$class][$property];
+    }
+
+    /**
+     * @return \ReflectionClass<object>
+     */
+    private function getReflectionClass(string $class): \ReflectionClass
+    {
+        if (!isset(self::$reflectionClassCache[$class])) {
+            self::$reflectionClassCache[$class] = new \ReflectionClass($class);
+        }
+        return self::$reflectionClassCache[$class];
+    }
+
+    public function toDocument(object $entity, EntityMetadata $metadata): Document
+    {
+        $data = [];
+
+        if ($metadata->idProperty !== null) {
+            $data['$id'] = $this->getPropertyValue($entity, $metadata->idProperty);
+        }
+
+        if ($metadata->versionProperty !== null) {
+            $data['$version'] = $this->getPropertyValue($entity, $metadata->versionProperty);
+        }
+
+        if ($metadata->createdAtProperty !== null) {
+            $data['$createdAt'] = $this->getPropertyValue($entity, $metadata->createdAtProperty);
+        }
+
+        if ($metadata->updatedAtProperty !== null) {
+            $data['$updatedAt'] = $this->getPropertyValue($entity, $metadata->updatedAtProperty);
+        }
+
+        if ($metadata->tenantProperty !== null) {
+            $data['$tenant'] = $this->getPropertyValue($entity, $metadata->tenantProperty);
+        }
+
+        if ($metadata->permissionsProperty !== null) {
+            $data['$permissions'] = $this->getPropertyValue($entity, $metadata->permissionsProperty) ?? [];
+        }
+
+        foreach ($metadata->columns as $mapping) {
+            $value = $this->getPropertyValue($entity, $mapping->propertyName);
+            $data[$mapping->documentKey] = $value;
+        }
+
+        foreach ($metadata->embeddables as $mapping) {
+            $value = $this->getPropertyValue($entity, $mapping->propertyName);
+            if ($value === null) {
+                continue;
+            }
+            $embType = $this->metadataFactory->getTypeRegistry()?->getEmbeddable($mapping->typeName);
+            if ($embType !== null) {
+                foreach ($embType->decompose($value) as $key => $val) {
+                    $data[$mapping->prefix . $key] = $val;
+                }
+            }
+        }
+
+        foreach ($metadata->relationships as $mapping) {
+            $value = $this->getPropertyValue($entity, $mapping->propertyName);
+
+            if ($value === null) {
+                $data[$mapping->documentKey] = null;
+
+                continue;
+            }
+
+            if (\is_array($value)) {
+                $data[$mapping->documentKey] = \array_map(function (mixed $item) use ($mapping): mixed {
+                    if (\is_object($item)) {
+                        $relMeta = $this->metadataFactory->getMetadata($mapping->targetClass);
+
+                        return $this->toDocument($item, $relMeta);
+                    }
+
+                    return $item;
+                }, $value);
+            } elseif (\is_object($value)) {
+                $relMeta = $this->metadataFactory->getMetadata($mapping->targetClass);
+                $data[$mapping->documentKey] = $this->toDocument($value, $relMeta);
+            } else {
+                $data[$mapping->documentKey] = $value;
+            }
+        }
+
+        return new Document($data);
+    }
+
+    public function toEntity(Document $document, EntityMetadata $metadata, IdentityMap $identityMap): object
+    {
+        $id = $document->getId();
+
+        if ($id !== '' && $identityMap->has($metadata->collection, $id)) {
+            /** @var object $existing */
+            $existing = $identityMap->get($metadata->collection, $id);
+
+            return $existing;
+        }
+
+        $ref = $this->getReflectionClass($metadata->className);
+        $entity = $ref->newInstanceWithoutConstructor();
+
+        if ($id !== '') {
+            $identityMap->put($metadata->collection, $id, $entity);
+        }
+
+        if ($metadata->idProperty !== null) {
+            $this->setPropertyValue($entity, $metadata->idProperty, $id);
+        }
+
+        if ($metadata->versionProperty !== null) {
+            $this->setPropertyValue($entity, $metadata->versionProperty, $document->getAttribute('$version'));
+        }
+
+        if ($metadata->createdAtProperty !== null) {
+            $this->setPropertyValue($entity, $metadata->createdAtProperty, $document->getAttribute('$createdAt'));
+        }
+
+        if ($metadata->updatedAtProperty !== null) {
+            $this->setPropertyValue($entity, $metadata->updatedAtProperty, $document->getAttribute('$updatedAt'));
+        }
+
+        if ($metadata->tenantProperty !== null) {
+            $this->setPropertyValue($entity, $metadata->tenantProperty, $document->getAttribute('$tenant'));
+        }
+
+        if ($metadata->permissionsProperty !== null) {
+            $this->setPropertyValue($entity, $metadata->permissionsProperty, $document->getPermissions());
+        }
+
+        foreach ($metadata->columns as $mapping) {
+            $value = $document->getAttribute($mapping->documentKey, $mapping->column->default);
+            $this->setPropertyValue($entity, $mapping->propertyName, $value);
+        }
+
+        foreach ($metadata->embeddables as $mapping) {
+            $embType = $this->metadataFactory->getTypeRegistry()?->getEmbeddable($mapping->typeName);
+            if ($embType !== null) {
+                $values = [];
+                foreach ($embType->attributes() as $attr) {
+                    $values[$attr->key] = $document->getAttribute($mapping->prefix . $attr->key);
+                }
+                $this->setPropertyValue($entity, $mapping->propertyName, $embType->compose($values));
+            }
+        }
+
+        foreach ($metadata->relationships as $mapping) {
+            $value = $document->getAttribute($mapping->documentKey);
+
+            if ($value === null) {
+                $isArray = $mapping->type === \Utopia\Database\RelationType::OneToMany
+                    || $mapping->type === \Utopia\Database\RelationType::ManyToMany;
+                $this->setPropertyValue($entity, $mapping->propertyName, $isArray ? [] : null);
+
+                continue;
+            }
+
+            $relMeta = $this->metadataFactory->getMetadata($mapping->targetClass);
+
+            if (\is_array($value)) {
+                $related = \array_map(function (mixed $item) use ($relMeta, $identityMap): mixed {
+                    if ($item instanceof Document && ! $item->isEmpty()) {
+                        return $this->toEntity($item, $relMeta, $identityMap);
+                    }
+
+                    return $item;
+                }, $value);
+                $this->setPropertyValue($entity, $mapping->propertyName, $related);
+            } elseif ($value instanceof Document && ! $value->isEmpty()) {
+                $this->setPropertyValue($entity, $mapping->propertyName, $this->toEntity($value, $relMeta, $identityMap));
+            } else {
+                $this->setPropertyValue($entity, $mapping->propertyName, $value);
+            }
+        }
+
+        return $entity;
+    }
+
+    public function applyDocumentToEntity(Document $document, object $entity, EntityMetadata $metadata): void
+    {
+        if ($metadata->idProperty !== null) {
+            $this->setPropertyValue($entity, $metadata->idProperty, $document->getId());
+        }
+
+        if ($metadata->versionProperty !== null) {
+            $this->setPropertyValue($entity, $metadata->versionProperty, $document->getAttribute('$version'));
+        }
+
+        if ($metadata->createdAtProperty !== null) {
+            $this->setPropertyValue($entity, $metadata->createdAtProperty, $document->getAttribute('$createdAt'));
+        }
+
+        if ($metadata->updatedAtProperty !== null) {
+            $this->setPropertyValue($entity, $metadata->updatedAtProperty, $document->getAttribute('$updatedAt'));
+        }
+    }
+
+    /**
+     * @return array<string, mixed>
+     */
+    public function takeSnapshot(object $entity, EntityMetadata $metadata): array
+    {
+        $snapshot = [];
+
+        if ($metadata->idProperty !== null) {
+            $snapshot['$id'] = $this->getPropertyValue($entity, $metadata->idProperty);
+        }
+
+        foreach ($metadata->columns as $mapping) {
+            $snapshot[$mapping->documentKey] = $this->getPropertyValue($entity, $mapping->propertyName);
+        }
+
+        foreach ($metadata->relationships as $mapping) {
+            $value = $this->getPropertyValue($entity, $mapping->propertyName);
+
+            if (\is_array($value)) {
+                $snapshot[$mapping->documentKey] = \array_map(function (mixed $item) use ($mapping): mixed {
+                    if (\is_object($item)) {
+                        $relMeta = $this->metadataFactory->getMetadata($mapping->targetClass);
+
+                        return $this->getId($item, $relMeta);
+                    }
+
+                    return $item;
+                }, $value);
+            } elseif (\is_object($value)) {
+                $relMeta = $this->metadataFactory->getMetadata($mapping->targetClass);
+                $snapshot[$mapping->documentKey] = $this->getId($value, $relMeta);
+            } else {
+                $snapshot[$mapping->documentKey] = $value;
+            }
+        }
+
+        return $snapshot;
+    }
+
+    public function getId(object $entity, EntityMetadata $metadata): ?string
+    {
+        if ($metadata->idProperty === null) {
+            return null;
+        }
+
+        /** @var string|null $value */
+        $value = $this->getPropertyValue($entity, $metadata->idProperty);
+
+        return $value;
+    }
+
+    /**
+     * @return array{collection: Collection, relationships: array<RelationshipModel>}
+     */
+    public function toCollectionDefinitions(EntityMetadata $metadata): array
+    {
+        $attributes = [];
+        foreach ($metadata->columns as $mapping) {
+            $col = $mapping->column;
+            $attributes[] = new Attribute(
+                key: $mapping->documentKey,
+                type: $col->type,
+                size: $col->size,
+                required: $col->required,
+                default: $col->default,
+                signed: $col->signed,
+                array: $col->array,
+                format: $col->format,
+                formatOptions: $col->formatOptions,
+                filters: $col->filters,
+            );
+        }
+
+        foreach ($metadata->embeddables as $mapping) {
+            $embType = $this->metadataFactory->getTypeRegistry()?->getEmbeddable($mapping->typeName);
+            if ($embType !== null) {
+                foreach ($embType->attributes() as $attr) {
+                    $prefixed = clone $attr;
+                    $prefixed->key = $mapping->prefix . $attr->key;
+                    $attributes[] = $prefixed;
+                }
+            }
+        }
+
+        $indexes = [];
+        foreach ($metadata->indexes as $tableIndex) {
+            $indexes[] = new Index(
+                key: $tableIndex->key,
+                type: $tableIndex->type,
+                attributes: $tableIndex->attributes,
+                lengths: $tableIndex->lengths,
+                orders: $tableIndex->orders,
+            );
+        }
+
+        $collection = new Collection(
+            id: $metadata->collection,
+            name: $metadata->collection,
+            attributes: $attributes,
+            indexes: $indexes,
+            permissions: $metadata->permissions,
+            documentSecurity: $metadata->documentSecurity,
+        );
+
+        $relationships = [];
+        foreach ($metadata->relationships as $mapping) {
+            $relMeta = $this->metadataFactory->getMetadata($mapping->targetClass);
+
+            $relationships[] = new RelationshipModel(
+                collection: $metadata->collection,
+                relatedCollection: $relMeta->collection,
+                type: $mapping->type,
+                twoWay: $mapping->twoWay,
+                key: $mapping->documentKey,
+                twoWayKey: $mapping->twoWayKey,
+                onDelete: $mapping->onDelete,
+                side: RelationSide::Parent,
+            );
+        }
+
+        return [
+            'collection' => $collection,
+            'relationships' => $relationships,
+        ];
+    }
+
+    private function getPropertyValue(object $entity, string $property): mixed
+    {
+        $ref = $this->getReflectionProperty($entity::class, $property);
+
+        if (! $ref->isInitialized($entity)) {
+            return null;
+        }
+
+        return $ref->getValue($entity);
+    }
+
+    private function setPropertyValue(object $entity, string $property, mixed $value): void
+    {
+        $ref = $this->getReflectionProperty($entity::class, $property);
+        $ref->setValue($entity, $value);
+    }
+}
diff --git a/src/Database/ORM/EntityMetadata.php b/src/Database/ORM/EntityMetadata.php
new file mode 100644
index 000000000..1d1e4a56e
--- /dev/null
+++ b/src/Database/ORM/EntityMetadata.php
@@ -0,0 +1,46 @@
+<?php
+
+namespace Utopia\Database\ORM;
+
+use Utopia\Database\ORM\Mapping\TableIndex;
+
+class EntityMetadata
+{
+    /**
+     * @param  array<string, ColumnMapping>  $columns
+     * @param  array<string, RelationshipMapping>  $relationships
+     * @param  array<TableIndex>  $indexes
+     * @param  array<string>  $permissions
+     * @param  array<string, EmbeddableMapping>  $embeddables
+     * @param  array<string>  $prePersistCallbacks
+     * @param  array<string>  $postPersistCallbacks
+     * @param  array<string>  $preUpdateCallbacks
+     * @param  array<string>  $postUpdateCallbacks
+     * @param  array<string>  $preRemoveCallbacks
+     * @param  array<string>  $postRemoveCallbacks
+     */
+    public function __construct(
+        public readonly string $className,
+        public readonly string $collection,
+        public readonly bool $documentSecurity,
+        public readonly array $permissions,
+        public readonly ?string $idProperty,
+        public readonly ?string $versionProperty,
+        public readonly ?string $createdAtProperty,
+        public readonly ?string $updatedAtProperty,
+        public readonly ?string $tenantProperty,
+        public readonly ?string $permissionsProperty,
+        public readonly array $columns,
+        public readonly array $relationships,
+        public readonly array $indexes,
+        public readonly array $embeddables = [],
+        public readonly ?string $softDeleteColumn = null,
+        public readonly array $prePersistCallbacks = [],
+        public readonly array $postPersistCallbacks = [],
+        public readonly array $preUpdateCallbacks = [],
+        public readonly array $postUpdateCallbacks = [],
+        public readonly array $preRemoveCallbacks = [],
+        public readonly array $postRemoveCallbacks = [],
+    ) {
+    }
+}
diff --git a/src/Database/ORM/EntityState.php b/src/Database/ORM/EntityState.php
new file mode 100644
index 000000000..54d7cf868
--- /dev/null
+++ b/src/Database/ORM/EntityState.php
@@ -0,0 +1,10 @@
+<?php
+
+namespace Utopia\Database\ORM;
+
+enum EntityState
+{
+    case New;
+    case Managed;
+    case Removed;
+}
diff --git a/src/Database/ORM/IdentityMap.php b/src/Database/ORM/IdentityMap.php
new file mode 100644
index 000000000..9c2e9362b
--- /dev/null
+++ b/src/Database/ORM/IdentityMap.php
@@ -0,0 +1,41 @@
+<?php
+
+namespace Utopia\Database\ORM;
+
+class IdentityMap
+{
+    /** @var array<string, array<string, object>> */
+    private array $map = [];
+
+    public function put(string $collection, string $id, object $entity): void
+    {
+        $this->map[$collection][$id] = $entity;
+    }
+
+    public function get(string $collection, string $id): ?object
+    {
+        return $this->map[$collection][$id] ?? null;
+    }
+
+    public function has(string $collection, string $id): bool
+    {
+        return isset($this->map[$collection][$id]);
+    }
+
+    public function remove(string $collection, string $id): void
+    {
+        unset($this->map[$collection][$id]);
+    }
+
+    public function clear(): void
+    {
+        $this->map = [];
+    }
+
+    public function all(): \Generator
+    {
+        foreach ($this->map as $collection) {
+            yield from $collection;
+        }
+    }
+}
diff --git a/src/Database/ORM/Mapping/BelongsTo.php b/src/Database/ORM/Mapping/BelongsTo.php
new file mode 100644
index 000000000..89caff5dc
--- /dev/null
+++ b/src/Database/ORM/Mapping/BelongsTo.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace Utopia\Database\ORM\Mapping;
+
+use Utopia\Query\Schema\ForeignKeyAction;
+
+#[\Attribute(\Attribute::TARGET_PROPERTY)]
+final class BelongsTo
+{
+    public function __construct(
+        public string $target,
+        public string $key = '',
+        public string $twoWayKey = '',
+        public bool $twoWay = true,
+        public ForeignKeyAction $onDelete = ForeignKeyAction::Restrict,
+    ) {
+    }
+}
diff --git a/src/Database/ORM/Mapping/BelongsToMany.php b/src/Database/ORM/Mapping/BelongsToMany.php
new file mode 100644
index 000000000..62ac84cae
--- /dev/null
+++ b/src/Database/ORM/Mapping/BelongsToMany.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace Utopia\Database\ORM\Mapping;
+
+use Utopia\Query\Schema\ForeignKeyAction;
+
+#[\Attribute(\Attribute::TARGET_PROPERTY)]
+final class BelongsToMany
+{
+    public function __construct(
+        public string $target,
+        public string $key = '',
+        public string $twoWayKey = '',
+        public bool $twoWay = true,
+        public ForeignKeyAction $onDelete = ForeignKeyAction::Cascade,
+    ) {
+    }
+}
diff --git a/src/Database/ORM/Mapping/Column.php b/src/Database/ORM/Mapping/Column.php
new file mode 100644
index 000000000..e49b96b4a
--- /dev/null
+++ b/src/Database/ORM/Mapping/Column.php
@@ -0,0 +1,27 @@
+<?php
+
+namespace Utopia\Database\ORM\Mapping;
+
+use Utopia\Query\Schema\ColumnType;
+
+#[\Attribute(\Attribute::TARGET_PROPERTY)]
+final class Column
+{
+    /**
+     * @param  array<string, mixed>  $formatOptions
+     * @param  array<string>  $filters
+     */
+    public function __construct(
+        public ColumnType $type = ColumnType::String,
+        public int $size = 0,
+        public bool $required = false,
+        public mixed $default = null,
+        public bool $signed = true,
+        public bool $array = false,
+        public ?string $format = null,
+        public array $formatOptions = [],
+        public array $filters = [],
+        public ?string $key = null,
+    ) {
+    }
+}
diff --git a/src/Database/ORM/Mapping/CreatedAt.php b/src/Database/ORM/Mapping/CreatedAt.php
new file mode 100644
index 000000000..f4b9d57db
--- /dev/null
+++ b/src/Database/ORM/Mapping/CreatedAt.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace Utopia\Database\ORM\Mapping;
+
+#[\Attribute(\Attribute::TARGET_PROPERTY)]
+final class CreatedAt
+{
+}
diff --git a/src/Database/ORM/Mapping/Embedded.php b/src/Database/ORM/Mapping/Embedded.php
new file mode 100644
index 000000000..1fe4f1a8f
--- /dev/null
+++ b/src/Database/ORM/Mapping/Embedded.php
@@ -0,0 +1,13 @@
+<?php
+
+namespace Utopia\Database\ORM\Mapping;
+
+#[\Attribute(\Attribute::TARGET_PROPERTY)]
+final class Embedded
+{
+    public function __construct(
+        public string $type,
+        public string $prefix = '',
+    ) {
+    }
+}
diff --git a/src/Database/ORM/Mapping/Entity.php b/src/Database/ORM/Mapping/Entity.php
new file mode 100644
index 000000000..fc32c3ac7
--- /dev/null
+++ b/src/Database/ORM/Mapping/Entity.php
@@ -0,0 +1,17 @@
+<?php
+
+namespace Utopia\Database\ORM\Mapping;
+
+#[\Attribute(\Attribute::TARGET_CLASS)]
+final class Entity
+{
+    /**
+     * @param  array<string>  $permissions
+     */
+    public function __construct(
+        public string $collection,
+        public bool $documentSecurity = true,
+        public array $permissions = [],
+    ) {
+    }
+}
diff --git a/src/Database/ORM/Mapping/HasMany.php b/src/Database/ORM/Mapping/HasMany.php
new file mode 100644
index 000000000..ad8657f7b
--- /dev/null
+++ b/src/Database/ORM/Mapping/HasMany.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace Utopia\Database\ORM\Mapping;
+
+use Utopia\Query\Schema\ForeignKeyAction;
+
+#[\Attribute(\Attribute::TARGET_PROPERTY)]
+final class HasMany
+{
+    public function __construct(
+        public string $target,
+        public string $key = '',
+        public string $twoWayKey = '',
+        public bool $twoWay = true,
+        public ForeignKeyAction $onDelete = ForeignKeyAction::SetNull,
+    ) {
+    }
+}
diff --git a/src/Database/ORM/Mapping/HasOne.php b/src/Database/ORM/Mapping/HasOne.php
new file mode 100644
index 000000000..58b554276
--- /dev/null
+++ b/src/Database/ORM/Mapping/HasOne.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace Utopia\Database\ORM\Mapping;
+
+use Utopia\Query\Schema\ForeignKeyAction;
+
+#[\Attribute(\Attribute::TARGET_PROPERTY)]
+final class HasOne
+{
+    public function __construct(
+        public string $target,
+        public string $key = '',
+        public string $twoWayKey = '',
+        public bool $twoWay = true,
+        public ForeignKeyAction $onDelete = ForeignKeyAction::Restrict,
+    ) {
+    }
+}
diff --git a/src/Database/ORM/Mapping/Id.php b/src/Database/ORM/Mapping/Id.php
new file mode 100644
index 000000000..54b24a89e
--- /dev/null
+++ b/src/Database/ORM/Mapping/Id.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace Utopia\Database\ORM\Mapping;
+
+#[\Attribute(\Attribute::TARGET_PROPERTY)]
+final class Id
+{
+}
diff --git a/src/Database/ORM/Mapping/Permissions.php b/src/Database/ORM/Mapping/Permissions.php
new file mode 100644
index 000000000..13cbbdb7e
--- /dev/null
+++ b/src/Database/ORM/Mapping/Permissions.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace Utopia\Database\ORM\Mapping;
+
+#[\Attribute(\Attribute::TARGET_PROPERTY)]
+final class Permissions
+{
+}
diff --git a/src/Database/ORM/Mapping/PostPersist.php b/src/Database/ORM/Mapping/PostPersist.php
new file mode 100644
index 000000000..4b8ce1c41
--- /dev/null
+++ b/src/Database/ORM/Mapping/PostPersist.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace Utopia\Database\ORM\Mapping;
+
+#[\Attribute(\Attribute::TARGET_METHOD)]
+final class PostPersist
+{
+}
diff --git a/src/Database/ORM/Mapping/PostRemove.php b/src/Database/ORM/Mapping/PostRemove.php
new file mode 100644
index 000000000..387b0fe4c
--- /dev/null
+++ b/src/Database/ORM/Mapping/PostRemove.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace Utopia\Database\ORM\Mapping;
+
+#[\Attribute(\Attribute::TARGET_METHOD)]
+final class PostRemove
+{
+}
diff --git a/src/Database/ORM/Mapping/PostUpdate.php b/src/Database/ORM/Mapping/PostUpdate.php
new file mode 100644
index 000000000..56367b889
--- /dev/null
+++ b/src/Database/ORM/Mapping/PostUpdate.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace Utopia\Database\ORM\Mapping;
+
+#[\Attribute(\Attribute::TARGET_METHOD)]
+final class PostUpdate
+{
+}
diff --git a/src/Database/ORM/Mapping/PrePersist.php b/src/Database/ORM/Mapping/PrePersist.php
new file mode 100644
index 000000000..6d078e7e6
--- /dev/null
+++ b/src/Database/ORM/Mapping/PrePersist.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace Utopia\Database\ORM\Mapping;
+
+#[\Attribute(\Attribute::TARGET_METHOD)]
+final class PrePersist
+{
+}
diff --git a/src/Database/ORM/Mapping/PreRemove.php b/src/Database/ORM/Mapping/PreRemove.php
new file mode 100644
index 000000000..1b644cb3c
--- /dev/null
+++ b/src/Database/ORM/Mapping/PreRemove.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace Utopia\Database\ORM\Mapping;
+
+#[\Attribute(\Attribute::TARGET_METHOD)]
+final class PreRemove
+{
+}
diff --git a/src/Database/ORM/Mapping/PreUpdate.php b/src/Database/ORM/Mapping/PreUpdate.php
new file mode 100644
index 000000000..3c31f559c
--- /dev/null
+++ b/src/Database/ORM/Mapping/PreUpdate.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace Utopia\Database\ORM\Mapping;
+
+#[\Attribute(\Attribute::TARGET_METHOD)]
+final class PreUpdate
+{
+}
diff --git a/src/Database/ORM/Mapping/SoftDelete.php b/src/Database/ORM/Mapping/SoftDelete.php
new file mode 100644
index 000000000..2193c93ef
--- /dev/null
+++ b/src/Database/ORM/Mapping/SoftDelete.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace Utopia\Database\ORM\Mapping;
+
+use Utopia\Query\Schema\ColumnType;
+
+#[\Attribute(\Attribute::TARGET_CLASS)]
+final class SoftDelete
+{
+    public function __construct(
+        public string $column = 'deletedAt',
+        public ColumnType $type = ColumnType::Datetime,
+    ) {
+    }
+}
diff --git a/src/Database/ORM/Mapping/TableIndex.php b/src/Database/ORM/Mapping/TableIndex.php
new file mode 100644
index 000000000..e2c45a23d
--- /dev/null
+++ b/src/Database/ORM/Mapping/TableIndex.php
@@ -0,0 +1,23 @@
+<?php
+
+namespace Utopia\Database\ORM\Mapping;
+
+use Utopia\Query\Schema\IndexType;
+
+#[\Attribute(\Attribute::TARGET_CLASS | \Attribute::IS_REPEATABLE)]
+final class TableIndex
+{
+    /**
+     * @param  array<string>  $attributes
+     * @param  array<int|null>  $lengths
+     * @param  array<string|null>  $orders
+     */
+    public function __construct(
+        public string $key,
+        public IndexType $type = IndexType::Index,
+        public array $attributes = [],
+        public array $lengths = [],
+        public array $orders = [],
+    ) {
+    }
+}
diff --git a/src/Database/ORM/Mapping/Tenant.php b/src/Database/ORM/Mapping/Tenant.php
new file mode 100644
index 000000000..58475bc49
--- /dev/null
+++ b/src/Database/ORM/Mapping/Tenant.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace Utopia\Database\ORM\Mapping;
+
+#[\Attribute(\Attribute::TARGET_PROPERTY)]
+final class Tenant
+{
+}
diff --git a/src/Database/ORM/Mapping/UpdatedAt.php b/src/Database/ORM/Mapping/UpdatedAt.php
new file mode 100644
index 000000000..42be6b68c
--- /dev/null
+++ b/src/Database/ORM/Mapping/UpdatedAt.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace Utopia\Database\ORM\Mapping;
+
+#[\Attribute(\Attribute::TARGET_PROPERTY)]
+final class UpdatedAt
+{
+}
diff --git a/src/Database/ORM/Mapping/Version.php b/src/Database/ORM/Mapping/Version.php
new file mode 100644
index 000000000..218affb56
--- /dev/null
+++ b/src/Database/ORM/Mapping/Version.php
@@ -0,0 +1,8 @@
+<?php
+
+namespace Utopia\Database\ORM\Mapping;
+
+#[\Attribute(\Attribute::TARGET_PROPERTY)]
+final class Version
+{
+}
diff --git a/src/Database/ORM/MetadataFactory.php b/src/Database/ORM/MetadataFactory.php
new file mode 100644
index 000000000..5fda1cdbd
--- /dev/null
+++ b/src/Database/ORM/MetadataFactory.php
@@ -0,0 +1,310 @@
+<?php
+
+namespace Utopia\Database\ORM;
+
+use ReflectionClass;
+use Utopia\Database\ORM\Mapping\BelongsTo;
+use Utopia\Database\ORM\Mapping\BelongsToMany;
+use Utopia\Database\ORM\Mapping\Column;
+use Utopia\Database\ORM\Mapping\CreatedAt;
+use Utopia\Database\ORM\Mapping\Embedded;
+use Utopia\Database\ORM\Mapping\Entity;
+use Utopia\Database\ORM\Mapping\HasMany;
+use Utopia\Database\ORM\Mapping\HasOne;
+use Utopia\Database\ORM\Mapping\Id;
+use Utopia\Database\ORM\Mapping\Permissions;
+use Utopia\Database\ORM\Mapping\PostPersist;
+use Utopia\Database\ORM\Mapping\PostRemove;
+use Utopia\Database\ORM\Mapping\PostUpdate;
+use Utopia\Database\ORM\Mapping\PrePersist;
+use Utopia\Database\ORM\Mapping\PreRemove;
+use Utopia\Database\ORM\Mapping\PreUpdate;
+use Utopia\Database\ORM\Mapping\SoftDelete;
+use Utopia\Database\ORM\Mapping\TableIndex;
+use Utopia\Database\ORM\Mapping\Tenant;
+use Utopia\Database\ORM\Mapping\UpdatedAt;
+use Utopia\Database\ORM\Mapping\Version;
+use Utopia\Database\RelationType;
+use Utopia\Database\Type\TypeRegistry;
+
+class MetadataFactory
+{
+    /** @var array<string, EntityMetadata> */
+    private static array $cache = [];
+
+    private ?TypeRegistry $typeRegistry = null;
+
+    public function setTypeRegistry(?TypeRegistry $typeRegistry): void
+    {
+        $this->typeRegistry = $typeRegistry;
+    }
+
+    public function getTypeRegistry(): ?TypeRegistry
+    {
+        return $this->typeRegistry;
+    }
+
+    public function getMetadata(string $className): EntityMetadata
+    {
+        if (isset(self::$cache[$className])) {
+            return self::$cache[$className];
+        }
+
+        $ref = new ReflectionClass($className);
+        $entityAttrs = $ref->getAttributes(Entity::class);
+
+        if ($entityAttrs === []) {
+            throw new \RuntimeException("Class {$className} is not annotated with #[Entity]");
+        }
+
+        /** @var Entity $entity */
+        $entity = $entityAttrs[0]->newInstance();
+
+        $softDeleteAttrs = $ref->getAttributes(SoftDelete::class);
+        $softDeleteColumn = null;
+        if ($softDeleteAttrs !== []) {
+            /** @var SoftDelete $sd */
+            $sd = $softDeleteAttrs[0]->newInstance();
+            $softDeleteColumn = $sd->column;
+        }
+
+        $idProperty = null;
+        $versionProperty = null;
+        $createdAtProperty = null;
+        $updatedAtProperty = null;
+        $tenantProperty = null;
+        $permissionsProperty = null;
+        $columns = [];
+        $relationships = [];
+        $embeddables = [];
+
+        foreach ($ref->getProperties() as $prop) {
+            $name = $prop->getName();
+
+            if ($prop->getAttributes(Id::class)) {
+                $idProperty = $name;
+
+                continue;
+            }
+
+            if ($prop->getAttributes(Version::class)) {
+                $versionProperty = $name;
+
+                continue;
+            }
+
+            if ($prop->getAttributes(CreatedAt::class)) {
+                $createdAtProperty = $name;
+
+                continue;
+            }
+
+            if ($prop->getAttributes(UpdatedAt::class)) {
+                $updatedAtProperty = $name;
+
+                continue;
+            }
+
+            if ($prop->getAttributes(Tenant::class)) {
+                $tenantProperty = $name;
+
+                continue;
+            }
+
+            if ($prop->getAttributes(Permissions::class)) {
+                $permissionsProperty = $name;
+
+                continue;
+            }
+
+            $embeddedAttrs = $prop->getAttributes(Embedded::class);
+            if ($embeddedAttrs !== []) {
+                /** @var Embedded $emb */
+                $emb = $embeddedAttrs[0]->newInstance();
+                $embeddables[$name] = new EmbeddableMapping($name, $emb->type, $emb->prefix ?: $name . '_');
+
+                continue;
+            }
+
+            $columnAttrs = $prop->getAttributes(Column::class);
+            if ($columnAttrs !== []) {
+                /** @var Column $col */
+                $col = $columnAttrs[0]->newInstance();
+                $docKey = $col->key ?? $name;
+                $columns[$name] = new ColumnMapping($name, $docKey, $col);
+
+                continue;
+            }
+
+            $rel = $this->parseRelationship($prop, $name);
+            if ($rel !== null) {
+                $relationships[$name] = $rel;
+            }
+        }
+
+        $indexes = [];
+        foreach ($ref->getAttributes(TableIndex::class) as $idxAttr) {
+            $indexes[] = $idxAttr->newInstance();
+        }
+
+        $lifecycleCallbacks = $this->parseLifecycleCallbacks($ref);
+
+        $metadata = new EntityMetadata(
+            className: $className,
+            collection: $entity->collection,
+            documentSecurity: $entity->documentSecurity,
+            permissions: $entity->permissions,
+            idProperty: $idProperty,
+            versionProperty: $versionProperty,
+            createdAtProperty: $createdAtProperty,
+            updatedAtProperty: $updatedAtProperty,
+            tenantProperty: $tenantProperty,
+            permissionsProperty: $permissionsProperty,
+            columns: $columns,
+            relationships: $relationships,
+            indexes: $indexes,
+            embeddables: $embeddables,
+            softDeleteColumn: $softDeleteColumn,
+            prePersistCallbacks: $lifecycleCallbacks['prePersist'],
+            postPersistCallbacks: $lifecycleCallbacks['postPersist'],
+            preUpdateCallbacks: $lifecycleCallbacks['preUpdate'],
+            postUpdateCallbacks: $lifecycleCallbacks['postUpdate'],
+            preRemoveCallbacks: $lifecycleCallbacks['preRemove'],
+            postRemoveCallbacks: $lifecycleCallbacks['postRemove'],
+        );
+
+        self::$cache[$className] = $metadata;
+
+        return $metadata;
+    }
+
+    /**
+     * Get the collection name for an entity class.
+     */
+    public function getCollection(string $className): string
+    {
+        return $this->getMetadata($className)->collection;
+    }
+
+    /**
+     * Clear the metadata cache (useful for testing).
+     */
+    public static function clearCache(): void
+    {
+        self::$cache = [];
+    }
+
+    private function parseRelationship(\ReflectionProperty $prop, string $name): ?RelationshipMapping
+    {
+        $hasOne = $prop->getAttributes(HasOne::class);
+        if ($hasOne !== []) {
+            /** @var HasOne $attr */
+            $attr = $hasOne[0]->newInstance();
+
+            return new RelationshipMapping(
+                propertyName: $name,
+                documentKey: $attr->key ?: $name,
+                type: RelationType::OneToOne,
+                targetClass: $attr->target,
+                twoWayKey: $attr->twoWayKey,
+                twoWay: $attr->twoWay,
+                onDelete: $attr->onDelete,
+            );
+        }
+
+        $belongsTo = $prop->getAttributes(BelongsTo::class);
+        if ($belongsTo !== []) {
+            /** @var BelongsTo $attr */
+            $attr = $belongsTo[0]->newInstance();
+
+            return new RelationshipMapping(
+                propertyName: $name,
+                documentKey: $attr->key ?: $name,
+                type: RelationType::ManyToOne,
+                targetClass: $attr->target,
+                twoWayKey: $attr->twoWayKey,
+                twoWay: $attr->twoWay,
+                onDelete: $attr->onDelete,
+            );
+        }
+
+        $hasMany = $prop->getAttributes(HasMany::class);
+        if ($hasMany !== []) {
+            /** @var HasMany $attr */
+            $attr = $hasMany[0]->newInstance();
+
+            return new RelationshipMapping(
+                propertyName: $name,
+                documentKey: $attr->key ?: $name,
+                type: RelationType::OneToMany,
+                targetClass: $attr->target,
+                twoWayKey: $attr->twoWayKey,
+                twoWay: $attr->twoWay,
+                onDelete: $attr->onDelete,
+            );
+        }
+
+        $belongsToMany = $prop->getAttributes(BelongsToMany::class);
+        if ($belongsToMany !== []) {
+            /** @var BelongsToMany $attr */
+            $attr = $belongsToMany[0]->newInstance();
+
+            return new RelationshipMapping(
+                propertyName: $name,
+                documentKey: $attr->key ?: $name,
+                type: RelationType::ManyToMany,
+                targetClass: $attr->target,
+                twoWayKey: $attr->twoWayKey,
+                twoWay: $attr->twoWay,
+                onDelete: $attr->onDelete,
+            );
+        }
+
+        return null;
+    }
+
+    /**
+     * @return array{prePersist: array<string>, postPersist: array<string>, preUpdate: array<string>, postUpdate: array<string>, preRemove: array<string>, postRemove: array<string>}
+     */
+    private function parseLifecycleCallbacks(ReflectionClass $ref): array
+    {
+        $callbacks = [
+            'prePersist' => [],
+            'postPersist' => [],
+            'preUpdate' => [],
+            'postUpdate' => [],
+            'preRemove' => [],
+            'postRemove' => [],
+        ];
+
+        foreach ($ref->getMethods() as $method) {
+            $name = $method->getName();
+
+            if ($method->getAttributes(PrePersist::class)) {
+                $callbacks['prePersist'][] = $name;
+            }
+
+            if ($method->getAttributes(PostPersist::class)) {
+                $callbacks['postPersist'][] = $name;
+            }
+
+            if ($method->getAttributes(PreUpdate::class)) {
+                $callbacks['preUpdate'][] = $name;
+            }
+
+            if ($method->getAttributes(PostUpdate::class)) {
+                $callbacks['postUpdate'][] = $name;
+            }
+
+            if ($method->getAttributes(PreRemove::class)) {
+                $callbacks['preRemove'][] = $name;
+            }
+
+            if ($method->getAttributes(PostRemove::class)) {
+                $callbacks['postRemove'][] = $name;
+            }
+        }
+
+        return $callbacks;
+    }
+}
diff --git a/src/Database/ORM/RelationshipMapping.php b/src/Database/ORM/RelationshipMapping.php
new file mode 100644
index 000000000..6dc0455b6
--- /dev/null
+++ b/src/Database/ORM/RelationshipMapping.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace Utopia\Database\ORM;
+
+use Utopia\Database\RelationType;
+use Utopia\Query\Schema\ForeignKeyAction;
+
+class RelationshipMapping
+{
+    public function __construct(
+        public readonly string $propertyName,
+        public readonly string $documentKey,
+        public readonly RelationType $type,
+        public readonly string $targetClass,
+        public readonly string $twoWayKey,
+        public readonly bool $twoWay,
+        public readonly ForeignKeyAction $onDelete,
+    ) {
+    }
+}
diff --git a/src/Database/ORM/UnitOfWork.php b/src/Database/ORM/UnitOfWork.php
new file mode 100644
index 000000000..25a08dd6d
--- /dev/null
+++ b/src/Database/ORM/UnitOfWork.php
@@ -0,0 +1,356 @@
+<?php
+
+namespace Utopia\Database\ORM;
+
+use SplObjectStorage;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+
+class UnitOfWork
+{
+    /** @var SplObjectStorage<object, EntityState> */
+    private SplObjectStorage $entityStates;
+
+    /** @var SplObjectStorage<object, array<string, mixed>> */
+    private SplObjectStorage $originalSnapshots;
+
+    /** @var array<int, object> */
+    private array $scheduledInsertions = [];
+
+    /** @var array<int, object> */
+    private array $scheduledDeletions = [];
+
+    private IdentityMap $identityMap;
+
+    private MetadataFactory $metadataFactory;
+
+    private EntityMapper $entityMapper;
+
+    public function __construct(
+        IdentityMap $identityMap,
+        MetadataFactory $metadataFactory,
+        EntityMapper $entityMapper,
+    ) {
+        $this->identityMap = $identityMap;
+        $this->metadataFactory = $metadataFactory;
+        $this->entityMapper = $entityMapper;
+        $this->entityStates = new SplObjectStorage();
+        $this->originalSnapshots = new SplObjectStorage();
+    }
+
+    public function persist(object $entity): void
+    {
+        if ($this->entityStates->contains($entity)) {
+            $state = $this->entityStates[$entity];
+
+            if ($state === EntityState::Managed) {
+                return;
+            }
+
+            if ($state === EntityState::Removed) {
+                $this->entityStates[$entity] = EntityState::Managed;
+                $key = \array_search($entity, $this->scheduledDeletions, true);
+                if ($key !== false) {
+                    unset($this->scheduledDeletions[$key]);
+                }
+
+                return;
+            }
+        }
+
+        $this->entityStates[$entity] = EntityState::New;
+        $this->scheduledInsertions[] = $entity;
+
+        $this->cascadePersist($entity);
+    }
+
+    public function remove(object $entity): void
+    {
+        if (! $this->entityStates->contains($entity)) {
+            return;
+        }
+
+        $state = $this->entityStates[$entity];
+
+        if ($state === EntityState::New) {
+            unset($this->entityStates[$entity]);
+            $key = \array_search($entity, $this->scheduledInsertions, true);
+            if ($key !== false) {
+                unset($this->scheduledInsertions[$key]);
+            }
+
+            return;
+        }
+
+        if ($state === EntityState::Managed) {
+            $metadata = $this->metadataFactory->getMetadata($entity::class);
+            if ($metadata->softDeleteColumn !== null) {
+                $ref = new \ReflectionProperty($entity, $metadata->softDeleteColumn);
+                $ref->setValue($entity, \date('Y-m-d H:i:s'));
+
+                return;
+            }
+
+            $this->entityStates[$entity] = EntityState::Removed;
+            $this->scheduledDeletions[] = $entity;
+        }
+    }
+
+    public function forceRemove(object $entity): void
+    {
+        if (! $this->entityStates->contains($entity)) {
+            return;
+        }
+
+        $state = $this->entityStates[$entity];
+
+        if ($state === EntityState::New) {
+            unset($this->entityStates[$entity]);
+            $key = \array_search($entity, $this->scheduledInsertions, true);
+            if ($key !== false) {
+                unset($this->scheduledInsertions[$key]);
+            }
+
+            return;
+        }
+
+        if ($state === EntityState::Managed) {
+            $this->entityStates[$entity] = EntityState::Removed;
+            $this->scheduledDeletions[] = $entity;
+        }
+    }
+
+    public function restore(object $entity): void
+    {
+        $metadata = $this->metadataFactory->getMetadata($entity::class);
+        if ($metadata->softDeleteColumn === null) {
+            return;
+        }
+
+        $ref = new \ReflectionProperty($entity, $metadata->softDeleteColumn);
+        $ref->setValue($entity, null);
+    }
+
+    public function registerManaged(object $entity, EntityMetadata $metadata): void
+    {
+        $this->entityStates[$entity] = EntityState::Managed;
+        $this->originalSnapshots[$entity] = $this->entityMapper->takeSnapshot($entity, $metadata);
+    }
+
+    public function flush(Database $db): void
+    {
+        /** @var array<string, array<object>> $inserts */
+        $inserts = [];
+        /** @var array<string, array<object>> $updates */
+        $updates = [];
+        /** @var array<string, array<object>> $deletes */
+        $deletes = [];
+
+        foreach ($this->scheduledInsertions as $entity) {
+            $metadata = $this->metadataFactory->getMetadata($entity::class);
+            $inserts[$metadata->collection][] = $entity;
+        }
+
+        foreach ($this->identityMap->all() as $entity) {
+            if (! $this->entityStates->contains($entity)) {
+                continue;
+            }
+
+            if ($this->entityStates[$entity] !== EntityState::Managed) {
+                continue;
+            }
+
+            $metadata = $this->metadataFactory->getMetadata($entity::class);
+            $currentSnapshot = $this->entityMapper->takeSnapshot($entity, $metadata);
+            $originalSnapshot = $this->originalSnapshots->contains($entity)
+                ? $this->originalSnapshots[$entity]
+                : [];
+
+            if ($currentSnapshot !== $originalSnapshot) {
+                $updates[$metadata->collection][] = $entity;
+            }
+        }
+
+        foreach ($this->scheduledDeletions as $entity) {
+            $metadata = $this->metadataFactory->getMetadata($entity::class);
+            $deletes[$metadata->collection][] = $entity;
+        }
+
+        if ($inserts === [] && $updates === [] && $deletes === []) {
+            return;
+        }
+
+        $db->withTransaction(function () use ($db, $inserts, $updates, $deletes): void {
+            foreach ($inserts as $collection => $entities) {
+                $documents = [];
+                $entityMap = [];
+
+                foreach ($entities as $entity) {
+                    $metadata = $this->metadataFactory->getMetadata($entity::class);
+                    $this->invokeCallbacks($entity, $metadata->prePersistCallbacks);
+                    $doc = $this->entityMapper->toDocument($entity, $metadata);
+                    $documents[] = $doc;
+                    $entityMap[] = $entity;
+                }
+
+                if (\count($documents) === 1) {
+                    $created = $db->createDocument($collection, $documents[0]);
+                    $metadata = $this->metadataFactory->getMetadata($entityMap[0]::class);
+                    $this->entityMapper->applyDocumentToEntity($created, $entityMap[0], $metadata);
+                    $this->identityMap->put($collection, $created->getId(), $entityMap[0]);
+                    $this->entityStates[$entityMap[0]] = EntityState::Managed;
+                    $this->originalSnapshots[$entityMap[0]] = $this->entityMapper->takeSnapshot($entityMap[0], $metadata);
+                    $this->invokeCallbacks($entityMap[0], $metadata->postPersistCallbacks);
+                } else {
+                    $idx = 0;
+                    $db->createDocuments($collection, $documents, Database::INSERT_BATCH_SIZE, function (Document $created) use (&$entityMap, &$idx, $collection): void {
+                        if (! isset($entityMap[$idx])) {
+                            return;
+                        }
+                        $entity = $entityMap[$idx];
+                        $metadata = $this->metadataFactory->getMetadata($entity::class);
+                        $this->entityMapper->applyDocumentToEntity($created, $entity, $metadata);
+                        $this->identityMap->put($collection, $created->getId(), $entity);
+                        $this->entityStates[$entity] = EntityState::Managed;
+                        $this->originalSnapshots[$entity] = $this->entityMapper->takeSnapshot($entity, $metadata);
+                        $this->invokeCallbacks($entity, $metadata->postPersistCallbacks);
+                        $idx++;
+                    });
+                }
+            }
+
+            foreach ($updates as $collection => $entities) {
+                foreach ($entities as $entity) {
+                    $metadata = $this->metadataFactory->getMetadata($entity::class);
+                    $this->invokeCallbacks($entity, $metadata->preUpdateCallbacks);
+                    $document = $this->entityMapper->toDocument($entity, $metadata);
+                    $id = $this->entityMapper->getId($entity, $metadata);
+
+                    if ($id === null) {
+                        continue;
+                    }
+
+                    $updated = $db->updateDocument($collection, $id, $document);
+                    $this->entityMapper->applyDocumentToEntity($updated, $entity, $metadata);
+                    $this->originalSnapshots[$entity] = $this->entityMapper->takeSnapshot($entity, $metadata);
+                    $this->invokeCallbacks($entity, $metadata->postUpdateCallbacks);
+                }
+            }
+
+            foreach ($deletes as $collection => $entities) {
+                foreach ($entities as $entity) {
+                    $metadata = $this->metadataFactory->getMetadata($entity::class);
+                    $id = $this->entityMapper->getId($entity, $metadata);
+
+                    if ($id === null) {
+                        continue;
+                    }
+
+                    $this->invokeCallbacks($entity, $metadata->preRemoveCallbacks);
+                    $db->deleteDocument($collection, $id);
+                    $this->identityMap->remove($collection, $id);
+                    $this->entityStates->detach($entity);
+
+                    if ($this->originalSnapshots->contains($entity)) {
+                        $this->originalSnapshots->detach($entity);
+                    }
+
+                    $this->invokeCallbacks($entity, $metadata->postRemoveCallbacks);
+                }
+            }
+        });
+
+        $this->scheduledInsertions = [];
+        $this->scheduledDeletions = [];
+    }
+
+    public function detach(object $entity): void
+    {
+        if ($this->entityStates->contains($entity)) {
+            $this->entityStates->detach($entity);
+        }
+
+        if ($this->originalSnapshots->contains($entity)) {
+            $this->originalSnapshots->detach($entity);
+        }
+
+        $key = \array_search($entity, $this->scheduledInsertions, true);
+        if ($key !== false) {
+            unset($this->scheduledInsertions[$key]);
+        }
+
+        $key = \array_search($entity, $this->scheduledDeletions, true);
+        if ($key !== false) {
+            unset($this->scheduledDeletions[$key]);
+        }
+
+        $metadata = $this->metadataFactory->getMetadata($entity::class);
+        $id = $this->entityMapper->getId($entity, $metadata);
+
+        if ($id !== null) {
+            $this->identityMap->remove($metadata->collection, $id);
+        }
+    }
+
+    public function clear(): void
+    {
+        $this->entityStates = new SplObjectStorage();
+        $this->originalSnapshots = new SplObjectStorage();
+        $this->scheduledInsertions = [];
+        $this->scheduledDeletions = [];
+        $this->identityMap->clear();
+    }
+
+    public function getState(object $entity): ?EntityState
+    {
+        if (! $this->entityStates->contains($entity)) {
+            return null;
+        }
+
+        return $this->entityStates[$entity];
+    }
+
+    public function getIdentityMap(): IdentityMap
+    {
+        return $this->identityMap;
+    }
+
+    private function cascadePersist(object $entity): void
+    {
+        $metadata = $this->metadataFactory->getMetadata($entity::class);
+
+        foreach ($metadata->relationships as $mapping) {
+            $ref = new \ReflectionProperty($entity, $mapping->propertyName);
+
+            if (! $ref->isInitialized($entity)) {
+                continue;
+            }
+
+            $value = $ref->getValue($entity);
+
+            if ($value === null) {
+                continue;
+            }
+
+            if (\is_array($value)) {
+                foreach ($value as $related) {
+                    if (\is_object($related) && ! $this->entityStates->contains($related)) {
+                        $this->persist($related);
+                    }
+                }
+            } elseif (\is_object($value) && ! $this->entityStates->contains($value)) {
+                $this->persist($value);
+            }
+        }
+    }
+
+    /**
+     * @param  array<string>  $methods
+     */
+    private function invokeCallbacks(object $entity, array $methods): void
+    {
+        foreach ($methods as $method) {
+            $entity->{$method}();
+        }
+    }
+}
diff --git a/src/Database/Operator.php b/src/Database/Operator.php
index b60b49fb6..b585613a0 100644
--- a/src/Database/Operator.php
+++ b/src/Database/Operator.php
@@ -13,117 +13,23 @@
  */
 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,
-    ];
-
-    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) {
@@ -134,14 +40,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
@@ -150,6 +60,8 @@ public function getAttribute(): string
     }
 
     /**
+     * Get all operator values.
+     *
      * @return array<mixed>
      */
     public function getValues(): array
@@ -158,7 +70,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
@@ -169,10 +83,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;
 
@@ -182,7 +96,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
@@ -195,7 +109,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
@@ -207,7 +121,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
@@ -220,34 +135,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;
     }
 
     /**
@@ -257,7 +154,7 @@ public static function isMethod(string $value): bool
      */
     public function isNumericOperation(): bool
     {
-        return \in_array($this->method, self::NUMERIC_TYPES);
+        return $this->method->isNumeric();
     }
 
     /**
@@ -267,7 +164,7 @@ public function isNumericOperation(): bool
      */
     public function isArrayOperation(): bool
     {
-        return \in_array($this->method, self::ARRAY_TYPES);
+        return $this->method->isArray();
     }
 
     /**
@@ -277,7 +174,7 @@ public function isArrayOperation(): bool
      */
     public function isStringOperation(): bool
     {
-        return \in_array($this->method, self::STRING_TYPES);
+        return $this->method->isString();
     }
 
     /**
@@ -287,10 +184,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
      *
@@ -298,13 +194,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
      */
@@ -312,21 +208,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
      */
@@ -336,57 +233,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
      */
@@ -395,16 +291,16 @@ 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 $value The amount to increment by
+     * @param  int|float|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
     {
@@ -412,15 +308,16 @@ public static function increment(int|float $value = 1, int|float|null $max = nul
         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 $value The amount to decrement by
+     * @param  int|float|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
     {
@@ -428,84 +325,84 @@ public static function decrement(int|float $value = 1, int|float|null $min = nul
         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 $factor The factor to multiply by
+     * @param  int|float|null  $max  Maximum value (won't multiply beyond this)
+     * @return self
      */
     public static function multiply(int|float $factor, int|float|null $max = null): self
     {
@@ -513,15 +410,16 @@ public static function multiply(int|float $factor, int|float|null $max = null):
         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 $divisor The divisor
+     * @param  int|float|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
@@ -533,57 +431,57 @@ 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  $divisor  The divisor for modulo operation
+     * @return self
      * @throws OperatorException if divisor is zero
      */
     public static function modulo(int|float $divisor): self
@@ -591,15 +489,16 @@ public static function modulo(int|float $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  $exponent  The exponent to raise to
+     * @param  int|float|null  $max  Maximum value (won't exceed this)
+     * @return self
      */
     public static function power(int|float $exponent, int|float|null $max = null): self
     {
@@ -607,58 +506,58 @@ public static function power(int|float $exponent, int|float|null $max = null): s
         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
@@ -669,16 +568,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);
@@ -694,5 +594,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 000000000..ac75158ba
--- /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 df6f7a9d6..123d8bfcb 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;
+use Throwable;
 use Utopia\Console;
 
 /**
  * A PDO wrapper that forwards method calls to the internal PDO instance.
  *
- * @mixin \PDO
+ * @mixin PhpPDO
+ *
+ * @method PDOStatement prepare(string $query, array<int, mixed> $options = [])
+ * @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)
  */
 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,7 +43,7 @@ public function __construct(
         protected ?string $password,
         protected array $config = []
     ) {
-        $this->pdo = new \PDO(
+        $this->pdo = new PhpPDO(
             $this->dsn,
             $this->username,
             $this->password,
@@ -35,18 +52,17 @@ public function __construct(
     }
 
     /**
-     * @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();
@@ -56,7 +72,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);
                 }
             }
@@ -67,12 +83,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,
@@ -83,8 +97,7 @@ public function reconnect(): void
     /**
      * Get the hostname from the DSN.
      *
-     * @return string
-     * @throws \Exception
+     * @throws Exception
      */
     public function getHostname(): string
     {
@@ -93,7 +106,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;
     }
@@ -102,11 +115,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.');
         }
 
@@ -117,6 +131,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;
         }
 
@@ -125,7 +140,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/PermissionType.php b/src/Database/PermissionType.php
new file mode 100644
index 000000000..dac87c723
--- /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 000000000..6841cde78
--- /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 000000000..bce6f8a70
--- /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 686a6ab37..777b85028 100644
--- a/src/Database/Query.php
+++ b/src/Database/Query.php
@@ -2,421 +2,98 @@
 
 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
-     *
-     * @param string $method
-     * @param string $attribute
-     * @param array<mixed> $values
+     * @param  array<mixed>  $values
      */
-    public function __construct(string $method, string $attribute = '', array $values = [])
+    public function __construct(Method|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;
-    }
+        $methodEnum = $method instanceof Method ? $method : Method::from($method);
 
-    public function __clone(): void
-    {
-        foreach ($this->values as $index => $value) {
-            if ($value instanceof self) {
-                $this->values[$index] = clone $value;
-            }
+        if ($attribute === '' && \in_array($methodEnum, [Method::OrderAsc, Method::OrderDesc])) {
+            $attribute = '$sequence';
         }
-    }
-
-    /**
-     * @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;
+        parent::__construct($methodEnum, $attribute, $values);
     }
 
     /**
-     * Sets attribute
-     *
-     * @param string $attribute
-     * @return self
-     */
-    public function setAttribute(string $attribute): self
-    {
-        $this->attribute = $attribute;
-
-        return $this;
-    }
-
-    /**
-     * Sets values
-     *
-     * @param array<mixed> $values
-     * @return self
-     */
-    public function setValues(array $values): self
-    {
-        $this->values = $values;
-
-        return $this;
-    }
-
-    /**
-     * Sets value
-     * @param mixed $value
-     * @return self
+     * @throws QueryException
      */
-    public function setValue(mixed $value): self
+    public static function parse(string $query): static
     {
-        $this->values = [$value];
+        try {
+            $parsed = parent::parse($query);
 
-        return $this;
+            return new static($parsed->getMethod(), $parsed->getAttribute(), $parsed->getValues());
+        } catch (BaseQueryException $e) {
+            throw new QueryException($e->getMessage(), $e->getCode(), $e);
+        }
     }
 
     /**
-     * Check if method is supported
+     * @param  array<string, mixed>  $query
      *
-     * @param string $value
-     * @return bool
+     * @throws QueryException
      */
-    public static function isMethod(string $value): bool
+    public static function parseQuery(array $query): 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::parseQuery($query);
 
-    /**
-     * 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 string $query
-     * @return self
-     * @throws QueryException
+     * @param  Document  $value
      */
-    public static function parse(string $query): self
+    public static function cursorAfter(mixed $value): static
     {
-        try {
-            $query = \json_decode($query, true, flags: JSON_THROW_ON_ERROR);
-        } catch (\JsonException $e) {
-            throw new QueryException('Invalid query: ' . $e->getMessage());
-        }
-
-        if (!\is_array($query)) {
-            throw new QueryException('Invalid query. Must be an array, got ' . \gettype($query));
-        }
-
-        return self::parseQuery($query);
+        return new static(Method::CursorAfter, values: [$value]);
     }
 
     /**
-     * Parse query
-     *
-     * @param array<string, mixed> $query
-     * @return self
-     * @throws QueryException
+     * @param  Document  $value
      */
-    public static function parseQuery(array $query): self
+    public static function cursorBefore(mixed $value): static
     {
-        $method = $query['method'] ?? '';
-        $attribute = $query['attribute'] ?? '';
-        $values = $query['values'] ?? [];
-
-        if (!\is_string($method)) {
-            throw new QueryException('Invalid query method. Must be a string, got ' . \gettype($method));
-        }
-
-        if (!self::isMethod($method)) {
-            throw new QueryException('Invalid query method: ' . $method);
-        }
-
-        if (!\is_string($attribute)) {
-            throw new QueryException('Invalid query attribute. Must be a string, got ' . \gettype($attribute));
-        }
-
-        if (!\is_array($values)) {
-            throw new QueryException('Invalid query values. Must be an array, got ' . \gettype($values));
-        }
-
-        if (\in_array($method, self::LOGICAL_TYPES)) {
-            foreach ($values as $index => $value) {
-                $values[$index] = self::parseQuery($value);
-            }
-        }
-
-        return new self($method, $attribute, $values);
+        return new static(Method::CursorBefore, values: [$value]);
     }
 
     /**
-     * Parse an array of queries
-     *
-     * @param array<string> $queries
-     *
-     * @return array<Query>
-     * @throws QueryException
+     * Check if method is supported. Accepts both string and Method enum.
      */
-    public static function parseQueries(array $queries): array
+    public static function isMethod(Method|string $value): bool
     {
-        $parsed = [];
-
-        foreach ($queries as $query) {
-            $parsed[] = Query::parse($query);
+        if ($value instanceof Method) {
+            return true;
         }
 
-        return $parsed;
+        return Method::tryFrom($value) !== null;
     }
 
     /**
@@ -424,20 +101,21 @@ public static function parseQueries(array $queries): array
      */
     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, [Method::And, Method::Or, Method::ElemMatch])) {
             foreach ($this->values as $index => $value) {
+                /** @var Query $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;
@@ -448,838 +126,79 @@ 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
-     *
-     * @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
+     * 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 $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
+    public static function groupForDatabase(array $queries): array
     {
-        $filters = [];
-        $selections = [];
-        $limit = null;
-        $offset = null;
-        $orderAttributes = [];
-        $orderTypes = [];
-        $cursor = null;
-        $cursorDirection = null;
-
-        foreach ($queries as $query) {
-            if (!$query instanceof Query) {
-                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;
-                    }
+        $grouped = parent::groupByType($queries);
 
-                    $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;
-            }
-        }
+        /** @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;
 
         return [
             'filters' => $filters,
             'selections' => $selections,
-            'limit' => $limit,
-            'offset' => $offset,
-            'orderAttributes' => $orderAttributes,
-            'orderTypes' => $orderTypes,
+            'aggregations' => $aggregations,
+            'groupBy' => $grouped->groupBy,
+            'having' => $having,
+            'joins' => $joins,
+            'distinct' => $grouped->distinct,
+            'limit' => $grouped->limit,
+            'offset' => $grouped->offset,
+            'orderAttributes' => $grouped->orderAttributes,
+            'orderTypes' => $grouped->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]);
-    }
-
-    /**
-     * Helper method to create Query with overlaps method
-     *
-     * @param string $attribute
-     * @param array<mixed> $values
-     * @return Query
-     */
-    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]);
+        $type = ColumnType::tryFrom($this->attributeType);
+        return in_array($type, [ColumnType::Point, ColumnType::Linestring, ColumnType::Polygon], true);
     }
 
     /**
-     * Helper method to create Query with vectorDot method
+     * Check whether this query targets an object (JSON/hashmap) attribute type.
      *
-     * @param string $attribute
-     * @param array<float> $vector
-     * @return Query
+     * @return bool True if the attribute type is object.
      */
-    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 000000000..1c0abacbd
--- /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 000000000..fafdad712
--- /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 000000000..d0d17a8a6
--- /dev/null
+++ b/src/Database/Relationship.php
@@ -0,0 +1,86 @@
+<?php
+
+namespace Utopia\Database;
+
+use Utopia\Query\Schema\ForeignKeyAction;
+
+/**
+ * Represents a relationship between two database collections, including its type, direction, and delete behavior.
+ */
+class Relationship
+{
+    public function __construct(
+        public string $collection,
+        public string $relatedCollection,
+        public RelationType $type,
+        public bool $twoWay = false,
+        public string $key = '',
+        public string $twoWayKey = '',
+        public ForeignKeyAction $onDelete = ForeignKeyAction::Restrict,
+        public RelationSide $side = RelationSide::Parent,
+    ) {
+    }
+
+    /**
+     * Convert this relationship to a Document representation.
+     *
+     * @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,
+        ]);
+    }
+
+    /**
+     * Create a Relationship instance from a collection ID and attribute Document.
+     *
+     * @param string $collection The parent collection ID
+     * @param Document $attribute The attribute document containing relationship options
+     * @return self
+     */
+    public static function fromDocument(string $collection, Document $attribute): self
+    {
+        $options = $attribute->getAttribute('options', []);
+
+        if ($options instanceof Document) {
+            $options = $options->getArrayCopy();
+        }
+
+        if (!\is_array($options)) {
+            $options = [];
+        }
+
+        /** @var string $relatedCollection */
+        $relatedCollection = $options['relatedCollection'] ?? '';
+        /** @var RelationType|string $relationType */
+        $relationType = $options['relationType'] ?? 'oneToOne';
+        /** @var bool $twoWay */
+        $twoWay = $options['twoWay'] ?? false;
+        /** @var string $key */
+        $key = $attribute->getAttribute('key', $attribute->getId());
+        /** @var string $twoWayKey */
+        $twoWayKey = $options['twoWayKey'] ?? '';
+        /** @var ForeignKeyAction|string $onDelete */
+        $onDelete = $options['onDelete'] ?? ForeignKeyAction::Restrict;
+        /** @var RelationSide|string $side */
+        $side = $options['side'] ?? RelationSide::Parent;
+
+        return new self(
+            collection: $collection,
+            relatedCollection: $relatedCollection,
+            type: $relationType instanceof RelationType ? $relationType : RelationType::from($relationType),
+            twoWay: $twoWay,
+            key: $key,
+            twoWayKey: $twoWayKey,
+            onDelete: $onDelete instanceof ForeignKeyAction ? $onDelete : ForeignKeyAction::from($onDelete),
+            side: $side instanceof RelationSide ? $side : RelationSide::from($side),
+        );
+    }
+}
diff --git a/src/Database/Repository/CompositeSpecification.php b/src/Database/Repository/CompositeSpecification.php
new file mode 100644
index 000000000..620994159
--- /dev/null
+++ b/src/Database/Repository/CompositeSpecification.php
@@ -0,0 +1,59 @@
+<?php
+
+namespace Utopia\Database\Repository;
+
+use Utopia\Database\Query;
+
+class CompositeSpecification implements Specification
+{
+    /**
+     * @param  array<Specification>  $specs
+     */
+    public function __construct(
+        private array $specs,
+        private string $operator = 'and',
+    ) {
+    }
+
+    /**
+     * @return array<Query>
+     */
+    public function toQueries(): array
+    {
+        $queries = [];
+
+        if ($this->operator === 'or') {
+            $groups = [];
+            foreach ($this->specs as $spec) {
+                $groups[] = $spec->toQueries();
+            }
+
+            if ($groups !== []) {
+                $orQueries = [];
+                foreach ($groups as $group) {
+                    $orQueries[] = Query::or($group);
+                }
+
+                return $orQueries;
+            }
+
+            return [];
+        }
+
+        foreach ($this->specs as $spec) {
+            $queries = \array_merge($queries, $spec->toQueries());
+        }
+
+        return $queries;
+    }
+
+    public function and(Specification $other): Specification
+    {
+        return new self([$this, $other], 'and');
+    }
+
+    public function or(Specification $other): Specification
+    {
+        return new self([$this, $other], 'or');
+    }
+}
diff --git a/src/Database/Repository/Repository.php b/src/Database/Repository/Repository.php
new file mode 100644
index 000000000..a251c9bd3
--- /dev/null
+++ b/src/Database/Repository/Repository.php
@@ -0,0 +1,108 @@
+<?php
+
+namespace Utopia\Database\Repository;
+
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Query;
+
+abstract class Repository
+{
+    /** @var array<Scope> */
+    private array $globalScopes = [];
+
+    public function __construct(
+        protected Database $db,
+    ) {
+    }
+
+    abstract public function collection(): string;
+
+    public function addScope(Scope $scope): void
+    {
+        $this->globalScopes[] = $scope;
+    }
+
+    public function clearScopes(): void
+    {
+        $this->globalScopes = [];
+    }
+
+    /**
+     * @param  array<Query>  $queries
+     * @return array<Query>
+     */
+    protected function applyScopes(array $queries): array
+    {
+        foreach ($this->globalScopes as $scope) {
+            $queries = \array_merge($queries, $scope->apply());
+        }
+
+        return $queries;
+    }
+
+    /**
+     * @param  array<Query>  $queries
+     * @return array<Document>
+     */
+    public function withoutScopes(array $queries = []): array
+    {
+        return $this->db->find($this->collection(), $queries);
+    }
+
+    public function findById(string $id): Document
+    {
+        return $this->db->getDocument($this->collection(), $id);
+    }
+
+    /**
+     * @param  array<Query>  $queries
+     * @return array<Document>
+     */
+    public function findAll(array $queries = []): array
+    {
+        return $this->db->find($this->collection(), $this->applyScopes($queries));
+    }
+
+    public function findOneBy(string $attribute, mixed $value): Document
+    {
+        $results = $this->db->find($this->collection(), $this->applyScopes([
+            Query::equal($attribute, \is_array($value) ? $value : [$value]),
+            Query::limit(1),
+        ]));
+
+        return $results[0] ?? new Document();
+    }
+
+    /**
+     * @param  array<Query>  $queries
+     */
+    public function count(array $queries = []): int
+    {
+        return $this->db->count($this->collection(), $this->applyScopes($queries));
+    }
+
+    public function create(Document $document): Document
+    {
+        return $this->db->createDocument($this->collection(), $document);
+    }
+
+    public function update(string $id, Document $document): Document
+    {
+        return $this->db->updateDocument($this->collection(), $id, $document);
+    }
+
+    public function delete(string $id): bool
+    {
+        return $this->db->deleteDocument($this->collection(), $id);
+    }
+
+    /**
+     * @param  array<Query>  $baseQueries
+     * @return array<Document>
+     */
+    public function matching(Specification $spec, array $baseQueries = []): array
+    {
+        return $this->findAll(\array_merge($baseQueries, $spec->toQueries()));
+    }
+}
diff --git a/src/Database/Repository/Scope.php b/src/Database/Repository/Scope.php
new file mode 100644
index 000000000..13df2b848
--- /dev/null
+++ b/src/Database/Repository/Scope.php
@@ -0,0 +1,13 @@
+<?php
+
+namespace Utopia\Database\Repository;
+
+use Utopia\Database\Query;
+
+interface Scope
+{
+    /**
+     * @return array<Query>
+     */
+    public function apply(): array;
+}
diff --git a/src/Database/Repository/Specification.php b/src/Database/Repository/Specification.php
new file mode 100644
index 000000000..d9babad56
--- /dev/null
+++ b/src/Database/Repository/Specification.php
@@ -0,0 +1,17 @@
+<?php
+
+namespace Utopia\Database\Repository;
+
+use Utopia\Database\Query;
+
+interface Specification
+{
+    /**
+     * @return array<Query>
+     */
+    public function toQueries(): array;
+
+    public function and(Specification $other): Specification;
+
+    public function or(Specification $other): Specification;
+}
diff --git a/src/Database/Schema/DiffResult.php b/src/Database/Schema/DiffResult.php
new file mode 100644
index 000000000..c8d96b69d
--- /dev/null
+++ b/src/Database/Schema/DiffResult.php
@@ -0,0 +1,79 @@
+<?php
+
+namespace Utopia\Database\Schema;
+
+use Utopia\Database\Database;
+
+class DiffResult
+{
+    /**
+     * @param  array<SchemaChange>  $changes
+     */
+    public function __construct(
+        public readonly array $changes,
+    ) {
+    }
+
+    public function hasChanges(): bool
+    {
+        return $this->changes !== [];
+    }
+
+    public function apply(Database $db, string $collectionId): void
+    {
+        foreach ($this->changes as $change) {
+            match ($change->type) {
+                SchemaChangeType::AddAttribute => $change->attribute !== null
+                    ? $db->createAttribute($collectionId, $change->attribute)
+                    : null,
+                SchemaChangeType::DropAttribute => $change->attribute !== null
+                    ? $db->deleteAttribute($collectionId, $change->attribute->key)
+                    : null,
+                SchemaChangeType::ModifyAttribute => $change->attribute !== null
+                    ? $db->updateAttribute($collectionId, $change->attribute->key, $change->attribute)
+                    : null,
+                SchemaChangeType::AddIndex => $change->index !== null
+                    ? $db->createIndex($collectionId, $change->index)
+                    : null,
+                SchemaChangeType::DropIndex => $change->index !== null
+                    ? $db->deleteIndex($collectionId, $change->index->key)
+                    : null,
+                default => null,
+            };
+        }
+    }
+
+    /**
+     * @return array<SchemaChange>
+     */
+    public function getAdditions(): array
+    {
+        return \array_filter($this->changes, fn (SchemaChange $c) => \in_array($c->type, [
+            SchemaChangeType::AddAttribute,
+            SchemaChangeType::AddIndex,
+            SchemaChangeType::AddRelationship,
+            SchemaChangeType::CreateCollection,
+        ], true));
+    }
+
+    /**
+     * @return array<SchemaChange>
+     */
+    public function getRemovals(): array
+    {
+        return \array_filter($this->changes, fn (SchemaChange $c) => \in_array($c->type, [
+            SchemaChangeType::DropAttribute,
+            SchemaChangeType::DropIndex,
+            SchemaChangeType::DropRelationship,
+            SchemaChangeType::DropCollection,
+        ], true));
+    }
+
+    /**
+     * @return array<SchemaChange>
+     */
+    public function getModifications(): array
+    {
+        return \array_filter($this->changes, fn (SchemaChange $c) => $c->type === SchemaChangeType::ModifyAttribute);
+    }
+}
diff --git a/src/Database/Schema/Introspector.php b/src/Database/Schema/Introspector.php
new file mode 100644
index 000000000..461e637dd
--- /dev/null
+++ b/src/Database/Schema/Introspector.php
@@ -0,0 +1,138 @@
+<?php
+
+namespace Utopia\Database\Schema;
+
+use Utopia\Database\Collection;
+use Utopia\Database\Database;
+
+class Introspector
+{
+    public function __construct(
+        private Database $db,
+    ) {
+    }
+
+    public function introspectCollection(string $collectionId): Collection
+    {
+        $collectionDoc = $this->db->getCollection($collectionId);
+
+        if ($collectionDoc->isEmpty()) {
+            throw new \RuntimeException("Collection '{$collectionId}' not found");
+        }
+
+        return Collection::fromDocument($collectionDoc);
+    }
+
+    /**
+     * @return array<Collection>
+     */
+    public function introspectDatabase(): array
+    {
+        $collections = $this->db->listCollections();
+        $result = [];
+
+        foreach ($collections as $doc) {
+            $result[] = Collection::fromDocument($doc);
+        }
+
+        return $result;
+    }
+
+    public function generateEntityClass(string $collectionId, string $namespace = 'App\\Entity'): string
+    {
+        $collection = $this->introspectCollection($collectionId);
+        $className = $this->toPascalCase($collection->name ?: $collection->id);
+
+        $lines = [];
+        $lines[] = '<?php';
+        $lines[] = '';
+        $lines[] = "namespace {$namespace};";
+        $lines[] = '';
+        $lines[] = 'use Utopia\Database\ORM\Mapping\Column;';
+        $lines[] = 'use Utopia\Database\ORM\Mapping\Entity;';
+        $lines[] = 'use Utopia\Database\ORM\Mapping\Id;';
+        $lines[] = 'use Utopia\Database\ORM\Mapping\CreatedAt;';
+        $lines[] = 'use Utopia\Database\ORM\Mapping\UpdatedAt;';
+        $lines[] = 'use Utopia\Database\ORM\Mapping\Version;';
+        $lines[] = 'use Utopia\Query\Schema\ColumnType;';
+        $lines[] = '';
+        $lines[] = "#[Entity(collection: '{$collection->id}')]";
+        $lines[] = "class {$className}";
+        $lines[] = '{';
+        $lines[] = '    #[Id]';
+        $lines[] = '    public string $id = \'\';';
+        $lines[] = '';
+        $lines[] = '    #[Version]';
+        $lines[] = '    public ?int $version = null;';
+        $lines[] = '';
+        $lines[] = '    #[CreatedAt]';
+        $lines[] = '    public ?string $createdAt = null;';
+        $lines[] = '';
+        $lines[] = '    #[UpdatedAt]';
+        $lines[] = '    public ?string $updatedAt = null;';
+
+        foreach ($collection->attributes as $attr) {
+            $lines[] = '';
+            $phpType = $this->columnTypeToPhpType($attr->type, $attr->required, $attr->array);
+            $typeParam = $this->columnTypeToEnumString($attr->type);
+            $sizeParam = $attr->size > 0 ? ", size: {$attr->size}" : '';
+            $requiredParam = $attr->required ? ', required: true' : '';
+            $defaultParam = '';
+
+            if ($attr->default !== null) {
+                $defaultParam = match (true) {
+                    \is_string($attr->default) => " = '{$attr->default}'",
+                    \is_bool($attr->default) => ' = ' . ($attr->default ? 'true' : 'false'),
+                    \is_int($attr->default), \is_float($attr->default) => " = {$attr->default}",
+                    default => '',
+                };
+            } elseif (! $attr->required) {
+                $defaultParam = ' = null';
+            }
+
+            $lines[] = "    #[Column(type: {$typeParam}{$sizeParam}{$requiredParam})]";
+            $lines[] = "    public {$phpType} \${$attr->key}{$defaultParam};";
+        }
+
+        $lines[] = '}';
+        $lines[] = '';
+
+        return \implode("\n", $lines);
+    }
+
+    private function toPascalCase(string $value): string
+    {
+        return \str_replace(' ', '', \ucwords(\str_replace(['_', '-'], ' ', $value)));
+    }
+
+    private function columnTypeToPhpType(\Utopia\Query\Schema\ColumnType $type, bool $required, bool $array): string
+    {
+        if ($array) {
+            return 'array';
+        }
+
+        $base = match ($type) {
+            \Utopia\Query\Schema\ColumnType::String,
+            \Utopia\Query\Schema\ColumnType::Varchar,
+            \Utopia\Query\Schema\ColumnType::Text,
+            \Utopia\Query\Schema\ColumnType::MediumText,
+            \Utopia\Query\Schema\ColumnType::LongText,
+            \Utopia\Query\Schema\ColumnType::Enum,
+            \Utopia\Query\Schema\ColumnType::Datetime,
+            \Utopia\Query\Schema\ColumnType::Timestamp => 'string',
+            \Utopia\Query\Schema\ColumnType::Integer,
+            \Utopia\Query\Schema\ColumnType::BigInteger => 'int',
+            \Utopia\Query\Schema\ColumnType::Float,
+            \Utopia\Query\Schema\ColumnType::Double => 'float',
+            \Utopia\Query\Schema\ColumnType::Boolean => 'bool',
+            default => 'mixed',
+        };
+
+        return $required ? $base : "?{$base}";
+    }
+
+    private function columnTypeToEnumString(\Utopia\Query\Schema\ColumnType $type): string
+    {
+        return 'ColumnType::' . \ucfirst($type->value);
+    }
+}
diff --git a/src/Database/Schema/SchemaChange.php b/src/Database/Schema/SchemaChange.php
new file mode 100644
index 000000000..4a60316f8
--- /dev/null
+++ b/src/Database/Schema/SchemaChange.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace Utopia\Database\Schema;
+
+use Utopia\Database\Attribute;
+use Utopia\Database\Index;
+
+class SchemaChange
+{
+    public function __construct(
+        public readonly SchemaChangeType $type,
+        public readonly ?Attribute $attribute = null,
+        public readonly ?Attribute $previousAttribute = null,
+        public readonly ?Index $index = null,
+        public readonly ?string $collectionId = null,
+    ) {
+    }
+}
diff --git a/src/Database/Schema/SchemaChangeType.php b/src/Database/Schema/SchemaChangeType.php
new file mode 100644
index 000000000..5bbedc736
--- /dev/null
+++ b/src/Database/Schema/SchemaChangeType.php
@@ -0,0 +1,16 @@
+<?php
+
+namespace Utopia\Database\Schema;
+
+enum SchemaChangeType
+{
+    case CreateCollection;
+    case DropCollection;
+    case AddAttribute;
+    case DropAttribute;
+    case ModifyAttribute;
+    case AddIndex;
+    case DropIndex;
+    case AddRelationship;
+    case DropRelationship;
+}
diff --git a/src/Database/Schema/SchemaDiff.php b/src/Database/Schema/SchemaDiff.php
new file mode 100644
index 000000000..5430084a0
--- /dev/null
+++ b/src/Database/Schema/SchemaDiff.php
@@ -0,0 +1,77 @@
+<?php
+
+namespace Utopia\Database\Schema;
+
+use Utopia\Database\Attribute;
+use Utopia\Database\Collection;
+
+class SchemaDiff
+{
+    public function diff(Collection $source, Collection $target): DiffResult
+    {
+        $changes = [];
+
+        $sourceAttrs = [];
+        foreach ($source->attributes as $attr) {
+            $sourceAttrs[$attr->key] = $attr;
+        }
+
+        $targetAttrs = [];
+        foreach ($target->attributes as $attr) {
+            $targetAttrs[$attr->key] = $attr;
+        }
+
+        foreach ($targetAttrs as $key => $attr) {
+            if (! isset($sourceAttrs[$key])) {
+                $changes[] = new SchemaChange(SchemaChangeType::AddAttribute, attribute: $attr);
+            } elseif ($this->attributeDiffers($sourceAttrs[$key], $attr)) {
+                $changes[] = new SchemaChange(
+                    SchemaChangeType::ModifyAttribute,
+                    attribute: $attr,
+                    previousAttribute: $sourceAttrs[$key],
+                );
+            }
+        }
+
+        foreach ($sourceAttrs as $key => $attr) {
+            if (! isset($targetAttrs[$key])) {
+                $changes[] = new SchemaChange(SchemaChangeType::DropAttribute, attribute: $attr);
+            }
+        }
+
+        $sourceIndexes = [];
+        foreach ($source->indexes as $idx) {
+            $sourceIndexes[$idx->key] = $idx;
+        }
+
+        $targetIndexes = [];
+        foreach ($target->indexes as $idx) {
+            $targetIndexes[$idx->key] = $idx;
+        }
+
+        foreach ($targetIndexes as $key => $idx) {
+            if (! isset($sourceIndexes[$key])) {
+                $changes[] = new SchemaChange(SchemaChangeType::AddIndex, index: $idx);
+            }
+        }
+
+        foreach ($sourceIndexes as $key => $idx) {
+            if (! isset($targetIndexes[$key])) {
+                $changes[] = new SchemaChange(SchemaChangeType::DropIndex, index: $idx);
+            }
+        }
+
+        return new DiffResult($changes);
+    }
+
+    private function attributeDiffers(Attribute $source, Attribute $target): bool
+    {
+        return $source->type !== $target->type
+            || $source->size !== $target->size
+            || $source->required !== $target->required
+            || $source->signed !== $target->signed
+            || $source->array !== $target->array
+            || $source->format !== $target->format
+            || $source->default !== $target->default;
+    }
+}
diff --git a/src/Database/Seeder/Factory.php b/src/Database/Seeder/Factory.php
new file mode 100644
index 000000000..a954e0ccf
--- /dev/null
+++ b/src/Database/Seeder/Factory.php
@@ -0,0 +1,79 @@
+<?php
+
+namespace Utopia\Database\Seeder;
+
+use Faker\Factory as FakerFactory;
+use Faker\Generator;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+
+class Factory
+{
+    private Generator $faker;
+
+    /** @var array<string, FactoryDefinition> */
+    private array $definitions = [];
+
+    public function __construct(?Generator $faker = null)
+    {
+        $this->faker = $faker ?? FakerFactory::create();
+    }
+
+    public function define(string $collection, callable $definition): void
+    {
+        $this->definitions[$collection] = new FactoryDefinition($definition);
+    }
+
+    /**
+     * @param  array<string, mixed>  $overrides
+     */
+    public function make(string $collection, array $overrides = []): Document
+    {
+        if (! isset($this->definitions[$collection])) {
+            throw new \RuntimeException("No factory defined for collection '{$collection}'");
+        }
+
+        /** @var array<string, mixed> $data */
+        $data = ($this->definitions[$collection]->callback)($this->faker);
+
+        return new Document(\array_merge($data, $overrides));
+    }
+
+    /**
+     * @param  array<string, mixed>  $overrides
+     * @return array<Document>
+     */
+    public function makeMany(string $collection, int $count, array $overrides = []): array
+    {
+        $documents = [];
+        for ($i = 0; $i < $count; $i++) {
+            $documents[] = $this->make($collection, $overrides);
+        }
+
+        return $documents;
+    }
+
+    /**
+     * @param  array<string, mixed>  $overrides
+     */
+    public function create(string $collection, Database $db, array $overrides = []): Document
+    {
+        return $db->createDocument($collection, $this->make($collection, $overrides));
+    }
+
+    /**
+     * @param  array<string, mixed>  $overrides
+     * @return array<Document>
+     */
+    public function createMany(string $collection, Database $db, int $count, array $overrides = []): array
+    {
+        $documents = $this->makeMany($collection, $count, $overrides);
+
+        return $db->createDocuments($collection, $documents);
+    }
+
+    public function getFaker(): Generator
+    {
+        return $this->faker;
+    }
+}
diff --git a/src/Database/Seeder/FactoryDefinition.php b/src/Database/Seeder/FactoryDefinition.php
new file mode 100644
index 000000000..ce2fa6fc3
--- /dev/null
+++ b/src/Database/Seeder/FactoryDefinition.php
@@ -0,0 +1,14 @@
+<?php
+
+namespace Utopia\Database\Seeder;
+
+class FactoryDefinition
+{
+    /** @var callable */
+    public $callback;
+
+    public function __construct(callable $callback)
+    {
+        $this->callback = $callback;
+    }
+}
diff --git a/src/Database/Seeder/Fixture.php b/src/Database/Seeder/Fixture.php
new file mode 100644
index 000000000..636425a57
--- /dev/null
+++ b/src/Database/Seeder/Fixture.php
@@ -0,0 +1,64 @@
+<?php
+
+namespace Utopia\Database\Seeder;
+
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+
+class Fixture
+{
+    /** @var array<array{collection: string, id: string}> */
+    private array $created = [];
+
+    /**
+     * @param  array<array<string, mixed>>  $documents
+     */
+    public function load(Database $db, string $collection, array $documents): void
+    {
+        if ($documents === []) {
+            return;
+        }
+
+        $docs = \array_map(fn (array $d) => new Document($d), $documents);
+
+        if (\count($docs) === 1) {
+            $created = $db->createDocument($collection, $docs[0]);
+            $this->created[] = ['collection' => $collection, 'id' => $created->getId()];
+        } else {
+            $db->createDocuments($collection, $docs, Database::INSERT_BATCH_SIZE, function (Document $created) use ($collection): void {
+                $this->created[] = ['collection' => $collection, 'id' => $created->getId()];
+            });
+        }
+    }
+
+    public function cleanup(Database $db): void
+    {
+        if ($this->created === []) {
+            return;
+        }
+
+        $grouped = [];
+        foreach (\array_reverse($this->created) as $entry) {
+            $grouped[$entry['collection']][] = $entry['id'];
+        }
+
+        foreach ($grouped as $collection => $ids) {
+            foreach ($ids as $id) {
+                try {
+                    $db->deleteDocument($collection, $id);
+                } catch (\Throwable) {
+                }
+            }
+        }
+
+        $this->created = [];
+    }
+
+    /**
+     * @return array<array{collection: string, id: string}>
+     */
+    public function getCreated(): array
+    {
+        return $this->created;
+    }
+}
diff --git a/src/Database/Seeder/Seeder.php b/src/Database/Seeder/Seeder.php
new file mode 100644
index 000000000..9801b7c6d
--- /dev/null
+++ b/src/Database/Seeder/Seeder.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace Utopia\Database\Seeder;
+
+use Utopia\Database\Database;
+
+abstract class Seeder
+{
+    /**
+     * @return array<class-string<Seeder>>
+     */
+    public function dependencies(): array
+    {
+        return [];
+    }
+
+    abstract public function run(Database $db): void;
+}
diff --git a/src/Database/Seeder/SeederRunner.php b/src/Database/Seeder/SeederRunner.php
new file mode 100644
index 000000000..f0ed52c0d
--- /dev/null
+++ b/src/Database/Seeder/SeederRunner.php
@@ -0,0 +1,80 @@
+<?php
+
+namespace Utopia\Database\Seeder;
+
+use Utopia\Async\Promise;
+use Utopia\Database\Database;
+
+class SeederRunner
+{
+    /** @var array<class-string<Seeder>, Seeder> */
+    private array $seeders = [];
+
+    /** @var array<string, bool> */
+    private array $executed = [];
+
+    public function register(Seeder $seeder): void
+    {
+        $this->seeders[$seeder::class] = $seeder;
+    }
+
+    public function run(Database $db): void
+    {
+        $this->executed = [];
+        $remaining = $this->seeders;
+
+        while ($remaining !== []) {
+            $ready = [];
+            foreach ($remaining as $class => $seeder) {
+                $deps = $seeder->dependencies();
+                $allDepsResolved = true;
+                foreach ($deps as $dep) {
+                    if (! isset($this->executed[$dep])) {
+                        $allDepsResolved = false;
+                        break;
+                    }
+                }
+                if ($allDepsResolved) {
+                    $ready[$class] = $seeder;
+                }
+            }
+
+            if ($ready === []) {
+                $unresolved = \implode(', ', \array_keys($remaining));
+                throw new \RuntimeException("Circular dependency detected in seeders: {$unresolved}");
+            }
+
+            if (\count($ready) > 1) {
+                $tasks = [];
+                foreach ($ready as $class => $seeder) {
+                    $tasks[] = function () use ($seeder, $db): void {
+                        $seeder->run($db);
+                    };
+                }
+                Promise::map($tasks)->await();
+            } else {
+                foreach ($ready as $seeder) {
+                    $seeder->run($db);
+                }
+            }
+
+            foreach ($ready as $class => $seeder) {
+                $this->executed[$class] = true;
+                unset($remaining[$class]);
+            }
+        }
+    }
+
+    /**
+     * @return array<string, bool>
+     */
+    public function getExecuted(): array
+    {
+        return $this->executed;
+    }
+
+    public function reset(): void
+    {
+        $this->executed = [];
+    }
+}
diff --git a/src/Database/SetType.php b/src/Database/SetType.php
new file mode 100644
index 000000000..ef8ea0b40
--- /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/Traits/Async.php b/src/Database/Traits/Async.php
new file mode 100644
index 000000000..6fe8cab54
--- /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 000000000..6115eb64f
--- /dev/null
+++ b/src/Database/Traits/Attributes.php
@@ -0,0 +1,1397 @@
+<?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\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;
+        }
+
+        $existsInSchema = false;
+
+        $schemaAttributes = $this->adapter instanceof Feature\SchemaAttributes
+            ? $this->getSchemaAttributes($collection->getId())
+            : [];
+
+        try {
+            $attributeDoc = $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<Document> $checkAttrs */
+            $checkAttrs = $collection->getAttribute('attributes', []);
+            foreach ($checkAttrs as $attr) {
+                $attrKey = $attr->getAttribute('key', $attr->getId());
+                if (\strtolower(\is_string($attrKey) ? $attrKey : '') === \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->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;
+            }
+
+            $attributeDoc = $attribute->toDocument();
+        }
+
+        $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', $attributeDoc, 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->trigger(Event::DocumentPurge, new Document([
+            '$id' => $collection->getId(),
+            '$collection' => self::METADATA,
+        ]));
+
+        $this->trigger(Event::AttributeCreate, $attributeDoc);
+
+        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 instanceof Feature\SchemaAttributes
+            ? $this->getSchemaAttributes($collection->getId())
+            : [];
+
+        $attributeDocuments = [];
+        $attributesToCreate = [];
+        foreach ($attributes as $attribute) {
+            if (empty($attribute->key)) {
+                throw new DatabaseException('Missing attribute key');
+            }
+            if (empty($attribute->type)) {
+                throw new DatabaseException('Missing attribute type');
+            }
+
+            $existsInSchema = false;
+
+            try {
+                $attributeDocument = $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<Document> $checkAttrs2 */
+                $checkAttrs2 = $collection->getAttribute('attributes', []);
+                foreach ($checkAttrs2 as $attr) {
+                    $attrKey2 = $attr->getAttribute('key', $attr->getId());
+                    if (\strtolower(\is_string($attrKey2) ? $attrKey2 : '') === \strtolower($attribute->key)) {
+                        $existsInMetadata = true;
+                        break;
+                    }
+                }
+
+                if ($existsInMetadata) {
+                    throw $e;
+                }
+
+                // Schema-only orphan — check type match
+                $expectedColumnType = $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;
+                        }
+                    }
+                }
+
+                $attributeDocument = $attribute->toDocument();
+            }
+
+            $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
+                        );
+                        $created = true;
+                    } catch (DuplicateException) {
+                        // Column already exists in schema — skip
+                    }
+                }
+            }
+        }
+
+        foreach ($attributeDocuments as $attributeDocument) {
+            $collection->setAttribute('attributes', $attributeDocument, SetType::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()));
+
+        $this->trigger(Event::DocumentPurge, new Document([
+            '$id' => $collection->getId(),
+            '$collection' => self::METADATA,
+        ]));
+
+        $this->trigger(Event::AttributeCreate, $attributeDocuments);
+
+        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
+    ): Document {
+        $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, SetType::Append);
+
+        /** @var array<Document> $existingAttributes */
+        $existingAttributes = $collection->getAttribute('attributes', []);
+        $typedExistingAttrs = array_map(fn (Document $doc) => Attribute::fromDocument($doc), $existingAttributes);
+
+        $resolvedSchemaAttributes = $schemaAttributes ?? ($this->adapter instanceof Feature\SchemaAttributes
+            ? $this->getSchemaAttributes($collection->getId())
+            : []);
+        $typedSchemaAttrs = array_map(fn (Document $doc) => Attribute::fromDocument($doc), $resolvedSchemaAttributes);
+
+        $validator = new AttributeValidator(
+            attributes: $typedExistingAttrs,
+            schemaAttributes: $typedSchemaAttrs,
+            maxAttributes: $this->adapter->getLimitForAttributes(),
+            maxWidth: $this->adapter->getDocumentSizeLimit(),
+            maxStringLength: $this->adapter->getLimitForString(),
+            maxVarcharLength: $this->adapter->getMaxVarcharLength(),
+            maxIntLength: $this->adapter->getLimitForInt(),
+            supportForSchemaAttributes: $this->adapter instanceof Feature\SchemaAttributes,
+            supportForVectors: $this->adapter->supports(Capability::Vectors),
+            supportForSpatialAttributes: $this->adapter instanceof Feature\Spatial,
+            supportForObject: $this->adapter->supports(Capability::Objects),
+            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): 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, [ColumnType::Point->value, ColumnType::Linestring->value, ColumnType::Polygon->value]) && $type != ColumnType::Object->value) {
+                /** @var array<mixed> $defaultArr */
+                $defaultArr = $default;
+                foreach ($defaultArr as $value) {
+                    $this->validateDefaultTypes($type, $value);
+                }
+            }
+
+            return;
+        }
+
+        $defaultStr = \is_scalar($default) ? (string) $default : '[non-scalar]';
+
+        switch ($type) {
+            case ColumnType::String->value:
+            case ColumnType::Varchar->value:
+            case ColumnType::Text->value:
+            case ColumnType::MediumText->value:
+            case ColumnType::LongText->value:
+                if ($defaultType !== 'string') {
+                    throw new DatabaseException('Default value '.$defaultStr.' does not match given type '.$type);
+                }
+                break;
+            case ColumnType::Integer->value:
+            case ColumnType::Double->value:
+            case ColumnType::Boolean->value:
+                if ($type !== $defaultType) {
+                    throw new DatabaseException('Default value '.$defaultStr.' does not match given type '.$type);
+                }
+                break;
+            case ColumnType::Datetime->value:
+                if ($defaultType !== ColumnType::String->value) {
+                    throw new DatabaseException('Default value '.$defaultStr.' does not match given type '.$type);
+                }
+                break;
+            case ColumnType::Vector->value:
+                // 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::Double->value,
+                    ColumnType::Boolean->value,
+                    ColumnType::Datetime->value,
+                    ColumnType::Relationship->value,
+                ];
+                if ($this->adapter->supports(Capability::Vectors)) {
+                    $supportedTypes[] = ColumnType::Vector->value;
+                }
+                if ($this->adapter instanceof Feature\Spatial) {
+                    \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));
+        }
+    }
+
+    /**
+     * Update attribute metadata. Utility method for update attribute methods.
+     *
+     * @param  callable(Document, Document, int|string): void  $updateCallback  method that receives document, and returns it with changes applied
+     *
+     * @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');
+        }
+
+        /** @var array<Document> $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');
+        }
+
+        /** @var Document $attributeDoc */
+        $attributeDoc = $attributes[$index];
+
+        // Execute update from callback
+        $updateCallback($attributeDoc, $collection, $index);
+        $attributes[$index] = $attributeDoc;
+
+        $collection->setAttribute('attributes', $attributes);
+
+        $this->updateMetadata(
+            collection: $collection,
+            rollbackOperation: null,
+            shouldRollback: false,
+            operationDescription: "attribute metadata update '{$id}'"
+        );
+
+        $this->trigger(Event::AttributeUpdate, $attributeDoc);
+
+        return $attributeDoc;
+    }
+
+    /**
+     * 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 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  The collection identifier
+     * @param  string  $id  The attribute identifier
+     * @param  string  $format  Validation format of attribute
+     * @return Document The updated attribute document
+     *
+     * @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');
+            $attrType = $rawType instanceof ColumnType ? $rawType : ColumnType::from((string) $rawType);
+            if (! Structure::hasFormat($format, $attrType)) {
+                throw new DatabaseException('Format "'.$format.'" not available for attribute type "'.$attrType->value.'"');
+            }
+
+            $attribute->setAttribute('format', $format);
+        });
+    }
+
+    /**
+     * 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 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  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 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  The collection identifier
+     * @param  string  $id  The attribute identifier
+     * @param  mixed  $default  The new default value
+     * @return Document The updated attribute 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');
+            }
+
+            $rawAttrType = $attribute->getAttribute('type');
+            $this->validateDefaultTypes(\is_string($rawAttrType) ? $rawAttrType : '', $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  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 document
+     *
+     * @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
+    {
+        if ($type instanceof ColumnType) {
+            $type = $type->value;
+        }
+        $collectionDoc = $this->silent(fn () => $this->getCollection($collection));
+
+        if ($collectionDoc->getId() === self::METADATA) {
+            throw new DatabaseException('Cannot update metadata attributes');
+        }
+
+        /** @var array<Document> $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');
+        }
+
+        /** @var Document $attribute */
+        $attribute = $attributes[$attributeIndex];
+
+        /** @var string $originalType */
+        $originalType = $attribute->getAttribute('type');
+        /** @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) {
+            /** @var string $type */
+            $type = $attribute->getAttribute('type');
+        }
+        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 ($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::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 instanceof Feature\Spatial)) {
+                    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::Double->value,
+                    ColumnType::Boolean->value,
+                    ColumnType::Datetime->value,
+                    ColumnType::Relationship->value,
+                ];
+                if ($this->adapter->supports(Capability::Vectors)) {
+                    $supportedTypes[] = ColumnType::Vector->value;
+                }
+                if ($this->adapter instanceof Feature\Spatial) {
+                    \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, ColumnType::from($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);
+
+        /** @var array<Document> $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 $attrDoc) {
+                $typedAttr = Attribute::fromDocument($attrDoc);
+                $typedAttributeMap[\strtolower($typedAttr->key)] = $typedAttr;
+            }
+
+            /** @var array<Document> $spatialIndexes */
+            $spatialIndexes = $collectionDoc->getAttribute('indexes', []);
+            foreach ($spatialIndexes as $index) {
+                $typedIndex = Index::fromDocument($index);
+                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<Document> $depIndexes */
+                $depIndexes = $collectionDoc->getAttribute('indexes', []);
+                $typedDepIndexes = array_map(fn (Document $d) => Index::fromDocument($d), $depIndexes);
+                $validator = new IndexDependencyValidator(
+                    $typedDepIndexes,
+                    $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) {
+                $typedAttrsForValidation = array_map(fn (Document $d) => Attribute::fromDocument($d), $attributes);
+                $typedOriginalIndexes = array_map(fn (Document $d) => Index::fromDocument($d), $originalIndexes);
+                $validator = new IndexValidator(
+                    $typedAttrsForValidation,
+                    $typedOriginalIndexes,
+                    $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 instanceof Feature\Spatial,
+                    $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: ColumnType::from($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: ColumnType::from($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->trigger(Event::DocumentPurge, new Document([
+            '$id' => $collection,
+            '$collection' => self::METADATA,
+        ]));
+
+        $this->trigger(Event::AttributeUpdate, $attribute);
+
+        return $attribute;
+    }
+
+    /**
+     * Checks if attribute can be added to collection without exceeding limits.
+     *
+     * @param  Document  $collection  The collection document
+     * @param  Document  $attribute  The attribute document to check
+     * @return bool True if the attribute can be added
+     *
+     * @throws LimitException
+     */
+    public function checkAttribute(Document $collection, Document $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<Document> $attributes */
+        $attributes = $collection->getAttribute('attributes', []);
+        /** @var array<Document> $indexes */
+        $indexes = $collection->getAttribute('indexes', []);
+
+        /** @var Document|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::fromDocument($attribute)->type === ColumnType::Relationship) {
+            throw new DatabaseException('Cannot delete relationship as an attribute');
+        }
+
+        if ($this->validate) {
+            /** @var array<Document> $depIndexes */
+            $depIndexes = $collection->getAttribute('indexes', []);
+            $typedDepIndexes = array_map(fn (Document $d) => Index::fromDocument($d), $depIndexes);
+            $validator = new IndexDependencyValidator(
+                $typedDepIndexes,
+                $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: ColumnType::from($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->trigger(Event::DocumentPurge, new Document([
+            '$id' => $collection->getId(),
+            '$collection' => self::METADATA,
+        ]));
+
+        $this->trigger(Event::AttributeDelete, $attribute);
+
+        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<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) {
+            /** @var array<Document> $renameDepIndexes */
+            $renameDepIndexes = $collection->getAttribute('indexes', []);
+            $typedRenameDepIndexes = array_map(fn (Document $d) => Index::fromDocument($d), $renameDepIndexes);
+            $validator = new IndexDependencyValidator(
+                $typedRenameDepIndexes,
+                $this->adapter->supports(Capability::CastIndexArray),
+            );
+
+            if (! $validator->isValid($attribute)) {
+                throw new DependencyException($validator->getDescription());
+            }
+        }
+
+        $attribute->setAttribute('$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 instanceof Feature\SchemaAttributes) {
+                $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->trigger(Event::AttributeUpdate, $attribute);
+
+        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<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;
+    }
+
+    /**
+     * 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<Document> $attributes */
+        $attributes = $collection->getAttribute('attributes', []);
+        $filteredAttributes = \array_filter(
+            $attributes,
+            fn (Document $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 000000000..5f7d7f4b1
--- /dev/null
+++ b/src/Database/Traits/Collections.php
@@ -0,0 +1,471 @@
+<?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\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  string  $id  The collection identifier
+     * @param  array<Attribute|Document>  $attributes  Initial attributes for the collection
+     * @param  array<Index|Document>  $indexes  Initial indexes for the collection
+     * @param  array<string>|null  $permissions  Permission strings, defaults to allow any create
+     * @param  bool  $documentSecurity  Whether to enable document-level security
+     * @return Document The created collection metadata document
+     *
+     * @throws DatabaseException
+     * @throws DuplicateException
+     * @throws LimitException
+     */
+    public function createCollection(string $id, array $attributes = [], array $indexes = [], ?array $permissions = null, bool $documentSecurity = true, array $metadata = []): Document
+    {
+        $attributes = array_map(fn ($attr): Attribute => $attr instanceof Attribute ? $attr : Attribute::fromDocument($attr), $attributes);
+        $indexes = array_map(fn ($idx): Index => $idx instanceof Index ? $idx : Index::fromDocument($idx), $indexes);
+
+        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]))
+                );
+            }
+        }
+
+        $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->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;
+        }
+
+        // Convert models to Documents for collection metadata
+        $attributeDocs = array_map(fn (Attribute $attr) => $attr->toDocument(), $attributes);
+        $indexDocs = array_map(fn (Index $idx) => $idx->toDocument(), $indexes);
+
+        $collection = new Document(\array_merge([
+            '$id' => ID::custom($id),
+            '$permissions' => $permissions,
+            'name' => $id,
+            'attributes' => $attributeDocs,
+            'indexes' => $indexDocs,
+            '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 instanceof Feature\Spatial,
+                $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.');
+            }
+        }
+
+        $created = false;
+
+        try {
+            $this->adapter->createCollection($id, $attributes, $indexes);
+            $created = true;
+        } catch (DuplicateException $e) {
+            // Metadata check (above) already verified collection is absent
+            // from metadata. A DuplicateException from the adapter means the
+            // collection exists only in physical schema — an orphan from a prior
+            // partial failure. Skip creation and proceed to metadata creation.
+        }
+
+        if ($id === self::METADATA) {
+            return new Document(self::collectionMeta());
+        }
+
+        try {
+            $createdCollection = $this->silent(fn () => $this->createDocument(self::METADATA, $collection));
+        } 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->trigger(Event::CollectionCreate, $createdCollection);
+
+        return $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('$permissions', $permissions)
+            ->setAttribute('documentSecurity', $documentSecurity);
+
+        $collection = $this->skipValidation(fn () => $this->silent(fn () => $this->updateDocument(self::METADATA, $collection->getId(), $collection)));
+
+        $this->trigger(Event::CollectionUpdate, $collection);
+
+        return $collection;
+    }
+
+    /**
+     * Get Collection
+     *
+     * @param  string  $id  The collection identifier
+     * @return Document The collection metadata document, or an empty Document if not found
+     *
+     * @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();
+        }
+
+        $this->trigger(Event::CollectionRead, $collection);
+
+        return $collection;
+    }
+
+    /**
+     * List Collections
+     *
+     * @param  int  $limit  Maximum number of collections to return
+     * @param  int  $offset  Number of collections to skip
+     * @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),
+        ]));
+
+        $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->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');
+        }
+
+        /** @var array<Document> $allAttributes */
+        $allAttributes = $collection->getAttribute('attributes', []);
+        $relationships = \array_filter(
+            $allAttributes,
+            fn (Document $attribute) => Attribute::fromDocument($attribute)->type === ColumnType::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));
+        /** @var array<Document> $currentAttrDocs */
+        $currentAttrDocs = $currentCollection->isEmpty() ? [] : $currentCollection->getAttribute('attributes', []);
+        /** @var array<Document> $currentIdxDocs */
+        $currentIdxDocs = $currentCollection->isEmpty() ? [] : $currentCollection->getAttribute('indexes', []);
+        $currentAttributes = array_map(fn (Document $d) => Attribute::fromDocument($d), $currentAttrDocs);
+        $currentIndexes = array_map(fn (Document $d) => Index::fromDocument($d), $currentIdxDocs);
+
+        $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->trigger(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 000000000..ae1eb2b59
--- /dev/null
+++ b/src/Database/Traits/Databases.php
@@ -0,0 +1,92 @@
+<?php
+
+namespace Utopia\Database\Traits;
+
+use Utopia\Database\Attribute;
+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<Document> $metaAttributes */
+        $metaAttributes = self::collectionMeta()['attributes'];
+        $attributes = [];
+        foreach ($metaAttributes as $attribute) {
+            $attributes[] = Attribute::fromDocument($attribute);
+        }
+
+        $this->silent(fn () => $this->createCollection(self::METADATA, $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 000000000..6b484844c
--- /dev/null
+++ b/src/Database/Traits/Documents.php
@@ -0,0 +1,2695 @@
+<?php
+
+namespace Utopia\Database\Traits;
+
+use DateTime as PhpDateTime;
+use Exception;
+use Generator;
+use InvalidArgumentException;
+use Throwable;
+use Utopia\Console;
+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\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
+{
+    /**
+     * @param  array<Document>  $documents
+     * @return array<Document>
+     *
+     * @throws DatabaseException
+     */
+    protected function refetchDocuments(Document $collection, array $documents): array
+    {
+        if (empty($documents)) {
+            return $documents;
+        }
+
+        $docIds = array_map(fn ($doc) => $doc->getId(), $documents);
+
+        // Fetch fresh copies with computed operator values
+        $refetched = $this->getAuthorization()->skip(fn () => $this->silent(
+            fn () => $this->find($collection->getId(), [Query::equal('$id', $docIds)])
+        ));
+
+        $refetchedMap = [];
+        foreach ($refetched as $doc) {
+            $refetchedMap[$doc->getId()] = $doc;
+        }
+
+        $result = [];
+        foreach ($documents as $doc) {
+            $result[] = $refetchedMap[$doc->getId()] ?? $doc;
+        }
+
+        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 (Document $attribute) => Attribute::fromDocument($attribute)->type === ColumnType::Relationship
+        );
+
+        $selects = Query::groupForDatabase($queries)['selections'];
+        $selections = $this->validateSelections($collection, $selects);
+        $nestedSelections = $this->relationshipHook?->processQueries($relationships, $queries) ?? [];
+
+        $documentSecurity = $collection->getAttribute('documentSecurity', false);
+
+        [$collectionKey, $documentKey, $hashKey] = $this->getCacheKeys(
+            $collection->getId(),
+            $id,
+            $selections
+        );
+
+        try {
+            $cached = $this->cache->load($documentKey, self::TTL, $hashKey);
+        } catch (Exception $e) {
+            Console::warning('Warning: Failed to get document from cache: '.$e->getMessage());
+            $cached = null;
+        }
+
+        if ($cached) {
+            /** @var array<string, mixed> $cached */
+            $document = $this->createDocumentInstance($collection->getId(), $cached);
+
+            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;
+        }
+
+        $skipAuth = $collection->getId() !== self::METADATA
+            && $this->authorization->isValid(new Input(PermissionType::Read, $collection->getRead()));
+
+        $getDocument = fn () => $this->adapter->getDocument(
+            $collection,
+            $id,
+            $queries,
+            $forUpdate
+        );
+
+        $document = $skipAuth ? $this->authorization->skip($getDocument) : $getDocument();
+
+        if ($document->isEmpty()) {
+            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(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 (Document $attribute) => Attribute::fromDocument($attribute)->type === ColumnType::Relationship
+        );
+
+        // Don't save to cache if it's part of a relationship
+        if (empty($relationships)) {
+            try {
+                $this->cache->save($documentKey, $document->getArrayCopy(), $hashKey);
+                $this->cache->save($collectionKey, 'empty', $documentKey);
+            } 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<Document> $indexes */
+        $indexes = $collection->getAttribute('indexes', []);
+        foreach ($indexes as $index) {
+            $typedIndex = IndexModel::fromDocument($index);
+            if ($typedIndex->type !== IndexType::Ttl) {
+                continue;
+            }
+            $ttlSeconds = $typedIndex->ttl;
+            $ttlAttr = $typedIndex->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['$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('$id', (empty($id) || $id === 'unique()') ? ID::unique() : $id)
+            ->setAttribute('$collection', $collection->getId())
+            ->setAttribute('$createdAt', ($createdAt === null || ! $this->preserveDates) ? $time : $createdAt)
+            ->setAttribute('$updatedAt', ($updatedAt === null || ! $this->preserveDates) ? $time : $updatedAt);
+
+        if ($collection->getId() !== self::METADATA) {
+            $document->setAttribute('$version', 1);
+        }
+
+        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->supports(Capability::DefinedAttributes)
+            );
+            if (! $structure->isValid($document)) {
+                throw new StructureException($structure->getDescription());
+            }
+        }
+
+        $document = $this->adapter->castingBefore($collection, $document);
+
+        $document = $this->withTransaction(function () use ($collection, $document) {
+            $hook = $this->relationshipHook;
+            if ($hook?->isEnabled()) {
+                $document = $this->silent(fn () => $hook->afterDocumentCreate($collection, $document));
+            }
+
+            return $this->adapter->createDocument($collection, $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->adapter->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->trigger(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;
+
+        foreach ($documents as $document) {
+            $createdAt = $document->getCreatedAt();
+            $updatedAt = $document->getUpdatedAt();
+
+            $document
+                ->setAttribute('$id', (empty($document->getId()) || $document->getId() === 'unique()') ? 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 ($collection->getId() !== self::METADATA) {
+                $document->setAttribute('$version', 1);
+            }
+
+            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->supports(Capability::DefinedAttributes)
+                );
+                if (! $validator->isValid($document)) {
+                    throw new StructureException($validator->getDescription());
+                }
+            }
+
+            if ($this->relationshipHook?->isEnabled()) {
+                $document = $this->silent(fn () => $this->relationshipHook->afterDocumentCreate($collection, $document));
+            }
+
+            $document = $this->adapter->castingBefore($collection, $document);
+        }
+
+        foreach (\array_chunk($documents, $batchSize) as $chunk) {
+            $batch = $this->withTransaction(function () use ($collection, $chunk) {
+                return $this->adapter->createDocuments($collection, $chunk);
+            });
+
+            $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->adapter->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->trigger(Event::DocumentsCreate, new 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();
+        $document = $this->withTransaction(function () use ($collection, $id, $document, $newUpdatedAt) {
+            $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);
+            }
+            $createdAt = $document->getCreatedAt();
+
+            $document = \array_merge($old->getArrayCopy(), $document->getArrayCopy());
+            $document['$collection'] = $old->getAttribute('$collection'); // Make sure user doesn't switch collection ID
+            $document['$createdAt'] = ($createdAt === null || ! $this->preserveDates) ? $old->getCreatedAt() : $createdAt;
+
+            if ($this->adapter->getSharedTables()) {
+                $document['$tenant'] = $old->getTenant(); // Make sure user doesn't switch tenant
+            }
+            $document = new Document($document);
+
+            /** @var array<Document> $updateAttrs */
+            $updateAttrs = $collection->getAttribute('attributes', []);
+            $relationships = \array_filter($updateAttrs, function (Document $attribute) {
+                return Attribute::fromDocument($attribute)->type === ColumnType::Relationship;
+            });
+
+            $shouldUpdate = false;
+
+            if ($collection->getId() !== self::METADATA) {
+                $documentSecurity = $collection->getAttribute('documentSecurity', false);
+
+                foreach ($relationships as $relationship) {
+                    $typedRel = Attribute::fromDocument($relationship);
+                    $relationships[$typedRel->key] = $relationship;
+                }
+
+                foreach ($document as $key => $value) {
+                    if (Operator::isOperator($value)) {
+                        $shouldUpdate = true;
+                        break;
+                    }
+                }
+
+                $internalKeys = ['$internalId', '$collection', '$tenant', '$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::fromDocument($collection->getId(), $relationships[$key]);
+                        $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 ($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('$updatedAt', ($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('$version', $oldVersion + 1);
+            } elseif ($oldVersion !== null) {
+                $document->setAttribute('$version', $oldVersion);
+            }
+
+            $document = $this->encode($collection, $document);
+
+            if ($this->validate) {
+                $structureValidator = new Structure(
+                    $collection,
+                    $this->adapter->getIdAttributeType(),
+                    $this->adapter->getMinDateTime(),
+                    $this->adapter->getMaxDateTime(),
+                    $this->adapter->supports(Capability::DefinedAttributes),
+                    $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));
+            }
+
+            $document = $this->adapter->castingBefore($collection, $document);
+
+            $this->authorization->skip(fn () => $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 document to get computed values
+            $hasOperators = false;
+            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;
+        }
+
+        $hook = $this->relationshipHook;
+        if ($hook !== null && ! $hook->isInBatchPopulation() && $hook->isEnabled()) {
+            $documents = $this->silent(fn () => $hook->populateDocuments([$document], $collection, $hook->getFetchDepth()));
+            $document = $documents[0];
+        }
+
+        $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->trigger(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 = new DocumentsValidator(
+                $attributes,
+                $indexes,
+                $this->adapter->getIdAttributeType(),
+                $this->maxQueryValues,
+                $this->adapter->getMaxUIDLength(),
+                $this->adapter->getMinDateTime(),
+                $this->adapter->getMaxDateTime(),
+                $this->adapter->supports(Capability::DefinedAttributes)
+            );
+
+            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['$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->supports(Capability::DefinedAttributes),
+                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: PermissionType::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()));
+
+                    $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('$version', $docVersion + 1);
+                    }
+
+                    $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);
+            }
+
+            /** @var array<Document> $batch */
+            $batch = \array_map(
+                fn (Document $doc) =>
+                $this->decode(
+                    $collection,
+                    $this->adapter->castingAfter($collection, $doc)
+                ),
+                $batch
+            );
+
+            $batch = $this->decorateDocuments(Event::DocumentsUpdate, $collection, $batch);
+
+            foreach ($batch as $index => $doc) {
+                $doc->removeAttribute('$skipPermissionsUpdate');
+                $this->purgeCachedDocument($collection->getId(), $doc->getId());
+                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->trigger(Event::DocumentsUpdate, new 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->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;
+        $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(),
+                )));
+            }
+
+            // 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('$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('$id', (empty($document->getId()) || $document->getId() === 'unique()') ? 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);
+            }
+
+            if ($old->isEmpty()) {
+                $document->setAttribute('$version', 1);
+            } else {
+                $oldVersion = $old->getVersion();
+                if ($oldVersion !== null) {
+                    $document->setAttribute('$version', $oldVersion + 1);
+                } else {
+                    $document->setAttribute('$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['$id'];
+                if (! $attr->getAttribute('required') && ! \array_key_exists($attrId, (array) $document)) {
+                    $document->setAttribute(
+                        $attrId,
+                        $old->getAttribute($attrId, ($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->supports(Capability::DefinedAttributes),
+                    $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));
+            }
+
+            $seenIds[] = $document->getId();
+            $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++;
+                }
+            }
+
+            $hook = $this->relationshipHook;
+            if ($hook !== null && ! $hook->isInBatchPopulation() && $hook->isEnabled()) {
+                $batch = $this->silent(fn () => $hook->populateDocuments($batch, $collection, $hook->getFetchDepth()));
+            }
+
+            // 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);
+            }
+
+            /** @var array<Document> $batch */
+            $batch = \array_map(
+                fn (Document $doc) => $hasOperators
+                ? $this->adapter->castingAfter($collection, $doc)
+                : $this->decode($collection, $this->adapter->castingAfter($collection, $doc)),
+                $batch
+            );
+
+            $batch = $this->decorateDocuments(Event::DocumentsUpsert, $collection, $batch);
+
+            foreach ($batch as $index => $doc) {
+                if ($this->getSharedTables() && $this->getTenantPerDocument()) {
+                    $this->withTenant($doc->getTenant(), function () use ($collection, $doc) {
+                        $this->purgeCachedDocument($collection->getId(), $doc->getId());
+                    });
+                } else {
+                    $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(Event::DocumentsUpsert, 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
+     *
+     * @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->supports(Capability::DefinedAttributes)) {
+            /** @var array<Document> $allAttrs */
+            $allAttrs = $collection->getAttribute('attributes', []);
+            $typedAttrs = array_map(fn (Document $doc) => Attribute::fromDocument($doc), $allAttrs);
+            $matchedAttrs = \array_filter($typedAttrs, 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 (! \in_array($matchedAttr->type, [ColumnType::Integer, ColumnType::Double], true) || $matchedAttr->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(PermissionType::Update, \array_merge(
+                    $collection->getUpdate(),
+                    ((bool) $documentSecurity ? $document->getUpdate() : [])
+                )))) {
+                    throw new AuthorizationException($this->authorization->getDescription());
+                }
+            }
+
+            /** @var int|float $currentVal */
+            $currentVal = $document->getAttribute($attribute);
+            if (! \is_null($max) && ($currentVal + $value > $max)) {
+                throw new LimitException('Attribute value exceeds maximum limit: '.$max);
+            }
+
+            $time = DateTime::now();
+            $updatedAt = $document->getUpdatedAt();
+            $updatedAt = (empty($updatedAt) || ! $this->preserveDates) ? $time : DateTime::setTimezone($updatedAt);
+            $max = $max ? $max - $value : null;
+
+            $this->adapter->increaseDocumentAttribute(
+                $collection->getId(),
+                $id,
+                $attribute,
+                $value,
+                $updatedAt,
+                max: $max
+            );
+
+            /** @var int|float $currentAttrVal */
+            $currentAttrVal = $document->getAttribute($attribute);
+
+            return $document->setAttribute(
+                $attribute,
+                $currentAttrVal + $value
+            );
+        });
+
+        $this->purgeCachedDocument($collection->getId(), $id);
+
+        $this->trigger(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  $value  The value to decrease the attribute by, must be positive
+     * @param  int|float|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 $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->supports(Capability::DefinedAttributes)) {
+            /** @var array<Document> $decAllAttrs */
+            $decAllAttrs = $collection->getAttribute('attributes', []);
+            $typedDecAttrs = array_map(fn (Document $doc) => Attribute::fromDocument($doc), $decAllAttrs);
+            $matchedDecAttrs = \array_filter($typedDecAttrs, 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 (! \in_array($matchedDecAttr->type, [ColumnType::Integer, ColumnType::Double], true) || $matchedDecAttr->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(PermissionType::Update, \array_merge(
+                    $collection->getUpdate(),
+                    ((bool) $documentSecurity ? $document->getUpdate() : [])
+                )))) {
+                    throw new AuthorizationException($this->authorization->getDescription());
+                }
+            }
+
+            /** @var int|float $currentDecVal */
+            $currentDecVal = $document->getAttribute($attribute);
+            if (! \is_null($min) && ($currentDecVal - $value < $min)) {
+                throw new LimitException('Attribute value exceeds minimum limit: '.$min);
+            }
+
+            $time = DateTime::now();
+            $updatedAt = $document->getUpdatedAt();
+            $updatedAt = (empty($updatedAt) || ! $this->preserveDates) ? $time : DateTime::setTimezone($updatedAt);
+            $min = $min ? $min + $value : null;
+
+            $this->adapter->increaseDocumentAttribute(
+                $collection->getId(),
+                $id,
+                $attribute,
+                $value * -1,
+                $updatedAt,
+                min: $min
+            );
+
+            /** @var int|float $currentDecVal2 */
+            $currentDecVal2 = $document->getAttribute($attribute);
+
+            return $document->setAttribute(
+                $attribute,
+                $currentDecVal2 - $value
+            );
+        });
+
+        $this->purgeCachedDocument($collection->getId(), $id);
+
+        $this->trigger(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));
+
+        $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(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->purgeCachedDocument($collection->getId(), $id);
+
+            return $result;
+        });
+
+        if ($deleted) {
+            $this->trigger(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 = new DocumentsValidator(
+                $attributes,
+                $indexes,
+                $this->adapter->getIdAttributeType(),
+                $this->maxQueryValues,
+                $this->adapter->getMaxUIDLength(),
+                $this->adapter->getMinDateTime(),
+                $this->adapter->getMaxDateTime(),
+                $this->adapter->supports(Capability::DefinedAttributes)
+            );
+
+            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 = [];
+
+            $this->withTransaction(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 $index => $document) {
+                if ($this->getSharedTables() && $this->getTenantPerDocument()) {
+                    $this->withTenant($document->getTenant(), function () use ($collection, $document) {
+                        $this->purgeCachedDocument($collection->getId(), $document->getId());
+                    });
+                } else {
+                    $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(Event::DocumentsDelete, new 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);
+
+        $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.
+     *
+     * @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;
+    }
+
+    /**
+     * 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([
+                '$id' => $id,
+                '$collection' => $collectionId,
+            ]));
+        }
+
+        return $result;
+    }
+
+    /**
+     * 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
+    {
+        $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 = new DocumentsValidator(
+                $attributes,
+                $indexes,
+                $this->adapter->getIdAttributeType(),
+                $this->maxQueryValues,
+                $this->adapter->getMaxUIDLength(),
+                $this->adapter->getMinDateTime(),
+                $this->adapter->getMaxDateTime(),
+                $this->adapter->supports(Capability::DefinedAttributes)
+            );
+            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 (Document $attribute) => Attribute::fromDocument($attribute)->type === ColumnType::Relationship
+        );
+
+        $grouped = Query::groupForDatabase($queries);
+        $filters = $grouped['filters'];
+        $selects = $grouped['selections'];
+        $aggregations = $grouped['aggregations'];
+        $groupByAttrs = $grouped['groupBy'];
+        $having = $grouped['having'];
+        $joins = $grouped['joins'];
+        $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');
+        }
+
+        // Enforce collection-level read permission on each joined collection
+        if (! empty($joins)) {
+            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}'");
+                }
+            }
+        }
+
+        if (! $isAggregation) {
+            $uniqueOrderBy = false;
+            foreach ($orderAttributes as $order) {
+                if ($order === '$id' || $order === '$sequence') {
+                    $uniqueOrderBy = true;
+                }
+            }
+
+            if ($uniqueOrderBy === false) {
+                $orderAttributes[] = '$sequence';
+            }
+        }
+
+        if (! empty($cursor)) {
+            if ($isAggregation) {
+                throw new QueryException('Cursor pagination is not supported with aggregation queries');
+            }
+
+            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),
+            $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;
+            if ($this->queryCache !== null && $this->queryCache->isEnabled($collection->getId())) {
+                $cacheKey = $this->queryCache->buildQueryKey(
+                    $collection->getId(),
+                    $queries,
+                    $this->adapter->getNamespace(),
+                    $this->adapter->getTenant(),
+                );
+                $cached = $this->queryCache->get($cacheKey);
+                if ($cached !== null) {
+                    $results = $cached;
+                    $cacheKey = null;
+                }
+            }
+
+            if (! isset($results)) {
+                $getResults = fn () => $this->adapter->find(
+                    $collection,
+                    $queries,
+                    $limit ?? 25,
+                    $offset ?? 0,
+                    $orderAttributes,
+                    $orderTypes,
+                    $cursor,
+                    $cursorDirection,
+                    $forPermission
+                );
+
+                $results = $skipAuth ? $this->authorization->skip($getResults) : $getResults();
+
+                if ($cacheKey !== null && $this->queryCache !== null) {
+                    $this->queryCache->set($cacheKey, $results);
+                }
+            }
+        }
+
+        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));
+            }
+        }
+
+        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;
+        }
+
+        $results = $this->decorateDocuments(Event::DocumentFind, $collection, $results);
+
+        $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
+    {
+        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 = new DocumentsValidator(
+                $attributes,
+                $indexes,
+                $this->adapter->getIdAttributeType(),
+                $this->maxQueryValues,
+                $this->adapter->getMaxUIDLength(),
+                $this->adapter->getMinDateTime(),
+                $this->adapter->getMaxDateTime(),
+                $this->adapter->supports(Capability::DefinedAttributes)
+            );
+            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 (Document $attribute) => Attribute::fromDocument($attribute)->type === ColumnType::Relationship
+        );
+
+        $queries = Query::groupForDatabase($queries)['filters'];
+        $queries = $this->convertQueries($collection, $queries);
+
+        $convertedQueries = $this->relationshipHook !== null
+            ? $this->relationshipHook->convertQueries($relationships, $queries, $collection)
+            : $queries;
+
+        if ($convertedQueries === null) {
+            return 0;
+        }
+
+        $queries = $convertedQueries;
+
+        $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 = new DocumentsValidator(
+                $attributes,
+                $indexes,
+                $this->adapter->getIdAttributeType(),
+                $this->maxQueryValues,
+                $this->adapter->getMaxUIDLength(),
+                $this->adapter->getMinDateTime(),
+                $this->adapter->getMaxDateTime(),
+                $this->adapter->supports(Capability::DefinedAttributes)
+            );
+            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 (Document $attribute) => Attribute::fromDocument($attribute)->type === ColumnType::Relationship
+        );
+
+        $queries = $this->convertQueries($collection, $queries);
+        $convertedQueries = $this->relationshipHook !== null
+            ? $this->relationshipHook->convertQueries($relationships, $queries, $collection)
+            : $queries;
+
+        // If conversion returns null, it means no documents can match (relationship filter found no matches)
+        if ($convertedQueries === null) {
+            return 0;
+        }
+
+        $queries = $convertedQueries;
+
+        $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);
+    }
+
+    /**
+     * @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) {
+                    /** @var string $strVal */
+                    $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['$id'] ?? '',
+            $this->getInternalAttributes()
+        );
+
+        /** @var array<Document> $collAttrs */
+        $collAttrs = $collection->getAttribute('attributes', []);
+        foreach ($collAttrs as $attribute) {
+            $typedAttr = Attribute::fromDocument($attribute);
+            if ($typedAttr->type !== ColumnType::Relationship) {
+                $keys[] = $typedAttr->key;
+            }
+        }
+        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[] = '$id';
+        $selections[] = '$sequence';
+        $selections[] = '$collection';
+        $selections[] = '$createdAt';
+        $selections[] = '$updatedAt';
+        $selections[] = '$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());
+            }
+        }
+    }
+}
diff --git a/src/Database/Traits/Entities.php b/src/Database/Traits/Entities.php
new file mode 100644
index 000000000..b17bb19a8
--- /dev/null
+++ b/src/Database/Traits/Entities.php
@@ -0,0 +1,91 @@
+<?php
+
+namespace Utopia\Database\Traits;
+
+use Utopia\Database\Document;
+use Utopia\Database\ORM\EntityManager;
+use Utopia\Database\Query;
+
+trait Entities
+{
+    protected ?EntityManager $entityManager = null;
+
+    public function getEntityManager(): EntityManager
+    {
+        if ($this->entityManager === null) {
+            $this->entityManager = new EntityManager($this);
+        }
+
+        return $this->entityManager;
+    }
+
+    public function persistEntity(object $entity): void
+    {
+        $this->getEntityManager()->persist($entity);
+    }
+
+    public function removeEntity(object $entity): void
+    {
+        $this->getEntityManager()->remove($entity);
+    }
+
+    /**
+     * Flush all pending entity changes to the database.
+     */
+    public function flushEntities(): void
+    {
+        $this->getEntityManager()->flush();
+    }
+
+    /**
+     * @template T of object
+     * @param  class-string<T>  $className
+     * @return T|null
+     */
+    public function findEntity(string $className, string $id): ?object
+    {
+        return $this->getEntityManager()->find($className, $id);
+    }
+
+    /**
+     * @template T of object
+     * @param  class-string<T>  $className
+     * @param  array<Query>  $queries
+     * @return array<T>
+     */
+    public function findEntities(string $className, array $queries = []): array
+    {
+        return $this->getEntityManager()->findMany($className, $queries);
+    }
+
+    /**
+     * @template T of object
+     * @param  class-string<T>  $className
+     * @param  array<Query>  $queries
+     * @return T|null
+     */
+    public function findOneEntity(string $className, array $queries = []): ?object
+    {
+        return $this->getEntityManager()->findOne($className, $queries);
+    }
+
+    public function createCollectionFromEntity(string $className): Document
+    {
+        return $this->getEntityManager()->createCollectionFromEntity($className);
+    }
+
+    public function syncCollectionFromEntity(string $className): void
+    {
+        $this->getEntityManager()->syncCollectionFromEntity($className);
+    }
+
+    public function detachEntity(object $entity): void
+    {
+        $this->getEntityManager()->detach($entity);
+    }
+
+    public function clearEntityManager(): void
+    {
+        $this->getEntityManager()->clear();
+    }
+}
diff --git a/src/Database/Traits/Indexes.php b/src/Database/Traits/Indexes.php
new file mode 100644
index 000000000..57e9ced43
--- /dev/null
+++ b/src/Database/Traits/Indexes.php
@@ -0,0 +1,424 @@
+<?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<Document> $collectionAttributes */
+        $collectionAttributes = $collection->getAttribute('attributes', []);
+        $typedCollectionAttributes = array_map(fn (Document $doc) => Attribute::fromDocument($doc), $collectionAttributes);
+        $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 ($typedCollectionAttributes 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
+        );
+
+        $indexDoc = $index->toDocument();
+
+        if ($this->validate) {
+            /** @var array<Document> $collectionAttrsForValidation */
+            $collectionAttrsForValidation = $collection->getAttribute('attributes', []);
+            /** @var array<Document> $collectionIdxsForValidation */
+            $collectionIdxsForValidation = $collection->getAttribute('indexes', []);
+
+            $typedAttrsForValidation = array_map(fn (Document $doc) => Attribute::fromDocument($doc), $collectionAttrsForValidation);
+            $typedIdxsForValidation = array_map(fn (Document $doc) => Index::fromDocument($doc), $collectionIdxsForValidation);
+
+            $validator = new IndexValidator(
+                $typedAttrsForValidation,
+                $typedIdxsForValidation,
+                $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 instanceof Feature\Spatial,
+                $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', $indexDoc, SetType::Append);
+
+        $this->updateMetadata(
+            collection: $collection,
+            rollbackOperation: fn () => $this->cleanupIndex($collection->getId(), $id),
+            shouldRollback: $created,
+            operationDescription: "index creation '{$id}'"
+        );
+
+        $this->trigger(Event::IndexCreate, $indexDoc);
+
+        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['$id'], $indexes));
+
+        if ($index === false) {
+            throw new NotFoundException('Index not found');
+        }
+
+        $indexNewExists = \in_array($new, \array_map(fn ($idx) => $idx['$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('$id', $new);
+                $indexNew = $value;
+                $indexes[$key] = $value;
+                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()));
+
+        $this->trigger(Event::IndexRename, $indexNew);
+
+        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<Document> $indexes */
+        $indexes = $collection->getAttribute('indexes', []);
+
+        /** @var Document|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<Document> $collectionAttributes */
+        $collectionAttributes = $collection->getAttribute('attributes', []);
+        $typedDeletedIndex = Index::fromDocument($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) {
+                $typedCollAttr = Attribute::fromDocument($collectionAttribute);
+                if ($typedCollAttr->key === $baseAttr) {
+                    $indexAttributeTypes[$attr] = $typedCollAttr->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->trigger(Event::IndexDelete, $indexDeleted);
+
+        return $deleted;
+    }
+
+    /**
+     * Update index metadata. Utility method for update index methods.
+     *
+     * @param  callable(Document, Document, int|string): void  $updateCallback  method that receives document, and returns it with changes applied
+     *
+     * @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');
+        }
+
+        /** @var array<Document> $indexes */
+        $indexes = $collection->getAttribute('indexes', []);
+        $index = \array_search($id, \array_map(fn ($idx) => $idx['$id'], $indexes));
+
+        if ($index === false) {
+            throw new NotFoundException('Index not found');
+        }
+
+        /** @var Document $indexDoc */
+        $indexDoc = $indexes[$index];
+
+        // Execute update from callback
+        $updateCallback($indexDoc, $collection, $index);
+        $indexes[$index] = $indexDoc;
+
+        $collection->setAttribute('indexes', $indexes);
+
+        $this->updateMetadata(
+            collection: $collection,
+            rollbackOperation: null,
+            shouldRollback: false,
+            operationDescription: "index metadata update '{$id}'"
+        );
+
+        return $indexDoc;
+    }
+
+    /**
+     * 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 000000000..6ae449758
--- /dev/null
+++ b/src/Database/Traits/Relationships.php
@@ -0,0 +1,990 @@
+<?php
+
+namespace Utopia\Database\Traits;
+
+use Throwable;
+use Utopia\Console;
+use Utopia\Database\Adapter\Feature;
+use Utopia\Database\Attribute;
+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 {
+        $relationshipModel = new Relationship(
+            collection: $collectionId,
+            relatedCollection: $relatedCollectionId,
+            type: $type,
+            twoWay: $twoWay,
+            key: $key,
+            twoWayKey: $twoWayKey,
+            side: $side,
+        );
+        $this->cleanup(
+            fn () => $this->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 instanceof Feature\Relationships)) {
+            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<Document> $attributes */
+        $attributes = $collection->getAttribute('attributes', []);
+        foreach ($attributes as $attribute) {
+            $typedAttr = Attribute::fromDocument($attribute);
+            if (\strtolower($typedAttr->key) === \strtolower($id)) {
+                throw new DuplicateException('Attribute already exists');
+            }
+
+            if ($typedAttr->type === ColumnType::Relationship) {
+                $existingRel = Relationship::fromDocument($collection->getId(), $attribute);
+                if (
+                    \strtolower($existingRel->twoWayKey) === \strtolower($twoWayKey)
+                    && $existingRel->relatedCollection === $relatedCollection->getId()
+                ) {
+                    throw new DuplicateException('Related attribute already exists');
+                }
+            }
+        }
+
+        $relationship = new Document([
+            '$id' => ID::custom($id),
+            'key' => $id,
+            'type' => ColumnType::Relationship->value,
+            'required' => false,
+            'default' => null,
+            'options' => [
+                'relatedCollection' => $relatedCollection->getId(),
+                'relationType' => $type,
+                'twoWay' => $twoWay,
+                'twoWayKey' => $twoWayKey,
+                'onDelete' => $onDelete,
+                'side' => RelationSide::Parent,
+            ],
+        ]);
+
+        $twoWayRelationship = new Document([
+            '$id' => ID::custom($twoWayKey),
+            'key' => $twoWayKey,
+            'type' => ColumnType::Relationship->value,
+            'required' => false,
+            'default' => null,
+            'options' => [
+                'relatedCollection' => $collection->getId(),
+                'relationType' => $type,
+                'twoWay' => $twoWay,
+                'twoWayKey' => $id,
+                'onDelete' => $onDelete,
+                'side' => RelationSide::Child,
+            ],
+        ]);
+
+        $this->checkAttribute($collection, $relationship);
+        $this->checkAttribute($relatedCollection, $twoWayRelationship);
+
+        $junctionCollection = null;
+        if ($type === RelationType::ManyToMany) {
+            $junctionCollection = '_'.$collection->getSequence().'_'.$relatedCollection->getSequence();
+            $junctionAttributes = [
+                new Attribute(
+                    key: $id,
+                    type: ColumnType::String,
+                    size: Database::LENGTH_KEY,
+                    required: true,
+                ),
+                new Attribute(
+                    key: $twoWayKey,
+                    type: ColumnType::String,
+                    size: Database::LENGTH_KEY,
+                    required: true,
+                ),
+            ];
+            $junctionIndexes = [
+                new Index(
+                    key: '_index_'.$id,
+                    type: IndexType::Key,
+                    attributes: [$id],
+                ),
+                new Index(
+                    key: '_index_'.$twoWayKey,
+                    type: IndexType::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;
+
+        $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(), new Index(key: $indexKey, type: IndexType::Unique, attributes: [$id]));
+                        $indexesCreated[] = ['collection' => $collection->getId(), 'index' => $indexKey];
+                        if ($twoWay) {
+                            $this->createIndex($relatedCollection->getId(), new Index(key: $twoWayIndexKey, type: IndexType::Unique, attributes: [$twoWayKey]));
+                            $indexesCreated[] = ['collection' => $relatedCollection->getId(), 'index' => $twoWayIndexKey];
+                        }
+                        break;
+                    case RelationType::OneToMany:
+                        $this->createIndex($relatedCollection->getId(), new Index(key: $twoWayIndexKey, type: IndexType::Key, attributes: [$twoWayKey]));
+                        $indexesCreated[] = ['collection' => $relatedCollection->getId(), 'index' => $twoWayIndexKey];
+                        break;
+                    case RelationType::ManyToOne:
+                        $this->createIndex($collection->getId(), new Index(key: $indexKey, type: IndexType::Key, 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<Document> $attributes */
+                        $attributes = $collection->getAttribute('attributes', []);
+                        $collection->setAttribute('attributes', array_filter($attributes, fn (Document $attr) => $attr->getId() !== $id));
+                        $this->updateDocument(self::METADATA, $collection->getId(), $collection);
+
+                        /** @var array<Document> $relatedAttributes */
+                        $relatedAttributes = $relatedCollection->getAttribute('attributes', []);
+                        $relatedCollection->setAttribute('attributes', array_filter($relatedAttributes, fn (Document $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->trigger(Event::AttributeCreate, $relationship);
+
+        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 instanceof Feature\Relationships)) {
+            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<Document> $attributes */
+        $attributes = $collection->getAttribute('attributes', []);
+
+        if (
+            $newKey !== null
+            && \in_array($newKey, \array_map(fn (Document $attribute) => Attribute::fromDocument($attribute)->key, $attributes))
+        ) {
+            throw new DuplicateException('Relationship already exists');
+        }
+
+        $attributeIndex = array_search($id, array_map(fn (Document $attribute) => Attribute::fromDocument($attribute)->key, $attributes));
+
+        if ($attributeIndex === false) {
+            throw new NotFoundException('Relationship not found');
+        }
+
+        /** @var Document $attribute */
+        $attribute = $attributes[$attributeIndex];
+        $oldRel = Relationship::fromDocument($collection->getId(), $attribute);
+
+        $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<Document> $relatedAttrs */
+        $relatedAttrs = $relatedCollection->getAttribute('attributes', []);
+        if (
+            $newTwoWayKey !== null
+            && \in_array($newTwoWayKey, \array_map(fn (Document $attribute) => Attribute::fromDocument($attribute)->key, $relatedAttrs))
+        ) {
+            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 instanceof Feature\SchemaAttributes) {
+                    $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('$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('$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('$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 {
+                    $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('$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('$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('$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 {
+                    $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 instanceof Feature\Relationships)) {
+            throw new DatabaseException('Adapter does not support relationships');
+        }
+
+        $collection = $this->silent(fn () => $this->getCollection($collection));
+        /** @var array<int|string, Document> $attributes */
+        $attributes = $collection->getAttribute('attributes', []);
+        $relationship = null;
+
+        foreach ($attributes as $name => $attribute) {
+            $typedAttr = Attribute::fromDocument($attribute);
+            if ($typedAttr->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::fromDocument($collection->getId(), $relationship);
+
+        $relatedCollection = $this->silent(fn () => $this->getCollection($rel->relatedCollection));
+        /** @var array<int|string, Document> $relatedAttributes */
+        $relatedAttributes = $relatedCollection->getAttribute('attributes', []);
+
+        foreach ($relatedAttributes as $name => $attribute) {
+            $typedRelAttr = Attribute::fromDocument($attribute);
+            if ($typedRelAttr->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->trigger(Event::AttributeDelete, $relationship);
+
+        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 000000000..c3e336124
--- /dev/null
+++ b/src/Database/Traits/Transactions.php
@@ -0,0 +1,24 @@
+<?php
+
+namespace Utopia\Database\Traits;
+
+/**
+ * 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->adapter->withTransaction($callback);
+    }
+}
diff --git a/src/Database/Type/CustomType.php b/src/Database/Type/CustomType.php
new file mode 100644
index 000000000..4a36be6af
--- /dev/null
+++ b/src/Database/Type/CustomType.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace Utopia\Database\Type;
+
+use Utopia\Query\Schema\ColumnType;
+
+interface CustomType
+{
+    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/EmbeddableType.php b/src/Database/Type/EmbeddableType.php
new file mode 100644
index 000000000..3e0c64ded
--- /dev/null
+++ b/src/Database/Type/EmbeddableType.php
@@ -0,0 +1,22 @@
+<?php
+
+namespace Utopia\Database\Type;
+
+use Utopia\Database\Attribute;
+
+interface EmbeddableType
+{
+    public function name(): string;
+
+    /**
+     * @return array<Attribute>
+     */
+    public function attributes(): array;
+
+    /**
+     * @return array<string, mixed>
+     */
+    public function decompose(mixed $value): array;
+
+    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 000000000..e0bbb1ca7
--- /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, CustomType> */
+    private array $types = [];
+
+    /** @var array<string, EmbeddableType> */
+    private array $embeddables = [];
+
+    public function register(CustomType $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(EmbeddableType $type): void
+    {
+        $this->embeddables[$type->name()] = $type;
+    }
+
+    public function get(string $name): ?CustomType
+    {
+        return $this->types[$name] ?? null;
+    }
+
+    public function getEmbeddable(string $name): ?EmbeddableType
+    {
+        return $this->embeddables[$name] ?? null;
+    }
+
+    /**
+     * @return array<string, CustomType>
+     */
+    public function all(): array
+    {
+        return $this->types;
+    }
+
+    /**
+     * @return array<string, EmbeddableType>
+     */
+    public function allEmbeddables(): array
+    {
+        return $this->embeddables;
+    }
+}
diff --git a/src/Database/Validator/Attribute.php b/src/Database/Validator/Attribute.php
index 021a85d97..d60820898 100644
--- a/src/Database/Validator/Attribute.php
+++ b/src/Database/Validator/Attribute.php
@@ -2,44 +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 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,
@@ -60,12 +55,12 @@ public function __construct(
         protected bool $sharedTables = false,
     ) {
         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;
         }
     }
 
@@ -73,8 +68,6 @@ public function __construct(
      * Get Type
      *
      * Returns validator type.
-     *
-     * @return string
      */
     public function getType(): string
     {
@@ -83,7 +76,6 @@ public function getType(): string
 
     /**
      * Returns validator description
-     * @return string
      */
     public function getDescription(): string
     {
@@ -94,8 +86,6 @@ public function getDescription(): string
      * Is array
      *
      * Function will return true if object is array.
-     *
-     * @return bool
      */
     public function isArray(): bool
     {
@@ -106,33 +96,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;
         }
 
@@ -142,16 +146,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);
             }
@@ -163,13 +165,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;
         }
 
@@ -177,10 +177,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);
@@ -193,18 +194,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);
         }
 
@@ -214,14 +210,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 => [],
         };
     }
@@ -229,17 +223,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);
         }
 
@@ -249,26 +238,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);
         }
 
@@ -278,105 +269,104 @@ 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:
+            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:
+            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:
+            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:
                 $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_FLOAT:
-            case Database::VAR_BOOLEAN:
-            case Database::VAR_DATETIME:
-            case Database::VAR_RELATIONSHIP:
+            case ColumnType::Float:
+            case ColumnType::Double:
+            case ColumnType::Boolean:
+            case ColumnType::Datetime:
+            case ColumnType::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);
                 }
@@ -389,22 +379,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);
                         }
@@ -414,27 +404,28 @@ 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_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::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);
         }
 
@@ -444,28 +435,24 @@ 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);
+        $default = $attribute->default;
+        $type = $attribute->type;
 
         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)) {
+        if (\is_array($default) && ! $attribute->array && ! \in_array($type, [ColumnType::Vector, ColumnType::Object, ColumnType::Point, ColumnType::Linestring, ColumnType::Polygon], true)) {
             $this->message = 'Cannot set an array default value for a non-array attribute';
             throw new DatabaseException($this->message);
         }
@@ -478,13 +465,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  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): void
+    protected function validateDefaultTypes(ColumnType $type, mixed $default): void
     {
         $defaultType = \gettype($default);
 
@@ -495,40 +481,48 @@ protected function validateDefaultTypes(string $type, mixed $default): void
 
         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);
                 }
             }
+
             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_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:
+                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)';
@@ -537,24 +531,25 @@ protected function validateDefaultTypes(string $type, mixed $default): void
                 break;
             default:
                 $supportedTypes = [
-                    Database::VAR_STRING,
-                    Database::VAR_VARCHAR,
-                    Database::VAR_TEXT,
-                    Database::VAR_MEDIUMTEXT,
-                    Database::VAR_LONGTEXT,
-                    Database::VAR_INTEGER,
-                    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::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 5f5ac179b..8da1c6dad 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 8db9e8058..5a021152e 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/Datetime.php b/src/Database/Validator/Datetime.php
index 7950b1e07..3120285b5 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 8b07db2ce..b1ccaa8db 100644
--- a/src/Database/Validator/Index.php
+++ b/src/Database/Validator/Index.php
@@ -2,44 +2,42 @@
 
 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\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 +56,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 +76,6 @@ public function __construct(
      * Get Type
      *
      * Returns validator type.
-     *
-     * @return string
      */
     public function getType(): string
     {
@@ -82,7 +84,6 @@ public function getType(): string
 
     /**
      * Returns validator description
-     * @return string
      */
     public function getDescription(): string
     {
@@ -93,8 +94,6 @@ public function getDescription(): string
      * Is array
      *
      * Function will return true if object is array.
-     *
-     * @return bool
      */
     public function isArray(): bool
     {
@@ -105,362 +104,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] ?? '';
+                if (! empty($direction)) {
+                    $this->message = 'Invalid index order "'.$direction.'" 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 +508,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 +517,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 +538,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 +590,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 +619,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 +662,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 +705,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 +730,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 +758,40 @@ 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))) {
+            if (empty(\array_diff($existingIndex->orders, $index->orders)) &&
+                empty(\array_diff($index->orders, $existingIndex->orders))) {
                 $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 +801,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 +914,6 @@ 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;
     }
 }
diff --git a/src/Database/Validator/IndexDependency.php b/src/Database/Validator/IndexDependency.php
index 7e8453b83..1d218a493 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 a24e0d21d..efc201e54 100644
--- a/src/Database/Validator/IndexedQueries.php
+++ b/src/Database/Validator/IndexedQueries.php
@@ -3,20 +3,27 @@
 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\Schema\IndexType;
 
+/**
+ * Validates queries against available indexes, ensuring search queries have matching fulltext indexes.
+ */
 class IndexedQueries extends Queries
 {
     /**
-     * @var array<Document>
+     * @var array<AttributeVO>
      */
     protected array $attributes = [];
 
     /**
-     * @var array<Document>
+     * @var array<IndexVO>
      */
     protected array $indexes = [];
 
@@ -25,32 +32,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: '_uid_', type: IndexType::Unique, attributes: ['$id']);
+        $this->indexes[] = new IndexVO(key: '_created_at_', type: IndexType::Key, attributes: ['$createdAt']);
+        $this->indexes[] = new IndexVO(key: '_updated_at_', type: IndexType::Key, attributes: ['$updatedAt']);
 
         foreach ($indexes as $index) {
-            $this->indexes[] = $index;
+            $this->indexes[] = $index instanceof IndexVO ? $index : IndexVO::fromDocument($index);
         }
 
         parent::__construct($validators);
@@ -59,20 +58,21 @@ public function __construct(array $attributes = [], array $indexes = [], array $
     /**
      * Count vector queries across entire query tree
      *
-     * @param array<Query> $queries
-     * @return int
+     * @param  array<Query>  $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());
+                /** @var array<Query> $nestedValues */
+                $nestedValues = $query->getValues();
+                $count += $this->countVectorQueries($nestedValues);
             }
         }
 
@@ -80,28 +80,29 @@ private function countVectorQueries(array $queries): int
     }
 
     /**
-     * @param mixed $value
-     * @return bool
+     * @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 ($query->isNested() && $query->getMethod() !== Method::Having) {
                 if (! self::isValid($query->getValues())) {
                     return false;
                 }
@@ -113,30 +114,32 @@ public function isValid($value): bool
         $vectorQueryCount = $this->countVectorQueries($queries);
         if ($vectorQueryCount > 1) {
             $this->message = 'Cannot use multiple vector queries in a single request';
+
             return false;
         }
 
-        $grouped = Query::groupByType($queries);
+        $grouped = Query::groupForDatabase($queries);
         $filters = $grouped['filters'];
 
         foreach ($filters as $filter) {
             if (
-                $filter->getMethod() === Query::TYPE_SEARCH ||
-                $filter->getMethod() === Query::TYPE_NOT_SEARCH
+                $filter->getMethod() === Method::Search ||
+                $filter->getMethod() === Method::NotSearch
             ) {
                 $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 === [$filter->getAttribute()]
                     ) {
                         $matched = true;
                     }
                 }
 
-                if (!$matched) {
+                if (! $matched) {
                     $this->message = "Searching by attribute \"{$filter->getAttribute()}\" requires a fulltext index.";
+
                     return false;
                 }
             }
diff --git a/src/Database/Validator/Key.php b/src/Database/Validator/Key.php
index 843444677..efed6d5b7 100644
--- a/src/Database/Validator/Key.php
+++ b/src/Database/Validator/Key.php
@@ -5,6 +5,9 @@
 use Utopia\Database\Database;
 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 +16,6 @@ class Key extends Validator
      * Get Description.
      *
      * Returns validator description
-     *
-     * @return string
      */
     public function getDescription(): string
     {
@@ -28,20 +29,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 +55,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 = ['$id', '$createdAt', '$updatedAt'];
 
             // If exact match, no need for any further checks
             return \in_array($value, $allowList);
@@ -85,8 +83,6 @@ public function isValid($value): bool
      * Is array
      *
      * Function will return true if object is array.
-     *
-     * @return bool
      */
     public function isArray(): bool
     {
@@ -97,8 +93,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 cf09be0b1..29ff3ab6e 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 d4524d901..1893ecda9 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,19 +19,18 @@ 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;
         }
 
         // Allow empty or associative arrays (non-list)
-        return empty($value) || (is_array($value) && !array_is_list($value));
+        return empty($value) || (is_array($value) && ! array_is_list($value));
     }
 
     /**
diff --git a/src/Database/Validator/Operator.php b/src/Database/Validator/Operator.php
index 46f1b8db3..858905a50 100644
--- a/src/Database/Validator/Operator.php
+++ b/src/Database/Validator/Operator.php
@@ -2,17 +2,26 @@
 
 namespace Utopia\Database\Validator;
 
+use Throwable;
+use Utopia\Database\Attribute as AttributeVO;
 use Utopia\Database\Database;
 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 +32,23 @@ 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)
     {
         $this->collection = $collection;
         $this->currentDocument = $currentDocument;
 
-        foreach ($collection->getAttribute('attributes', []) as $attribute) {
-            $this->attributes[$attribute->getAttribute('key', $attribute->getId())] = $attribute;
+        /** @var array<Document> $collectionAttributes */
+        $collectionAttributes = $collection->getAttribute('attributes', []);
+        foreach ($collectionAttributes as $attribute) {
+            $typed = 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,31 +57,35 @@ 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 */
+
+        $relationTypeRaw = $options['relationType'] ?? '';
+        $sideRaw = $options['side'] ?? '';
 
-        $relationType = $options['relationType'] ?? '';
-        $side = $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;
         }
 
@@ -84,8 +96,6 @@ private function isRelationshipArray(Document|array $attribute): bool
      * Get Description
      *
      * Returns validator description
-     *
-     * @return string
      */
     public function getDescription(): string
     {
@@ -96,18 +106,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 +124,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,155 +138,171 @@ 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;
 
         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 (! \in_array($type, [ColumnType::Integer, ColumnType::Double])) {
+                    $this->message = "Cannot apply {$methodName} operator to non-numeric field '{$operator->getAttribute()}'";
+
                     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]) || ! \is_numeric($values[0])) {
+                    $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";
+                if (($method === OperatorType::Divide || $method === OperatorType::Modulo) && (float) $values[0] === 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 && ! \is_numeric($values[1])) {
+                    $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])) {
+                if ($this->currentDocument !== null && $type === ColumnType::Integer && ! isset($values[1])) {
+                    /** @var int|float $currentValue */
                     $currentValue = $this->currentDocument->getAttribute($operator->getAttribute()) ?? 0;
+                    /** @var int|float $operatorValue */
                     $operatorValue = $values[0];
 
                     // 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,
+                        OperatorType::Increment => $currentValue + $operatorValue,
+                        OperatorType::Decrement => $currentValue - $operatorValue,
+                        OperatorType::Multiply => $currentValue * $operatorValue,
+                        OperatorType::Divide => $currentValue / $operatorValue,
+                        OperatorType::Modulo => (int) $currentValue % (int) $operatorValue,
+                        OperatorType::Power => $currentValue ** $operatorValue,
                     };
 
                     if ($predictedResult > Database::MAX_INT) {
-                        $this->message = "Cannot apply {$method} operator: would overflow maximum value of " . Database::MAX_INT;
+                        $this->message = "Cannot apply {$methodName} 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;
+                        $this->message = "Cannot apply {$methodName} operator: would underflow minimum value of ".Database::MIN_INT;
+
                         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) && $type === ColumnType::Integer) {
                     $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;
+                            $this->message = "Cannot apply {$methodName} operator: array items must be between ".Database::MIN_INT.' and '.Database::MAX_INT;
+
                             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 ($type === ColumnType::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;
+                        $this->message = "Cannot apply {$methodName} operator: array items must be between ".Database::MIN_INT.' and '.Database::MAX_INT;
+
                         return false;
                     }
                 }
@@ -294,184 +314,206 @@ 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;
                 }
 
                 $validConditions = [
                     'equal', 'notEqual',  // Comparison
                     'greaterThan', 'greaterThanEqual', 'lessThan', 'lessThanEqual',  // Numeric
-                    'isNull', 'isNotNull' // Null checks
+                    'isNull', 'isNotNull', // Null checks
                 ];
-                if (!\in_array($values[0], $validConditions, true)) {
-                    $this->message = "Invalid array filter condition '{$values[0]}'. Must be one of: " . \implode(', ', $validConditions);
+                if (! \in_array($values[0], $validConditions, true)) {
+                    $this->message = "Invalid array filter condition '{$values[0]}'. Must be one of: ".\implode(', ', $validConditions);
+
                     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;
@@ -481,8 +523,6 @@ private function validateOperatorForAttribute(
      * Is array
      *
      * Function will return true if object is array.
-     *
-     * @return bool
      */
     public function isArray(): bool
     {
@@ -493,8 +533,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 fd8f5a989..b30e785e8 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) {
+            /** @var array<string, mixed> $attribute */
+            /** @var string $name */
             $name = $attribute['$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['$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($structure, $keys)) {
+        if (! $this->checkForInvalidAttributeValues($structure, $keys)) {
             return false;
         }
 
diff --git a/src/Database/Validator/Permissions.php b/src/Database/Validator/Permissions.php
index 13e737205..5d08137e1 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 4f9125182..8cf2d955f 100644
--- a/src/Database/Validator/Queries.php
+++ b/src/Database/Validator/Queries.php
@@ -2,15 +2,18 @@
 
 namespace Utopia\Database\Validator;
 
+use Throwable;
 use Utopia\Database\Query;
 use Utopia\Database\Validator\Query\Base;
+use Utopia\Database\Validator\Query\Order;
+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 +21,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 +38,6 @@ public function __construct(array $validators = [], int $length = 0)
      * Get Description.
      *
      * Returns validator description
-     *
-     * @return string
      */
     public function getDescription(): string
     {
@@ -47,87 +45,143 @@ public function getDescription(): string
     }
 
     /**
-     * @param array<Query|string> $value
+     * Validate an array of queries, checking each against registered method-type validators.
+     *
+     * @param mixed $value Array of Query objects or query strings
      * @return bool
      */
     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;
         }
 
+        /** @var array<string> $aggregationAliases */
+        $aggregationAliases = [];
+        foreach ($value as $q) {
+            if (! $q instanceof Query) {
+                try {
+                    $q = Query::parse($q);
+                } catch (Throwable) {
+                    continue;
+                }
+            }
+            if (\in_array($q->getMethod(), [
+                Method::Count, Method::CountDistinct, Method::Sum, Method::Avg,
+                Method::Min, Method::Max, Method::Stddev, Method::Variance,
+            ], true)) {
+                $alias = $q->getValue('');
+                if (\is_string($alias) && $alias !== '') {
+                    $aggregationAliases[] = $alias;
+                }
+            }
+        }
+        if (! empty($aggregationAliases)) {
+            foreach ($this->validators as $validator) {
+                if ($validator instanceof Order) {
+                    $validator->addAggregationAliases($aggregationAliases);
+                }
+            }
+        }
+
         foreach ($value as $query) {
-            if (!$query instanceof Query) {
+            if (! $query instanceof Query) {
                 try {
                     $query = Query::parse($query);
-                } catch (\Throwable $e) {
-                    $this->message = 'Invalid query: ' . $e->getMessage();
+                } catch (Throwable $e) {
+                    $this->message = 'Invalid query: '.$e->getMessage();
+
                     return false;
                 }
             }
 
-            if ($query->isNested()) {
-                if (!self::isValid($query->getValues())) {
+            if ($query->isNested() && $query->getMethod() !== Method::Having) {
+                /** @var array<Query|string> $nestedValues */
+                $nestedValues = $query->getValues();
+                if (! self::isValid($nestedValues)) {
                     return false;
                 }
             }
 
             $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,
+                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::Count,
+                Method::CountDistinct,
+                Method::Sum,
+                Method::Avg,
+                Method::Min,
+                Method::Max,
+                Method::Stddev,
+                Method::Variance => Base::METHOD_TYPE_AGGREGATE,
+                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 => '',
             };
 
@@ -136,16 +190,18 @@ public function isValid($value): bool
                 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 +213,6 @@ public function isValid($value): bool
      * Is array
      *
      * Function will return true if object is array.
-     *
-     * @return bool
      */
     public function isArray(): bool
     {
@@ -169,8 +223,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 5907c50e7..29e575241 100644
--- a/src/Database/Validator/Queries/Document.php
+++ b/src/Database/Validator/Queries/Document.php
@@ -3,35 +3,39 @@
 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\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([
+        $attributes[] = new BaseDocument([
             '$id' => '$id',
             'key' => '$id',
-            'type' => Database::VAR_STRING,
+            'type' => ColumnType::String->value,
             'array' => false,
         ]);
-        $attributes[] = new \Utopia\Database\Document([
+        $attributes[] = new BaseDocument([
             '$id' => '$createdAt',
             'key' => '$createdAt',
-            'type' => Database::VAR_DATETIME,
+            'type' => ColumnType::Datetime->value,
             'array' => false,
         ]);
-        $attributes[] = new \Utopia\Database\Document([
+        $attributes[] = new BaseDocument([
             '$id' => '$updatedAt',
             'key' => '$updatedAt',
-            'type' => Database::VAR_DATETIME,
+            'type' => ColumnType::Datetime->value,
             'array' => false,
         ]);
 
diff --git a/src/Database/Validator/Queries/Documents.php b/src/Database/Validator/Queries/Documents.php
index e55852bb8..0d491ab4c 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,32 +35,32 @@ 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
     ) {
         $attributes[] = new Document([
             '$id' => '$id',
             'key' => '$id',
-            'type' => Database::VAR_STRING,
+            'type' => ColumnType::String->value,
             'array' => false,
         ]);
         $attributes[] = new Document([
             '$id' => '$sequence',
             'key' => '$sequence',
-            'type' => Database::VAR_ID,
+            'type' => ColumnType::Id->value,
             'array' => false,
         ]);
         $attributes[] = new Document([
             '$id' => '$createdAt',
             'key' => '$createdAt',
-            'type' => Database::VAR_DATETIME,
+            'type' => ColumnType::Datetime->value,
             'array' => false,
         ]);
         $attributes[] = new Document([
             '$id' => '$updatedAt',
             'key' => '$updatedAt',
-            'type' => Database::VAR_DATETIME,
+            'type' => ColumnType::Datetime->value,
             'array' => false,
         ]);
 
@@ -73,6 +78,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 000000000..1b848cad7
--- /dev/null
+++ b/src/Database/Validator/Query/Aggregate.php
@@ -0,0 +1,38 @@
+<?php
+
+namespace Utopia\Database\Validator\Query;
+
+use Utopia\Database\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;
+    }
+
+    /**
+     * Validate that the value is a valid aggregate query.
+     *
+     * @param mixed $value The query to validate
+     * @return bool
+     */
+    public function isValid($value): bool
+    {
+        if (! $value instanceof Query) {
+            $this->message = 'Value must be a Query';
+
+            return false;
+        }
+
+        return true;
+    }
+}
diff --git a/src/Database/Validator/Query/Base.php b/src/Database/Validator/Query/Base.php
index a37fdd65a..2f9f8db3a 100644
--- a/src/Database/Validator/Query/Base.php
+++ b/src/Database/Validator/Query/Base.php
@@ -4,23 +4,39 @@
 
 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 +47,6 @@ public function getDescription(): string
      * Is array
      *
      * Function will return true if object is array.
-     *
-     * @return bool
      */
     public function isArray(): bool
     {
@@ -43,8 +57,6 @@ public function isArray(): bool
      * Get Type
      *
      * Returns validator type.
-     *
-     * @return string
      */
     public function getType(): string
     {
diff --git a/src/Database/Validator/Query/Cursor.php b/src/Database/Validator/Query/Cursor.php
index 58053fe60..615a37136 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 000000000..09ef336ea
--- /dev/null
+++ b/src/Database/Validator/Query/Distinct.php
@@ -0,0 +1,38 @@
+<?php
+
+namespace Utopia\Database\Validator\Query;
+
+use Utopia\Database\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;
+    }
+
+    /**
+     * Validate that the value is a valid distinct query.
+     *
+     * @param mixed $value The query to validate
+     * @return bool
+     */
+    public function isValid($value): bool
+    {
+        if (! $value instanceof Query) {
+            $this->message = 'Value must be a Query';
+
+            return false;
+        }
+
+        return true;
+    }
+}
diff --git a/src/Database/Validator/Query/Filter.php b/src/Database/Validator/Query/Filter.php
index dd07e44c8..94c94c1ea 100644
--- a/src/Database/Validator/Query/Filter.php
+++ b/src/Database/Validator/Query/Filter.php
@@ -2,16 +2,23 @@
 
 namespace Utopia\Database\Validator\Query;
 
-use Utopia\Database\Database;
+use DateTime;
 use Utopia\Database\Document;
 use Utopia\Database\Query;
+use Utopia\Database\RelationSide;
+use Utopia\Database\RelationType;
 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
 {
     /**
@@ -20,34 +27,39 @@ class Filter extends Base
     protected array $schema = [];
 
     /**
-     * @param array<Document> $attributes
-     * @param int $maxValuesCount
-     * @param \DateTime $minAllowedDate
-     * @param \DateTime $maxAllowedDate
+     * @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 DateTime $minAllowedDate = new DateTime('0000-01-01'),
+        private readonly DateTime $maxAllowedDate = new DateTime('9999-12-31'),
         private bool $supportForAttributes = true
     ) {
         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 type string to ColumnType enum for typed comparisons
+            if (isset($copy['type']) && \is_string($copy['type'])) {
+                $copy['type'] = ColumnType::from($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;
         }
 
@@ -63,8 +75,9 @@ protected function isValidAttribute(string $attribute): bool
         }
 
         // 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;
         }
 
@@ -72,67 +85,72 @@ 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])) {
+        if (\str_contains($attribute, '.') && ! isset($this->schema[$attribute])) {
             // For relationships, just validate the top level.
             // Utopia will validate each nested level during the recursive calls.
             $attribute = \explode('.', $attribute)[0];
         }
 
         // 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;
+            $this->message = 'Query on attribute has greater than '.$this->maxValuesCount.' values: '.$attribute;
+
             return false;
         }
 
-        if (!$this->supportForAttributes && !isset($this->schema[$attribute])) {
+        if (! $this->supportForAttributes && ! isset($this->schema[$attribute])) {
             return true;
         }
+        /** @var array<string, mixed> $attributeSchema */
         $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;
         }
 
@@ -140,47 +158,49 @@ protected function isValidAttributeAndValues(string $attribute, array $values, s
             $validator = null;
 
             switch ($attributeType) {
-                case Database::VAR_ID:
+                case ColumnType::Id:
                     $validator = new Sequence($this->idAttributeType, $attribute === '$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:
                     $validator = new Text(0, 0);
                     break;
 
-                case Database::VAR_INTEGER:
+                case ColumnType::Integer:
+                    /** @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_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:
                     $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);
@@ -188,110 +208,145 @@ protected function isValidAttributeAndValues(string $attribute, array $values, s
                     }
 
                     // 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 . '"';
+                    elseif (\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 instanceof Document) {
+                $options = $options->getArrayCopy();
+            }
+
+            /** @var array<string, mixed> $options */
 
-            if ($options['relationType'] === Database::RELATION_ONE_TO_ONE && $options['twoWay'] === false && $options['side'] === Database::RELATION_SIDE_CHILD) {
+            /** @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;
             }
         }
@@ -300,8 +355,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
     {
@@ -326,13 +380,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;
         }
 
@@ -352,7 +403,7 @@ private function isValidObjectQueryValues(mixed $values): bool
         }
 
         foreach ($values as $value) {
-            if (!$this->isValidObjectQueryValues($value)) {
+            if (! $this->isValidObjectQueryValues($value)) {
                 return false;
             }
         }
@@ -367,145 +418,166 @@ 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])) {
+                if (\str_contains($attributeKey, '.') && ! isset($this->schema[$attributeKey])) {
                     $attributeKey = \explode('.', $attributeKey)[0];
                 }
 
+                /** @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 array<Query> $andOrValues */
+                $andOrValues = $value->getValues();
+                $filters = Query::groupForDatabase($andOrValues)['filters'];
 
                 if (count($value->getValues()) !== count($filters)) {
-                    $this->message = \ucfirst($method) . ' queries can only contain filter queries';
+                    $this->message = \ucfirst($method->value).' 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;
                 }
 
                 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'];
+                /** @var array<Query> $elemMatchValues */
+                $elemMatchValues = $value->getValues();
+                $filters = Query::groupForDatabase($elemMatchValues)['filters'];
                 if (count($value->getValues()) !== 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;
                 }
+
                 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);
                 }
 
@@ -513,11 +585,21 @@ public function isValid($value): bool
         }
     }
 
+    /**
+     * Get the maximum number of values allowed in a single filter query.
+     *
+     * @return int
+     */
     public function getMaxValuesCount(): int
     {
         return $this->maxValuesCount;
     }
 
+    /**
+     * Get the method type this validator handles.
+     *
+     * @return string
+     */
     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 000000000..972a72adf
--- /dev/null
+++ b/src/Database/Validator/Query/GroupBy.php
@@ -0,0 +1,45 @@
+<?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 that the value is a valid groupBy query with at least one attribute.
+     *
+     * @param mixed $value The query to validate
+     * @return bool
+     */
+    public function isValid($value): bool
+    {
+        if (! $value instanceof Query) {
+            $this->message = 'Value must be a Query';
+
+            return false;
+        }
+
+        $columns = $value->getValues();
+        if (empty($columns)) {
+            $this->message = 'GroupBy requires at least one attribute';
+
+            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 000000000..22c109de0
--- /dev/null
+++ b/src/Database/Validator/Query/Having.php
@@ -0,0 +1,45 @@
+<?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 that the value is a valid having query with at least one condition.
+     *
+     * @param mixed $value The query to validate
+     * @return bool
+     */
+    public function isValid($value): bool
+    {
+        if (! $value instanceof Query) {
+            $this->message = 'Value must be a Query';
+
+            return false;
+        }
+
+        $conditions = $value->getValues();
+        if (empty($conditions)) {
+            $this->message = 'Having requires at least one condition';
+
+            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 000000000..89c1ebb13
--- /dev/null
+++ b/src/Database/Validator/Query/Join.php
@@ -0,0 +1,45 @@
+<?php
+
+namespace Utopia\Database\Validator\Query;
+
+use Utopia\Database\Query;
+
+/**
+ * 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 that the value is a valid join query with a table name.
+     *
+     * @param mixed $value The query to validate
+     * @return bool
+     */
+    public function isValid($value): bool
+    {
+        if (! $value instanceof Query) {
+            $this->message = 'Value must be a Query';
+
+            return false;
+        }
+
+        $table = $value->getAttribute();
+        if (empty($table)) {
+            $this->message = 'Join requires a table name';
+
+            return false;
+        }
+
+        return true;
+    }
+}
diff --git a/src/Database/Validator/Query/Limit.php b/src/Database/Validator/Query/Limit.php
index facc266d7..960199268 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 8d59be4d0..5ec80fd75 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 limit: '.$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 5d9970a01..c7ecd1beb 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,20 +17,17 @@ class Order extends Base
     protected array $schema = [];
 
     /**
-     * @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('$id'));
+            $this->schema[$attrKey] = $attribute->getArrayCopy();
         }
     }
 
-    /**
-     * @param string $attribute
-     * @return bool
-     */
     protected function isValidAttribute(string $attribute): bool
     {
         if (\str_contains($attribute, '.')) {
@@ -40,14 +41,16 @@ protected function isValidAttribute(string $attribute): bool
             $attribute = \explode('.', $attribute)[0];
 
             if (isset($this->schema[$attribute])) {
-                $this->message = 'Cannot order by nested attribute: ' . $attribute;
+                $this->message = 'Cannot order by nested attribute: '.$attribute;
+
                 return false;
             }
         }
 
         // 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 +64,43 @@ 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 addAggregationAliases(array $aliases): void
+    {
+        foreach ($aliases as $alias) {
+            $this->schema[$alias] = ['$id' => $alias, 'key' => $alias];
+        }
+    }
+
+    /**
+     * 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 b0ed9e564..6482e1d5c 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,14 @@ class Select extends Base
     protected array $schema = [];
 
     /**
-     * List of internal attributes
-     *
-     * @var array<string>
-     */
-    protected const INTERNAL_ATTRIBUTES = [
-        '$id',
-        '$sequence',
-        '$createdAt',
-        '$updatedAt',
-        '$permissions',
-        '$collection',
-    ];
-
-    /**
-     * @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('$id'));
+            $this->schema[$attrKey] = $attribute->getArrayCopy();
         }
     }
 
@@ -45,37 +37,40 @@ 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;
         }
 
         if (\count($value->getValues()) !== \count(\array_unique($value->getValues()))) {
             $this->message = 'Duplicate attributes selected';
+
             return false;
 
         }
-        foreach ($value->getValues() as $attribute) {
+        foreach ($value->getValues() as $attributeValue) {
+            /** @var string $attribute */
+            $attribute = $attributeValue;
             if (\str_contains($attribute, '.')) {
-                //special symbols with `dots`
+                // special symbols with `dots`
                 if (isset($this->schema[$attribute])) {
                     continue;
                 }
@@ -90,14 +85,21 @@ 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;
     }
 
+    /**
+     * 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 91202191e..f8f254e47 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 7e3ebca27..9584a69a7 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($this->primary ? 1 : 0, 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 912f05b2b..41533ea21 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 a65734dbd..dee44fb56 100644
--- a/src/Database/Validator/Structure.php
+++ b/src/Database/Validator/Structure.php
@@ -3,6 +3,7 @@
 namespace Utopia\Database\Validator;
 
 use Closure;
+use DateTime;
 use Exception;
 use Utopia\Database\Database;
 use Utopia\Database\Document;
@@ -10,6 +11,7 @@
 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 +19,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
 {
     /**
@@ -25,7 +30,7 @@ class Structure extends Validator
     protected array $attributes = [
         [
             '$id' => '$id',
-            'type' => Database::VAR_STRING,
+            'type' => 'string',
             'size' => 255,
             'required' => false,
             'signed' => true,
@@ -34,7 +39,7 @@ class Structure extends Validator
         ],
         [
             '$id' => '$sequence',
-            'type' => Database::VAR_ID,
+            'type' => 'id',
             'size' => 0,
             'required' => false,
             'signed' => true,
@@ -43,7 +48,7 @@ class Structure extends Validator
         ],
         [
             '$id' => '$collection',
-            'type' => Database::VAR_STRING,
+            'type' => 'string',
             'size' => 255,
             'required' => true,
             'signed' => true,
@@ -52,7 +57,7 @@ class Structure extends Validator
         ],
         [
             '$id' => '$tenant',
-            'type' => Database::VAR_ID,
+            'type' => 'id',
             'size' => 0,
             'required' => false,
             'default' => null,
@@ -62,8 +67,8 @@ class Structure extends Validator
         ],
         [
             '$id' => '$permissions',
-            'type' => Database::VAR_STRING,
-            'size' => 67000, // medium text
+            'type' => 'string',
+            'size' => 67000,
             'required' => false,
             'signed' => true,
             'array' => true,
@@ -71,7 +76,7 @@ class Structure extends Validator
         ],
         [
             '$id' => '$createdAt',
-            'type' => Database::VAR_DATETIME,
+            'type' => 'datetime',
             'size' => 0,
             'required' => true,
             'signed' => false,
@@ -80,13 +85,23 @@ class Structure extends Validator
         ],
         [
             '$id' => '$updatedAt',
-            'type' => Database::VAR_DATETIME,
+            'type' => 'datetime',
             'size' => 0,
             'required' => true,
             'signed' => false,
             'array' => false,
             'filters' => [],
-        ]
+        ],
+        [
+            '$id' => '$version',
+            'type' => 'integer',
+            'size' => 0,
+            'required' => false,
+            'default' => null,
+            'signed' => false,
+            'array' => false,
+            'filters' => [],
+        ],
     ];
 
     /**
@@ -94,20 +109,16 @@ class Structure extends Validator
      */
     protected static array $formats = [];
 
-    /**
-     * @var string
-     */
     protected string $message = 'General Error';
 
     /**
      * 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 ?Document $currentDocument = null
     ) {
@@ -127,28 +138,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  $callback  Callback that accepts $params in order and returns Validator
+     * @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;
         }
 
@@ -158,17 +164,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];
@@ -179,8 +184,6 @@ public static function getFormat(string $name, string $type): array
 
     /**
      * Remove a Validator
-     *
-     * @param string $name
      */
     public static function removeFormat(string $name): void
     {
@@ -191,8 +194,6 @@ public static function removeFormat(string $name): void
      * Get Description.
      *
      * Returns validator description
-     *
-     * @return string
      */
     public function getDescription(): string
     {
@@ -204,40 +205,44 @@ 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';
+
             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<array<string, mixed>> $attributes */
+        $attributes = \array_merge($this->attributes, $collectionAttributes);
 
-        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($structure, $keys)) {
+        if (! $this->checkForInvalidAttributeValues($structure, $keys)) {
             return false;
         }
 
@@ -247,26 +252,27 @@ 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>>  $attributes
+     * @param  array<string, mixed>  $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
+            /** @var array<string, mixed> $attribute */
+            /** @var string $name */
             $name = $attribute['$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;
             }
         }
@@ -277,19 +283,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, mixed>  $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;
             }
         }
@@ -300,31 +305,36 @@ 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, mixed>  $keys
      */
     protected function checkForInvalidAttributeValues(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)) {
+                if (! $operatorValidator->isValid($value)) {
                     $this->message = $operatorValidator->getDescription();
+
                     return false;
                 }
+
                 continue;
             }
 
+            /** @var array<string, mixed> $attribute */
             $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;
 
@@ -332,72 +342,78 @@ protected function checkForInvalidAttributeValues(array $structure, array $keys)
                 continue;
             }
 
-            if ($type === Database::VAR_RELATIONSHIP) {
+            $columnType = ColumnType::tryFrom($type);
+
+            if ($columnType === ColumnType::Relationship) {
                 continue;
             }
 
             $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['$id'] ?? '') === '$sequence');
                     break;
 
-                case Database::VAR_VARCHAR:
-                case Database::VAR_TEXT:
-                case Database::VAR_MEDIUMTEXT:
-                case Database::VAR_LONGTEXT:
-                case Database::VAR_STRING:
+                case ColumnType::Varchar:
+                case ColumnType::Text:
+                case ColumnType::MediumText:
+                case ColumnType::LongText:
+                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
                     $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 = $size >= 8 ? 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_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;
                     }
             }
@@ -407,36 +423,41 @@ protected function checkForInvalidAttributeValues(array $structure, array $keys)
 
             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, ColumnType::from($type));
+                /** @var Validator $formatValidator */
+                $formatValidator = $formatDef['callback']($attribute);
+                $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;
                     }
                 }
@@ -450,8 +471,6 @@ protected function checkForInvalidAttributeValues(array $structure, array $keys)
      * Is array
      *
      * Function will return true if object is array.
-     *
-     * @return bool
      */
     public function isArray(): bool
     {
@@ -462,8 +481,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 743adbcde..2fd403950 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, and underscore. Can\'t start with a leading underscore';
     }
 }
diff --git a/src/Database/Validator/Vector.php b/src/Database/Validator/Vector.php
index b81d0b3aa..b2b4007f5 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/tests/e2e/Adapter/Base.php b/tests/e2e/Adapter/Base.php
index 4baeba35b..71d5b983a 100644
--- a/tests/e2e/Adapter/Base.php
+++ b/tests/e2e/Adapter/Base.php
@@ -3,12 +3,13 @@
 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\JoinTests;
 use Tests\E2E\Adapter\Scopes\ObjectAttributeTests;
 use Tests\E2E\Adapter\Scopes\OperatorTests;
 use Tests\E2E\Adapter\Scopes\PermissionTests;
@@ -17,64 +18,59 @@
 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 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);
 
@@ -82,4 +78,8 @@ public function tearDown(): void
 
     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 923de242e..5936bd167 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/MirrorTest.php b/tests/e2e/Adapter/MirrorTest.php
index 31bf3f3b6..956bd0e11 100644
--- a/tests/e2e/Adapter/MirrorTest.php
+++ b/tests/e2e/Adapter/MirrorTest.php
@@ -6,6 +6,7 @@
 use Utopia\Cache\Adapter\Redis as RedisAdapter;
 use Utopia\Cache\Cache;
 use Utopia\Database\Adapter\MariaDB;
+use Utopia\Database\Attribute;
 use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Exception;
@@ -18,13 +19,18 @@
 use Utopia\Database\Helpers\Role;
 use Utopia\Database\Mirror;
 use Utopia\Database\PDO;
+use Utopia\Query\Schema\ColumnType;
 
 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,40 +69,43 @@ 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();
 
@@ -107,7 +116,7 @@ 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();
@@ -119,7 +128,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,7 +142,7 @@ public function testGetMirrorDestination(): void
      * @throws Exception
      * @throws \RedisException
      */
-    public function testCreateMirroredCollection(): void
+    public function test_create_mirrored_collection(): void
     {
         $database = $this->getDatabase();
 
@@ -141,7 +150,9 @@ public function testCreateMirroredCollection(): void
 
         // 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,7 +162,7 @@ public function testCreateMirroredCollection(): void
      * @throws Conflict
      * @throws Exception
      */
-    public function testUpdateMirroredCollection(): void
+    public function test_update_mirrored_collection(): void
     {
         $database = $this->getDatabase();
 
@@ -166,7 +177,7 @@ public function testUpdateMirroredCollection(): void
             [
                 Permission::read(Role::users()),
             ],
-            $collection->getAttribute('documentSecurity')
+            (bool) $collection->getAttribute('documentSecurity')
         );
 
         // Asset both databases have updated the collection
@@ -175,13 +186,15 @@ 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();
 
@@ -191,7 +204,9 @@ public function testDeleteMirroredCollection(): void
 
         // 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,17 +217,12 @@ 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,
-            ]),
+            new Attribute(key: 'name', type: ColumnType::String, size: Database::LENGTH_KEY, required: true),
         ], permissions: [
             Permission::create(Role::any()),
             Permission::read(Role::any()),
@@ -220,7 +230,7 @@ public function testCreateMirroredDocument(): void
 
         $document = $database->createDocument('testCreateMirroredDocument', new Document([
             'name' => 'Jake',
-            '$permissions' => []
+            '$permissions' => [],
         ]));
 
         // Assert document is created in both databases
@@ -229,9 +239,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,17 +256,12 @@ 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,
-            ]),
+            new Attribute(key: 'name', type: ColumnType::String, size: Database::LENGTH_KEY, required: true),
         ], permissions: [
             Permission::create(Role::any()),
             Permission::read(Role::any()),
@@ -263,7 +270,7 @@ public function testUpdateMirroredDocument(): void
 
         $document = $database->createDocument('testUpdateMirroredDocument', new Document([
             'name' => 'Jake',
-            '$permissions' => []
+            '$permissions' => [],
         ]));
 
         $document = $database->updateDocument(
@@ -278,23 +285,20 @@ 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,
-            ]),
+            new Attribute(key: 'name', type: ColumnType::String, size: Database::LENGTH_KEY, required: true),
         ], permissions: [
             Permission::create(Role::any()),
             Permission::read(Role::any()),
@@ -303,26 +307,30 @@ public function testDeleteMirroredDocument(): void
 
         $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());
     }
 
     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;
@@ -330,14 +338,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 1c7eb9237..4779a1c56 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 8e92bb216..4e45fa740 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 94c2d4147..6412947d2 100644
--- a/tests/e2e/Adapter/PoolTest.php
+++ b/tests/e2e/Adapter/PoolTest.php
@@ -9,6 +9,7 @@
 use Utopia\Database\Adapter;
 use Utopia\Database\Adapter\MySQL;
 use Utopia\Database\Adapter\Pool;
+use Utopia\Database\Attribute;
 use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Exception;
@@ -19,6 +20,7 @@
 use Utopia\Database\PDO;
 use Utopia\Pools\Adapter\Stack;
 use Utopia\Pools\Pool as UtopiaPool;
+use Utopia\Query\Schema\ColumnType;
 
 class PoolTest extends Base
 {
@@ -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
         });
 
         $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->createAttribute($collection, new Attribute(key: 'title', type: ColumnType::String, 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 58beaf64e..c998588e5 100644
--- a/tests/e2e/Adapter/PostgresTest.php
+++ b/tests/e2e/Adapter/PostgresTest.php
@@ -12,7 +12,9 @@
 class PostgresTest extends Base
 {
     public static ?Database $database = null;
+
     protected static ?PDO $pdo = null;
+
     protected static string $namespace;
 
     /**
@@ -20,7 +22,7 @@ class PostgresTest extends Base
      */
     public function getDatabase(): Database
     {
-        if (!is_null(self::$database)) {
+        if (! is_null(self::$database)) {
             return self::$database;
         }
 
@@ -32,14 +34,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();
@@ -48,14 +51,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;
@@ -63,13 +68,13 @@ 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/SQLiteTest.php b/tests/e2e/Adapter/SQLiteTest.php
index 6061352e4..1ae87d995 100644
--- a/tests/e2e/Adapter/SQLiteTest.php
+++ b/tests/e2e/Adapter/SQLiteTest.php
@@ -12,38 +12,38 @@
 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));
 
         $database = new Database(new SQLite($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 +52,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;
@@ -67,9 +69,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 04ebd79f9..0db142660 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 000000000..82f770571
--- /dev/null
+++ b/tests/e2e/Adapter/Scopes/AggregationTests.php
@@ -0,0 +1,1473 @@
+<?php
+
+namespace Tests\E2E\Adapter\Scopes;
+
+use PHPUnit\Framework\Attributes\DataProvider;
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
+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\Schema\ColumnType;
+
+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 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($collection, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($collection, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+        $database->createAttribute($collection, new Attribute(key: 'category', type: ColumnType::String, size: 50, required: true));
+        $database->createAttribute($collection, new Attribute(key: 'price', type: ColumnType::Integer, size: 0, required: true));
+        $database->createAttribute($collection, new Attribute(key: 'stock', type: ColumnType::Integer, size: 0, required: true));
+        $database->createAttribute($collection, new Attribute(key: 'rating', type: ColumnType::Double, size: 0, required: false, 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($collection, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($collection, new Attribute(key: 'product_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($collection, new Attribute(key: 'customer_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($collection, new Attribute(key: 'quantity', type: ColumnType::Integer, size: 0, required: true));
+        $database->createAttribute($collection, new Attribute(key: 'total', type: ColumnType::Integer, size: 0, required: true));
+        $database->createAttribute($collection, new Attribute(key: 'status', type: ColumnType::String, 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($collection, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($collection, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+        $database->createAttribute($collection, new Attribute(key: 'email', type: ColumnType::String, size: 200, required: true));
+        $database->createAttribute($collection, new Attribute(key: 'country', type: ColumnType::String, size: 50, required: true));
+        $database->createAttribute($collection, new Attribute(key: 'tier', type: ColumnType::String, 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($collection, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($collection, new Attribute(key: 'product_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($collection, new Attribute(key: 'customer_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($collection, new Attribute(key: 'score', type: ColumnType::Integer, size: 0, required: true));
+        $database->createAttribute($collection, new Attribute(key: 'comment', type: ColumnType::String, size: 500, required: false, 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()),
+                ],
+            ])));
+        }
+    }
+
+    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($col, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($col, new Attribute(key: 'value', type: ColumnType::Integer, size: 0, 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);
+        $avgPrice = (float) $results[0]->getAttribute('avg_price');
+        $this->assertEqualsWithDelta(309.44, $avgPrice, 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'),
+        ]);
+        $avgPrice = (float) $results[0]->getAttribute('avg_price');
+        $this->assertEqualsWithDelta(833.33, $avgPrice, 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')]);
+        $avgRating = (float) $results[0]->getAttribute('avg_rating');
+        $this->assertEqualsWithDelta(4.09, $avgRating, 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, (float) $results[0]->getAttribute('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, (float) $results[0]->getAttribute('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) {
+            $mapped[$doc->getAttribute('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) {
+            $mapped[$doc->getAttribute('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) {
+            $mapped[$doc->getAttribute('category')] = (float) $doc->getAttribute('avg_price');
+        }
+        $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) {
+            $mapped[$doc->getAttribute('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) {
+            $mapped[$doc->getAttribute('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) {
+            $mapped[$doc->getAttribute('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) {
+            $mapped[$doc->getAttribute('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) {
+            $mapped[$doc->getAttribute('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) {
+            $mapped[$doc->getAttribute('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) {
+            $mapped[$doc->getAttribute('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) {
+            $mapped[$doc->getAttribute('name')] = $doc;
+        }
+
+        $this->assertEquals(3, $mapped['Laptop']->getAttribute('review_count'));
+        $this->assertEqualsWithDelta(4.0, (float) $mapped['Laptop']->getAttribute('avg_score'), 0.1);
+        $this->assertEquals(3, $mapped['Novel']->getAttribute('review_count'));
+        $this->assertEqualsWithDelta(4.67, (float) $mapped['Novel']->getAttribute('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) {
+            $mapped[$doc->getAttribute('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) {
+            $mapped[$doc->getAttribute('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) {
+            $mapped[$doc->getAttribute('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('jp_apg_c', permissions: [Permission::create(Role::any()), Permission::read(Role::any()), Permission::read(Role::user('viewer'))]);
+        $database->createAttribute('jp_apg_c', new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+        $database->createCollection('jp_apg_o', permissions: [Permission::create(Role::any()), Permission::read(Role::any())], documentSecurity: true);
+        $database->createAttribute('jp_apg_o', new Attribute(key: 'customer_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('jp_apg_o', new Attribute(key: 'amount', type: ColumnType::Integer, size: 0, 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) {
+            $mapped[$doc->getAttribute('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('jp_ljpf_p', permissions: [Permission::create(Role::any()), Permission::read(Role::any())], documentSecurity: true);
+        $database->createAttribute('jp_ljpf_p', new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+        $database->createCollection('jp_ljpf_r', permissions: [Permission::create(Role::any()), Permission::read(Role::any()), Permission::read(Role::user('tester'))]);
+        $database->createAttribute('jp_ljpf_r', new Attribute(key: 'product_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('jp_ljpf_r', new Attribute(key: 'score', type: ColumnType::Integer, size: 0, 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, 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),
+        };
+
+        $queries = array_merge($filters, [$aggQuery]);
+        $results = $database->find($col, $queries);
+        $this->assertCount(1, $results);
+
+        if ($method === 'avg') {
+            $this->assertEqualsWithDelta($expected, (float) $results[0]->getAttribute($alias), 1.0);
+        } else {
+            $this->assertEquals($expected, $results[0]->getAttribute($alias));
+        }
+    }
+
+    /**
+     * @return array<string, 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'),
+        };
+
+        $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);
+    }
+
+}
diff --git a/tests/e2e/Adapter/Scopes/AttributeTests.php b/tests/e2e/Adapter/Scopes/AttributeTests.php
index bf376d101..a0baf20bb 100644
--- a/tests/e2e/Adapter/Scopes/AttributeTests.php
+++ b/tests/e2e/Adapter/Scopes/AttributeTests.php
@@ -4,10 +4,12 @@
 
 use Exception;
 use Throwable;
+use Utopia\Database\Adapter\Feature;
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
 use Utopia\Database\Database;
 use Utopia\Database\DateTime;
 use Utopia\Database\Document;
-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;
@@ -19,13 +21,49 @@
 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\RelationType;
 use Utopia\Database\Validator\Datetime as DatetimeValidator;
 use Utopia\Database\Validator\Structure;
+use Utopia\Query\OrderDirection;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\IndexType;
 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);
@@ -40,30 +78,30 @@ private function createRandomString(int $length = 10): 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 +110,167 @@ public function testCreateDeleteAttribute(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $database->createCollection('attributes');
+        $database->createCollection($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(), new Attribute(key: 'string1', type: ColumnType::String, size: 128, required: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), new Attribute(key: 'string2', type: ColumnType::String, size: 16382 + 1, required: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), new Attribute(key: 'string3', type: ColumnType::String, size: 65535 + 1, required: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), new Attribute(key: 'string4', type: ColumnType::String, size: 16777215 + 1, required: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), new Attribute(key: 'integer', type: ColumnType::Integer, size: 0, required: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), new Attribute(key: 'bigint', type: ColumnType::Integer, size: 8, required: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), new Attribute(key: 'float', type: ColumnType::Double, size: 0, required: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), new Attribute(key: 'boolean', type: ColumnType::Boolean, size: 0, required: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), new Attribute(key: 'id', type: ColumnType::Id, size: 0, 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->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), new Attribute(key: 'varchar1', type: ColumnType::Varchar, size: 255, required: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), new Attribute(key: 'varchar2', type: ColumnType::Varchar, size: 128, required: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), new Attribute(key: 'text1', type: ColumnType::Text, size: 65535, required: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), new Attribute(key: 'mediumtext1', type: ColumnType::MediumText, size: 16777215, required: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), new Attribute(key: 'longtext1', type: ColumnType::LongText, size: 4294967295, required: true)));
+
+        $this->assertEquals(true, $database->createIndex($this->getAttributesCollection(), new Index(key: 'id_index', type: IndexType::Key, attributes: ['id'])));
+        $this->assertEquals(true, $database->createIndex($this->getAttributesCollection(), new Index(key: 'string1_index', type: IndexType::Key, attributes: ['string1'])));
+        $this->assertEquals(true, $database->createIndex($this->getAttributesCollection(), new Index(key: 'string2_index', type: IndexType::Key, attributes: ['string2'], lengths: [255])));
+        $this->assertEquals(true, $database->createIndex($this->getAttributesCollection(), new Index(key: 'multi_index', type: IndexType::Key, attributes: ['string1', 'string2', 'string3'], lengths: [128, 128, 128])));
+        $this->assertEquals(true, $database->createIndex($this->getAttributesCollection(), new Index(key: 'varchar1_index', type: IndexType::Key, attributes: ['varchar1'])));
+        $this->assertEquals(true, $database->createIndex($this->getAttributesCollection(), new Index(key: 'varchar2_index', type: IndexType::Key, attributes: ['varchar2'])));
+        $this->assertEquals(true, $database->createIndex($this->getAttributesCollection(), new Index(key: 'text1_index', type: IndexType::Key, attributes: ['text1'], lengths: [255])));
+
+        $collection = $database->getCollection($this->getAttributesCollection());
         $this->assertCount(14, $collection->getAttribute('attributes'));
         $this->assertCount(7, $collection->getAttribute('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->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), new Attribute(key: 'string_list', type: ColumnType::String, size: 128, required: true, default: null, signed: true, array: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), new Attribute(key: 'integer_list', type: ColumnType::Integer, size: 0, required: true, default: null, signed: true, array: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), new Attribute(key: 'float_list', type: ColumnType::Double, size: 0, required: true, default: null, signed: true, array: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), new Attribute(key: 'boolean_list', type: ColumnType::Boolean, size: 0, required: true, default: null, signed: true, array: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), new Attribute(key: 'varchar_list', type: ColumnType::Varchar, size: 128, required: true, default: null, signed: true, array: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), new Attribute(key: 'text_list', type: ColumnType::Text, size: 65535, required: true, default: null, signed: true, array: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), new Attribute(key: 'mediumtext_list', type: ColumnType::MediumText, size: 16777215, required: true, default: null, signed: true, array: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), new Attribute(key: 'longtext_list', type: ColumnType::LongText, size: 4294967295, required: true, default: null, signed: true, array: true)));
+
+        $collection = $database->getCollection($this->getAttributesCollection());
         $this->assertCount(22, $collection->getAttribute('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->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), new Attribute(key: 'string_default', type: ColumnType::String, size: 256, required: false, default: 'test')));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), new Attribute(key: 'integer_default', type: ColumnType::Integer, size: 0, required: false, default: 1)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), new Attribute(key: 'float_default', type: ColumnType::Double, size: 0, required: false, default: 1.5)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), new Attribute(key: 'boolean_default', type: ColumnType::Boolean, size: 0, required: false, default: false)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), new Attribute(key: 'datetime_default', type: ColumnType::Datetime, size: 0, required: false, default: '2000-06-12T14:12:55.000+00:00', signed: true, array: false, format: null, formatOptions: [], filters: ['datetime'])));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), new Attribute(key: 'varchar_default', type: ColumnType::Varchar, size: 255, required: false, default: 'varchar default')));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), new Attribute(key: 'text_default', type: ColumnType::Text, size: 65535, required: false, default: 'text default')));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), new Attribute(key: 'mediumtext_default', type: ColumnType::MediumText, size: 16777215, required: false, default: 'mediumtext default')));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), new Attribute(key: 'longtext_default', type: ColumnType::LongText, size: 4294967295, required: false, default: 'longtext default')));
+
+        $collection = $database->getCollection($this->getAttributesCollection());
         $this->assertCount(31, $collection->getAttribute('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->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->getAttribute('attributes'));
         $this->assertCount(0, $collection->getAttribute('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->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->getAttribute('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->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->getAttribute('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(), new Attribute(key: 'as_5dasdasdas', type: ColumnType::Boolean, size: 0, required: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), new Attribute(key: 'as5dasdasdas_', type: ColumnType::Boolean, size: 0, required: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), new Attribute(key: '.as5dasdasdas', type: ColumnType::Boolean, size: 0, required: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), new Attribute(key: '-as5dasdasdas', type: ColumnType::Boolean, size: 0, required: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), new Attribute(key: 'as-5dasdasdas', type: ColumnType::Boolean, size: 0, required: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), new Attribute(key: 'as5dasdasdas-', type: ColumnType::Boolean, size: 0, required: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), new Attribute(key: 'socialAccountForYoutubeSubscribersss', type: ColumnType::Boolean, size: 0, required: true)));
+        $this->assertEquals(true, $database->createAttribute($this->getAttributesCollection(), new Attribute(key: '5f058a89258075f058a89258075f058t9214', type: ColumnType::Boolean, size: 0, required: true)));
 
         // Test non-shared tables duplicates throw duplicate
-        $database->createAttribute('attributes', 'duplicate', Database::VAR_STRING, 128, true);
+        $database->createAttribute($this->getAttributesCollection(), new Attribute(key: 'duplicate', type: ColumnType::String, size: 128, required: true));
         try {
-            $database->createAttribute('attributes', 'duplicate', Database::VAR_STRING, 128, true);
+            $database->createAttribute($this->getAttributesCollection(), new Attribute(key: 'duplicate', type: ColumnType::String, 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(), new Attribute(key: 'string1', type: ColumnType::String, 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');
+        $collection = $database->getCollection($this->getAttributesCollection());
         $attributes = $collection->getAttribute('attributes');
         $attribute = end($attributes);
         $this->assertEquals('string1', $attribute->getId());
 
-        $this->assertEquals(true, $database->deleteAttribute('attributes', 'string1'));
+        $this->assertEquals(true, $database->deleteAttribute($this->getAttributesCollection(), 'string1'));
 
-        $collection = $database->getCollection('attributes');
+        $collection = $database->getCollection($this->getAttributesCollection());
         $attributes = $collection->getAttribute('attributes');
         $attribute = end($attributes);
         $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($this->getAttributesCollection());
+
+        self::$attributesCollectionFixtureInit = true;
     }
 
     public function testAttributeKeyWithSymbols(): void
@@ -248,13 +280,13 @@ public function testAttributeKeyWithSymbols(): void
 
         $database->createCollection('attributesWithKeys');
 
-        $this->assertEquals(true, $database->createAttribute('attributesWithKeys', 'key_with.sym$bols', Database::VAR_STRING, 128, true));
+        $this->assertEquals(true, $database->createAttribute('attributesWithKeys', new Attribute(key: 'key_with.sym$bols', type: ColumnType::String, 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,18 +298,17 @@ public function testAttributeKeyWithSymbols(): void
 
     public function testAttributeNamesWithDots(): void
     {
+        if (! ($this->getDatabase()->getAdapter() instanceof Feature\Relationships)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
         $database->createCollection('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', new Attribute(key: 'dots.name', type: ColumnType::String, size: 255, required: false)));
 
         $document = $database->find('dots.parent', [
             Query::select(['dots.name']),
@@ -286,19 +317,9 @@ public function testAttributeNamesWithDots(): void
 
         $database->createCollection('dots');
 
-        $this->assertTrue($database->createAttribute(
-            collection: 'dots',
-            id: 'name',
-            type: Database::VAR_STRING,
-            size: 255,
-            required: false
-        ));
-
-        $database->createRelationship(
-            collection: 'dots.parent',
-            relatedCollection: 'dots',
-            type: Database::RELATION_ONE_TO_ONE
-        );
+        $this->assertTrue($database->createAttribute('dots', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: false)));
+
+        $database->createRelationship(new Relationship(collection: 'dots.parent', relatedCollection: 'dots', type: RelationType::OneToOne));
 
         $database->createDocument('dots.parent', new Document([
             '$id' => ID::custom('father'),
@@ -317,7 +338,7 @@ public function testAttributeNamesWithDots(): void
                     Permission::update(Role::any()),
                     Permission::delete(Role::any()),
                 ],
-            ]
+            ],
         ]));
 
         $documents = $database->find('dots.parent', [
@@ -327,18 +348,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($collection);
+        $database->createAttribute($collection, new Attribute(key: 'name', type: ColumnType::String, size: 128, required: true));
+        $database->createAttribute($collection, new Attribute(key: 'inStock', type: ColumnType::Integer, size: 0, required: false));
+        $database->createAttribute($collection, new Attribute(key: 'date', type: ColumnType::String, size: 128, required: false));
 
-        $database->createDocument('flowers', new Document([
+        $database->createDocument($collection, new Document([
             '$id' => 'flowerWithDate',
             '$permissions' => [
                 Permission::read(Role::any()),
@@ -348,52 +369,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($this->getColorsCollection());
+        $database->createAttribute($this->getColorsCollection(), new Attribute(key: 'name', type: ColumnType::String, size: 128, required: true));
+        $database->createAttribute($this->getColorsCollection(), new Attribute(key: 'hex', type: ColumnType::String, size: 128, required: true));
 
-        $database->createIndex('colors', 'index1', Database::INDEX_KEY, ['name'], [128], [Database::ORDER_ASC]);
+        $database->createIndex($this->getColorsCollection(), new Index(key: 'index1', type: IndexType::Key, attributes: ['name'], lengths: [128], orders: [OrderDirection::Asc->value]));
 
-        $database->createDocument('colors', new Document([
+        $database->createDocument($this->getColorsCollection(), new Document([
             '$permissions' => [
                 Permission::read(Role::any()),
                 Permission::create(Role::any()),
@@ -401,70 +423,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');
+        $colors = $database->getCollection($this->getColorsCollection());
         $this->assertEquals('hex', $colors->getAttribute('attributes')[1]['$id']);
         $this->assertEquals('verbose', $colors->getAttribute('attributes')[0]['$id']);
         $this->assertCount(2, $colors->getAttribute('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->assertEquals('verbose', $colors->getAttribute('indexes')[0]->getAttribute('attributes')[0]);
         $this->assertCount(1, $colors->getAttribute('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($collection);
+        $database->createAttribute($collection, new Attribute(key: 'name', type: ColumnType::String, size: 128, required: true));
+        $database->createAttribute($collection, new Attribute(key: 'inStock', type: ColumnType::Integer, size: 0, required: false));
+        $database->createAttribute($collection, new Attribute(key: 'date', type: ColumnType::String, size: 128, required: false));
+
+        $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(), new Attribute(key: 'cartModel', type: ColumnType::String, size: 2000, required: false));
 
-        $doc = $database->createDocument('flowers', new Document([
+        $doc = $database->createDocument($this->getFlowersCollection(), new Document([
             '$permissions' => [
                 Permission::read(Role::any()),
                 Permission::create(Role::any()),
@@ -473,37 +540,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(), new Attribute(key: 'cartModel', type: ColumnType::String, size: 2000, required: false));
+        } catch (\Exception $e) {
+            // Already exists
+        }
+
+        $database->createAttribute($this->getFlowersCollection(), new Attribute(key: 'price', type: ColumnType::Integer, size: 0, required: false));
 
-        $doc = $database->createDocument('flowers', new Document([
+        $doc = $database->createDocument($this->getFlowersCollection(), new Document([
             '$permissions' => [
                 Permission::read(Role::any()),
                 Permission::create(Role::any()),
@@ -514,7 +588,7 @@ public function testUpdateAttributeFormat(): void
             'name' => 'Lily Priced',
             'inStock' => 50,
             'cartModel' => '{}',
-            'price' => 500
+            'price' => 500,
         ]));
 
         $this->assertIsNumeric($doc->getAttribute('price'));
@@ -525,14 +599,14 @@ public function testUpdateAttributeFormat(): void
             $max = $attribute['formatOptions']['max'];
 
             return new Range($min, $max);
-        }, Database::VAR_INTEGER);
+        }, ColumnType::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,29 +616,90 @@ 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(), new Attribute(key: 'cartModel', type: ColumnType::String, size: 2000, required: false));
+        } catch (\Exception $e) {
+            // Already exists
+        }
+
+        // Add price attribute and set format (from testUpdateAttributeFormat)
+        try {
+            $database->createAttribute($this->getFlowersCollection(), new Attribute(key: 'price', type: ColumnType::Integer, size: 0, required: false));
+        } 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', function ($attribute) {
+            $min = $attribute['formatOptions']['min'];
+            $max = $attribute['formatOptions']['max'];
+
+            return new Range($min, $max);
+        }, 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);
+        }, ColumnType::Integer);
 
         /** @var Database $database */
         $database = $this->getDatabase();
 
         // price attribute
-        $collection = $database->getCollection('flowers');
+        $collection = $database->getCollection($this->getFlowersCollection());
         $attribute = $collection->getAttribute('attributes')[4];
         $this->assertEquals(true, $attribute['signed']);
         $this->assertEquals(0, $attribute['size']);
@@ -574,8 +709,8 @@ 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');
+        $database->updateAttribute($this->getFlowersCollection(), 'price', default: 100);
+        $collection = $database->getCollection($this->getFlowersCollection());
         $attribute = $collection->getAttribute('attributes')[4];
         $this->assertEquals('integer', $attribute['type']);
         $this->assertEquals(true, $attribute['signed']);
@@ -586,8 +721,8 @@ 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');
+        $database->updateAttribute($this->getFlowersCollection(), 'price', format: 'priceRangeNew');
+        $collection = $database->getCollection($this->getFlowersCollection());
         $attribute = $collection->getAttribute('attributes')[4];
         $this->assertEquals('integer', $attribute['type']);
         $this->assertEquals(true, $attribute['signed']);
@@ -598,8 +733,8 @@ 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');
+        $database->updateAttribute($this->getFlowersCollection(), 'price', format: '');
+        $collection = $database->getCollection($this->getFlowersCollection());
         $attribute = $collection->getAttribute('attributes')[4];
         $this->assertEquals('integer', $attribute['type']);
         $this->assertEquals(true, $attribute['signed']);
@@ -610,8 +745,8 @@ 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');
+        $database->updateAttribute($this->getFlowersCollection(), 'price', formatOptions: ['min' => 1, 'max' => 999]);
+        $collection = $database->getCollection($this->getFlowersCollection());
         $attribute = $collection->getAttribute('attributes')[4];
         $this->assertEquals('integer', $attribute['type']);
         $this->assertEquals(true, $attribute['signed']);
@@ -622,8 +757,8 @@ 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');
+        $database->updateAttribute($this->getFlowersCollection(), 'price', formatOptions: []);
+        $collection = $database->getCollection($this->getFlowersCollection());
         $attribute = $collection->getAttribute('attributes')[4];
         $this->assertEquals('integer', $attribute['type']);
         $this->assertEquals(true, $attribute['signed']);
@@ -634,8 +769,8 @@ public function testUpdateAttributeStructure(): void
         $this->assertEquals('', $attribute['format']);
         $this->assertEquals([], $attribute['formatOptions']);
 
-        $database->updateAttribute('flowers', 'price', signed: false);
-        $collection = $database->getCollection('flowers');
+        $database->updateAttribute($this->getFlowersCollection(), 'price', signed: false);
+        $collection = $database->getCollection($this->getFlowersCollection());
         $attribute = $collection->getAttribute('attributes')[4];
         $this->assertEquals('integer', $attribute['type']);
         $this->assertEquals(false, $attribute['signed']);
@@ -646,8 +781,8 @@ public function testUpdateAttributeStructure(): void
         $this->assertEquals('', $attribute['format']);
         $this->assertEquals([], $attribute['formatOptions']);
 
-        $database->updateAttribute('flowers', 'price', required: true);
-        $collection = $database->getCollection('flowers');
+        $database->updateAttribute($this->getFlowersCollection(), 'price', required: true);
+        $collection = $database->getCollection($this->getFlowersCollection());
         $attribute = $collection->getAttribute('attributes')[4];
         $this->assertEquals('integer', $attribute['type']);
         $this->assertEquals(false, $attribute['signed']);
@@ -658,8 +793,8 @@ 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');
+        $database->updateAttribute($this->getFlowersCollection(), 'price', type: ColumnType::String, size: Database::LENGTH_KEY, format: '');
+        $collection = $database->getCollection($this->getFlowersCollection());
         $attribute = $collection->getAttribute('attributes')[4];
         $this->assertEquals('string', $attribute['type']);
         $this->assertEquals(false, $attribute['signed']);
@@ -676,8 +811,8 @@ public function testUpdateAttributeStructure(): void
         $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');
+        $database->updateAttribute($this->getFlowersCollection(), 'date', type: ColumnType::Datetime, size: 0, filters: ['datetime']);
+        $collection = $database->getCollection($this->getFlowersCollection());
         $attribute = $collection->getAttribute('attributes')[2];
         $this->assertEquals('datetime', $attribute['type']);
         $this->assertEquals(0, $attribute['size']);
@@ -688,11 +823,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 +836,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');
 
-        $this->assertEquals(true, $database->createAttribute('rename_test', 'rename_me', Database::VAR_STRING, 128, true));
+        $this->assertEquals(true, $database->createAttribute('rename_test', new Attribute(key: 'rename_me', type: ColumnType::String, size: 128, required: true)));
 
         $doc = $database->createDocument('rename_test', new Document([
             '$permissions' => [
@@ -717,13 +853,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', new Index(key: 'renameIndexes', type: IndexType::Key, attributes: ['rename_me'], lengths: [], orders: [OrderDirection::Desc->value, OrderDirection::Desc->value]));
 
         $database->updateAttribute(
             collection: 'rename_test',
@@ -750,25 +886,26 @@ public function testUpdateAttributeRename(): void
         $this->assertEquals('renamed', $collection->getAttribute('attributes')[0]['$id']);
         $this->assertEquals('renamed', $collection->getAttribute('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) {
+            if (! $supportsIdenticalIndexes) {
                 $this->assertTrue(true, 'Exception thrown as expected when getSupportForIdenticalIndexes=false');
+
                 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());
             }
         }
 
@@ -801,7 +938,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 +952,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 +972,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($collection);
+        $database->createAttribute($collection, new Attribute(key: 'name', type: ColumnType::String, size: 128, required: true));
+        $database->createAttribute($collection, new Attribute(key: 'hex', type: ColumnType::String, size: 128, required: true));
+        $database->createIndex($collection, new Index(key: 'index1', type: IndexType::Key, attributes: ['name'], lengths: [128], orders: [OrderDirection::Asc->value]));
+        $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,6 +1040,7 @@ public function testExceptionWidthLimit(): void
 
         if ($database->getAdapter()->getDocumentSizeLimit() === 0) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -1030,7 +1048,7 @@ public function testExceptionWidthLimit(): void
 
         $attributes[] = new Document([
             '$id' => ID::custom('varchar_16000'),
-            'type' => Database::VAR_STRING,
+            'type' => ColumnType::String->value,
             'size' => 16000,
             'required' => true,
             'default' => null,
@@ -1041,7 +1059,7 @@ public function testExceptionWidthLimit(): void
 
         $attributes[] = new Document([
             '$id' => ID::custom('varchar_200'),
-            'type' => Database::VAR_STRING,
+            'type' => ColumnType::String->value,
             'size' => 200,
             'required' => true,
             'default' => null,
@@ -1051,7 +1069,7 @@ public function testExceptionWidthLimit(): void
         ]);
 
         try {
-            $database->createCollection("attributes_row_size", $attributes);
+            $database->createCollection('attributes_row_size', $attributes);
             $this->fail('Failed to throw exception');
         } catch (\Throwable $e) {
             $this->assertInstanceOf(LimitException::class, $e);
@@ -1061,14 +1079,13 @@ public function testExceptionWidthLimit(): void
         /**
          * Remove last attribute
          */
-
         array_pop($attributes);
 
-        $collection = $database->createCollection("attributes_row_size", $attributes);
+        $collection = $database->createCollection('attributes_row_size', $attributes);
 
         $attribute = new Document([
             '$id' => ID::custom('breaking'),
-            'type' => Database::VAR_STRING,
+            'type' => ColumnType::String->value,
             'size' => 200,
             'required' => true,
             'default' => null,
@@ -1088,7 +1105,7 @@ public function testExceptionWidthLimit(): void
         }
 
         try {
-            $database->createAttribute($collection->getId(), 'breaking', Database::VAR_STRING, 200, true);
+            $database->createAttribute($collection->getId(), new Attribute(key: 'breaking', type: ColumnType::String, size: 200, required: true));
             $this->fail('Failed to throw exception');
         } catch (\Throwable $e) {
             $this->assertInstanceOf(LimitException::class, $e);
@@ -1103,14 +1120,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');
 
-        $this->assertEquals(true, $database->createAttribute('resize_test', 'resize_me', Database::VAR_STRING, 128, true));
+        $this->assertEquals(true, $database->createAttribute('resize_test', new Attribute(key: 'resize_me', type: ColumnType::String, size: 128, required: true)));
         $document = $database->createDocument('resize_test', new Document([
             '$id' => ID::unique(),
             '$permissions' => [
@@ -1119,7 +1137,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 +1153,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 +1175,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', new Attribute(key: 'attr1', type: ColumnType::String, size: $length, required: true)));
+            $this->assertEquals(true, $database->createAttribute('resize_test', new Attribute(key: 'attr2', type: ColumnType::String, 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', new Index(key: 'index1', type: IndexType::Key, 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,7 +1196,7 @@ 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', new Index(key: 'index1', type: IndexType::Key, attributes: ['attr1', 'attr2'], lengths: [$length, $length]));
 
             $collection = $database->getCollection('resize_test');
             $indexes = $collection->getAttribute('indexes', []);
@@ -1186,7 +1204,7 @@ public function testUpdateAttributeSize(): void
             $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 +1216,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', new Index(key: 'index1', type: IndexType::Key, 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]);
 
-            $database->updateAttribute('resize_test', 'attr1', Database::VAR_STRING, 5000);
+            $database->updateAttribute('resize_test', 'attr1', ColumnType::String->value, 5000);
         }
     }
 
@@ -1229,6 +1247,7 @@ function (mixed $value) {
                     return;
                 }
                 $value = json_decode($value, true);
+
                 return base64_decode($value['data']);
             }
         );
@@ -1236,8 +1255,8 @@ function (mixed $value) {
         $col = $database->createCollection(__FUNCTION__);
         $this->assertNotNull($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(), new Attribute(key: 'title', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($col->getId(), new Attribute(key: 'encrypt', type: ColumnType::String, size: 128, required: true, filters: ['encrypt']));
 
         $database->createDocument($col->getId(), new Document([
             'title' => 'Sample Title',
@@ -1265,7 +1284,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));
 
@@ -1278,37 +1297,6 @@ public function updateStringAttributeSize(int $size, Document $document): Docume
         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
@@ -1330,85 +1318,27 @@ public function testArrayAttribute(): void
             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,
-            '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,
-            'cards',
-            Database::VAR_STRING,
-            size: 5000,
-            required: false,
-            array: true
-        ));
-
-        $this->assertEquals(true, $database->createAttribute(
-            $collection,
-            'numbers',
-            Database::VAR_INTEGER,
-            size: 0,
-            required: false,
-            array: true
-        ));
-
-        $this->assertEquals(true, $database->createAttribute(
-            $collection,
-            'age',
-            Database::VAR_INTEGER,
-            size: 0,
-            required: false,
-            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,
-            'short',
-            Database::VAR_STRING,
-            size: 5,
-            required: false,
-            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, new Attribute(key: 'booleans', type: ColumnType::Boolean, size: 0, required: true, array: true)));
+
+        $this->assertEquals(true, $database->createAttribute($collection, new Attribute(key: 'names', type: ColumnType::String, size: 255, required: false, array: true)));
+
+        $this->assertEquals(true, $database->createAttribute($collection, new Attribute(key: 'cards', type: ColumnType::String, size: 5000, required: false, array: true)));
+
+        $this->assertEquals(true, $database->createAttribute($collection, new Attribute(key: 'numbers', type: ColumnType::Integer, size: 0, required: false, array: true)));
+
+        $this->assertEquals(true, $database->createAttribute($collection, new Attribute(key: 'age', type: ColumnType::Integer, size: 0, required: false, signed: false)));
+
+        $this->assertEquals(true, $database->createAttribute($collection, new Attribute(key: 'tv_show', type: ColumnType::String, size: $database->getAdapter()->getMaxIndexLength() - 68, required: false, signed: false)));
+
+        $this->assertEquals(true, $database->createAttribute($collection, new Attribute(key: 'short', type: ColumnType::String, size: 5, required: false, signed: false, array: true)));
+
+        $this->assertEquals(true, $database->createAttribute($collection, new Attribute(key: 'pref', type: ColumnType::String, size: 16384, required: false, 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());
             }
         }
@@ -1430,7 +1360,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());
             }
         }
@@ -1441,7 +1371,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());
             }
         }
@@ -1452,7 +1382,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());
             }
         }
@@ -1463,7 +1393,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());
             }
         }
@@ -1490,14 +1420,14 @@ public function testArrayAttribute(): void
         $this->assertEquals('Antony', $document->getAttribute('names')[1]);
         $this->assertEquals(100, $document->getAttribute('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, new Index(key: 'idx_cards', type: IndexType::Key, attributes: ['cards'], lengths: [100]));
         }
 
-        if ($database->getAdapter()->getSupportForCastIndexArray()) {
+        if ($database->getAdapter()->supports(Capability::CastIndexArray)) {
             /**
              * Delete attribute
              */
@@ -1524,7 +1454,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);
@@ -1536,14 +1466,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, new Index(key: 'indx', type: IndexType::Fulltext, 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());
@@ -1551,12 +1481,12 @@ public function testArrayAttribute(): void
             }
 
             try {
-                $database->createIndex($collection, 'indx', Database::INDEX_KEY, ['numbers', 'names'], [100,100]);
-                if ($database->getAdapter()->getSupportForAttributes()) {
+                $database->createIndex($collection, new Index(key: 'indx', type: IndexType::Key, 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());
@@ -1564,44 +1494,37 @@ public function testArrayAttribute(): void
             }
         }
 
-        $this->assertEquals(true, $database->createAttribute(
-            $collection,
-            'long_size',
-            Database::VAR_STRING,
-            size: 2000,
-            required: false,
-            array: true
-        ));
-
-        if ($database->getAdapter()->getSupportForIndexArray()) {
-            if ($database->getAdapter()->getSupportForAttributes() && $database->getAdapter()->getMaxIndexLength() > 0) {
+        $this->assertEquals(true, $database->createAttribute($collection, new Attribute(key: 'long_size', type: ColumnType::String, size: 2000, required: false, array: true)));
+
+        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, new Index(key: 'indx1', type: IndexType::Key, attributes: ['long_size'], lengths: [], orders: []));
                 $database->deleteIndex($collection, 'indx1');
-                $database->createIndex($collection, 'indx2', Database::INDEX_KEY, ['long_size'], [1000], []);
+                $database->createIndex($collection, new Index(key: 'indx2', type: IndexType::Key, attributes: ['long_size'], lengths: [1000], orders: []));
 
                 try {
-                    $database->createIndex($collection, 'indx_numbers', Database::INDEX_KEY, ['tv_show', 'numbers'], [], []); // [700, 255]
+                    $database->createIndex($collection, new Index(key: 'indx_numbers', type: IndexType::Key, attributes: ['tv_show', 'numbers'], lengths: [], orders: [])); // [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, new Index(key: 'indx4', type: IndexType::Key, attributes: ['age', 'names'], lengths: [10, 255], orders: []));
                     $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, new Index(key: 'indx6', type: IndexType::Key, attributes: ['age', 'names'], lengths: [null, 999], orders: [])));
+            $this->assertTrue($database->createIndex($collection, new Index(key: 'indx7', type: IndexType::Key, attributes: ['age', 'booleans'], lengths: [0, 999], orders: [])));
         }
 
-        if ($this->getDatabase()->getAdapter()->getSupportForQueryContains()) {
+        if ($this->getDatabase()->getAdapter()->supports(Capability::QueryContains)) {
             try {
                 $database->find($collection, [
                     Query::equal('names', ['Joe']),
@@ -1613,7 +1536,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) {
@@ -1621,66 +1544,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);
 
@@ -1688,37 +1611,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);
         }
@@ -1730,20 +1653,20 @@ public function testCreateDatetime(): void
         $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']));
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
+            $this->assertEquals(true, $database->createAttribute('datetime', new Attribute(key: 'date', type: ColumnType::Datetime, size: 0, required: true, default: null, signed: true, array: false, format: null, formatOptions: [], filters: ['datetime'])));
+            $this->assertEquals(true, $database->createAttribute('datetime', new Attribute(key: 'date2', type: ColumnType::Datetime, size: 0, required: false, default: null, signed: true, array: false, format: null, formatOptions: [], 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);
             }
         }
@@ -1789,26 +1712,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);
             }
         }
@@ -1816,13 +1739,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) {
@@ -1832,9 +1755,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) {
@@ -1844,18 +1767,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);
 
@@ -1865,7 +1788,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);
@@ -1880,373 +1803,31 @@ public function testCreateDatetimeAddingAutoFilter(): void
         $database->createCollection('datetime_auto_filter');
 
         $this->expectException(Exception::class);
-        $database->createAttribute('datetime_auto', 'date_auto', Database::VAR_DATETIME, 0, false, filters:['json']);
+        $database->createAttribute('datetime_auto', new Attribute(key: 'date_auto', type: ColumnType::Datetime, size: 0, required: false, 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:[]);
+        $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']);
+        $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 testCreateAttributesSuccessMultiple(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForBatchCreateAttributes()) {
+        if (! $database->getAdapter()->supports(Capability::BatchCreateAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $database->createCollection(__FUNCTION__);
 
-        $attributes = [
-            [
-                '$id' => 'a',
-                'type' => Database::VAR_STRING,
-                'size' => 10,
-                'required' => false
-            ],
-            [
-                '$id' => 'b',
-                'type' => Database::VAR_INTEGER,
-                'size' => 0,
-                'required' => false
-            ],
-        ];
+        $attributes = [new Attribute(key: 'a', type: ColumnType::String, size: 10, required: false), new Attribute(key: 'b', type: ColumnType::Integer, size: 0, required: false)];
 
         $result = $database->createAttributes(__FUNCTION__, $attributes);
         $this->assertTrue($result);
@@ -2271,27 +1852,15 @@ 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__);
 
-        $attributes = [
-            [
-                '$id' => 'a',
-                'type' => Database::VAR_STRING,
-                'size' => 10,
-                'required' => false
-            ],
-            [
-                '$id' => 'b',
-                'type' => Database::VAR_INTEGER,
-                'size' => 0,
-                'required' => false
-            ],
-        ];
+        $attributes = [new Attribute(key: 'a', type: ColumnType::String, size: 10, required: false), new Attribute(key: 'b', type: ColumnType::Integer, size: 0, required: false)];
 
         $result = $database->createAttributes(__FUNCTION__, $attributes);
         $this->assertTrue($result);
@@ -2310,9 +1879,6 @@ public function testCreateAttributesDelete(): void
         $this->assertEquals('b', $attrs[0]['$id']);
     }
 
-    /**
-     * @depends testCreateDeleteAttribute
-     */
     public function testStringTypeAttributes(): void
     {
         /** @var Database $database */
@@ -2321,14 +1887,14 @@ public function testStringTypeAttributes(): void
         $database->createCollection('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', new Attribute(key: 'varchar_field', type: ColumnType::Varchar, size: 255, required: false, default: 'default varchar')));
+        $this->assertEquals(true, $database->createAttribute('stringTypes', new Attribute(key: 'text_field', type: ColumnType::Text, size: 65535, required: false)));
+        $this->assertEquals(true, $database->createAttribute('stringTypes', new Attribute(key: 'mediumtext_field', type: ColumnType::MediumText, size: 16777215, required: false)));
+        $this->assertEquals(true, $database->createAttribute('stringTypes', new Attribute(key: 'longtext_field', type: ColumnType::LongText, size: 4294967295, required: false)));
 
         // 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', new Attribute(key: 'varchar_array', type: ColumnType::Varchar, size: 128, required: false, default: null, signed: true, array: true)));
+        $this->assertEquals(true, $database->createAttribute('stringTypes', new Attribute(key: 'text_array', type: ColumnType::Text, size: 65535, required: false, default: null, signed: true, array: true)));
 
         $collection = $database->getCollection('stringTypes');
         $this->assertCount(6, $collection->getAttribute('attributes'));
@@ -2384,7 +1950,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'),
@@ -2420,10 +1986,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', new Index(key: 'varchar_index', type: IndexType::Key, 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 f2487c197..e4cf1e9eb 100644
--- a/tests/e2e/Adapter/Scopes/CollectionTests.php
+++ b/tests/e2e/Adapter/Scopes/CollectionTests.php
@@ -3,29 +3,52 @@
 namespace Tests\E2E\Adapter\Scopes;
 
 use Exception;
+use PHPUnit\Framework\Attributes\Depends;
+use Utopia\Database\Adapter\Feature;
+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\Event;
 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\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\Hook\Lifecycle;
+use Utopia\Database\Hook\Transform;
+use Utopia\Database\Index;
 use Utopia\Database\Query;
+use Utopia\Database\Relationship;
+use Utopia\Database\RelationType;
+use Utopia\Query\OrderDirection;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\ForeignKeyAction;
+use Utopia\Query\Schema\IndexType;
 
 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;
         }
 
@@ -35,14 +58,20 @@ public function testCreateExistsDelete(): void
         $this->assertEquals(true, $database->create());
     }
 
-    /**
-     * @depends testCreateExistsDelete
-     */
     public function testCreateListExistsDeleteCollection(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
+        // Clean up any leftover collections from prior runs
+        foreach ($database->listCollections(100) as $col) {
+            try {
+                $database->deleteCollection($col->getId());
+            } catch (\Throwable) {
+                // ignore
+            }
+        }
+
         $this->assertInstanceOf('Utopia\Database\Document', $database->createCollection('actors', permissions: [
             Permission::create(Role::any()),
             Permission::read(Role::any()),
@@ -79,73 +108,17 @@ 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' => [],
-            ]),
+            new Attribute(key: 'attribute1', type: ColumnType::String, size: 256, required: false, signed: true, array: false, filters: []),
+            new Attribute(key: 'attribute2', type: ColumnType::Integer, size: 0, required: false, signed: true, array: false, filters: []),
+            new Attribute(key: 'attribute3', type: ColumnType::Boolean, size: 0, required: false, signed: true, array: false, filters: []),
+            new Attribute(key: 'attribute4', type: ColumnType::Id, size: 0, required: false, signed: false, 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('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'],
-            ]),
+            new Index(key: 'index1', type: IndexType::Key, attributes: ['attribute1'], lengths: [256], orders: ['ASC']),
+            new Index(key: 'index2', type: IndexType::Key, attributes: ['attribute2'], lengths: [], orders: ['DESC']),
+            new Index(key: 'index3', type: IndexType::Key, attributes: ['attribute3', 'attribute2'], lengths: [], orders: ['DESC', 'ASC']),
+            new Index(key: 'index4', type: IndexType::Key, attributes: ['attribute4'], lengths: [], orders: ['DESC']),
         ];
 
         $collection = $database->createCollection('withSchema', $attributes, $indexes);
@@ -156,47 +129,32 @@ public function testCreateCollectionWithSchema(): void
         $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(ColumnType::String->value, $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(ColumnType::Integer->value, $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(ColumnType::Boolean->value, $collection->getAttribute('attributes')[2]['type']);
         $this->assertEquals('attribute4', $collection->getAttribute('attributes')[3]['$id']);
-        $this->assertEquals(Database::VAR_ID, $collection->getAttribute('attributes')[3]['type']);
+        $this->assertEquals(ColumnType::Id->value, $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(IndexType::Key->value, $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(IndexType::Key->value, $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(IndexType::Key->value, $collection->getAttribute('indexes')[2]['type']);
         $this->assertEquals('index4', $collection->getAttribute('indexes')[3]['$id']);
-        $this->assertEquals(Database::INDEX_KEY, $collection->getAttribute('indexes')[3]['type']);
-
+        $this->assertEquals(IndexType::Key->value, $collection->getAttribute('indexes')[3]['type']);
 
         $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 Attribute(key: 'attribute-one', type: ColumnType::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'],
-            ])
+            new Index(key: 'index-one', type: IndexType::Key, attributes: ['attribute-one'], lengths: [256], orders: ['ASC']),
         ]);
 
         $this->assertEquals(false, $collection2->isEmpty());
@@ -204,158 +162,14 @@ public function testCreateCollectionWithSchema(): void
         $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->assertEquals(ColumnType::String->value, $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->assertEquals(IndexType::Key->value, $collection2->getAttribute('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 */
@@ -371,24 +185,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', new Attribute(key: 'string1', type: ColumnType::String, size: 20000, required: true));
+        $database->createAttribute('sizeTest2', new Attribute(key: 'string2', type: ColumnType::String, size: 254 + 1, required: true));
+        $database->createAttribute('sizeTest2', new Attribute(key: 'string3', type: ColumnType::String, size: 254 + 1, required: true));
+        $database->createIndex('sizeTest2', new Index(key: 'index', type: IndexType::Key, 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',
             ]));
@@ -402,7 +217,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);
             }
         });
 
@@ -428,18 +243,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', new Attribute(key: 'string1', type: ColumnType::String, size: 20000, required: true));
+        $this->getDatabase()->createAttribute('sizeTestDisk2', new Attribute(key: 'string2', type: ColumnType::String, size: 254 + 1, required: true));
+        $this->getDatabase()->createAttribute('sizeTestDisk2', new Attribute(key: 'string3', type: ColumnType::String, size: 254 + 1, required: true));
+        $this->getDatabase()->createIndex('sizeTestDisk2', new Index(key: 'index', type: IndexType::Key, 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,
             ]));
         }
 
@@ -454,8 +269,9 @@ 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;
         }
 
@@ -463,18 +279,18 @@ public function testSizeFullText(): void
 
         $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', new Attribute(key: 'string1', type: ColumnType::String, size: 128, required: true));
+        $database->createAttribute('fullTextSizeTest', new Attribute(key: 'string2', type: ColumnType::String, size: 254, required: true));
+        $database->createAttribute('fullTextSizeTest', new Attribute(key: 'string3', type: ColumnType::String, size: 254, required: true));
+        $database->createIndex('fullTextSizeTest', new Index(key: 'index', type: IndexType::Key, 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,
             ]));
         }
 
@@ -482,54 +298,18 @@ public function testSizeFullText(): void
 
         $this->assertGreaterThan($size1, $size2);
 
-        $database->createIndex('fullTextSizeTest', 'fulltext_index', Database::INDEX_FULLTEXT, ['string1']);
+        $database->createIndex('fullTextSizeTest', new Index(key: 'fulltext_index', type: IndexType::Fulltext, 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() instanceof Feature\SchemaAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -540,17 +320,16 @@ public function testSchemaAttributes(): void
 
         $db->createCollection($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, new Attribute(key: 'username', type: ColumnType::String, size: 128, required: true));
+        $db->createAttribute($collection, new Attribute(key: 'story', type: ColumnType::String, size: 20000, required: true));
+        $db->createAttribute($collection, new Attribute(key: 'string_list', type: ColumnType::String, size: 128, required: true, default: null, signed: true, array: true));
+        $db->createAttribute($collection, new Attribute(key: 'dob', type: ColumnType::Datetime, size: 0, required: false, default: '2000-06-12T14:12:55.000+00:00', signed: true, array: false, format: null, formatOptions: [], filters: ['datetime']));
 
         $attributes = [];
         foreach ($db->getSchemaAttributes($collection) as $attribute) {
             /**
              * @var Document $attribute
              */
-
             $attributes[$attribute->getId()] = $attribute;
         }
 
@@ -590,111 +369,23 @@ 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,
-            ]),
+            new Attribute(key: 'username', type: ColumnType::String, size: 100, required: false, signed: true, array: false),
+            new Attribute(key: 'cards', type: ColumnType::String, size: 5000, required: false, signed: true, 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],
-            ]),
+            new Index(key: 'idx_username', type: IndexType::Key, attributes: ['username'], lengths: [100], orders: []),
+            new Index(key: 'idx_username_uid', type: IndexType::Key, attributes: ['username', '$id'], lengths: [99, 200], orders: [OrderDirection::Desc->value]),
         ];
 
-        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],
-            ]);
+        if ($database->getAdapter()->supports(Capability::IndexArray)) {
+            $indexes[] = new Index(key: 'idx_cards', type: IndexType::Key, attributes: ['cards'], lengths: [500], orders: [OrderDirection::Desc->value]);
         }
 
         $collection = $database->createCollection(
@@ -711,77 +402,23 @@ public function testCreateCollectionWithSchemaIndexes(): void
 
         $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);
+        $this->assertEquals($collection->getAttribute('indexes')[1]['orders'][0], OrderDirection::Desc->value);
 
-        if ($database->getAdapter()->getSupportForIndexArray()) {
+        if ($database->getAdapter()->supports(Capability::IndexArray)) {
             $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);
         }
     }
 
-    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;
-    }
-
-    public function testUpdateDeleteCollectionNotFound(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        try {
-            $database->deleteCollection('not_found');
-            $this->fail('Failed to throw exception');
-        } catch (Exception $e) {
-            $this->assertEquals('Collection not found', $e->getMessage());
-        }
-
-        try {
-            $database->updateCollection('not_found', [], true);
-            $this->fail('Failed to throw exception');
-        } catch (Exception $e) {
-            $this->assertEquals('Collection not found', $e->getMessage());
-        }
-    }
-
     public function testGetCollectionId(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForGetConnectionId()) {
+        if (! ($database->getAdapter() instanceof Feature\ConnectionId)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -795,25 +432,11 @@ public function testKeywords(): void
 
         // Collection name tests
         $attributes = [
-            new Document([
-                '$id' => ID::custom('attribute1'),
-                'type' => Database::VAR_STRING,
-                'size' => 256,
-                'required' => false,
-                'signed' => true,
-                'array' => false,
-                'filters' => [],
-            ]),
+            new Attribute(key: 'attribute1', type: ColumnType::String, size: 256, 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 Index(key: 'index1', type: IndexType::Key, attributes: ['attribute1'], lengths: [256], orders: ['ASC']),
         ];
 
         foreach ($keywords as $keyword) {
@@ -847,12 +470,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);
             $this->assertEquals($collectionName, $collection->getId());
 
-            $attribute = $database->createAttribute($collectionName, $keyword, Database::VAR_STRING, 128, true);
+            $attribute = $database->createAttribute($collectionName, new Attribute(key: $keyword, type: ColumnType::String, size: 128, required: true));
             $this->assertEquals(true, $attribute);
 
             $document = new Document([
@@ -862,29 +485,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());
@@ -894,70 +517,25 @@ 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() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
+        // Create 'testers' collection if not already created (was created by testMetadata in sequential mode)
+        if ($database->getCollection('testers')->isEmpty()) {
+            $database->createCollection('testers');
+        }
+
         $database->createCollection('devices');
 
-        $database->createRelationship(
-            collection: 'testers',
-            relatedCollection: 'devices',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-            twoWayKey: 'tester'
-        );
+        $database->createRelationship(new Relationship(collection: 'testers', relatedCollection: 'devices', type: RelationType::OneToMany, twoWay: true, twoWayKey: 'tester'));
 
         $testers = $database->getCollection('testers');
         $devices = $database->getCollection('devices');
@@ -976,14 +554,14 @@ public function testDeleteCollectionDeletesRelationships(): void
         $this->assertEquals(0, \count($devices->getAttribute('indexes')));
     }
 
-
     public function testCascadeMultiDelete(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -991,41 +569,29 @@ public function testCascadeMultiDelete(): void
         $database->createCollection('cascadeMultiDelete2');
         $database->createCollection('cascadeMultiDelete3');
 
-        $database->createRelationship(
-            collection: 'cascadeMultiDelete1',
-            relatedCollection: 'cascadeMultiDelete2',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-            onDelete: Database::RELATION_MUTATE_CASCADE
-        );
+        $database->createRelationship(new Relationship(collection: 'cascadeMultiDelete1', relatedCollection: 'cascadeMultiDelete2', type: RelationType::OneToMany, 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(new Relationship(collection: 'cascadeMultiDelete2', relatedCollection: 'cascadeMultiDelete3', type: RelationType::OneToMany, 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()),
                             ],
                         ],
                     ],
@@ -1064,38 +630,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
@@ -1104,49 +677,30 @@ public function testSharedTables(): void
         $tenant2 = 2;
 
         $database
-            ->setDatabase('sharedTables')
+            ->setDatabase($sharedTablesDb)
             ->setNamespace('')
             ->setSharedTables(true)
             ->setTenant($tenant1)
             ->create();
 
-        $this->assertEquals(true, $database->exists('sharedTables'));
+        $this->assertEquals(true, $database->exists($sharedTablesDb));
 
         $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 Attribute(key: 'name', type: ColumnType::String, size: 128, required: true),
+            new Attribute(key: 'lifeStory', type: ColumnType::String, size: 65536, required: true),
         ], [
-            new Document([
-                '$id' => 'idx_name',
-                'type' => Database::INDEX_KEY,
-                'attributes' => ['name']
-            ])
+            new Index(key: 'idx_name', type: IndexType::Key, attributes: ['name']),
         ], [
             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', new Index(key: 'idx_lifeStory', type: IndexType::Fulltext, attributes: ['lifeStory']));
         }
 
         $docId = ID::unique();
@@ -1157,7 +711,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);
@@ -1168,7 +722,7 @@ public function testSharedTables(): void
          * Remove Permissions
          */
         $doc->setAttribute('$permissions', [
-            Permission::read(Role::any())
+            Permission::read(Role::any()),
         ]);
 
         $database->updateDocument('people', $docId, $doc);
@@ -1233,9 +787,11 @@ public function testSharedTables(): void
         // Reset state
         $database
             ->setSharedTables($sharedTables)
+            ->setTenant($tenant)
             ->setNamespace($namespace)
             ->setDatabase($schema);
     }
+
     /**
      * @throws LimitException
      * @throws DuplicateException
@@ -1247,7 +803,7 @@ public function testCreateDuplicates(): void
         $database = $this->getDatabase();
 
         $database->createCollection('duplicates', permissions: [
-            Permission::read(Role::any())
+            Permission::read(Role::any()),
         ]);
 
         try {
@@ -1261,6 +817,7 @@ public function testCreateDuplicates(): void
 
         $database->deleteCollection('duplicates');
     }
+
     public function testSharedTablesDuplicates(): void
     {
         /** @var Database $database */
@@ -1268,18 +825,22 @@ 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)
@@ -1287,8 +848,8 @@ public function testSharedTablesDuplicates(): void
 
         // 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->createAttribute('duplicates', new Attribute(key: 'name', type: ColumnType::String, size: 10, required: false));
+        $database->createIndex('duplicates', new Index(key: 'nameIndex', type: IndexType::Key, attributes: ['name']));
 
         $database->setTenant(2);
 
@@ -1299,13 +860,13 @@ public function testSharedTablesDuplicates(): void
         }
 
         try {
-            $database->createAttribute('duplicates', 'name', Database::VAR_STRING, 10, false);
+            $database->createAttribute('duplicates', new Attribute(key: 'name', type: ColumnType::String, size: 10, required: false));
         } catch (DuplicateException) {
             // Ignore
         }
 
         try {
-            $database->createIndex('duplicates', 'nameIndex', Database::INDEX_KEY, ['name']);
+            $database->createIndex('duplicates', new Index(key: 'nameIndex', type: IndexType::Key, attributes: ['name']));
         } catch (DuplicateException) {
             // Ignore
         }
@@ -1314,7 +875,8 @@ public function testSharedTablesDuplicates(): void
         $this->assertEquals(1, \count($collection->getAttribute('attributes')));
         $this->assertEquals(1, \count($collection->getAttribute('indexes')));
 
-        $database->setTenant(1);
+        $database->setTenant(null);
+        $database->purgeCachedCollection('duplicates');
 
         $collection = $database->getCollection('duplicates');
         $this->assertEquals(1, \count($collection->getAttribute('attributes')));
@@ -1322,6 +884,7 @@ public function testSharedTablesDuplicates(): void
 
         $database
             ->setSharedTables($sharedTables)
+            ->setTenant($tenant)
             ->setNamespace($namespace)
             ->setDatabase($schema);
     }
@@ -1338,7 +901,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();
@@ -1352,20 +915,21 @@ 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,
+                    'type' => ColumnType::String->value,
                     'size' => 128,
                     'required' => true,
                 ]),
@@ -1380,7 +944,7 @@ public function testSharedTablesMultiTenantCreateCollection(): void
             $database->createCollection($colName, [
                 new Document([
                     '$id' => 'name',
-                    'type' => Database::VAR_STRING,
+                    'type' => ColumnType::String->value,
                     'size' => 128,
                     'required' => true,
                 ]),
@@ -1399,8 +963,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
@@ -1421,8 +988,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.
@@ -1433,7 +1000,7 @@ public function testSharedTablesMultiTenantCreate(): void
                 $database->setTenant($tenant2);
                 $database->create();
                 $this->assertTrue(true);
-            } elseif ($database->getAdapter()->getSupportForSchemas()) {
+            } elseif ($database->getAdapter()->supports(Capability::Schemas)) {
                 $dbName = 'stMultiCreate';
                 if ($database->exists($dbName)) {
                     $database->setDatabase($dbName)->delete();
@@ -1451,6 +1018,7 @@ public function testSharedTablesMultiTenantCreate(): void
                 $database->delete();
             } else {
                 $this->expectNotToPerformAssertions();
+
                 return;
             }
         } finally {
@@ -1468,56 +1036,65 @@ 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);
+            $test = $this;
+            $database->addHook(new class ($events, $test) implements Lifecycle {
+                /** @param array<Event> $events */
+                public function __construct(private array &$events, private $test)
+                {
+                }
+
+                public function handle(Event $event, mixed $data): void
+                {
+                    $shifted = array_shift($this->events);
+                    $this->test->assertEquals($shifted, $event);
+                }
             });
 
-            if ($this->getDatabase()->getAdapter()->getSupportForSchemas()) {
+            if ($this->getDatabase()->getAdapter()->supports(Capability::Schemas)) {
                 $database->setDatabase('hellodb');
                 $database->create();
             } else {
@@ -1532,10 +1109,10 @@ public function testEvents(): void
             $database->createCollection($collectionId);
             $database->listCollections();
             $database->getCollection($collectionId);
-            $database->createAttribute($collectionId, 'attr1', Database::VAR_INTEGER, 2, false);
+            $database->createAttribute($collectionId, new Attribute(key: 'attr1', type: ColumnType::Integer, size: 2, required: false));
             $database->updateAttributeRequired($collectionId, 'attr1', true);
-            $indexId1 = 'index2_' . uniqid();
-            $database->createIndex($collectionId, $indexId1, Database::INDEX_KEY, ['attr1']);
+            $indexId1 = 'index2_'.uniqid();
+            $database->createIndex($collectionId, new Index(key: $indexId1, type: IndexType::Key, attributes: ['attr1']));
 
             $document = $database->createDocument($collectionId, new Document([
                 '$id' => 'doc1',
@@ -1548,9 +1125,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));
@@ -1561,7 +1135,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);
 
@@ -1585,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);
         });
     }
 
@@ -1597,9 +1167,9 @@ 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([
+        $this->assertInstanceOf('Utopia\Database\Document', $database->createCollection($this->getCreatedAtCollection()));
+        $database->createAttribute($this->getCreatedAtCollection(), new Attribute(key: 'title', type: ColumnType::String, size: 100, required: false));
+        $document = $database->createDocument($this->getCreatedAtCollection(), new Document([
             '$id' => ID::custom('uid123'),
 
             '$permissions' => [
@@ -1614,28 +1184,25 @@ 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($this->getCreatedAtCollection());
     }
 
-
     public function testTransformations(): void
     {
         /** @var Database $database */
@@ -1644,10 +1211,10 @@ public function testTransformations(): void
         $database->createCollection('docs', attributes: [
             new Document([
                 '$id' => 'name',
-                'type' => Database::VAR_STRING,
+                'type' => ColumnType::String->value,
                 'size' => 767,
                 'required' => true,
-            ])
+            ]),
         ]);
 
         $database->createDocument('docs', new Document([
@@ -1655,13 +1222,19 @@ public function testTransformations(): void
             'name' => 'value1',
         ]));
 
-        $database->before(Database::EVENT_DOCUMENT_READ, 'test', function (string $query) {
-            return "SELECT 1";
-        });
+        $hook = new class () implements Transform {
+            public function transform(Event $event, string $query): string
+            {
+                return 'SELECT 1';
+            }
+        };
+        $database->addHook($hook);
 
         $result = $database->getDocument('docs', 'doc1');
 
         $this->assertTrue($result->isEmpty());
+
+        $database->removeTransform($hook::class);
     }
 
     public function testSetGlobalCollection(): void
@@ -1685,17 +1258,17 @@ public function testSetGlobalCollection(): void
         $this->assertNotEmpty($hashKey);
 
         if ($db->getSharedTables()) {
-            $this->assertStringNotContainsString((string)$db->getAdapter()->getTenant(), $collectionKey);
+            $this->assertStringNotContainsString((string) $db->getAdapter()->getTenant(), $collectionKey);
         }
 
-        // 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);
+            $this->assertStringContainsString((string) $db->getAdapter()->getTenant(), $collectionKeyRegular);
         }
 
         // Non metadata collection should contain tenant in the cache key
@@ -1710,64 +1283,34 @@ 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,
-            ]),
+            new Attribute(key: 'name', type: ColumnType::String, size: 256, required: true, array: false),
+            new Attribute(key: 'age', type: ColumnType::Integer, size: 0, required: false, array: false),
+            new Attribute(key: 'isActive', type: ColumnType::Boolean, size: 0, required: false, array: false),
         ];
 
         $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'],
-            ]),
+            new Index(key: 'idx_name', type: IndexType::Key, attributes: ['name'], lengths: [128], orders: ['ASC']),
+            new Index(key: 'idx_name_age', type: IndexType::Key, attributes: ['name', 'age'], lengths: [128, null], orders: ['ASC', 'DESC']),
         ];
 
         $collectionDocument = $database->createCollection(
diff --git a/tests/e2e/Adapter/Scopes/CustomDocumentTypeTests.php b/tests/e2e/Adapter/Scopes/CustomDocumentTypeTests.php
deleted file mode 100644
index 9953e73e2..000000000
--- 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 d16004d32..522016689 100644
--- a/tests/e2e/Adapter/Scopes/DocumentTests.php
+++ b/tests/e2e/Adapter/Scopes/DocumentTests.php
@@ -4,8 +4,12 @@
 
 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\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Exception as DatabaseException;
@@ -20,115 +24,84 @@
 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;
 
 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();
         }
-
-        /**
-         * 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'));
+        return self::$moviesCollection;
     }
 
-    public function testBigintSequence(): void
+    protected function getDocumentsCollection(): string
     {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        $database->createCollection(__FUNCTION__);
-
-        $sequence = 5_000_000_000_000_000;
-        if ($database->getAdapter()->getIdAttributeType() == Database::VAR_UUID7) {
-            $sequence = '01995753-881b-78cf-9506-2cffecf8f227';
+        if (self::$documentsCollection === '') {
+            self::$documentsCollection = 'documents_' . uniqid();
         }
+        return self::$documentsCollection;
+    }
 
-        $document = $database->createDocument(__FUNCTION__, new Document([
-            '$sequence' => (string)$sequence,
-            '$permissions' => [
-                Permission::read(Role::any()),
-            ],
-        ]));
-
-        $this->assertSame((string)$sequence, $document->getSequence());
+    protected function getIncDecCollection(): string
+    {
+        if (self::$incDecCollection === '') {
+            self::$incDecCollection = 'increase_decrease_' . uniqid();
+        }
+        return self::$incDecCollection;
+    }
 
-        $document = $database->getDocument(__FUNCTION__, $document->getId());
-        $this->assertSame((string)$sequence, $document->getSequence());
+    private static bool $documentsFixtureInit = false;
 
-        $document = $database->findOne(__FUNCTION__, [Query::equal('$sequence', [(string)$sequence])]);
-        $this->assertSame((string)$sequence, $document->getSequence());
+    private static ?Document $documentsFixtureDoc = null;
 
-        /**
-         * 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());
+    /**
+     * Create the $this->getDocumentsCollection() collection with standard attributes and a test document.
+     * Cached for non-functional mode backward compatibility.
+     */
+    protected function initDocumentsFixture(): Document
+    {
+        if (self::$documentsFixtureInit && self::$documentsFixtureDoc !== null) {
+            return clone self::$documentsFixtureDoc;
         }
-    }
 
-    public function testCreateDocument(): Document
-    {
-        /** @var Database $database */
         $database = $this->getDatabase();
+        $collection = $this->getDocumentsCollection();
+
+        $database->createCollection($collection);
 
-        $database->createCollection('documents');
-
-        $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));
+        $database->createAttribute($collection, new Attribute(key: 'string', type: ColumnType::String, size: 128, required: true));
+        $database->createAttribute($collection, new Attribute(key: 'integer_signed', type: ColumnType::Integer, size: 0, required: true));
+        $database->createAttribute($collection, new Attribute(key: 'integer_unsigned', type: ColumnType::Integer, size: 4, required: true, signed: false));
+        $database->createAttribute($collection, new Attribute(key: 'bigint_signed', type: ColumnType::Integer, size: 8, required: true));
+        $database->createAttribute($collection, new Attribute(key: 'bigint_unsigned', type: ColumnType::Integer, size: 9, required: true, signed: false));
+        $database->createAttribute($collection, new Attribute(key: 'float_signed', type: ColumnType::Double, size: 0, required: true));
+        $database->createAttribute($collection, new Attribute(key: 'float_unsigned', type: ColumnType::Double, size: 0, required: true, signed: false));
+        $database->createAttribute($collection, new Attribute(key: 'boolean', type: ColumnType::Boolean, size: 0, required: true));
+        $database->createAttribute($collection, new Attribute(key: 'colors', type: ColumnType::String, size: 32, required: true, default: null, signed: true, array: true));
+        $database->createAttribute($collection, new Attribute(key: 'empty', type: ColumnType::String, size: 32, required: false, default: null, signed: true, array: true));
+        $database->createAttribute($collection, new Attribute(key: 'with-dash', type: ColumnType::String, size: 128, required: false, default: null));
+        $database->createAttribute($collection, new Attribute(key: 'id', type: ColumnType::Id, size: 0, required: false, default: null));
 
         $sequence = '1000000';
-        if ($database->getAdapter()->getIdAttributeType() == Database::VAR_UUID7) {
-            $sequence = '01890dd5-7331-7f3a-9c1b-123456789abc' ;
+        if ($database->getAdapter()->getIdAttributeType() == ColumnType::Uuid7->value) {
+            $sequence = '01890dd5-7331-7f3a-9c1b-123456789abc';
         }
 
-        $document = $database->createDocument('documents', new Document([
+        $document = $database->createDocument($collection, new Document([
             '$permissions' => [
                 Permission::read(Role::any()),
                 Permission::read(Role::user(ID::custom('1'))),
@@ -157,6 +130,244 @@ public function testCreateDocument(): Document
             'id' => $sequence,
         ]));
 
+        self::$documentsFixtureInit = true;
+        self::$documentsFixtureDoc = $document;
+
+        return $document;
+    }
+
+    private static bool $moviesFixtureInit = false;
+
+    private static ?array $moviesFixtureData = null;
+
+    /**
+     * Create the movies collection with standard test data.
+     * Returns ['$sequence' => ...].
+     */
+    protected function initMoviesFixture(): array
+    {
+        if (self::$moviesFixtureInit && self::$moviesFixtureData !== null) {
+            $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
+            $this->getDatabase()->getAuthorization()->addRole('user:x');
+            return self::$moviesFixtureData;
+        }
+
+        $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
+        $this->getDatabase()->getAuthorization()->addRole('user:x');
+        $database = $this->getDatabase();
+        $collection = $this->getMoviesCollection();
+
+        $database->createCollection($collection, permissions: [
+            Permission::create(Role::any()),
+            Permission::update(Role::users()),
+        ]);
+
+        $database->createAttribute($collection, new Attribute(key: 'name', type: ColumnType::String, size: 128, required: true));
+        $database->createAttribute($collection, new Attribute(key: 'director', type: ColumnType::String, size: 128, required: true));
+        $database->createAttribute($collection, new Attribute(key: 'year', type: ColumnType::Integer, size: 0, required: true));
+        $database->createAttribute($collection, new Attribute(key: 'price', type: ColumnType::Double, size: 0, required: true));
+        $database->createAttribute($collection, new Attribute(key: 'active', type: ColumnType::Boolean, size: 0, required: true));
+        $database->createAttribute($collection, new Attribute(key: 'genres', type: ColumnType::String, size: 32, required: true, default: null, signed: true, array: true));
+        $database->createAttribute($collection, new Attribute(key: 'with-dash', type: ColumnType::String, size: 128, required: true));
+        $database->createAttribute($collection, new Attribute(key: 'nullable', type: ColumnType::String, size: 128, required: false));
+
+        $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')),
+        ];
+
+        $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',
+        ]));
+
+        $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',
+        ]));
+
+        $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',
+        ]));
+
+        $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',
+        ]));
+
+        $database->createDocument($collection, new Document([
+            '$permissions' => $permissions,
+            'name' => 'Work in Progress',
+            'director' => 'TBD',
+            'year' => 2025,
+            'price' => 0.0,
+            'active' => false,
+            'genres' => [],
+            'with-dash' => 'Works3',
+        ]));
+
+        $database->createDocument($collection, 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',
+        ]));
+
+        self::$moviesFixtureInit = true;
+        self::$moviesFixtureData = ['$sequence' => $document->getSequence()];
+
+        return self::$moviesFixtureData;
+    }
+
+    private static bool $incDecFixtureInit = false;
+
+    private static ?Document $incDecFixtureDoc = null;
+
+    /**
+     * Create the increase_decrease collection and perform initial operations.
+     */
+    protected function initIncreaseDecreaseFixture(): Document
+    {
+        if (self::$incDecFixtureInit && self::$incDecFixtureDoc !== null) {
+            return self::$incDecFixtureDoc;
+        }
+
+        $database = $this->getDatabase();
+        $collection = $this->getIncDecCollection();
+
+        $database->createCollection($collection);
+
+        $database->createAttribute($collection, new Attribute(key: 'increase', type: ColumnType::Integer, size: 0, required: true));
+        $database->createAttribute($collection, new Attribute(key: 'decrease', type: ColumnType::Integer, size: 0, required: true));
+        $database->createAttribute($collection, new Attribute(key: 'increase_text', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($collection, new Attribute(key: 'increase_float', type: ColumnType::Double, size: 0, required: true));
+        $database->createAttribute($collection, new Attribute(key: 'sizes', type: ColumnType::Integer, size: 8, required: false, array: 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()),
+            ],
+        ]));
+
+        $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);
+
+        $document = $database->getDocument($collection, $document->getId());
+
+        self::$incDecFixtureInit = true;
+        self::$incDecFixtureDoc = $document;
+
+        return $document;
+    }
+
+    public function testBigintSequence(): void
+    {
+        /** @var Database $database */
+        $database = $this->getDatabase();
+
+        $database->createCollection(__FUNCTION__);
+
+        $sequence = 5_000_000_000_000_000;
+        if ($database->getAdapter()->getIdAttributeType() == ColumnType::Uuid7->value) {
+            $sequence = '01995753-881b-78cf-9506-2cffecf8f227';
+        }
+
+        $document = $database->createDocument(__FUNCTION__, new Document([
+            '$sequence' => (string) $sequence,
+            '$permissions' => [
+                Permission::read(Role::any()),
+            ],
+        ]));
+
+        $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
@@ -181,14 +392,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' => [
@@ -242,7 +452,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());
@@ -268,7 +478,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,
@@ -282,14 +492,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,
@@ -303,14 +513,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' => '',
@@ -327,7 +537,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());
             }
@@ -336,8 +546,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' => '',
@@ -355,25 +564,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' => '',
@@ -393,64 +602,32 @@ 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
+    public function testCreateDocuments(): void
     {
+        $count = 3;
+        $collection = 'testCreateDocuments';
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $database->createCollection('numericalIds');
+        $database->createCollection($collection);
 
-        $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
-    {
-        $count = 3;
-        $collection = 'testCreateDocuments';
-
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        $database->createCollection($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, new Attribute(key: 'string', type: ColumnType::String, size: 128, required: true)));
+        $this->assertEquals(true, $database->createAttribute($collection, new Attribute(key: 'integer', type: ColumnType::Integer, size: 0, required: true)));
+        $this->assertEquals(true, $database->createAttribute($collection, new Attribute(key: 'bigint', type: ColumnType::Integer, size: 8, required: true)));
 
         // Create an array of documents with random attributes. Don't use the createDocument function
         $documents = [];
@@ -488,7 +665,7 @@ public function testCreateDocuments(): void
         }
 
         $documents = $database->find($collection, [
-            Query::orderAsc()
+            Query::orderAsc(),
         ]);
 
         $this->assertEquals($count, \count($documents));
@@ -511,17 +688,17 @@ public function testCreateDocumentsWithAutoIncrement(): void
 
         $database->createCollection(__FUNCTION__);
 
-        $this->assertEquals(true, $database->createAttribute(__FUNCTION__, 'string', Database::VAR_STRING, 128, true));
+        $this->assertEquals(true, $database->createAttribute(__FUNCTION__, new Attribute(key: 'string', type: ColumnType::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;
@@ -542,7 +719,7 @@ public function testCreateDocumentsWithAutoIncrement(): void
         $this->assertEquals($count, \count($documents));
 
         $documents = $database->find(__FUNCTION__, [
-            Query::orderAsc()
+            Query::orderAsc(),
         ]);
 
         foreach ($documents as $index => $document) {
@@ -561,10 +738,10 @@ public function testCreateDocumentsWithDifferentAttributes(): void
 
         $database->createCollection($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, new Attribute(key: 'string', type: ColumnType::String, size: 128, required: true)));
+        $this->assertEquals(true, $database->createAttribute($collection, new Attribute(key: 'integer', type: ColumnType::Integer, size: 0, required: false)));
+        $this->assertEquals(true, $database->createAttribute($collection, new Attribute(key: 'bigint', type: ColumnType::Integer, size: 8, required: false)));
+        $this->assertEquals(true, $database->createAttribute($collection, new Attribute(key: 'string_default', type: ColumnType::String, size: 128, required: false, default: 'default')));
 
         $documents = [
             new Document([
@@ -624,88 +801,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() instanceof Feature\Upserts)) {
             $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->createAttribute(__FUNCTION__, new Attribute(key: 'string', type: ColumnType::String, size: 128, required: true));
+        $database->createAttribute(__FUNCTION__, new Attribute(key: 'integer', type: ColumnType::Integer, size: 0, required: true));
+        $database->createAttribute(__FUNCTION__, new Attribute(key: 'bigint', type: ColumnType::Integer, size: 8, required: true));
 
         $documents = [
             new Document([
@@ -816,14 +926,15 @@ public function testUpsertDocumentsInc(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForUpserts()) {
+        if (! ($database->getAdapter() instanceof Feature\Upserts)) {
             $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->createAttribute(__FUNCTION__, new Attribute(key: 'string', type: ColumnType::String, size: 128, required: false));
+        $database->createAttribute(__FUNCTION__, new Attribute(key: 'integer', type: ColumnType::Integer, size: 0, required: false));
 
         $documents = [
             new Document([
@@ -888,13 +999,14 @@ public function testUpsertDocumentsPermissions(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForUpserts()) {
+        if (! ($database->getAdapter() instanceof Feature\Upserts)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $database->createCollection(__FUNCTION__);
-        $database->createAttribute(__FUNCTION__, 'string', Database::VAR_STRING, 128, true);
+        $database->createAttribute(__FUNCTION__, new Attribute(key: 'string', type: ColumnType::String, size: 128, required: true));
 
         $document = new Document([
             '$id' => 'first',
@@ -972,6754 +1084,6775 @@ 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() instanceof Feature\Upserts)) {
             $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(__FUNCTION__);
+        $db->createAttribute(__FUNCTION__, new Attribute(key: 'v', type: ColumnType::Integer, size: 0, 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')
-        ]);
-
-        $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'));
+    public function testFindCheckInteger(): void
+    {
+        $this->initMoviesFixture();
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        // Ensure set null on existing document is allowed
-        $docs = $database->upsertDocuments(__FUNCTION__, [
-            $existingDocument
-                ->setAttribute('first', 'first')
-                ->setAttribute('last', null),
-            $newDocument
-                ->setAttribute('last', 'last')
+        /**
+         * Query with dash attribute
+         */
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::equal('with-dash', ['Works']),
         ]);
 
-        $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(2, count($documents));
 
-        $doc3 = new Document([
-            '$id' => 'third',
-            'last' => 'last',
-            'first' => 'third',
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::equal('with-dash', ['Works2', 'Works3']),
         ]);
 
-        $doc4 = new Document([
-            '$id' => 'fourth',
-            'first' => 'fourth',
-            'last' => 'last',
-        ]);
+        $this->assertEquals(4, count($documents));
 
-        // Ensure mismatch of attribute orders is allowed
-        $docs = $database->upsertDocuments(__FUNCTION__, [
-            $doc3,
-            $doc4
+        /**
+         * Check an Integer condition
+         */
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::equal('year', [2019]),
         ]);
 
-        $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'));
+        $this->assertEquals(2, count($documents));
+        $this->assertEquals('Frozen II', $documents[0]['name']);
+        $this->assertEquals('Captain Marvel', $documents[1]['name']);
     }
 
-    public function testUpsertDocumentsNoop(): void
+    public function testFindBoolean(): void
     {
-        if (!$this->getDatabase()->getAdapter()->getSupportForUpserts()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $this->getDatabase()->createCollection(__FUNCTION__);
-        $this->getDatabase()->createAttribute(__FUNCTION__, 'string', Database::VAR_STRING, 128, true);
+        $this->initMoviesFixture();
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        $document = new Document([
-            '$id' => 'first',
-            'string' => 'text📝',
-            '$permissions' => [
-                Permission::read(Role::any()),
-                Permission::create(Role::any()),
-                Permission::update(Role::any()),
-                Permission::delete(Role::any()),
-            ],
+        /**
+         * Boolean condition
+         */
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::equal('active', [true]),
         ]);
 
-        $count = $this->getDatabase()->upsertDocuments(__FUNCTION__, [$document]);
-        $this->assertEquals(1, $count);
+        $this->assertEquals(4, count($documents));
+    }
 
-        // No changes, should return 0
-        $count = $this->getDatabase()->upsertDocuments(__FUNCTION__, [$document]);
-        $this->assertEquals(0, $count);
+    public function testFindFloat(): void
+    {
+        $this->initMoviesFixture();
+        /** @var Database $database */
+        $database = $this->getDatabase();
+
+        /**
+         * Float condition
+         */
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::lessThan('price', 26.00),
+            Query::greaterThan('price', 25.98),
+        ]);
+
+        $this->assertEquals(1, count($documents));
     }
 
-    public function testUpsertDuplicateIds(): void
+    public function testFindContains(): void
     {
-        $db = $this->getDatabase();
-        if (!$db->getAdapter()->getSupportForUpserts()) {
+        $this->initMoviesFixture();
+        /** @var Database $database */
+        $database = $this->getDatabase();
+
+        if (! $database->getAdapter()->supports(Capability::QueryContains)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $db->createCollection(__FUNCTION__);
-        $db->createAttribute(__FUNCTION__, 'num', Database::VAR_INTEGER, 0, true);
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::contains('genres', ['comics']),
+        ]);
 
-        $doc1 = new Document(['$id' => 'dup', 'num' => 1]);
-        $doc2 = new Document(['$id' => 'dup', 'num' => 2]);
+        $this->assertEquals(2, count($documents));
+
+        /**
+         * Array contains OR condition
+         */
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::contains('genres', ['comics', 'kids']),
+        ]);
+
+        $this->assertEquals(4, count($documents));
+
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::contains('genres', ['non-existent']),
+        ]);
+
+        $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(), new Index(key: 'name', type: IndexType::Fulltext, 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($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, new Attribute(key: 'ft', type: ColumnType::String, size: 128, required: true)));
+        $this->assertTrue($database->createIndex($collection, new Index(key: 'ft-index', type: IndexType::Fulltext, 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',
-            ]),
+    public function testFindByID(): void
+    {
+        $this->initMoviesFixture();
+        /** @var Database $database */
+        $database = $this->getDatabase();
+
+        /**
+         * $id condition
+         */
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::equal('$id', ['frozen']),
         ]);
 
-        $doc2Updated = $database->getDocument($collectionName, 'doc2');
-        $this->assertEquals('Bob Updated', $doc2Updated->getAttribute('name'));
-        $this->assertEquals($originalSeq2, $doc2Updated->getSequence()); // Sequence preserved
+        $this->assertEquals(1, count($documents));
+        $this->assertEquals('Frozen', $documents[0]['name']);
+    }
 
-        // Test: withPreserveSequence helper
-        $database->setPreserveSequence(false);
+    public function testFindByInternalID(): void
+    {
+        $data = $this->initMoviesFixture();
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        $doc1 = $database->getDocument($collectionName, 'doc1');
-        $currentSeq1 = $doc1->getSequence();
+        /**
+         * Test that internal ID queries are handled correctly
+         */
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::equal('$sequence', [$data['$sequence']]),
+        ]);
 
-        $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',
-                ]),
-            ]);
-        });
-
-        $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());
+        $this->assertEquals(1, count($documents));
+    }
 
-        // Test: With preserveSequence=true, invalid $sequence should throw error (SQL adapters only)
-        $database->setPreserveSequence(true);
+    public function testOrSingleQuery(): void
+    {
+        $this->initMoviesFixture();
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
         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',
+            $database->find($this->getMoviesCollection(), [
+                Query::or([
+                    Query::equal('active', [true]),
                 ]),
             ]);
-            // 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());
-            }
+            $this->fail('Failed to throw exception');
+        } catch (Exception $e) {
+            $this->assertEquals('Invalid query: Or queries require at least two queries', $e->getMessage());
         }
-
-        $database->setPreserveSequence(false);
-        $database->deleteCollection($collectionName);
     }
 
-    public function testRespectNulls(): Document
+    public function testOrMultipleQueries(): void
     {
+        $this->initMoviesFixture();
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $database->createCollection('documents_nulls');
-
-        $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));
+        $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));
 
-        $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')),
-            ],
-        ]));
+        $queries = [
+            Query::equal('active', [true]),
+            Query::or([
+                Query::equal('name', ['Frozen']),
+                Query::equal('name', ['Frozen II']),
+                Query::equal('director', ['Joe Johnston']),
+            ]),
+        ];
 
-        $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;
+        $this->assertCount(3, $database->find($this->getMoviesCollection(), $queries));
+        $this->assertEquals(3, $database->count($this->getMoviesCollection(), $queries));
     }
 
-    public function testCreateDocumentDefaults(): void
+    public function testOrNested(): 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']));
-
-        $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]);
+        $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]),
+                ]),
+            ]),
+        ];
 
-        $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'));
+        $documents = $database->find($this->getMoviesCollection(), $queries);
+        $this->assertCount(1, $documents);
+        $this->assertArrayNotHasKey('name', $documents[0]);
 
-        // cleanup collection
-        $database->deleteCollection('defaults');
+        $count = $database->count($this->getMoviesCollection(), $queries);
+        $this->assertEquals(1, $count);
     }
 
-    public function testIncreaseDecrease(): Document
+    public function testAndSingleQuery(): void
     {
+        $this->initMoviesFixture();
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $collection = 'increase_decrease';
-        $database->createCollection($collection);
-
-        $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));
-
-        $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()),
-            ]
-        ]));
-
-        $updatedAt = $document->getUpdatedAt();
-
-        $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'));
-
-        $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'));
-
-        return $document;
+        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));
+
+        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'),
+            ]);
+        }
 
-            $database->increaseDocumentAttribute('increase_decrease', $document->getId(), 'increase', 1);
+        $this->assertEquals(0, count($documents));
+    }
 
-            $after = $database->getDocument('increase_decrease', $document->getId());
-            $this->assertSame($increase + 1, $after->getAttribute('increase'));
-            $this->assertSame($updatedAt, $after->getUpdatedAt());
+    public function testFindStartsWithWords(): void
+    {
+        $this->initMoviesFixture();
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-            $database->decreaseDocumentAttribute('increase_decrease', $document->getId(), 'decrease', 1);
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::startsWith('name', 'Work in Progress'),
+        ]);
 
-            $after = $database->getDocument('increase_decrease', $document->getId());
-            $this->assertSame($decrease - 1, $after->getAttribute('decrease'));
-            $this->assertSame($updatedAt, $after->getUpdatedAt());
-        } finally {
-            $database->setPreserveDates(false);
-        }
+        $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(), new Index(key: 'name', type: IndexType::Fulltext, 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));
+        $this->getDatabase()->getAuthorization()->addRole('user:x');
 
-        $documents = $database->find('movies', [
-            Query::between('price', 30, 35),
-        ]);
-        $this->assertEquals(0, 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('$createdAt', '1975-12-06', '2050-12-06'),
-        ]);
-        $this->assertEquals(6, count($documents));
+        $sum = $database->sum($this->getMoviesCollection(), 'year', [Query::equal('year', [2019])], 1);
+        $this->assertEquals(2019, $sum);
 
-        $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));
-    }
+        $this->getDatabase()->getAuthorization()->removeRole('user:x');
 
-    public function testFindFloat(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        /**
-         * 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: [
+        $collection = 'testUpdateDocuments';
+        $this->getDatabase()->getAuthorization()->cleanRoles();
+        $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
+
+        $database->createCollection($collection, attributes: [
+            new Attribute(key: 'string', type: ColumnType::String, size: 100, required: false, default: null, signed: true, array: false, format: '', filters: []),
+            new Attribute(key: 'integer', type: ColumnType::Integer, size: 10000, required: false, default: null, signed: true, array: false, format: '', filters: []),
+        ], permissions: [
+            Permission::read(Role::any()),
             Permission::create(Role::any()),
-            Permission::update(Role::users())
-        ]);
+            Permission::update(Role::any()),
+            Permission::delete(Role::any()),
+        ], documentSecurity: false);
 
-        $this->assertTrue($database->createAttribute($collection, 'ft', Database::VAR_STRING, 128, true));
-        $this->assertTrue($database->createIndex($collection, 'ft-index', Database::INDEX_FULLTEXT, ['ft']));
+        for ($i = 0; $i < 10; $i++) {
+            $database->createDocument($collection, new Document([
+                '$id' => 'doc'.$i,
+                'string' => 'text📝 '.$i,
+                'integer' => $i,
+            ]));
+        }
 
-        $database->createDocument($collection, new Document([
-            '$permissions' => [Permission::read(Role::any())],
-            'ft' => 'Alf: chapter_4@nasa.com'
-        ]));
+        // 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;
+        });
 
-        $documents = $database->find($collection, [
-            Query::search('ft', 'chapter_4'),
-        ]);
-        $this->assertEquals(1, count($documents));
+        $this->assertEquals(5, $count);
 
-        $database->createDocument($collection, new Document([
-            '$permissions' => [Permission::read(Role::any())],
-            'ft' => 'al@ba.io +-*)(<>~'
-        ]));
+        foreach ($results as $document) {
+            $this->assertEquals('text📝 updated', $document->getAttribute('string'));
+        }
 
-        $documents = $database->find($collection, [
-            Query::search('ft', 'al@ba.io'), // === al ba io*
+        $updatedDocuments = $database->find($collection, [
+            Query::greaterThanEqual('integer', 5),
         ]);
 
-        if ($database->getAdapter()->getSupportForFulltextWildcardIndex()) {
-            $this->assertEquals(0, count($documents));
-        } else {
-            $this->assertEquals(1, count($documents));
-        }
-
-        $database->createDocument($collection, new Document([
-            '$permissions' => [Permission::read(Role::any())],
-            'ft' => 'donald duck'
-        ]));
+        $this->assertCount(5, $updatedDocuments);
 
-        $database->createDocument($collection, new Document([
-            '$permissions' => [Permission::read(Role::any())],
-            'ft' => 'donald trump'
-        ]));
+        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'),
-            Query::orderAsc('ft'),
+        $controlDocuments = $database->find($collection, [
+            Query::lessThan('integer', 5),
         ]);
-        $this->assertEquals(2, count($documents));
 
-        $documents = $database->find($collection, [
-            Query::search('ft', '"donald trump"'), // Exact match
-        ]);
+        $this->assertEquals(count($controlDocuments), 5);
 
-        $this->assertEquals(1, count($documents));
-    }
+        foreach ($controlDocuments as $document) {
+            $this->assertNotEquals('text📝 updated', $document->getAttribute('string'));
+        }
 
-    public function testFindMultipleConditions(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        // Test Update all documents
+        $this->assertEquals(10, $database->updateDocuments($collection, new Document([
+            'string' => 'text📝 updated all',
+        ])));
 
-        /**
-         * Multiple conditions
-         */
-        $documents = $database->find('movies', [
-            Query::equal('director', ['TBD']),
-            Query::equal('year', [2026]),
-        ]);
+        $updatedDocuments = $database->find($collection);
 
-        $this->assertEquals(1, count($documents));
+        $this->assertEquals(count($updatedDocuments), 10);
 
-        /**
-         * Multiple conditions and OR values
-         */
-        $documents = $database->find('movies', [
-            Query::equal('name', ['Frozen II', 'Captain Marvel']),
-        ]);
+        foreach ($updatedDocuments as $document) {
+            $this->assertEquals('text📝 updated all', $document->getAttribute('string'));
+        }
 
-        $this->assertEquals(2, count($documents));
-        $this->assertEquals('Frozen II', $documents[0]['name']);
-        $this->assertEquals('Captain Marvel', $documents[1]['name']);
-    }
+        // TEST: Can't delete documents in the past
+        $oneHourAgo = (new \DateTime())->sub(new \DateInterval('PT1H'));
 
-    public function testFindByID(): void
-    {
-        /** @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());
+        }
 
-        /**
-         * $id condition
-         */
-        $documents = $database->find('movies', [
-            Query::equal('$id', ['frozen']),
-        ]);
+        // 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);
 
-        $this->assertEquals(1, count($documents));
-        $this->assertEquals('Frozen', $documents[0]['name']);
-    }
-    /**
-     * @depends testFind
-     * @param array<string, mixed> $data
-     * @return void
-     * @throws \Utopia\Database\Exception
-     */
-    public function testFindByInternalID(array $data): void
-    {
-        /** @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());
+        }
 
-        /**
-         * Test that internal ID queries are handled correctly
-         */
-        $documents = $database->find('movies', [
-            Query::equal('$sequence', [$data['$sequence']]),
+        // Check document level permissions
+        $database->updateCollection($collection, permissions: [], documentSecurity: true);
+
+        $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')),
+                ],
+            ]));
+        });
+
+        $this->getDatabase()->getAuthorization()->addRole(Role::user('asd')->toString());
+
+        $database->updateDocuments($collection, new Document([
+            'string' => 'permission text',
+        ]));
+
+        $documents = $database->find($collection, [
+            Query::equal('string', ['permission text']),
         ]);
 
-        $this->assertEquals(1, count($documents));
+        $this->assertCount(1, $documents);
+
+        $this->getDatabase()->getAuthorization()->skip(function () use ($collection, $database) {
+            $unmodifiedDocuments = $database->find($collection, [
+                Query::equal('string', ['text📝 updated all']),
+            ]);
+
+            $this->assertCount(9, $unmodifiedDocuments);
+        });
+
+        $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()),
+                ],
+            ]));
+        });
+
+        // Test we can update more documents than batchSize
+        $this->assertEquals(10, $database->updateDocuments($collection, new Document([
+            'string' => 'batchSize Test',
+        ]), batchSize: 2));
+
+        $documents = $database->find($collection);
+
+        foreach ($documents as $document) {
+            $this->assertEquals('batchSize Test', $document->getAttribute('string'));
+        }
+
+        $this->getDatabase()->getAuthorization()->cleanRoles();
+        $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
     }
 
-    public function testFindOrderBy(): void
+    public function testUpdateDocumentsWithCallbackSupport(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        /**
-         * ORDER BY
-         */
-        $documents = $database->find('movies', [
-            Query::limit(25),
-            Query::offset(0),
-            Query::orderDesc('price'),
-            Query::orderAsc('name')
+        if (! $database->getAdapter()->supports(Capability::BatchOperations)) {
+            $this->expectNotToPerformAssertions();
+
+            return;
+        }
+
+        $collection = 'update_callback';
+        $this->getDatabase()->getAuthorization()->cleanRoles();
+        $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
+
+        $database->createCollection($collection, attributes: [
+            new Attribute(key: 'string', type: ColumnType::String, size: 100, required: false, default: null, signed: true, array: false, format: '', filters: []),
+            new Attribute(key: 'integer', type: ColumnType::Integer, size: 10000, required: false, default: null, signed: true, array: false, format: '', 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,
+            ]));
+        }
+        // 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());
+        });
+
+        $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']);
+        $this->assertEquals(false, $document->isEmpty());
+
+        $this->getDatabase()->getAuthorization()->cleanRoles();
+
+        $document = $database->getDocument($document->getCollection(), $document->getId());
+        $this->assertEquals(true, $document->isEmpty());
+
+        $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
     }
-    public function testFindOrderByMultipleAttributes(): void
+
+    public function testWritePermissionsSuccess(): void
     {
+        $this->initDocumentsFixture();
+        $this->getDatabase()->getAuthorization()->cleanRoles();
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        /**
-         * ORDER BY - Multiple attributes
-         */
-        $documents = $database->find('movies', [
-            Query::limit(25),
-            Query::offset(0),
-            Query::orderDesc('price'),
-            Query::orderDesc('name')
-        ]);
-
-        $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->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'],
+        ]));
     }
 
-    public function testFindOrderByCursorAfter(): void
+    public function testWritePermissionsUpdateFailure(): void
     {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        $this->initDocumentsFixture();
+        $this->expectException(AuthorizationException::class);
 
-        /**
-         * ORDER BY - After
-         */
-        $movies = $database->find('movies', [
-            Query::limit(25),
-            Query::offset(0),
-        ]);
+        $this->getDatabase()->getAuthorization()->cleanRoles();
+        $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
 
-        $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']);
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        $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']);
+        $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(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();
 
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::cursorAfter($movies[5])
-        ]);
-        $this->assertEmpty(count($documents));
+        $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'],
+        ]));
 
-        /**
-         * Multiple order by, Test tie-break on year 2019
-         */
-        $movies = $database->find('movies', [
-            Query::orderAsc('year'),
-            Query::orderAsc('price'),
-        ]);
+    }
 
-        $this->assertEquals(6, count($movies));
+    public function testUniqueIndexDuplicate(): void
+    {
+        $this->initMoviesFixture();
 
-        $this->assertEquals($movies[0]['name'], 'Captain America: The First Avenger');
-        $this->assertEquals($movies[0]['year'], 2011);
-        $this->assertEquals($movies[0]['price'], 25.94);
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        $this->assertEquals($movies[1]['name'], 'Frozen');
-        $this->assertEquals($movies[1]['year'], 2013);
-        $this->assertEquals($movies[1]['price'], 39.5);
+        $this->assertEquals(true, $database->createIndex($this->getMoviesCollection(), new Index(key: 'uniqueIndex', type: IndexType::Unique, attributes: ['name'], lengths: [128], orders: [OrderDirection::Asc->value])));
 
-        $this->assertEquals($movies[2]['name'], 'Captain Marvel');
-        $this->assertEquals($movies[2]['year'], 2019);
-        $this->assertEquals($movies[2]['price'], 25.99);
+        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',
+            ]));
 
-        $this->assertEquals($movies[3]['name'], 'Frozen II');
-        $this->assertEquals($movies[3]['year'], 2019);
-        $this->assertEquals($movies[3]['price'], 39.5);
+            $this->fail('Failed to throw exception');
+        } catch (Throwable $e) {
+            $this->assertInstanceOf(DuplicateException::class, $e);
+        }
+    }
 
-        $this->assertEquals($movies[4]['name'], 'Work in Progress');
-        $this->assertEquals($movies[4]['year'], 2025);
-        $this->assertEquals($movies[4]['price'], 0);
+    public function testUniqueIndexDuplicateUpdate(): void
+    {
+        $this->initMoviesFixture();
 
-        $this->assertEquals($movies[5]['name'], 'Work in Progress 2');
-        $this->assertEquals($movies[5]['year'], 2026);
-        $this->assertEquals($movies[5]['price'], 0);
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        $pos = 2;
-        $documents = $database->find('movies', [
-            Query::orderAsc('year'),
-            Query::orderAsc('price'),
-            Query::cursorAfter($movies[$pos])
-        ]);
+        // Ensure the unique index exists (created in testUniqueIndexDuplicate)
+        try {
+            $database->createIndex($this->getMoviesCollection(), new Index(key: 'uniqueIndex', type: IndexType::Unique, attributes: ['name'], lengths: [128], orders: [OrderDirection::Asc->value]));
+        } catch (\Throwable) {
+            // Index may already exist
+        }
 
-        $this->assertEquals(3, count($documents));
+        $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',
+        ]));
 
-        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']);
+        try {
+            $database->updateDocument($this->getMoviesCollection(), $document->getId(), $document->setAttribute('name', 'Frozen'));
+
+            $this->fail('Failed to throw exception');
+        } catch (Throwable $e) {
+            $this->assertInstanceOf(DuplicateException::class, $e);
         }
-    }
 
+        $database->deleteDocument($this->getMoviesCollection(), $document->getId());
+    }
 
-    public function testFindOrderByCursorBefore(): void
+    public function propagateBulkDocuments(string $collection, int $amount = 10, bool $documentSecurity = false): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        /**
-         * ORDER BY - Before
-         */
-        $movies = $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::cursorBefore($movies[5])
-        ]);
-        $this->assertEquals(2, count($documents));
-        $this->assertEquals($movies[3]['name'], $documents[0]['name']);
-        $this->assertEquals($movies[4]['name'], $documents[1]['name']);
+    public function testFulltextIndexWithInteger(): void
+    {
+        $this->initDocumentsFixture();
 
-        $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']);
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        $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']);
+        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::cursorBefore($movies[1])
-        ]);
-        $this->assertEquals(1, count($documents));
-        $this->assertEquals($movies[0]['name'], $documents[0]['name']);
+            $database->createIndex($this->getDocumentsCollection(), new Index(key: 'fulltext_integer', type: IndexType::Fulltext, attributes: ['string', 'integer_signed']));
+        } else {
+            $this->expectNotToPerformAssertions();
 
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::cursorBefore($movies[0])
-        ]);
-        $this->assertEmpty(count($documents));
+            return;
+        }
     }
 
-    public function testFindOrderByAfterNaturalOrder(): void
+    public function testEnableDisableValidation(): 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),
+        $database->createCollection('validation', permissions: [
+            Permission::create(Role::any()),
+            Permission::read(Role::any()),
+            Permission::update(Role::any()),
+            Permission::delete(Role::any()),
+        ]);
+
+        $database->createAttribute('validation', new Attribute(key: 'name', type: ColumnType::String, size: 10, required: false));
+
+        $database->createDocument('validation', new Document([
+            '$id' => 'docwithmorethan36charsasitsidentifier',
+            'name' => 'value1',
         ]));
 
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::orderDesc(''),
-            Query::cursorAfter($movies[1])
+        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();
+
+        $database->find('validation', queries: [
+            Query::equal('$id', ['docwithmorethan36charsasitsidentifier']),
         ]);
-        $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(''),
-            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->enableValidation();
 
-        $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']);
+        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('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::orderDesc(''),
-            Query::cursorAfter($movies[5])
-        ]);
-        $this->assertEmpty(count($documents));
+        $database->skipValidation(function () use ($database) {
+            $database->find('validation', queries: [
+                Query::equal('$id', ['docwithmorethan36charsasitsidentifier']),
+            ]);
+        });
+
+        $database->enableValidation();
     }
-    public function testFindOrderByBeforeNaturalOrder(): void
+
+    public function testExceptionDuplicate(): void
     {
+        $document = $this->initDocumentsFixture();
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        /**
-         * ORDER BY - Before by natural order
-         */
-        $movies = $database->find('movies', [
-            Query::limit(25),
-            Query::offset(0),
-            Query::orderDesc(''),
-        ]);
-
-        $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']);
-
-        $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']);
-
-        $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']);
+        $document->setAttribute('$id', 'duplicated');
+        $document->removeAttribute('$sequence');
 
-        $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->createDocument($document->getCollection(), $document);
+        $document->removeAttribute('$sequence');
 
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::orderDesc(''),
-            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 testFindOrderBySingleAttributeAfter(): void
+    public function testExceptionCaseInsensitiveDuplicate(): void
     {
+        $document = $this->initDocumentsFixture();
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        /**
-         * ORDER BY - Single Attribute After
-         */
-        $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::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('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('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('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 testFindOrderBySingleAttributeBefore(): void
+    public function testEmptyTenant(): void
     {
+        $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')
-        ]);
+        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('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']);
+            $document = $documents[0];
+            $doc = $database->getDocument($document->getCollection(), $document->getId());
+            $this->assertEquals($document->getTenant(), $doc->getTenant());
 
-        $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']);
+            return;
+        }
 
-        $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']);
+        $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('year'),
-            Query::cursorBefore($movies[1])
-        ]);
-        $this->assertEquals(1, count($documents));
-        $this->assertEquals($movies[0]['name'], $documents[0]['name']);
+        $this->assertArrayHasKey('$id', $doc);
+        $this->assertArrayNotHasKey('$tenant', $doc);
 
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::orderDesc('year'),
-            Query::cursorBefore($movies[0])
-        ]);
-        $this->assertEmpty(count($documents));
+        $document = $database->getDocument($this->getDocumentsCollection(), $doc->getId());
+        $this->assertArrayHasKey('$id', $document);
+        $this->assertArrayNotHasKey('$tenant', $document);
+
+        $document = $database->updateDocument($this->getDocumentsCollection(), $document->getId(), $document);
+        $this->assertArrayHasKey('$id', $document);
+        $this->assertArrayNotHasKey('$tenant', $document);
+
+        $database->deleteDocument($this->getDocumentsCollection(), $document->getId());
     }
 
-    public function testFindOrderByMultipleAttributeAfter(): void
+    public function testDateTimeDocument(): void
     {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
         /**
-         * ORDER BY - Multiple Attribute After
+         * @var Database $database
          */
-        $movies = $database->find('movies', [
-            Query::limit(25),
-            Query::offset(0),
-            Query::orderDesc('price'),
-            Query::orderAsc('year')
-        ]);
+        $database = $this->getDatabase();
+        $collection = 'create_modify_dates';
+        $database->createCollection($collection);
+        $this->assertEquals(true, $database->createAttribute($collection, new Attribute(key: 'string', type: ColumnType::String, size: 128, required: false)));
+        $this->assertEquals(true, $database->createAttribute($collection, new Attribute(key: 'datetime', type: ColumnType::Datetime, size: 0, required: false, default: null, signed: true, array: false, format: null, formatOptions: [], filters: ['datetime'])));
 
-        $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']);
+        $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'));
 
-        $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']);
-
-        $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']);
-
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::orderDesc('price'),
-            Query::orderAsc('year'),
-            Query::cursorAfter($movies[5])
-        ]);
-        $this->assertEmpty(count($documents));
-    }
-
-    public function testFindOrderByMultipleAttributeBefore(): void
-    {
-        /** @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')
-        ]);
-
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::orderDesc('price'),
-            Query::orderAsc('year'),
-            Query::cursorBefore($movies[5])
-        ]);
+        $doc = $database->getDocument($collection, 'doc1');
+        $this->assertNotEmpty($doc->getAttribute('datetime'));
+        $this->assertNotEmpty($doc->getAttribute('$createdAt'));
+        $this->assertNotEmpty($doc->getAttribute('$updatedAt'));
 
-        $this->assertEquals(2, count($documents));
-        $this->assertEquals($movies[3]['name'], $documents[0]['name']);
-        $this->assertEquals($movies[4]['name'], $documents[1]['name']);
+        $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,
+        ]));
 
-        $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']);
+        $this->assertEquals($doc->getAttribute('$createdAt'), $date);
+        $this->assertNotEmpty($doc->getAttribute('$updatedAt'));
+        $this->assertNotEquals($doc->getAttribute('$updatedAt'), $date);
 
-        $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']);
+        $doc = $database->getDocument($collection, 'doc2');
 
-        $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']);
+        $this->assertEquals($doc->getAttribute('$createdAt'), $date);
+        $this->assertNotEmpty($doc->getAttribute('$updatedAt'));
+        $this->assertNotEquals($doc->getAttribute('$updatedAt'), $date);
 
-        $documents = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::orderDesc('price'),
-            Query::orderAsc('year'),
-            Query::cursorBefore($movies[0])
-        ]);
-        $this->assertEmpty(count($documents));
+        $database->setPreserveDates(false);
+        $database->deleteCollection($collection);
     }
-    public function testFindOrderByAndCursor(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        /**
-         * ORDER BY + CURSOR
-         */
-        $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
+    public function testUpsertDateOperations(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        /**
-         * 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']);
-    }
+        if (! ($database->getAdapter() instanceof Feature\Upserts)) {
+            $this->expectNotToPerformAssertions();
 
-    public function testFindOrderByCreateDateAndCursor(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+            return;
+        }
 
-        /**
-         * ORDER BY CREATE DATE + CURSOR
-         */
-        $documentsTest = $database->find('movies', [
-            Query::limit(2),
-            Query::offset(0),
-            Query::orderDesc('$createdAt'),
-        ]);
+        $collection = 'upsert_date_operations';
+        $database->createCollection($collection);
+        $this->assertEquals(true, $database->createAttribute($collection, new Attribute(key: 'string', type: ColumnType::String, size: 128, required: false)));
 
-        $documents = $database->find('movies', [
-            Query::limit(1),
-            Query::offset(0),
-            Query::orderDesc('$createdAt'),
-            Query::cursorAfter($documentsTest[0])
-        ]);
+        $database->setPreserveDates(true);
 
-        $this->assertEquals($documentsTest[1]['$id'], $documents[0]['$id']);
-    }
+        $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())];
 
-    public function testFindOrderByUpdateDateAndCursor(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        // 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];
 
-        /**
-         * 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($createDate, $upsertDoc1->getAttribute('$createdAt'));
+        $this->assertNotEquals($createDate, $upsertDoc1->getAttribute('$updatedAt'));
 
-        $this->assertEquals($documentsTest[1]['$id'], $documents[0]['$id']);
-    }
+        // 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';
-
-        // All documents should be between past and future
-        $documents = $database->find('movies', [
-            Query::updatedBetween($pastDate, $futureDate),
-            Query::limit(25)
-        ]);
-
-        $this->assertGreaterThan(0, count($documents));
-
-        // No documents should exist in this range
-        $documents = $database->find('movies', [
-            Query::updatedBetween($pastDate, $pastDate),
-            Query::limit(25)
-        ]);
+        if (! ($database->getAdapter() instanceof Feature\Upserts)) {
+            $this->expectNotToPerformAssertions();
 
-        $this->assertEquals(0, count($documents));
+            return;
+        }
 
-        // Documents updated between recent past and near future
-        $documents = $database->find('movies', [
-            Query::updatedBetween($recentPastDate, $nearFutureDate),
-            Query::limit(25)
-        ]);
+        $collectionName = 'update_count';
+        $database->createCollection($collectionName);
 
-        $count = count($documents);
+        $database->createAttribute($collectionName, new Attribute(key: 'key', type: ColumnType::String, size: 60, required: false));
+        $database->createAttribute($collectionName, new Attribute(key: 'value', type: ColumnType::String, size: 60, required: false));
 
-        // Same count should be returned with expanded range
-        $documents = $database->find('movies', [
-            Query::updatedBetween($pastDate, $nearFutureDate),
-            Query::limit(25)
-        ]);
+        $permissions = [Permission::read(Role::any()), Permission::write(Role::any()), Permission::update(Role::any())];
 
-        $this->assertGreaterThanOrEqual($count, count($documents));
-    }
+        $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);
 
-    public function testFindLimit(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        $updates = new Document(['value' => 'test']);
+        $newDocs = [];
+        $count = $database->updateDocuments($collectionName, $updates, onNext: function ($doc) use (&$newDocs) {
+            $newDocs[] = $doc;
+        });
 
-        /**
-         * Limit
-         */
-        $documents = $database->find('movies', [
-            Query::limit(4),
-            Query::offset(0),
-            Query::orderAsc('name')
-        ]);
+        $this->assertCount(4, $newDocs);
+        $this->assertEquals(4, $count);
 
-        $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']);
+        $database->deleteCollection($collectionName);
     }
 
-
-    public function testFindLimitAndOffset(): void
+    public function testUpsertWithJSONFilters(): void
     {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        /**
-         * Limit + Offset
-         */
-        $documents = $database->find('movies', [
-            Query::limit(4),
-            Query::offset(2),
-            Query::orderAsc('name')
-        ]);
+        $database = static::getDatabase();
 
-        $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']);
-    }
+        if (! $database->getAdapter()->supports(Capability::DefinedAttributes)) {
+            $this->expectNotToPerformAssertions();
 
-    public function testFindOrQueries(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+            return;
+        }
 
-        /**
-         * Test that OR queries are handled correctly
-         */
-        $documents = $database->find('movies', [
-            Query::equal('director', ['TBD', 'Joe Johnston']),
-            Query::equal('year', [2025]),
+        // Create collection with JSON filter attribute
+        $collection = ID::unique();
+        $database->createCollection($collection, permissions: [
+            Permission::read(Role::any()),
+            Permission::create(Role::any()),
+            Permission::update(Role::any()),
+            Permission::delete(Role::any()),
         ]);
-        $this->assertEquals(1, count($documents));
-    }
-
-    /**
-     * @depends testUpdateDocument
-     */
-    public function testFindEdgeCases(Document $document): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        $collection = 'edgeCases';
 
-        $database->createCollection($collection);
+        $database->createAttribute($collection, new Attribute(key: 'name', type: ColumnType::String, size: 128, required: true));
+        $database->createAttribute($collection, new Attribute(key: 'metadata', type: ColumnType::String, size: 4000, required: true, filters: ['json']));
 
-        $this->assertEquals(true, $database->createAttribute($collection, 'value', Database::VAR_STRING, 256, true));
+        $permissions = [
+            Permission::read(Role::any()),
+            Permission::create(Role::any()),
+            Permission::update(Role::any()),
+            Permission::delete(Role::any()),
+        ];
 
-        $values = [
-            'NormalString',
-            '{"type":"json","somekey":"someval"}',
-            '{NormalStringInBraces}',
-            '"NormalStringInDoubleQuotes"',
-            '{"NormalStringInDoubleQuotesAndBraces"}',
-            "'NormalStringInSingleQuotes'",
-            "{'NormalStringInSingleQuotesAndBraces'}",
-            "SingleQuote'InMiddle",
-            'DoubleQuote"InMiddle',
-            'Slash/InMiddle',
-            'Backslash\InMiddle',
-            'Colon:InMiddle',
-            '"quoted":"colon"'
+        // Test 1: Insertion (createDocument) with JSON filter
+        $docId1 = 'json-doc-1';
+        $initialMetadata = [
+            'version' => '1.0.0',
+            'tags' => ['php', 'database'],
+            'config' => [
+                'debug' => false,
+                'timeout' => 30,
+            ],
         ];
 
-        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
-            ]));
-        }
+        $document1 = $database->createDocument($collection, new Document([
+            '$id' => $docId1,
+            'name' => 'Initial Document',
+            'metadata' => $initialMetadata,
+            '$permissions' => $permissions,
+        ]));
 
-        /**
-         * Check Basic
-         */
-        $documents = $database->find($collection);
+        $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(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'));
+        // 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,
+        ];
 
-        /**
-         * Check `equals` query
-         */
-        foreach ($values as $value) {
-            $documents = $database->find($collection, [
-                Query::limit(25),
-                Query::equal('value', [$value])
-            ]);
+        $document1->setAttribute('name', 'Updated Document');
+        $document1->setAttribute('metadata', $updatedMetadata);
 
-            $this->assertEquals(1, count($documents));
-            $this->assertEquals($value, $documents[0]->getAttribute('value'));
-        }
-    }
+        $updatedDoc = $database->updateDocument($collection, $docId1, $document1);
 
-    public function testOrSingleQuery(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        $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']);
 
-        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());
-        }
-    }
+        // Test 3: Upsert - Create new document (upsertDocument)
+        $docId2 = 'json-doc-2';
+        $newMetadata = [
+            'version' => '1.5.0',
+            'tags' => ['javascript', 'node'],
+            'config' => [
+                'debug' => false,
+                'timeout' => 45,
+            ],
+        ];
 
-    public function testOrMultipleQueries(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        $document2 = new Document([
+            '$id' => $docId2,
+            'name' => 'New Upsert Document',
+            'metadata' => $newMetadata,
+            '$permissions' => $permissions,
+        ]);
 
-        $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));
+        $upsertedDoc = $database->upsertDocument($collection, $document2);
 
-        $queries = [
-            Query::equal('active', [true]),
-            Query::or([
-                Query::equal('name', ['Frozen']),
-                Query::equal('name', ['Frozen II']),
-                Query::equal('director', ['Joe Johnston'])
-            ])
-        ];
+        $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']);
 
-        $this->assertCount(3, $database->find('movies', $queries));
-        $this->assertEquals(3, $database->count('movies', $queries));
-    }
+        // 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,
+        ]);
 
-    public function testOrNested(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        $upsertedDoc2 = $database->upsertDocument($collection, $document2);
 
-        $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]),
-                ])
-            ])
-        ];
-
-        $documents = $database->find('movies', $queries);
-        $this->assertCount(1, $documents);
-        $this->assertArrayNotHasKey('name', $documents[0]);
-
-        $count = $database->count('movies', $queries);
-        $this->assertEquals(1, $count);
-    }
-
-    public function testAndSingleQuery(): void
-    {
-        /** @var Database $database */
-        $database = $this->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());
-        }
-    }
-
-    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));
-    }
+        $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']);
 
-    public function testAndNested(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        // Test 5: Upsert - Bulk upsertDocuments (create and update)
+        $docId3 = 'json-doc-3';
+        $docId4 = 'json-doc-4';
 
-        $queries = [
-            Query::or([
-                Query::equal('active', [false]),
-                Query::and([
-                    Query::equal('active', [true]),
-                    Query::equal('name', ['Frozen']),
-                ])
-            ])
+        $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,
+            ]),
         ];
 
-        $documents = $database->find('movies', $queries);
-        $this->assertCount(3, $documents);
-
-        $count = $database->count('movies', $queries);
+        $count = $database->upsertDocuments($collection, $bulkDocuments);
         $this->assertEquals(3, $count);
-    }
-
-    public function testNestedIDQueries(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
-
-        $database->createCollection('movies_nested_id', permissions: [
-            Permission::create(Role::any()),
-            Permission::update(Role::users())
-        ]);
-
-        $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',
-        ]));
-
-        $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',
-        ]));
-
-        $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',
-        ]));
-
-        $queries = [
-            Query::or([
-                Query::equal('$id', ["1"]),
-                Query::equal('$id', ["2"])
-            ])
-        ];
-
-        $documents = $database->find('movies_nested_id', $queries);
-        $this->assertCount(2, $documents);
-
-        // Make sure the query was not modified by reference
-        $this->assertEquals($queries[0]->getValues()[0]->getAttribute(), '$id');
 
-        $count = $database->count('movies_nested_id', $queries);
-        $this->assertEquals(2, $count);
-    }
-
-    public function testFindNull(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        $documents = $database->find('movies', [
-            Query::isNull('nullable'),
-        ]);
-
-        $this->assertEquals(5, count($documents));
-    }
+        // 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']);
 
-    public function testFindNotNull(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        $bulkDoc2 = $database->getDocument($collection, $docId4);
+        $this->assertEquals('Bulk Upsert 2', $bulkDoc2->getAttribute('name'));
+        $this->assertEquals('3.1.0', $bulkDoc2->getAttribute('metadata')['version']);
 
-        $documents = $database->find('movies', [
-            Query::isNotNull('nullable'),
-        ]);
+        $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']);
 
-        $this->assertEquals(1, count($documents));
+        // Cleanup
+        $database->deleteCollection($collection);
     }
 
-    public function testFindStartsWith(): void
+    public function testFindRegex(): void
     {
         /** @var Database $database */
-        $database = $this->getDatabase();
-
-        $documents = $database->find('movies', [
-            Query::startsWith('name', 'Work'),
-        ]);
+        $database = static::getDatabase();
 
-        $this->assertEquals(2, count($documents));
+        // Skip test if regex is not supported
+        if (! $database->getAdapter()->supports(Capability::Regex)) {
+            $this->expectNotToPerformAssertions();
 
-        if ($this->getDatabase()->getAdapter() instanceof SQL) {
-            $documents = $database->find('movies', [
-                Query::startsWith('name', '%ork'),
-            ]);
-        } else {
-            $documents = $database->find('movies', [
-                Query::startsWith('name', '.*ork'),
-            ]);
+            return;
         }
 
-        $this->assertEquals(0, count($documents));
-    }
-
-    public function testFindStartsWithWords(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        $documents = $database->find('movies', [
-            Query::startsWith('name', 'Work in Progress'),
-        ]);
-
-        $this->assertEquals(2, count($documents));
-    }
+        // Determine regex support type
+        $supportsPCRE = $database->getAdapter()->supports(Capability::PCRE);
+        $supportsPOSIX = $database->getAdapter()->supports(Capability::POSIX);
 
-    public function testFindEndsWith(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        // 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
+        }
 
-        $documents = $database->find('movies', [
-            Query::endsWith('name', 'Marvel'),
+        $database->createCollection('moviesRegex', permissions: [
+            Permission::create(Role::any()),
+            Permission::read(Role::any()),
+            Permission::update(Role::any()),
+            Permission::delete(Role::any()),
         ]);
 
-        $this->assertEquals(1, count($documents));
-    }
-
-    public function testFindNotContains(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
+            $this->assertEquals(true, $database->createAttribute('moviesRegex', new Attribute(key: 'name', type: ColumnType::String, size: 128, required: true)));
+            $this->assertEquals(true, $database->createAttribute('moviesRegex', new Attribute(key: 'director', type: ColumnType::String, size: 128, required: true)));
+            $this->assertEquals(true, $database->createAttribute('moviesRegex', new Attribute(key: 'year', type: ColumnType::Integer, size: 0, required: true)));
+        }
 
-        if (!$database->getAdapter()->getSupportForQueryContains()) {
-            $this->expectNotToPerformAssertions();
-            return;
+        if ($database->getAdapter()->supports(Capability::TrigramIndex)) {
+            $database->createIndex('moviesRegex', new Index(key: 'trigram_name', type: IndexType::Trigram, attributes: ['name']));
+            $database->createIndex('moviesRegex', new Index(key: 'trigram_director', type: IndexType::Trigram, attributes: ['director']));
         }
 
-        // Test notContains with array attributes - should return documents that don't contain specified genres
-        $documents = $database->find('movies', [
-            Query::notContains('genres', ['comics'])
-        ]);
-
-        $this->assertEquals(4, count($documents)); // All movies except the 2 with 'comics' genre
-
-        // Test notContains with multiple values (AND logic - exclude documents containing ANY of these)
-        $documents = $database->find('movies', [
-            Query::notContains('genres', ['comics', 'kids']),
-        ]);
-
-        $this->assertEquals(2, count($documents)); // Movies that have neither 'comics' nor 'kids'
-
-        // Test notContains with non-existent genre - should return all documents
-        $documents = $database->find('movies', [
-            Query::notContains('genres', ['non-existent']),
-        ]);
-
-        $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'
-
-        // 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
-
-        // Test notContains with case sensitivity
-        $documents = $database->find('movies', [
-            Query::notContains('genres', ['COMICS']) // Different case
+        // 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(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);
-        }
-    }
+        // 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).'/';
 
-    public function testFindNotSearch(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+            // Get all documents to manually verify
+            $allDocuments = $database->find('moviesRegex');
 
-        // 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;
+            // Manually filter documents that match the pattern
+            $expectedMatches = [];
+            foreach ($allDocuments as $doc) {
+                $value = $doc->getAttribute($attribute);
+                if (preg_match($phpPattern, $value)) {
+                    $expectedMatches[] = $doc->getId();
                 }
             }
 
-            // 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'),
-            ]);
-
-            $this->assertEquals(6, count($documents));
-
-            // Test notSearch with partial term
-            if ($this->getDatabase()->getAdapter()->getSupportForFulltextWildCardIndex()) {
-                $documents = $database->find('movies', [
-                    Query::notSearch('name', 'cap'),
-                ]);
+            // Get IDs from query results
+            $actualMatches = array_map(fn ($doc) => $doc->getId(), $queryResults);
 
-                $this->assertEquals(4, count($documents)); // All movies except those matching 'cap'
+            // 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 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 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
+            // 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}'"
+            );
+        };
 
-            // 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
-        }
+        // 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'),
+        ]);
 
-        $this->assertEquals(true, true); // Test must do an assertion
-    }
+        // Verify completeness: all matching documents returned, no extra documents
+        $verifyRegexQuery('name', '^Captain', $documents);
 
-    public function testFindNotStartsWith(): 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));
 
-        // Test notStartsWith - should return documents that don't start with 'Work'
-        $documents = $database->find('movies', [
-            Query::notStartsWith('name', 'Work'),
+        // Test regex pattern - match movies containing 'Frozen'
+        $pattern = '/Frozen/';
+        $documents = $database->find('moviesRegex', [
+            Query::regex('name', 'Frozen'),
         ]);
 
-        $this->assertEquals(4, count($documents)); // All movies except the 2 starting with 'Work'
+        // Verify completeness: all matching documents returned, no extra documents
+        $verifyRegexQuery('name', 'Frozen', $documents);
 
-        // Test notStartsWith with non-existent prefix - should return all documents
-        $documents = $database->find('movies', [
-            Query::notStartsWith('name', 'NonExistent'),
+        // 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));
 
-        $this->assertEquals(6, count($documents));
+        // Test regex pattern - match movies ending with 'Marvel'
+        $pattern = '/Marvel$/';
+        $documents = $database->find('moviesRegex', [
+            Query::regex('name', 'Marvel$'),
+        ]);
 
-        // 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'),
-            ]);
-        }
+        // Verify completeness: all matching documents returned, no extra documents
+        $verifyRegexQuery('name', 'Marvel$', $documents);
 
-        $this->assertEquals(6, count($documents)); // Should return all since no movie starts with these patterns
+        $this->assertEquals(1, count($documents)); // Only Captain Marvel
+        $this->assertEquals('Captain Marvel', $documents[0]->getAttribute('name'));
 
-        // Test notStartsWith with empty string - should return no documents (all strings start with empty)
-        $documents = $database->find('movies', [
-            Query::notStartsWith('name', ''),
+        // Test regex pattern - match movies with 'Work' in the name
+        $pattern = '/.*Work.*/';
+        $documents = $database->find('moviesRegex', [
+            Query::regex('name', '.*Work.*'),
         ]);
-        $this->assertEquals(0, count($documents)); // No documents since all strings start with empty string
 
-        // Test notStartsWith with single character
-        $documents = $database->find('movies', [
-            Query::notStartsWith('name', 'C'),
-        ]);
-        $this->assertGreaterThanOrEqual(4, count($documents)); // Movies not starting with 'C'
+        // Verify completeness: all matching documents returned, no extra documents
+        $verifyRegexQuery('name', '.*Work.*', $documents);
 
-        // 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 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));
 
-        // Test notStartsWith combined with other queries
-        $documents = $database->find('movies', [
-            Query::notStartsWith('name', 'Work'),
-            Query::equal('year', [2006])
+        // Test regex pattern - match movies with 'Buck' in director
+        $pattern = '/.*Buck.*/';
+        $documents = $database->find('moviesRegex', [
+            Query::regex('director', '.*Buck.*'),
         ]);
-        $this->assertLessThanOrEqual(4, count($documents)); // Subset of non-Work movies from 2006
-    }
 
-    public function testFindNotEndsWith(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        // Verify completeness: all matching documents returned, no extra documents
+        $verifyRegexQuery('director', '.*Buck.*', $documents);
 
-        // Test notEndsWith - should return documents that don't end with 'Marvel'
-        $documents = $database->find('movies', [
-            Query::notEndsWith('name', 'Marvel'),
-        ]);
-
-        $this->assertEquals(5, count($documents)); // All movies except the 1 ending with 'Marvel'
+        // 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));
 
-        // Test notEndsWith with non-existent suffix - should return all documents
-        $documents = $database->find('movies', [
-            Query::notEndsWith('name', 'NonExistent'),
+        // 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(6, count($documents));
+        // 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)"
+            );
+        }
 
-        // Test notEndsWith with partial suffix
-        $documents = $database->find('movies', [
-            Query::notEndsWith('name', 'vel'),
-        ]);
+        // 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();
+            }
+        }
 
-        $this->assertEquals(5, count($documents)); // All movies except the 1 ending with 'vel' (from 'Marvel')
+        $actualMatches = array_map(fn ($doc) => $doc->getId(), $documents);
+        sort($actualMatches);
 
-        // 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
+        // The database might be case-sensitive (MongoDB) or case-insensitive (MySQL/MariaDB)
+        // Check which one matches the actual results
+        sort($expectedMatchesCaseSensitive);
+        sort($expectedMatchesCaseInsensitive);
 
-        // Test notEndsWith with single character
-        $documents = $database->find('movies', [
-            Query::notEndsWith('name', 'l'),
-        ]);
-        $this->assertGreaterThanOrEqual(5, count($documents)); // Movies not ending with 'l'
+        // Verify that actual results match either case-sensitive or case-insensitive expectations
+        $matchesCaseSensitive = ($expectedMatchesCaseSensitive === $actualMatches);
+        $matchesCaseInsensitive = ($expectedMatchesCaseInsensitive === $actualMatches);
 
-        // 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
+        $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 notEndsWith combined with limit
-        $documents = $database->find('movies', [
-            Query::notEndsWith('name', 'Marvel'),
-            Query::limit(3)
+        // 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(3, count($documents)); // Limited to 3 results
-        $this->assertLessThanOrEqual(5, count($documents)); // But still excluding Marvel movies
-    }
 
-    public function testFindOrderRandom(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        // 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'"
+            );
+        }
 
-        if (!$database->getAdapter()->getSupportForOrderRandom()) {
-            $this->expectNotToPerformAssertions();
-            return;
+        // 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 orderRandom with default limit
-        $documents = $database->find('movies', [
-            Query::orderRandom(),
-            Query::limit(1),
+        // Test regex combined with other queries
+        $pattern = '/^Captain/';
+        $documents = $database->find('moviesRegex', [
+            Query::regex('name', '^Captain'),
+            Query::greaterThan('year', 2010),
         ]);
-        $this->assertEquals(1, count($documents));
-        $this->assertNotEmpty($documents[0]['name']); // Ensure we got a valid document
 
-        // Test orderRandom with multiple documents
-        $documents = $database->find('movies', [
-            Query::orderRandom(),
-            Query::limit(3),
-        ]);
-        $this->assertEquals(3, count($documents));
+        // 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");
+        }
 
-        // 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(),
+        // 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();
+            }
+        }
+        $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),
         ]);
 
-        // Extract IDs for comparison
-        $firstIds = array_map(fn ($doc) => $doc['$id'], $firstSet);
-        $secondIds = array_map(fn ($doc) => $doc['$id'], $secondSet);
+        $this->assertEquals(3, count($documents));
 
-        // 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));
+        // 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}'"
+            );
+        }
 
-        // 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
+        // Note: With limit, we can't verify completeness, but we can verify all returned match
 
-        // Test orderRandom with filters
-        $documents = $database->find('movies', [
-            Query::greaterThan('price', 10),
-            Query::orderRandom(),
-            Query::limit(2),
+        // Test regex with non-matching pattern
+        $pattern = '/^NonExistentPattern$/';
+        $documents = $database->find('moviesRegex', [
+            Query::regex('name', '^NonExistentPattern$'),
         ]);
-        $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
-    }
+        $this->assertEquals(0, count($documents));
 
-    public function testFindNotBetween(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        // 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}'");
 
-        // 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
+        // Verify completeness: no documents should be returned
+        $this->assertEquals([], array_map(fn ($doc) => $doc->getId(), $documents));
 
-        // Test notBetween with range that includes no documents - should return all documents
-        $documents = $database->find('movies', [
-            Query::notBetween('price', 30, 35),
+        // 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(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
+        // Verify completeness: all matching documents returned, no extra documents
+        $verifyRegexQuery('name', '.*:.*', $documents);
 
-        // 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
+        // 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 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'),
+        // ReDOS safety: ensure pathological patterns respond quickly and do not hang
+        $catastrophicPattern = '(a+)+$';
+        $start = microtime(true);
+        $redosDocs = $database->find('moviesRegex', [
+            Query::regex('name', $catastrophicPattern),
         ]);
-        $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
+        $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 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 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),
+            ]);
 
-        // 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
+            // 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 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
+            // 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}'"
+            );
+        }
 
-        // Test notBetween with extreme ranges
-        $documents = $database->find('movies', [
-            Query::notBetween('year', -1000, 1000), // Very wide range
+        // 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->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
+        // 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 testFindSelect(): void
+    public function testRegexInjection(): void
     {
         /** @var Database $database */
-        $database = $this->getDatabase();
+        $database = static::getDatabase();
 
-        $documents = $database->find('movies', [
-            Query::select(['name', 'year'])
-        ]);
+        // Skip test if regex is not supported
+        if (! $database->getAdapter()->supports(Capability::Regex)) {
+            $this->expectNotToPerformAssertions();
 
-        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);
+            return;
         }
 
-        $documents = $database->find('movies', [
-            Query::select(['name', 'year', '$id'])
+        $collectionName = 'injectionTest';
+        $database->createCollection($collectionName, permissions: [
+            Permission::create(Role::any()),
+            Permission::read(Role::any()),
+            Permission::update(Role::any()),
+            Permission::delete(Role::any()),
         ]);
 
-        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);
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
+            $this->assertEquals(true, $database->createAttribute($collectionName, new Attribute(key: 'text', type: ColumnType::String, size: 1000, required: true)));
         }
 
-        $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);
-        }
+        // 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',
+        ]));
 
-        $documents = $database->find('movies', [
-            Query::select(['name', 'year', '$collection'])
-        ]);
+        $database->createDocument($collectionName, new Document([
+            '$permissions' => [
+                Permission::read(Role::any()),
+                Permission::create(Role::any()),
+                Permission::update(Role::any()),
+                Permission::delete(Role::any()),
+            ],
+            'text' => 'other',
+        ]));
 
-        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);
-        }
+        // 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
+        ];
 
-        $documents = $database->find('movies', [
-            Query::select(['name', 'year', '$createdAt'])
-        ]);
+        // 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
+        ];
 
-        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);
-        }
+        $allInjectionPatterns = array_merge($sqlInjectionPatterns, $mongoInjectionPatterns);
 
-        $documents = $database->find('movies', [
-            Query::select(['name', 'year', '$updatedAt'])
-        ]);
+        foreach ($allInjectionPatterns 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);
-        }
+                // 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;
 
-        $documents = $database->find('movies', [
-            Query::select(['name', 'year', '$permissions'])
-        ]);
+                        // 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."
+                            );
+                        }
+                    }
+                }
 
-        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);
-        }
-    }
+                // 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);
 
-    /** @depends testFind */
-    public function testForeach(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+                    // If pattern is invalid, skip validation
+                    if ($matches === false) {
+                        continue;
+                    }
 
-        /**
-         * 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'));
+                    // 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."
+                        );
+                    }
+                }
 
-        /**
-         * Test, foreach generator
-         */
-        $documents = [];
-        foreach ($database->iterate('movies', queries: [Query::limit(2)]) as $document) {
-            $documents[] = $document;
+            } 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);
+            }
         }
-        $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, foreach with initial cursor
-         */
 
-        $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));
-
-        /**
-         * Test, foreach with initial offset
-         */
+        // Test that legitimate regex patterns still work correctly
+        $legitimatePatterns = [
+            'target',      // Should match "target"
+            '^target',     // Should match "target" (anchored)
+            'other',       // Should match "other"
+        ];
 
-        $documents = [];
-        $database->foreach('movies', queries: [Query::limit(2), Query::offset(2)], callback: function ($document) use (&$documents) {
-            $documents[] = $document;
-        });
-        $this->assertEquals(4, count($documents));
+        foreach ($legitimatePatterns as $pattern) {
+            try {
+                $results = $database->find($collectionName, [
+                    Query::regex('text', $pattern),
+                ]);
 
-        /**
-         * Test, cursor before throws error
-         */
-        try {
-            $database->foreach('movies', queries: [Query::cursorBefore($documents[0]), Query::offset(2)], callback: function ($document) use (&$documents) {
-                $documents[] = $document;
-            });
+                $this->assertIsArray($results);
 
-        } catch (Throwable $e) {
-            $this->assertInstanceOf(DatabaseException::class, $e);
-            $this->assertEquals('Cursor ' . Database::CURSOR_BEFORE . ' not supported in this method.', $e->getMessage());
+                // 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);
     }
 
     /**
-     * @depends testFind
-     */
-    public function testCount(): 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);
-
-        $this->getDatabase()->getAuthorization()->removeRole('user:x');
-        $count = $database->count('movies');
-        $this->assertEquals(5, $count);
-
-        $this->getDatabase()->getAuthorization()->disable();
-        $count = $database->count('movies');
-        $this->assertEquals(6, $count);
-        $this->getDatabase()->getAuthorization()->reset();
-
-        $this->getDatabase()->getAuthorization()->disable();
-        $count = $database->count('movies', [], 3);
-        $this->assertEquals(3, $count);
-        $this->getDatabase()->getAuthorization()->reset();
-
-        /**
-         * 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();
-    }
-
-    /**
-     * @depends testFind
+     * 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 testSum(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        $this->getDatabase()->getAuthorization()->addRole('user:x');
-
-        $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));
-
-        $sum = $database->sum('movies', 'year', [Query::equal('year', [2019])], 1);
-        $this->assertEquals(2019, $sum);
-
-        $this->getDatabase()->getAuthorization()->removeRole('user:x');
-
-        $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));
-    }
-
-    public function testEncodeDecode(): 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],
-                ]
+    //    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, new Attribute(key: 'text', type: ColumnType::String, 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() instanceof Feature\Timeouts);
+    //
+    //        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);
+    //    }
+
+    public function testNonUtfChars(): void
+    {
+        /** @var Database $database */
+        $database = $this->getDatabase();
+
+        if (!$database->getAdapter()->getSupportNonUtfCharacters()) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $database->createCollection(__FUNCTION__);
+        $this->assertEquals(true, $database->createAttribute(__FUNCTION__, new Attribute(key: 'title', type: ColumnType::String, size: 128, required: true)));
+
+        $nonUtfString = "Hello\x00World\xC3\x28\xFF\xFE\xA0Test\x00End";
+
+        try {
+            $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'));
+    }
+
+    public function testCreateDocumentNumericalId(): void
+    {
+        /** @var Database $database */
+        $database = $this->getDatabase();
+
+        $database->createCollection('numericalIds');
+
+        $this->assertEquals(true, $database->createAttribute('numericalIds', new Attribute(key: 'name', type: ColumnType::String, size: 128, required: 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 testSkipPermissions(): void
+    {
+        /** @var Database $database */
+        $database = $this->getDatabase();
+
+        if (!($database->getAdapter() instanceof Feature\Upserts)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $database->createCollection(__FUNCTION__);
+        $database->createAttribute(__FUNCTION__, new Attribute(key: 'number', type: ColumnType::Integer, size: 0, required: 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 testUpsertDocumentsAttributeMismatch(): void
+    {
+        /** @var Database $database */
+        $database = $this->getDatabase();
+
+        if (!($database->getAdapter() instanceof Feature\Upserts)) {
+            $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__, new Attribute(key: 'first', type: ColumnType::String, size: 128, required: true));
+        $database->createAttribute(__FUNCTION__, new Attribute(key: 'last', type: ColumnType::String, size: 128, required: false));
+
+        $existingDocument = $database->createDocument(__FUNCTION__, new Document([
+            '$id' => 'first',
+            'first' => 'first',
+            'last' => 'last',
+        ]));
+
+        $newDocument = new Document([
+            '$id' => 'second',
+            'first' => 'second',
+        ]);
+
+        // Ensure missing optionals on new document is allowed
+        $docs = $database->upsertDocuments(__FUNCTION__, [
+            $existingDocument->setAttribute('first', 'updated'),
+            $newDocument,
+        ]);
+
+        $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'));
+
+        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());
+            }
+        }
+
+        // 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 testUpsertDocumentsNoop(): void
+    {
+        if (!($this->getDatabase()->getAdapter() instanceof Feature\Upserts)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $this->getDatabase()->createCollection(__FUNCTION__);
+        $this->getDatabase()->createAttribute(__FUNCTION__, new Attribute(key: 'string', type: ColumnType::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')),
+                Permission::create(Role::any()),
+                Permission::update(Role::any()),
+                Permission::delete(Role::any()),
             ],
-            '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',
+        ]);
+
+        $count = $this->getDatabase()->upsertDocuments(__FUNCTION__, [$document]);
+        $this->assertEquals(1, $count);
+
+        // No changes, should return 0
+        $count = $this->getDatabase()->upsertDocuments(__FUNCTION__, [$document]);
+        $this->assertEquals(0, $count);
+    }
+
+    public function testUpsertDuplicateIds(): void
+    {
+        $db = $this->getDatabase();
+        if (!($db->getAdapter() instanceof Feature\Upserts)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $db->createCollection(__FUNCTION__);
+        $db->createAttribute(__FUNCTION__, new Attribute(key: 'num', type: ColumnType::Integer, size: 0, required: true));
+
+        $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());
+        }
+    }
+
+    public function testPreserveSequenceUpsert(): void
+    {
+        /** @var Database $database */
+        $database = $this->getDatabase();
+
+        if (!($database->getAdapter() instanceof Feature\Upserts)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $collectionName = 'preserve_sequence_upsert';
+
+        $database->createCollection($collectionName);
+
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
+            $database->createAttribute($collectionName, new Attribute(key: 'name', type: ColumnType::String, size: 128, required: true));
+        }
+
+        // Create initial documents
+        $doc1 = $database->createDocument($collectionName, new Document([
+            '$id' => 'doc1',
+            '$permissions' => [
+                Permission::read(Role::any()),
+                Permission::update(Role::any()),
             ],
-            'tags' => [
-                ['$id' => '1', 'label' => 'x'],
-                ['$id' => '2', 'label' => 'y'],
-                ['$id' => '3', 'label' => 'z'],
+            'name' => 'Alice',
+        ]));
+
+        $doc2 = $database->createDocument($collectionName, new Document([
+            '$id' => 'doc2',
+            '$permissions' => [
+                Permission::read(Role::any()),
+                Permission::update(Role::any()),
             ],
+            'name' => 'Bob',
+        ]));
+
+        $originalSeq1 = $doc1->getSequence();
+        $originalSeq2 = $doc2->getSequence();
+
+        $this->assertNotEmpty($originalSeq1);
+        $this->assertNotEmpty($originalSeq2);
+
+        // Test: Without preserveSequence (default), $sequence should be ignored
+        $database->setPreserveSequence(false);
+
+        $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',
+            ]),
+        ]);
+
+        $doc1Updated = $database->getDocument($collectionName, 'doc1');
+        $this->assertEquals('Alice Updated', $doc1Updated->getAttribute('name'));
+        $this->assertEquals($originalSeq1, $doc1Updated->getSequence()); // Sequence unchanged
+
+        // Test: With preserveSequence=true, $sequence from document should be used
+        $database->setPreserveSequence(true);
+
+        $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
+
+        // Test: withPreserveSequence helper
+        $database->setPreserveSequence(false);
+
+        $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',
+                ]),
+            ]);
+        });
+
+        $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 {
+            $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) {
+            if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
+                $this->assertInstanceOf(StructureException::class, $e);
+                $this->assertStringContainsString('sequence', $e->getMessage());
+            }
+        }
+
+        $database->setPreserveSequence(false);
+        $database->deleteCollection($collectionName);
+    }
+
+    public function testRespectNulls(): void
+    {
+        /** @var Database $database */
+        $database = $this->getDatabase();
+
+        $database->createCollection('documents_nulls');
+
+        $this->assertEquals(true, $database->createAttribute('documents_nulls', new Attribute(key: 'string', type: ColumnType::String, size: 128, required: false)));
+        $this->assertEquals(true, $database->createAttribute('documents_nulls', new Attribute(key: 'integer', type: ColumnType::Integer, size: 0, required: false)));
+        $this->assertEquals(true, $database->createAttribute('documents_nulls', new Attribute(key: 'bigint', type: ColumnType::Integer, size: 8, required: false)));
+        $this->assertEquals(true, $database->createAttribute('documents_nulls', new Attribute(key: 'float', type: ColumnType::Double, size: 0, required: false)));
+        $this->assertEquals(true, $database->createAttribute('documents_nulls', new Attribute(key: 'boolean', type: ColumnType::Boolean, size: 0, required: false)));
+
+        $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')),
+            ],
+        ]));
+
+        $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'));
+    }
+
+    public function testCreateDocumentDefaults(): void
+    {
+        /** @var Database $database */
+        $database = $this->getDatabase();
+
+        $database->createCollection('defaults');
+
+        $this->assertEquals(true, $database->createAttribute('defaults', new Attribute(key: 'string', type: ColumnType::String, size: 128, required: false, default: 'default')));
+        $this->assertEquals(true, $database->createAttribute('defaults', new Attribute(key: 'integer', type: ColumnType::Integer, size: 0, required: false, default: 1)));
+        $this->assertEquals(true, $database->createAttribute('defaults', new Attribute(key: 'float', type: ColumnType::Double, size: 0, required: false, default: 1.5)));
+        $this->assertEquals(true, $database->createAttribute('defaults', new Attribute(key: 'boolean', type: ColumnType::Boolean, size: 0, required: false, default: true)));
+        $this->assertEquals(true, $database->createAttribute('defaults', new Attribute(key: 'colors', type: ColumnType::String, size: 32, required: false, default: ['red', 'green', 'blue'], array: true)));
+        $this->assertEquals(true, $database->createAttribute('defaults', new Attribute(key: 'datetime', type: ColumnType::Datetime, size: 0, required: false, 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 testIncreaseDecrease(): void
+    {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $result = $database->encode($collection, $document);
+        $collection = $this->getIncDecCollection();
+        $database->createCollection($collection);
 
-        $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'));
+        $this->assertEquals(true, $database->createAttribute($collection, new Attribute(key: 'increase', type: ColumnType::Integer, size: 0, required: true)));
+        $this->assertEquals(true, $database->createAttribute($collection, new Attribute(key: 'decrease', type: ColumnType::Integer, size: 0, required: true)));
+        $this->assertEquals(true, $database->createAttribute($collection, new Attribute(key: 'increase_text', type: ColumnType::String, size: 255, required: true)));
+        $this->assertEquals(true, $database->createAttribute($collection, new Attribute(key: 'increase_float', type: ColumnType::Double, size: 0, required: true)));
+        $this->assertEquals(true, $database->createAttribute($collection, new Attribute(key: 'sizes', type: ColumnType::Integer, size: 8, required: false, array: true)));
 
-        $result = $database->decode($collection, $document);
+        $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->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'));
-    }
-    /**
-     * @depends testGetDocument
-     */
-    public function testUpdateDocument(Document $document): Document
-    {
-        $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');
+        $updatedAt = $document->getUpdatedAt();
 
-        $new = $this->getDatabase()->updateDocument($document->getCollection(), $document->getId(), $document);
+        $doc = $database->increaseDocumentAttribute($collection, $document->getId(), 'increase', 1, 101);
+        $this->assertEquals(101, $doc->getAttribute('increase'));
 
-        $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'));
+        $document = $database->getDocument($collection, $document->getId());
+        $this->assertEquals(101, $document->getAttribute('increase'));
+        $this->assertNotEquals($updatedAt, $document->getUpdatedAt());
 
-        $oldPermissions = $document->getPermissions();
+        $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'));
 
-        $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);
+        $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'));
 
-        $this->getDatabase()->updateDocument($new->getCollection(), $new->getId(), $new);
+        $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'));
 
-        $new = $this->getDatabase()->getDocument($new->getCollection(), $new->getId());
+        self::$incDecFixtureInit = true;
+        self::$incDecFixtureDoc = $document;
+    }
 
-        $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 testIncreaseLimitMax(): void
+    {
+        $document = $this->initIncreaseDecreaseFixture();
 
-        $new->setAttribute('$permissions', $oldPermissions);
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        $this->getDatabase()->updateDocument($new->getCollection(), $new->getId(), $new);
+        $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();
 
-        $new = $this->getDatabase()->getDocument($new->getCollection(), $new->getId());
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        $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());
+        try {
+            $database->decreaseDocumentAttribute(
+                $this->getIncDecCollection(),
+                $document->getId(),
+                'decrease',
+                10,
+                99
+            );
+            $this->fail('Failed to throw exception');
+        } catch (Exception $e) {
+            $this->assertInstanceOf(LimitException::class, $e);
+        }
 
-        // 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());
+        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();
 
-        // Reset ID
-        $new->setAttribute('$id', $id);
-        $new = $this->getDatabase()->updateDocument($new->getCollection(), $newId, $new);
-        $this->assertEquals($id, $new->getId());
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        return $document;
+        try {
+            $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();
 
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-    /**
-     * @depends testUpdateDocument
-     */
-    public function testUpdateDocumentConflict(Document $document): void
+        try {
+            $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->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'));
+        $document = $this->initIncreaseDecreaseFixture();
+
+        /** @var Database $database */
+        $database = $this->getDatabase();
+
+        $database->setPreserveDates(true);
 
-        $oneHourAgo = (new \DateTime())->sub(new \DateInterval('PT1H'));
-        $document->setAttribute('integer_signed', 8);
         try {
-            $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->assertTrue($e instanceof ConflictException);
-            $this->assertEquals('Document was updated after the request timestamp', $e->getMessage());
+            $before = $database->getDocument($this->getIncDecCollection(), $document->getId());
+            $updatedAt = $before->getUpdatedAt();
+            $increase = $before->getAttribute('increase');
+            $decrease = $before->getAttribute('decrease');
+
+            $database->increaseDocumentAttribute($this->getIncDecCollection(), $document->getId(), 'increase', 1);
+
+            $after = $database->getDocument($this->getIncDecCollection(), $document->getId());
+            $this->assertSame($increase + 1, $after->getAttribute('increase'));
+            $this->assertSame($updatedAt, $after->getUpdatedAt());
+
+            $database->decreaseDocumentAttribute($this->getIncDecCollection(), $document->getId(), 'decrease', 1);
+
+            $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();
+
+        $documentId = $document->getId();
+
+        /** @var Database $database */
+        $database = $this->getDatabase();
+
+        $document = $database->getDocument($this->getDocumentsCollection(), $documentId, [
+            Query::select(['string', 'integer_signed']),
+        ]);
+
+        $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);
+
+        $document = $database->getDocument($this->getDocumentsCollection(), $documentId, [
+            Query::select(['string', 'integer_signed', '$id']),
+        ]);
 
-    /**
-     * @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());
-        });
+        $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);
     }
 
-    /**
-     * @depends testGetDocument
-     */
-    public function testUpdateDocumentDuplicatePermissions(Document $document): Document
+    public function testFindOne(): 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);
+        $this->initMoviesFixture();
 
-        $this->getDatabase()->updateDocument($new->getCollection(), $new->getId(), $new);
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        $new = $this->getDatabase()->getDocument($new->getCollection(), $new->getId());
+        $document = $database->findOne($this->getMoviesCollection(), [
+            Query::offset(2),
+            Query::orderAsc('name')
+        ]);
 
-        $this->assertContains('guests', $new->getRead());
-        $this->assertContains('guests', $new->getCreate());
+        $this->assertFalse($document->isEmpty());
+        $this->assertEquals('Frozen', $document->getAttribute('name'));
 
-        return $document;
+        $document = $database->findOne($this->getMoviesCollection(), [
+            Query::offset(10)
+        ]);
+        $this->assertTrue($document->isEmpty());
     }
 
-    /**
-     * @depends testUpdateDocument
-     */
-    public function testDeleteDocument(Document $document): void
+    public function testFindBasicChecks(): void
     {
-        $result = $this->getDatabase()->deleteDocument($document->getCollection(), $document->getId());
-        $document = $this->getDatabase()->getDocument($document->getCollection(), $document->getId());
-
-        $this->assertEquals(true, $result);
-        $this->assertEquals(true, $document->isEmpty());
-    }
+        $this->initMoviesFixture();
 
-    public function testUpdateDocuments(): void
-    {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForBatchOperations()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $collection = 'testUpdateDocuments';
-        $this->getDatabase()->getAuthorization()->cleanRoles();
-        $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
-
-        $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);
-
-        for ($i = 0; $i < 10; $i++) {
-            $database->createDocument($collection, new Document([
-                '$id' => 'doc' . $i,
-                'string' => 'text📝 ' . $i,
-                'integer' => $i
-            ]));
-        }
-
-        // 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;
-        });
+        $this->getDatabase()->getAuthorization()->removeRole('user:x');
 
-        $this->assertEquals(5, $count);
+        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 ($doc1, $doc2) {
+                return strcmp($doc1['$id'], $doc2['$id']);
+            });
 
-        foreach ($results as $document) {
-            $this->assertEquals('text📝 updated', $document->getAttribute('string'));
-        }
+            $firstDocumentId = $sortedDocuments[0]->getId();
+            $lastDocumentId = $sortedDocuments[\count($sortedDocuments) - 1]->getId();
 
-        $updatedDocuments = $database->find($collection, [
-            Query::greaterThanEqual('integer', 5),
-        ]);
+            /**
+             * 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->assertCount(5, $updatedDocuments);
+            /**
+             * 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());
 
-        foreach ($updatedDocuments as $document) {
-            $this->assertEquals('text📝 updated', $document->getAttribute('string'));
-            $this->assertGreaterThanOrEqual(5, $document->getAttribute('integer'));
+        } finally {
+            $this->getDatabase()->getAuthorization()->addRole('user:x');
         }
+    }
 
-        $controlDocuments = $database->find($collection, [
-            Query::lessThan('integer', 5),
-        ]);
+    public function testFindCheckPermissions(): void
+    {
+        $this->initMoviesFixture();
 
-        $this->assertEquals(count($controlDocuments), 5);
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        foreach ($controlDocuments as $document) {
-            $this->assertNotEquals('text📝 updated', $document->getAttribute('string'));
-        }
+        /**
+         * Check Permissions
+         */
+        $this->getDatabase()->getAuthorization()->addRole('user:x');
+        $documents = $database->find($this->getMoviesCollection());
 
-        // Test Update all documents
-        $this->assertEquals(10, $database->updateDocuments($collection, new Document([
-            'string' => 'text📝 updated all',
-        ])));
+        $this->assertEquals(6, count($documents));
+    }
 
-        $updatedDocuments = $database->find($collection);
+    public function testFindStringQueryEqual(): void
+    {
+        $this->initMoviesFixture();
 
-        $this->assertEquals(count($updatedDocuments), 10);
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        foreach ($updatedDocuments as $document) {
-            $this->assertEquals('text📝 updated all', $document->getAttribute('string'));
-        }
+        /**
+         * String condition
+         */
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::equal('director', ['TBD']),
+        ]);
 
-        // TEST: Can't delete documents in the past
-        $oneHourAgo = (new \DateTime())->sub(new \DateInterval('PT1H'));
+        $this->assertEquals(2, 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($this->getMoviesCollection(), [
+            Query::equal('director', ['']),
+        ]);
 
-        // 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);
+        $this->assertEquals(0, 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());
-        }
+    public function testFindNotEqual(): void
+    {
+        $this->initMoviesFixture();
 
-        // 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')),
-                ],
-            ]));
-        });
+        /**
+         * Not Equal query
+         */
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::notEqual('director', 'TBD'),
+        ]);
 
-        $this->getDatabase()->getAuthorization()->addRole(Role::user('asd')->toString());
+        $this->assertGreaterThan(0, count($documents));
 
-        $database->updateDocuments($collection, new Document([
-            'string' => 'permission text',
-        ]));
+        foreach ($documents as $document) {
+            $this->assertTrue($document['director'] !== 'TBD');
+        }
 
-        $documents = $database->find($collection, [
-            Query::equal('string', ['permission text']),
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::notEqual('director', ''),
         ]);
 
-        $this->assertCount(1, $documents);
+        $total = $database->count($this->getMoviesCollection());
 
-        $this->getDatabase()->getAuthorization()->skip(function () use ($collection, $database) {
-            $unmodifiedDocuments = $database->find($collection, [
-                Query::equal('string', ['text📝 updated all']),
-            ]);
+        $this->assertEquals($total, count($documents));
+    }
 
-            $this->assertCount(9, $unmodifiedDocuments);
-        });
+    public function testFindBetween(): void
+    {
+        $this->initMoviesFixture();
 
-        $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));
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::between('price', 25.94, 25.99),
+        ]);
+        $this->assertEquals(2, count($documents));
 
-        $documents = $database->find($collection);
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::between('price', 30, 35),
+        ]);
+        $this->assertEquals(0, count($documents));
 
-        foreach ($documents as $document) {
-            $this->assertEquals('batchSize Test', $document->getAttribute('string'));
-        }
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::between('$createdAt', '1975-12-06', '2050-12-06'),
+        ]);
+        $this->assertEquals(6, count($documents));
 
-        $this->getDatabase()->getAuthorization()->cleanRoles();
-        $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
+        $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));
     }
 
-    public function testUpdateDocumentsWithCallbackSupport(): void
+    public function testFindMultipleConditions(): void
     {
+        $this->initMoviesFixture();
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForBatchOperations()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $collection = 'update_callback';
-        $this->getDatabase()->getAuthorization()->cleanRoles();
-        $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
+        /**
+         * Multiple conditions
+         */
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::equal('director', ['TBD']),
+            Query::equal('year', [2026]),
+        ]);
 
-        $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);
+        $this->assertEquals(1, count($documents));
 
-        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());
-        }
+        /**
+         * Multiple conditions and OR values
+         */
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::equal('name', ['Frozen II', 'Captain Marvel']),
+        ]);
 
-        // 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());
-        });
+        $this->assertEquals(2, count($documents));
+        $this->assertEquals('Frozen II', $documents[0]['name']);
+        $this->assertEquals('Captain Marvel', $documents[1]['name']);
+    }
 
-        $this->assertEquals(5, $count);
+    public function testFindOrderBy(): void
+    {
+        $this->initMoviesFixture();
 
-        foreach ($results as $document) {
-            $this->assertEquals('text📝 updated', $document->getAttribute('string'));
-        }
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        $updatedDocuments = $database->find($collection, [
-            Query::greaterThanEqual('integer', 5),
+        /**
+         * ORDER BY
+         */
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(25),
+            Query::offset(0),
+            Query::orderDesc('price'),
+            Query::orderAsc('name')
         ]);
 
-        $this->assertCount(5, $updatedDocuments);
+        $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']);
     }
 
-    /**
-     * @depends testCreateDocument
-     */
-    public function testReadPermissionsSuccess(Document $document): Document
+    public function testFindOrderByNatural(): 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'],
+        /**
+         * 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(false, $document->isEmpty());
+        $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']);
+    }
 
-        $this->getDatabase()->getAuthorization()->cleanRoles();
+    public function testFindOrderByMultipleAttributes(): void
+    {
+        $this->initMoviesFixture();
 
-        $document = $database->getDocument($document->getCollection(), $document->getId());
-        $this->assertEquals(true, $document->isEmpty());
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
+        /**
+         * ORDER BY - Multiple attributes
+         */
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(25),
+            Query::offset(0),
+            Query::orderDesc('price'),
+            Query::orderDesc('name')
+        ]);
 
-        return $document;
+        $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']);
     }
 
-    /**
-     * @depends testCreateDocument
-     */
-    public function testWritePermissionsSuccess(Document $document): void
+    public function testFindOrderByCursorAfter(): 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'],
-        ]));
-    }
+        /**
+         * ORDER BY - After
+         */
+        $movies = $database->find($this->getMoviesCollection(), [
+            Query::limit(25),
+            Query::offset(0),
+        ]);
 
-    /**
-     * @depends testCreateDocument
-     */
-    public function testWritePermissionsUpdateFailure(Document $document): Document
-    {
-        $this->expectException(AuthorizationException::class);
+        $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']);
 
-        $this->getDatabase()->getAuthorization()->cleanRoles();
-        $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
+        $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']);
 
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        $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']);
 
-        $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'],
-        ]));
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::cursorAfter($movies[5])
+        ]);
+        $this->assertEmpty(count($documents));
+
+        /**
+         * Multiple order by, Test tie-break on year 2019
+         */
+        $movies = $database->find($this->getMoviesCollection(), [
+            Query::orderAsc('year'),
+            Query::orderAsc('price'),
+        ]);
+
+        $this->assertEquals(6, count($movies));
+
+        $this->assertEquals($movies[0]['name'], 'Captain America: The First Avenger');
+        $this->assertEquals($movies[0]['year'], 2011);
+        $this->assertEquals($movies[0]['price'], 25.94);
+
+        $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);
+
+        $this->assertEquals($movies[3]['name'], 'Frozen II');
+        $this->assertEquals($movies[3]['year'], 2019);
+        $this->assertEquals($movies[3]['price'], 39.5);
 
-        $this->getDatabase()->getAuthorization()->cleanRoles();
+        $this->assertEquals($movies[4]['name'], 'Work in Progress');
+        $this->assertEquals($movies[4]['year'], 2025);
+        $this->assertEquals($movies[4]['price'], 0);
 
-        $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'],
-        ]));
+        $this->assertEquals($movies[5]['name'], 'Work in Progress 2');
+        $this->assertEquals($movies[5]['year'], 2026);
+        $this->assertEquals($movies[5]['price'], 0);
 
-        return $document;
+        $pos = 2;
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::orderAsc('year'),
+            Query::orderAsc('price'),
+            Query::cursorAfter($movies[$pos])
+        ]);
+
+        $this->assertEquals(3, count($documents));
+
+        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']);
+        }
     }
 
-    /**
-     * @depends testFind
-     */
-    public function testUniqueIndexDuplicate(): void
+    public function testFindOrderByCursorBefore(): void
     {
+        $this->initMoviesFixture();
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $this->assertEquals(true, $database->createIndex('movies', 'uniqueIndex', Database::INDEX_UNIQUE, ['name'], [128], [Database::ORDER_ASC]));
+        /**
+         * ORDER BY - Before
+         */
+        $movies = $database->find($this->getMoviesCollection(), [
+            Query::limit(25),
+            Query::offset(0),
+        ]);
 
-        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'
-            ]));
+        $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->fail('Failed to throw exception');
-        } catch (Throwable $e) {
-            $this->assertInstanceOf(DuplicateException::class, $e);
-        }
+        $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']);
+
+        $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));
     }
 
-    /**
-     * Test that DuplicateException messages differentiate between
-     * document ID duplicates and unique index violations.
-     */
-    public function testDuplicateExceptionMessages(): void
+    public function testFindOrderByAfterNaturalOrder(): void
     {
+        $this->initMoviesFixture();
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForUniqueIndex()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $database->createCollection('duplicateMessages');
-        $database->createAttribute('duplicateMessages', 'email', Database::VAR_STRING, 128, true);
-        $database->createIndex('duplicateMessages', 'emailUnique', Database::INDEX_UNIQUE, ['email'], [128]);
-
-        // Create first document
-        $database->createDocument('duplicateMessages', new Document([
-            '$id' => 'dup_msg_1',
-            '$permissions' => [
-                Permission::read(Role::any()),
-            ],
-            'email' => 'test@example.com',
+        /**
+         * ORDER BY - After by natural order
+         */
+        $movies = array_reverse($database->find($this->getMoviesCollection(), [
+            Query::limit(25),
+            Query::offset(0),
         ]));
 
-        // 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());
-        }
+        $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 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());
-        }
+        $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']);
 
-        $database->deleteCollection('duplicateMessages');
+        $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']);
+
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::orderDesc(''),
+            Query::cursorAfter($movies[5])
+        ]);
+        $this->assertEmpty(count($documents));
     }
-    /**
-     * @depends testUniqueIndexDuplicate
-     */
-    public function testUniqueIndexDuplicateUpdate(): void
+
+    public function testFindOrderByBeforeNaturalOrder(): 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'
-        ]));
+        /**
+         * ORDER BY - Before by natural order
+         */
+        $movies = $database->find($this->getMoviesCollection(), [
+            Query::limit(25),
+            Query::offset(0),
+            Query::orderDesc(''),
+        ]);
+
+        $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']);
+
+        $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']);
+
+        $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']);
 
-        try {
-            $database->updateDocument('movies', $document->getId(), $document->setAttribute('name', 'Frozen'));
+        $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']);
 
-            $this->fail('Failed to throw exception');
-        } catch (Throwable $e) {
-            $this->assertInstanceOf(DuplicateException::class, $e);
-        }
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::orderDesc(''),
+            Query::cursorBefore($movies[0])
+        ]);
+        $this->assertEmpty(count($documents));
     }
 
-    public function propagateBulkDocuments(string $collection, int $amount = 10, bool $documentSecurity = false): void
+    public function testFindOrderBySingleAttributeAfter(): void
     {
-        /** @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()),
-                    ],
-                ] : [])
-            ));
-        }
-    }
+        $this->initMoviesFixture();
 
-    public function testDeleteBulkDocuments(): void
-    {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForBatchOperations()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $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->propagateBulkDocuments('bulk_delete');
-
-        $docs = $database->find('bulk_delete');
-        $this->assertCount(10, $docs);
-
         /**
-         * Test Short select query, test pagination as well, Add order to select
+         * ORDER BY - Single Attribute 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
-        );
-
-        $this->assertEquals(2, $count);
+        $movies = $database->find($this->getMoviesCollection(), [
+            Query::limit(25),
+            Query::offset(0),
+            Query::orderDesc('year')
+        ]);
 
-        // TEST: Bulk Delete All Documents
-        $this->assertEquals(8, $database->deleteDocuments('bulk_delete'));
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::orderDesc('year'),
+            Query::cursorAfter($movies[1])
+        ]);
 
-        $docs = $database->find('bulk_delete');
-        $this->assertCount(0, $docs);
+        $this->assertEquals(2, count($documents));
+        $this->assertEquals($movies[2]['name'], $documents[0]['name']);
+        $this->assertEquals($movies[3]['name'], $documents[1]['name']);
 
-        // TEST: Bulk delete documents with queries.
-        $this->propagateBulkDocuments('bulk_delete');
+        $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']);
 
-        $results = [];
-        $count = $database->deleteDocuments('bulk_delete', [
-            Query::greaterThanEqual('integer', 5)
-        ], onNext: function ($doc) use (&$results) {
-            $results[] = $doc;
-        });
+        $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']);
 
-        $this->assertEquals(5, $count);
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::orderDesc('year'),
+            Query::cursorAfter($movies[5])
+        ]);
+        $this->assertEmpty(count($documents));
+    }
 
-        foreach ($results as $document) {
-            $this->assertGreaterThanOrEqual(5, $document->getAttribute('integer'));
-        }
+    public function testFindOrderBySingleAttributeBefore(): void
+    {
+        $this->initMoviesFixture();
 
-        $docs = $database->find('bulk_delete');
-        $this->assertEquals(5, \count($docs));
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        // TEST (FAIL): Can't delete documents in the past
-        $oneHourAgo = (new \DateTime())->sub(new \DateInterval('PT1H'));
+        /**
+         * ORDER BY - Single Attribute Before
+         */
+        $movies = $database->find($this->getMoviesCollection(), [
+            Query::limit(25),
+            Query::offset(0),
+            Query::orderDesc('year')
+        ]);
 
-        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());
-        }
+        $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 (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) {
-        }
+        $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']);
 
-        $database->updateCollection('bulk_delete', [
-            Permission::create(Role::any()),
-            Permission::read(Role::any()),
-            Permission::delete(Role::any())
-        ], false);
+        $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']);
 
-        $this->assertEquals(5, $database->deleteDocuments('bulk_delete'));
-        $this->assertEquals(0, \count($this->getDatabase()->find('bulk_delete')));
+        $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']);
 
-        // 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);
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::orderDesc('year'),
+            Query::cursorBefore($movies[0])
+        ]);
+        $this->assertEmpty(count($documents));
+    }
 
-        $this->assertEquals(0, $database->deleteDocuments('bulk_delete'));
+    public function testFindOrderByMultipleAttributeAfter(): void
+    {
+        $this->initMoviesFixture();
 
-        $documents = $this->getDatabase()->getAuthorization()->skip(function () use ($database) {
-            return $database->find('bulk_delete');
-        });
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        $this->assertEquals(10, \count($documents));
+        /**
+         * ORDER BY - Multiple Attribute After
+         */
+        $movies = $database->find($this->getMoviesCollection(), [
+            Query::limit(25),
+            Query::offset(0),
+            Query::orderDesc('price'),
+            Query::orderAsc('year')
+        ]);
 
-        $database->updateCollection('bulk_delete', [
-            Permission::create(Role::any()),
-            Permission::read(Role::any()),
-            Permission::delete(Role::any())
-        ], false);
+        $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']);
 
-        $database->deleteDocuments('bulk_delete');
+        $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']);
 
-        $this->assertEquals(0, \count($this->getDatabase()->find('bulk_delete')));
+        $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']);
 
-        // Teardown
-        $database->deleteCollection('bulk_delete');
+        $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 testDeleteBulkDocumentsQueries(): void
+    public function testFindOrderByMultipleAttributeBefore(): void
     {
+        $this->initMoviesFixture();
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForBatchOperations()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $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())
-            ]
-        );
-
-        // 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')));
+        /**
+         * ORDER BY - Multiple Attribute Before
+         */
+        $movies = $database->find($this->getMoviesCollection(), [
+            Query::limit(25),
+            Query::offset(0),
+            Query::orderDesc('price'),
+            Query::orderAsc('year')
+        ]);
 
-        $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('price'),
+            Query::orderAsc('year'),
+            Query::cursorBefore($movies[5])
+        ]);
 
-        // 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'));
+        $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('bulk_delete_queries', 100);
-        $this->assertEquals(50, $database->deleteDocuments('bulk_delete_queries', [Query::offset(50)]));
+        $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']);
 
-        $docs = $database->find('bulk_delete_queries', [Query::limit(100)]);
-        $this->assertEquals(50, \count($docs));
+        $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']);
 
-        $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('price'),
+            Query::orderAsc('year'),
+            Query::cursorBefore($movies[1])
+        ]);
+        $this->assertEquals(1, count($documents));
+        $this->assertEquals($movies[0]['name'], $documents[0]['name']);
 
-        $database->deleteCollection('bulk_delete_queries');
+        $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));
     }
 
-    public function testDeleteBulkDocumentsWithCallbackSupport(): void
+    public function testFindOrderByAndCursor(): void
     {
+        $this->initMoviesFixture();
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForBatchOperations()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $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
-        );
-
-        $this->propagateBulkDocuments('bulk_delete_with_callback');
-
-        $docs = $database->find('bulk_delete_with_callback');
-        $this->assertCount(10, $docs);
-
         /**
-         * Test Short select query, test pagination as well, Add order to select
+         * ORDER BY + CURSOR
          */
-        $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),
-                ],
-                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());
-            }
-        );
+        $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])
+        ]);
 
-        $this->assertEquals(2, $count);
+        $this->assertEquals($documentsTest[1]['$id'], $documents[0]['$id']);
+    }
 
-        // TEST: Bulk Delete All Documents without passing callbacks
-        $this->assertEquals(8, $database->deleteDocuments('bulk_delete_with_callback'));
+    public function testFindOrderByIdAndCursor(): void
+    {
+        $this->initMoviesFixture();
 
-        $docs = $database->find('bulk_delete_with_callback');
-        $this->assertCount(0, $docs);
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        // TEST: Bulk delete documents with queries with callbacks
-        $this->propagateBulkDocuments('bulk_delete_with_callback');
+        /**
+         * 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])
+        ]);
 
-        $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());
-        });
+        $this->assertEquals($documentsTest[1]['$id'], $documents[0]['$id']);
+    }
 
-        $this->assertEquals(5, $count);
+    public function testFindOrderByCreateDateAndCursor(): void
+    {
+        $this->initMoviesFixture();
 
-        foreach ($results as $document) {
-            $this->assertGreaterThanOrEqual(5, $document->getAttribute('integer'));
-        }
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        $docs = $database->find('bulk_delete_with_callback');
-        $this->assertEquals(5, \count($docs));
+        /**
+         * ORDER BY CREATE DATE + CURSOR
+         */
+        $documentsTest = $database->find($this->getMoviesCollection(), [
+            Query::limit(2),
+            Query::offset(0),
+            Query::orderDesc('$createdAt'),
+        ]);
 
-        // Teardown
-        $database->deleteCollection('bulk_delete_with_callback');
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(1),
+            Query::offset(0),
+            Query::orderDesc('$createdAt'),
+            Query::cursorAfter($documentsTest[0])
+        ]);
+
+        $this->assertEquals($documentsTest[1]['$id'], $documents[0]['$id']);
     }
 
-    public function testUpdateDocumentsQueries(): void
+    public function testFindOrderByUpdateDateAndCursor(): void
     {
+        $this->initMoviesFixture();
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForBatchOperations()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $collection = 'testUpdateDocumentsQueries';
+        /**
+         * ORDER BY UPDATE DATE + CURSOR
+         */
+        $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->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);
+        $this->assertEquals($documentsTest[1]['$id'], $documents[0]['$id']);
+    }
 
-        // Test limit
-        $this->propagateBulkDocuments($collection, 100);
+    public function testFindCreatedBefore(): void
+    {
+        $this->initMoviesFixture();
 
-        $this->assertEquals(10, $database->updateDocuments($collection, new Document([
-            'text' => 'text📝 updated',
-        ]), [Query::limit(10)]));
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        $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)));
+        /**
+         * Test Query::createdBefore wrapper
+         */
+        $futureDate = '2050-01-01T00:00:00.000Z';
+        $pastDate = '1900-01-01T00:00:00.000Z';
 
-        // 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::createdBefore($futureDate),
+            Query::limit(1)
+        ]);
 
-        $docs = $database->find($collection, [Query::equal('text', ['text📝 updated']), Query::limit(100)]);
-        $this->assertCount(50, $docs);
+        $this->assertGreaterThan(0, count($documents));
 
-        $lastDoc = end($docs);
-        $this->assertNotEmpty($lastDoc);
-        $this->assertEquals('doc99', $lastDoc->getId());
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::createdBefore($pastDate),
+            Query::limit(1)
+        ]);
 
-        $this->assertEquals(100, $database->deleteDocuments($collection));
+        $this->assertEquals(0, count($documents));
     }
 
-    /**
-     * @depends testCreateDocument
-     */
-    public function testFulltextIndexWithInteger(): void
+    public function testFindCreatedAfter(): 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');
-            }
+        /**
+         * Test Query::createdAfter wrapper
+         */
+        $futureDate = '2050-01-01T00:00:00.000Z';
+        $pastDate = '1900-01-01T00:00:00.000Z';
 
-            $database->createIndex('documents', 'fulltext_integer', Database::INDEX_FULLTEXT, ['string','integer_signed']);
-        } else {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-    }
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::createdAfter($pastDate),
+            Query::limit(1)
+        ]);
 
-    public function testEnableDisableValidation(): void
-    {
-        $database = $this->getDatabase();
+        $this->assertGreaterThan(0, count($documents));
 
-        $database->createCollection('validation', permissions: [
-            Permission::create(Role::any()),
-            Permission::read(Role::any()),
-            Permission::update(Role::any()),
-            Permission::delete(Role::any())
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::createdAfter($futureDate),
+            Query::limit(1)
         ]);
 
-        $database->createAttribute(
-            'validation',
-            'name',
-            Database::VAR_STRING,
-            10,
-            false
-        );
+        $this->assertEquals(0, count($documents));
+    }
 
-        $database->createDocument('validation', new Document([
-            '$id' => 'docwithmorethan36charsasitsidentifier',
-            'name' => 'value1',
-        ]));
+    public function testFindUpdatedBefore(): void
+    {
+        $this->initMoviesFixture();
 
-        try {
-            $database->find('validation', queries: [
-                Query::equal('$id', ['docwithmorethan36charsasitsidentifier']),
-            ]);
-            $this->fail('Failed to throw exception');
-        } catch (Exception $e) {
-            $this->assertInstanceOf(Exception::class, $e);
-        }
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        $database->disableValidation();
+        /**
+         * Test Query::updatedBefore wrapper
+         */
+        $futureDate = '2050-01-01T00:00:00.000Z';
+        $pastDate = '1900-01-01T00:00:00.000Z';
 
-        $database->find('validation', queries: [
-            Query::equal('$id', ['docwithmorethan36charsasitsidentifier']),
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::updatedBefore($futureDate),
+            Query::limit(1)
         ]);
 
-        $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);
-        }
+        $this->assertGreaterThan(0, count($documents));
 
-        $database->skipValidation(function () use ($database) {
-            $database->find('validation', queries: [
-                Query::equal('$id', ['docwithmorethan36charsasitsidentifier']),
-            ]);
-        });
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::updatedBefore($pastDate),
+            Query::limit(1)
+        ]);
 
-        $database->enableValidation();
+        $this->assertEquals(0, count($documents));
     }
 
-    /**
-     * @depends testGetDocument
-     */
-    public function testExceptionDuplicate(Document $document): void
+    public function testFindUpdatedAfter(): void
     {
+        $this->initMoviesFixture();
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $document->setAttribute('$id', 'duplicated');
-        $document->removeAttribute('$sequence');
+        /**
+         * Test Query::updatedAfter wrapper
+         */
+        $futureDate = '2050-01-01T00:00:00.000Z';
+        $pastDate = '1900-01-01T00:00:00.000Z';
 
-        $database->createDocument($document->getCollection(), $document);
-        $document->removeAttribute('$sequence');
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::updatedAfter($pastDate),
+            Query::limit(1)
+        ]);
 
-        try {
-            $database->createDocument($document->getCollection(), $document);
-            $this->fail('Failed to throw exception');
-        } catch (Throwable $e) {
-            $this->assertInstanceOf(DuplicateException::class, $e);
-        }
+        $this->assertGreaterThan(0, count($documents));
+
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::updatedAfter($futureDate),
+            Query::limit(1)
+        ]);
+
+        $this->assertEquals(0, count($documents));
     }
 
-    /**
-     * @depends testGetDocument
-     */
-    public function testExceptionCaseInsensitiveDuplicate(Document $document): Document
+    public function testFindCreatedBetween(): void
     {
+        $this->initMoviesFixture();
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        $document->setAttribute('$id', 'caseSensitive');
-        $document->removeAttribute('$sequence');
+        /**
+         * 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';
 
-        $database->createDocument($document->getCollection(), $document);
+        // All documents should be between past and future
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::createdBetween($pastDate, $futureDate),
+            Query::limit(25)
+        ]);
 
-        $document->setAttribute('$id', 'CaseSensitive');
-        $document->removeAttribute('$sequence');
+        $this->assertGreaterThan(0, count($documents));
 
-        try {
-            $database->createDocument($document->getCollection(), $document);
-            $this->fail('Failed to throw exception');
-        } catch (Throwable $e) {
-            $this->assertInstanceOf(DuplicateException::class, $e);
-        }
+        // No documents should exist in this range
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::createdBetween($pastDate, $pastDate),
+            Query::limit(25)
+        ]);
 
-        return $document;
+        $this->assertEquals(0, count($documents));
+
+        // Documents created between recent past and near future
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::createdBetween($recentPastDate, $nearFutureDate),
+            Query::limit(25)
+        ]);
+
+        $count = count($documents);
+
+        // Same count should be returned with expanded range
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::createdBetween($pastDate, $nearFutureDate),
+            Query::limit(25)
+        ]);
+
+        $this->assertGreaterThanOrEqual($count, count($documents));
     }
 
-    public function testEmptyTenant(): void
+    public function testFindUpdatedBetween(): void
     {
+        $this->initMoviesFixture();
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if ($database->getAdapter()->getSharedTables()) {
-            $documents = $database->find(
-                'documents',
-                [Query::select(['*'])] // Mongo bug with Integer UID
-            );
+        /**
+         * 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';
 
-            $document = $documents[0];
-            $doc = $database->getDocument($document->getCollection(), $document->getId());
-            $this->assertEquals($document->getTenant(), $doc->getTenant());
-            return;
-        }
+        // All documents should be between past and future
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::updatedBetween($pastDate, $futureDate),
+            Query::limit(25)
+        ]);
 
-        $documents = $database->find(
-            'documents',
-            [Query::notEqual('$id', '56000')] // Mongo bug with Integer UID
-        );
+        $this->assertGreaterThan(0, count($documents));
 
-        $document = $documents[0];
-        $this->assertArrayHasKey('$id', $document);
-        $this->assertArrayNotHasKey('$tenant', $document);
+        // No documents should exist in this range
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::updatedBetween($pastDate, $pastDate),
+            Query::limit(25)
+        ]);
 
-        $document = $database->getDocument('documents', $document->getId());
-        $this->assertArrayHasKey('$id', $document);
-        $this->assertArrayNotHasKey('$tenant', $document);
+        $this->assertEquals(0, count($documents));
 
-        $document = $database->updateDocument('documents', $document->getId(), $document);
-        $this->assertArrayHasKey('$id', $document);
-        $this->assertArrayNotHasKey('$tenant', $document);
+        // Documents updated between recent past and near future
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::updatedBetween($recentPastDate, $nearFutureDate),
+            Query::limit(25)
+        ]);
+
+        $count = count($documents);
+
+        // Same count should be returned with expanded range
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::updatedBetween($pastDate, $nearFutureDate),
+            Query::limit(25)
+        ]);
+
+        $this->assertGreaterThanOrEqual($count, count($documents));
     }
 
-    public function testEmptyOperatorValues(): void
+    public function testFindLimit(): 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());
-        }
+        /**
+         * Limit
+         */
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(4),
+            Query::offset(0),
+            Query::orderAsc('name')
+        ]);
 
-        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());
-        }
+        $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']);
     }
 
-    public function testDateTimeDocument(): void
+    public function testFindLimitAndOffset(): void
     {
-        /**
-         * @var Database $database
-         */
-        $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'));
+        $this->initMoviesFixture();
 
-        $doc = $database->getDocument($collection, 'doc1');
-        $this->assertNotEmpty($doc->getAttribute('datetime'));
-        $this->assertNotEmpty($doc->getAttribute('$createdAt'));
-        $this->assertNotEmpty($doc->getAttribute('$updatedAt'));
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        $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
-        ]));
+        /**
+         * Limit + Offset
+         */
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::limit(4),
+            Query::offset(2),
+            Query::orderAsc('name')
+        ]);
 
-        $this->assertEquals($doc->getAttribute('$createdAt'), $date);
-        $this->assertNotEmpty($doc->getAttribute('$updatedAt'));
-        $this->assertNotEquals($doc->getAttribute('$updatedAt'), $date);
+        $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']);
+    }
 
-        $doc = $database->getDocument($collection, 'doc2');
+    public function testFindOrQueries(): void
+    {
+        $this->initMoviesFixture();
 
-        $this->assertEquals($doc->getAttribute('$createdAt'), $date);
-        $this->assertNotEmpty($doc->getAttribute('$updatedAt'));
-        $this->assertNotEquals($doc->getAttribute('$updatedAt'), $date);
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        $database->setPreserveDates(false);
-        $database->deleteCollection($collection);
+        /**
+         * Test that OR queries are handled correctly
+         */
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::equal('director', ['TBD', 'Joe Johnston']),
+            Query::equal('year', [2025]),
+        ]);
+        $this->assertEquals(1, count($documents));
     }
-
-    public function testSingleDocumentDateOperations(): void
+    public function testFindEdgeCases(): void
     {
         /** @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);
-
-        $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
-        ]));
 
-        $this->assertEquals($createDate, $doc->getAttribute('$createdAt'));
-        $this->assertNotEquals($createDate, $doc->getAttribute('$updatedAt'));
-
-        // Update with custom updatedAt
-        $doc->setAttribute('string', 'updated');
-        $doc->setAttribute('$updatedAt', $updateDate);
-        $updatedDoc = $database->updateDocument($collection, 'doc1', $doc);
+        $collection = 'edgeCases';
 
-        $this->assertEquals($createDate, $updatedDoc->getAttribute('$createdAt'));
-        $this->assertEquals($updateDate, $updatedDoc->getAttribute('$updatedAt'));
+        $database->createCollection($collection);
 
-        // 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
-        ]));
+        $this->assertEquals(true, $database->createAttribute($collection, new Attribute(key: 'value', type: ColumnType::String, size: 256, required: true)));
 
-        $this->assertEquals($createDate, $doc2->getAttribute('$createdAt'));
-        $this->assertEquals($updateDate, $doc2->getAttribute('$updatedAt'));
+        $values = [
+            'NormalString',
+            '{"type":"json","somekey":"someval"}',
+            '{NormalStringInBraces}',
+            '"NormalStringInDoubleQuotes"',
+            '{"NormalStringInDoubleQuotesAndBraces"}',
+            "'NormalStringInSingleQuotes'",
+            "{'NormalStringInSingleQuotesAndBraces'}",
+            "SingleQuote'InMiddle",
+            'DoubleQuote"InMiddle',
+            'Slash/InMiddle',
+            'Backslash\InMiddle',
+            'Colon:InMiddle',
+            '"quoted":"colon"'
+        ];
 
-        // 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'
-        ]));
+        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
+            ]));
+        }
 
+        /**
+         * Check Basic
+         */
+        $documents = $database->find($collection);
 
-        $doc3->setAttribute('string', 'updated_no_dates');
-        $doc3->setAttribute('$createdAt', $createDate);
-        $doc3->setAttribute('$updatedAt', $updateDate);
-        $updatedDoc3 = $database->updateDocument($collection, 'doc3', $doc3);
+        $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'));
 
-        $this->assertEquals($createDate, $updatedDoc3->getAttribute('$createdAt'));
-        $this->assertEquals($updateDate, $updatedDoc3->getAttribute('$updatedAt'));
+        /**
+         * Check `equals` query
+         */
+        foreach ($values as $value) {
+            $documents = $database->find($collection, [
+                Query::limit(25),
+                Query::equal('value', [$value])
+            ]);
 
-        // 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(1, count($documents));
+            $this->assertEquals($value, $documents[0]->getAttribute('value'));
+        }
+    }
 
-        $originalCreatedAt4 = $doc4->getAttribute('$createdAt');
-        $originalUpdatedAt4 = $doc4->getAttribute('$updatedAt');
+    public function testNestedIDQueries(): void
+    {
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        sleep(1); // Ensure $updatedAt differs when adapter timestamp precision is seconds
+        $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
 
-        $doc4->setAttribute('$updatedAt', null);
-        $doc4->setAttribute('$createdAt', null);
-        $updatedDoc4 = $database->updateDocument($collection, 'doc4', document: $doc4);
+        $database->createCollection('movies_nested_id', permissions: [
+            Permission::create(Role::any()),
+            Permission::update(Role::users())
+        ]);
 
-        $this->assertEquals($originalCreatedAt4, $updatedDoc4->getAttribute('$createdAt'));
-        $this->assertNotEquals($originalUpdatedAt4, $updatedDoc4->getAttribute('$updatedAt'));
+        $this->assertEquals(true, $database->createAttribute('movies_nested_id', new Attribute(key: 'name', type: ColumnType::String, size: 128, required: true)));
 
-        // Test 5: Update only updatedAt
-        $updatedDoc4->setAttribute('$updatedAt', $updateDate);
-        $updatedDoc4->setAttribute('$createdAt', $createDate);
-        $finalDoc4 = $database->updateDocument($collection, 'doc4', $updatedDoc4);
+        $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',
+        ]));
 
-        $this->assertEquals($createDate, $finalDoc4->getAttribute('$createdAt'));
-        $this->assertEquals($updateDate, $finalDoc4->getAttribute('$updatedAt'));
+        $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',
+        ]));
 
-        // 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
+        $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',
         ]));
 
-        $this->assertNotEquals($date2, $doc5->getAttribute('$createdAt'));
-        $this->assertEquals($date2, $doc5->getAttribute('$updatedAt'));
+        $queries = [
+            Query::or([
+                Query::equal('$id', ["1"]),
+                Query::equal('$id', ["2"])
+            ])
+        ];
 
-        $doc5->setAttribute('string', 'doc5_updated');
-        $doc5->setAttribute('$createdAt', $date1);
-        $updatedDoc5 = $database->updateDocument($collection, 'doc5', $doc5);
+        $documents = $database->find('movies_nested_id', $queries);
+        $this->assertCount(2, $documents);
 
-        $this->assertEquals($date1, $updatedDoc5->getAttribute('$createdAt'));
-        $this->assertEquals($date2, $updatedDoc5->getAttribute('$updatedAt'));
+        // Make sure the query was not modified by reference
+        $this->assertEquals($queries[0]->getValues()[0]->getAttribute(), '$id');
 
-        // 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
-        ]));
+        $count = $database->count('movies_nested_id', $queries);
+        $this->assertEquals(2, $count);
+    }
 
-        $this->assertEquals($date1, $doc6->getAttribute('$createdAt'));
-        $this->assertEquals($date2, $doc6->getAttribute('$updatedAt'));
+    public function testFindNotBetween(): 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 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
 
-        // Test 8: Preserve dates disabled
-        $database->setPreserveDates(false);
+        // 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));
 
-        $customDate = '2000-01-01T10:00:00.000+00:00';
+        // 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
 
-        $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
-        ]));
+        // 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
 
-        $this->assertNotEquals($customDate, $doc7->getAttribute('$createdAt'));
-        $this->assertNotEquals($customDate, $doc7->getAttribute('$updatedAt'));
+        // 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
 
-        // 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);
+        // 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
 
-        $this->assertNotEquals($customDate, $updatedDoc7->getAttribute('$createdAt'));
-        $this->assertNotEquals($customDate, $updatedDoc7->getAttribute('$updatedAt'));
+        // 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
 
-        // 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
-        ]));
+        // 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
 
-        $newUpdatedAt = $doc11->getUpdatedAt();
+        // 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
 
-        $newDoc11 = new Document([
-            'string' => 'no_dates_update',
+        // Test notBetween with extreme ranges
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::notBetween('year', -1000, 1000), // Very wide range
         ]);
-        $updatedDoc7 = $database->updateDocument($collection, 'doc11', $newDoc11);
-        $this->assertNotEquals($newUpdatedAt, $updatedDoc7->getAttribute('$updatedAt'));
+        $this->assertLessThanOrEqual(6, count($documents)); // Movies outside this range
 
-        $database->setPreserveDates(false);
-        $database->deleteCollection($collection);
+        // 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
     }
 
-    public function testBulkDocumentDateOperations(): void
+    public function testFindSelect(): 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);
-
-        $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())];
-
-        // 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
-            ])
-        ];
 
-        $database->createDocuments($collection, $documents);
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::select(['name', 'year'])
+        ]);
 
-        // Verify initial state
-        foreach (['doc1', 'doc3'] as $id) {
-            $doc = $database->getDocument($collection, $id);
-            $this->assertEquals($createDate, $doc->getAttribute('$createdAt'), "createdAt 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);
         }
 
-        foreach (['doc2', 'doc3'] as $id) {
-            $doc = $database->getDocument($collection, $id);
-            $this->assertEquals($updateDate, $doc->getAttribute('$updatedAt'), "updatedAt mismatch for $id");
-        }
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::select(['name', 'year', '$id'])
+        ]);
 
-        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");
+        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 2: Bulk update with custom dates
-        $updateDoc = new Document([
-            'string' => 'updated',
-            '$createdAt' => $createDate,
-            '$updatedAt' => $updateDate
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::select(['name', 'year', '$sequence'])
         ]);
-        $ids = [];
-        foreach ($documents as $doc) {
-            $ids[] = $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);
         }
-        $count = $database->updateDocuments($collection, $updateDoc, [
-            Query::equal('$id', $ids)
+
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::select(['name', 'year', '$collection'])
         ]);
-        $this->assertEquals(6, $count);
 
-        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");
+        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);
         }
 
-        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");
-        }
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::select(['name', 'year', '$createdAt'])
+        ]);
 
-        // Test 3: Bulk update with preserve dates disabled
-        $database->setPreserveDates(false);
+        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);
+        }
 
-        $customDate = 'should be ignored anyways so no error';
-        $updateDocDisabled = new Document([
-            'string' => 'disabled_update',
-            '$createdAt' => $customDate,
-            '$updatedAt' => $customDate
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::select(['name', 'year', '$updatedAt'])
         ]);
 
-        $countDisabled = $database->updateDocuments($collection, $updateDocDisabled);
-        $this->assertEquals(6, $countDisabled);
-
-        // Test 4: Bulk update with preserve dates re-enabled
-        $database->setPreserveDates(true);
+        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);
+        }
 
-        $newDate = '2000-03-01T20:45:00.000+00:00';
-        $updateDocEnabled = new Document([
-            'string' => 'enabled_update',
-            '$createdAt' => $newDate,
-            '$updatedAt' => $newDate
+        $documents = $database->find($this->getMoviesCollection(), [
+            Query::select(['name', 'year', '$permissions'])
         ]);
 
-        $countEnabled = $database->updateDocuments($collection, $updateDocEnabled);
-        $this->assertEquals(6, $countEnabled);
-
-        $database->setPreserveDates(false);
-        $database->deleteCollection($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);
+        }
     }
 
-    public function testUpsertDateOperations(): 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('moviesEmpty');
+        $documents = [];
+        foreach ($database->iterate('moviesEmpty', queries: [Query::limit(2)]) as $document) {
+            $documents[] = $document;
         }
+        $this->assertEquals(0, \count($documents));
+        $this->assertTrue($database->deleteCollection('moviesEmpty'));
 
-        $collection = 'upsert_date_operations';
-        $database->createCollection($collection);
-        $this->assertEquals(true, $database->createAttribute($collection, 'string', Database::VAR_STRING, 128, false));
-
-        $database->setPreserveDates(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())];
-
-        // 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];
-
-        $this->assertEquals($createDate, $updatedUpsertDoc1->getAttribute('$createdAt'));
-        $this->assertEquals($updateDate, $updatedUpsertDoc1->getAttribute('$updatedAt'));
+        /**
+         * Test, foreach generator
+         */
+        $documents = [];
+        foreach ($database->iterate($this->getMoviesCollection(), queries: [Query::limit(2)]) as $document) {
+            $documents[] = $document;
+        }
+        $this->assertEquals(6, count($documents));
 
-        // 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;
+        /**
+         * Test, foreach goes through all the documents
+         */
+        $documents = [];
+        $database->foreach($this->getMoviesCollection(), queries: [Query::limit(2)], callback: function ($document) use (&$documents) {
+            $documents[] = $document;
         });
-        $upsertDoc2 = $upsertResults2[0];
+        $this->assertEquals(6, count($documents));
 
-        $this->assertEquals($createDate, $upsertDoc2->getAttribute('$createdAt'));
-        $this->assertEquals($updateDate, $upsertDoc2->getAttribute('$updatedAt'));
+        /**
+         * Test, foreach with initial cursor
+         */
 
-        // 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;
+        $first = $documents[0];
+        $documents = [];
+        $database->foreach($this->getMoviesCollection(), queries: [Query::limit(2), Query::cursorAfter($first)], callback: function ($document) use (&$documents) {
+            $documents[] = $document;
         });
-        $updatedUpsertDoc2 = $updatedUpsertResults2[0];
-
-        $this->assertEquals($date3, $updatedUpsertDoc2->getAttribute('$createdAt'));
-        $this->assertEquals($date3, $updatedUpsertDoc2->getAttribute('$updatedAt'));
+        $this->assertEquals(5, count($documents));
 
-        // Test 5: Upsert with preserve dates disabled
-        $database->setPreserveDates(false);
+        /**
+         * Test, foreach with initial offset
+         */
 
-        $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;
+        $documents = [];
+        $database->foreach($this->getMoviesCollection(), queries: [Query::limit(2), Query::offset(2)], callback: function ($document) use (&$documents) {
+            $documents[] = $document;
         });
-        $upsertDoc3 = $upsertResults3[0];
+        $this->assertEquals(4, count($documents));
 
-        $this->assertNotEquals($customDate, $upsertDoc3->getAttribute('$createdAt'));
-        $this->assertNotEquals($customDate, $upsertDoc3->getAttribute('$updatedAt'));
+        /**
+         * 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;
+            });
 
-        // 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];
+        } catch (Throwable $e) {
+            $this->assertInstanceOf(DatabaseException::class, $e);
+            $this->assertEquals('Cursor ' . CursorDirection::Before->value . ' not supported in this method.', $e->getMessage());
+        }
 
-        $this->assertNotEquals($customDate, $updatedUpsertDoc3->getAttribute('$createdAt'));
-        $this->assertNotEquals($customDate, $updatedUpsertDoc3->getAttribute('$updatedAt'));
+    }
+    public function testCount(): void
+    {
+        $this->initMoviesFixture();
 
-        // Test 6: Bulk upsert operations with custom dates
-        $database->setPreserveDates(true);
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        // 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'
-            ])
-        ];
+        $count = $database->count($this->getMoviesCollection());
+        $this->assertEquals(6, $count);
+        $count = $database->count($this->getMoviesCollection(), [Query::equal('year', [2019])]);
 
-        $bulkUpsertResults = [];
-        $database->upsertDocuments($collection, $upsertDocuments, onNext: function ($doc) use (&$bulkUpsertResults) {
-            $bulkUpsertResults[] = $doc;
-        });
+        $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);
 
-        // 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");
-        }
+        $this->getDatabase()->getAuthorization()->removeRole('user:x');
+        $count = $database->count($this->getMoviesCollection());
+        $this->assertEquals(5, $count);
+        $this->getDatabase()->getAuthorization()->addRole('user:x');
 
-        foreach (['bulk_upsert2', 'bulk_upsert3'] as $id) {
-            $doc = $database->getDocument($collection, $id);
-            $this->assertEquals($updateDate, $doc->getAttribute('$updatedAt'), "updatedAt mismatch for $id");
-        }
+        $this->getDatabase()->getAuthorization()->disable();
+        $count = $database->count($this->getMoviesCollection());
+        $this->assertEquals(6, $count);
+        $this->getDatabase()->getAuthorization()->reset();
 
-        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");
-        }
+        $this->getDatabase()->getAuthorization()->disable();
+        $count = $database->count($this->getMoviesCollection(), [], 3);
+        $this->assertEquals(3, $count);
+        $this->getDatabase()->getAuthorization()->reset();
 
-        // 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 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]),
         ]);
+        $this->assertEquals(1, $count);
+        $this->getDatabase()->getAuthorization()->reset();
+    }
 
-        $upsertIds = [];
-        foreach ($upsertDocuments as $doc) {
-            $upsertIds[] = $doc->getId();
-        }
+    public function testEncodeDecode(): void
+    {
+        $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],
+                ]
+            ],
+        ]);
 
-        $database->updateDocuments($collection, $updateUpsertDoc, [
-            Query::equal('$id', $upsertIds)
+        $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'],
+            ],
         ]);
 
-        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");
-        }
-
-        // 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();
 
-        $upsertIds = [];
-        foreach ($upsertDocuments as $doc) {
-            $upsertIds[] = $doc->getId();
-        }
+        $result = $database->encode($collection, $document);
 
-        $database->updateDocuments($collection, $updateUpsertDoc, [
-            Query::equal('$id', $upsertIds)
-        ]);
+        $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'));
 
-        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");
-        }
+        $result = $database->decode($collection, $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;
-        }
+        $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'));
+    }
+    public function testUpdateDocumentConflict(): void
+    {
+        $document = $this->initDocumentsFixture();
 
-        $upsertUpdateResults = [];
-        $countUpsertUpdate = $database->upsertDocuments($collection, $upsertUpdateDocuments, onNext: function ($doc) use (&$upsertUpdateResults) {
-            $upsertUpdateResults[] = $doc;
+        $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(4, $countUpsertUpdate);
-
-        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");
-        }
-
-        // Test 12: Bulk upsert with preserve dates disabled
-        $database->setPreserveDates(false);
+        $this->assertEquals(7, $result->getAttribute('integer_signed'));
 
-        $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;
+        $oneHourAgo = (new \DateTime())->sub(new \DateInterval('PT1H'));
+        $document->setAttribute('integer_signed', 8);
+        try {
+            $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->assertTrue($e instanceof ConflictException);
+            $this->assertEquals('Document was updated after the request timestamp', $e->getMessage());
         }
+    }
+    public function testDeleteDocumentConflict(): void
+    {
+        $document = $this->initDocumentsFixture();
 
-        $upsertDisabledResults = [];
-        $countUpsertDisabled = $database->upsertDocuments($collection, $upsertDisabledDocuments, onNext: function ($doc) use (&$upsertDisabledResults) {
-            $upsertDisabledResults[] = $doc;
+        $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());
         });
-        $this->assertEquals(4, $countUpsertDisabled);
-
-        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");
-        }
-
-        $database->setPreserveDates(false);
-        $database->deleteCollection($collection);
     }
-
-    public function testUpdateDocumentsCount(): void
+    public function testUpdateDocumentDuplicatePermissions(): void
     {
-        /** @var Database $database */
-        $database = $this->getDatabase();
-
-        if (!$database->getAdapter()->getSupportForUpserts()) {
-            $this->expectNotToPerformAssertions();
-            return;
-        }
-
-        $collectionName = "update_count";
-        $database->createCollection($collectionName);
-
-        $database->createAttribute($collectionName, 'key', Database::VAR_STRING, 60, false);
-        $database->createAttribute($collectionName, 'value', Database::VAR_STRING, 60, false);
+        $document = $this->initDocumentsFixture();
 
-        $permissions = [Permission::read(Role::any()), Permission::write(Role::any()),Permission::update(Role::any())];
+        $new = $this->getDatabase()->updateDocument($document->getCollection(), $document->getId(), $document);
 
-        $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);
+        $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);
 
-        $updates = new Document(['value' => 'test']);
-        $newDocs = [];
-        $count = $database->updateDocuments($collectionName, $updates, onNext:function ($doc) use (&$newDocs) {
-            $newDocs[] = $doc;
-        });
+        $this->getDatabase()->updateDocument($new->getCollection(), $new->getId(), $new);
 
-        $this->assertCount(4, $newDocs);
-        $this->assertEquals(4, $count);
+        $new = $this->getDatabase()->getDocument($new->getCollection(), $new->getId());
 
-        $database->deleteCollection($collectionName);
+        $this->assertContains('guests', $new->getRead());
+        $this->assertContains('guests', $new->getCreate());
     }
 
-    public function testCreateUpdateDocumentsMismatch(): void
+    /**
+     * Test that DuplicateException messages differentiate between
+     * document ID duplicates and unique index violations.
+     */
+    public function testDuplicateExceptionMessages(): void
     {
         /** @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());
+        if (!$database->getAdapter()->supports(Capability::UniqueIndex)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
 
-        $database->createDocument($colName, new Document([
-            '$id' => 'doc4',
-            '$permissions' => $permissions,
-            'key' => 'doc4'
+        $database->createCollection('duplicateMessages');
+        $database->createAttribute('duplicateMessages', new Attribute(key: 'email', type: ColumnType::String, size: 128, required: true));
+        $database->createIndex('duplicateMessages', new Index(key: 'emailUnique', type: IndexType::Unique, attributes: ['email'], lengths: [128]));
+
+        // Create first document
+        $database->createDocument('duplicateMessages', new Document([
+            '$id' => 'dup_msg_1',
+            '$permissions' => [
+                Permission::read(Role::any()),
+            ],
+            'email' => 'test@example.com',
         ]));
 
-        $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'));
+        // 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());
+        }
 
-        $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'));
+        // 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($colName);
+
+        $database->deleteCollection('duplicateMessages');
     }
 
-    public function testBypassStructureWithSupportForAttributes(): void
+    public function testDeleteBulkDocuments(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
-        // for schemaless the validation will be automatically skipped
-        if (!$database->getAdapter()->getSupportForAttributes()) {
+        $database = $this->getDatabase();
+
+        if (!$database->getAdapter()->supports(Capability::BatchOperations)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-        $collectionId = 'successive_update_single';
+        $database->createCollection(
+            'bulk_delete',
+            attributes: [
+                new Document([
+                    '$id' => 'text',
+                    'type' => ColumnType::String,
+                    'size' => 100,
+                    'required' => true,
+                ]),
+                new Document([
+                    '$id' => 'integer',
+                    'type' => ColumnType::Integer,
+                    'size' => 10,
+                    'required' => true,
+                ])
+            ],
+            permissions: [
+                Permission::create(Role::any()),
+                Permission::read(Role::any()),
+                Permission::delete(Role::any())
+            ],
+            documentSecurity: false
+        );
 
-        $database->createCollection($collectionId);
-        $database->createAttribute($collectionId, 'attrA', Database::VAR_STRING, 50, true);
-        $database->createAttribute($collectionId, 'attrB', Database::VAR_STRING, 50, true);
+        $this->propagateBulkDocuments('bulk_delete');
 
-        // bypass required
-        $database->disableValidation();
+        $docs = $database->find('bulk_delete');
+        $this->assertCount(10, $docs);
 
-        $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 Short select query, test pagination as well, Add order to select
+         */
+        $selects = ['$sequence', '$id', '$collection', '$permissions', '$updatedAt'];
 
-        $docs = $database->find($collectionId);
-        foreach ($docs as $doc) {
-            $this->assertArrayHasKey('attrA', $doc->getAttributes());
-            $this->assertNull($doc->getAttribute('attrA'));
-            $this->assertEquals('B', $doc->getAttribute('attrB'));
+        $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(2, $count);
+
+        // TEST: Bulk Delete All Documents
+        $this->assertEquals(8, $database->deleteDocuments('bulk_delete'));
+
+        $docs = $database->find('bulk_delete');
+        $this->assertCount(0, $docs);
+
+        // TEST: Bulk delete documents with queries.
+        $this->propagateBulkDocuments('bulk_delete');
+
+        $results = [];
+        $count = $database->deleteDocuments('bulk_delete', [
+            Query::greaterThanEqual('integer', 5)
+        ], onNext: function ($doc) use (&$results) {
+            $results[] = $doc;
+        });
+
+        $this->assertEquals(5, $count);
+
+        foreach ($results as $document) {
+            $this->assertGreaterThanOrEqual(5, $document->getAttribute('integer'));
         }
-        // reset
-        $database->enableValidation();
+
+        $docs = $database->find('bulk_delete');
+        $this->assertEquals(5, \count($docs));
+
+        // TEST (FAIL): Can't delete documents in the past
+        $oneHourAgo = (new \DateTime())->sub(new \DateInterval('PT1H'));
 
         try {
-            $database->createDocuments($collectionId, [
-                new Document(['attrA' => null,'attrB' => 'B','$permissions' => $permissions])
-            ]);
+            $this->getDatabase()->withRequestTimestamp($oneHourAgo, function () {
+                return $this->getDatabase()->deleteDocuments('bulk_delete');
+            });
             $this->fail('Failed to throw exception');
-        } catch (Exception $e) {
-            $this->assertInstanceOf(StructureException::class, $e);
+        } catch (ConflictException $e) {
+            $this->assertEquals('Document was updated after the request timestamp', $e->getMessage());
         }
 
-        $database->deleteCollection($collectionId);
-    }
-
-    public function testValidationGuardsWithNullRequired(): void
-    {
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        if (!$database->getAdapter()->getSupportForAttributes()) {
-            $this->expectNotToPerformAssertions();
-            return;
+        // 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) {
         }
 
-        // Base collection and attributes
-        $collection = 'validation_guard_all';
-        $database->createCollection($collection, permissions: [
+        $database->updateCollection('bulk_delete', [
+            Permission::create(Role::any()),
             Permission::read(Role::any()),
+            Permission::delete(Role::any())
+        ], false);
+
+        $this->assertEquals(5, $database->deleteDocuments('bulk_delete'));
+        $this->assertEquals(0, \count($this->getDatabase()->find('bulk_delete')));
+
+        // TEST: Make sure we can't delete documents we don't have permissions for
+        $database->updateCollection('bulk_delete', [
             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);
+        ], true);
+        $this->propagateBulkDocuments('bulk_delete', documentSecurity: true);
 
-        // 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);
-        }
+        $this->assertEquals(0, $database->deleteDocuments('bulk_delete'));
 
-        $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();
+        $documents = $this->getDatabase()->getAuthorization()->skip(function () use ($database) {
+            return $database->find('bulk_delete');
+        });
 
-        // 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());
+        $this->assertEquals(10, \count($documents));
 
-        // 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->updateCollection('bulk_delete', [
+            Permission::create(Role::any()),
+            Permission::read(Role::any()),
+            Permission::delete(Role::any())
+        ], false);
 
-        $database->disableValidation();
-        $updated = $database->updateDocument($collection, 'valid', new Document([
-            'age' => null,
-        ]));
-        $this->assertNull($updated->getAttribute('age'));
-        $database->enableValidation();
+        $database->deleteDocuments('bulk_delete');
 
-        // 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,
-            ]));
+        $this->assertEquals(0, \count($this->getDatabase()->find('bulk_delete')));
+
+        // Teardown
+        $database->deleteCollection('bulk_delete');
+    }
+
+    public function testDeleteBulkDocumentsQueries(): void
+    {
+        /** @var Database $database */
+        $database = $this->getDatabase();
+
+        if (!$database->getAdapter()->supports(Capability::BatchOperations)) {
+            $this->expectNotToPerformAssertions();
+            return;
         }
 
-        // 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);
-            }
+        $database->createCollection(
+            'bulk_delete_queries',
+            attributes: [
+                new Document([
+                    '$id' => 'text',
+                    'type' => ColumnType::String,
+                    'size' => 100,
+                    'required' => true,
+                ]),
+                new Document([
+                    '$id' => 'integer',
+                    'type' => ColumnType::Integer,
+                    'size' => 10,
+                    'required' => true,
+                ])
+            ],
+            documentSecurity: false,
+            permissions: [
+                Permission::create(Role::any()),
+                Permission::read(Role::any()),
+                Permission::delete(Role::any())
+            ]
+        );
+
+        // 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')));
 
-            $database->disableValidation();
-            $count = $database->updateDocuments($collection, new Document([
-                'name' => null,
-            ]));
-            $this->assertGreaterThanOrEqual(3, $count); // at least the seeded docs are updated
-            $database->enableValidation();
-        }
+        // 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'));
 
-        // 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);
-            }
+        // Test Offset
+        $this->propagateBulkDocuments('bulk_delete_queries', 100);
+        $this->assertEquals(50, $database->deleteDocuments('bulk_delete_queries', [Query::offset(50)]));
 
-            $database->disableValidation();
-            $ucount = $database->upsertDocumentsWithIncrease(
-                collection: $collection,
-                attribute: 'value',
-                documents: [new Document([
-                    '$id' => 'u1',
-                    'name' => null,
-                    'value' => 1,
-                ])]
-            );
-            $this->assertEquals(1, $ucount);
-            $database->enableValidation();
-        }
+        $docs = $database->find('bulk_delete_queries', [Query::limit(100)]);
+        $this->assertEquals(50, \count($docs));
 
-        // Cleanup
-        $database->deleteCollection($collection);
+        $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 testUpsertWithJSONFilters(): void
+    public function testDeleteBulkDocumentsWithCallbackSupport(): 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()),
-            Permission::create(Role::any()),
-            Permission::update(Role::any()),
-            Permission::delete(Role::any()),
-        ]);
+        $database->createCollection(
+            'bulk_delete_with_callback',
+            attributes: [
+                new Document([
+                    '$id' => 'text',
+                    'type' => ColumnType::String,
+                    'size' => 100,
+                    'required' => true,
+                ]),
+                new Document([
+                    '$id' => 'integer',
+                    'type' => ColumnType::Integer,
+                    'size' => 10,
+                    'required' => true,
+                ])
+            ],
+            permissions: [
+                Permission::create(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_with_callback');
 
-        $permissions = [
-            Permission::read(Role::any()),
-            Permission::create(Role::any()),
-            Permission::update(Role::any()),
-            Permission::delete(Role::any()),
-        ];
+        $docs = $database->find('bulk_delete_with_callback');
+        $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,
-        ]));
+        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());
+        }
 
-        $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']);
+        $docs = $database->find('bulk_delete_with_callback');
+        $this->assertCount(10, $docs);
 
-        // Test 2: Update (updateDocument) with modified JSON filter
-        $updatedMetadata = [
-            'version' => '2.0.0',
-            'tags' => ['php', 'database', 'json'],
-            'config' => [
-                'debug' => true,
-                'timeout' => 60,
-                'cache' => true
+        $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),
             ],
-            'updated' => true
-        ];
+            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());
+            }
+        );
 
-        $document1->setAttribute('name', 'Updated Document');
-        $document1->setAttribute('metadata', $updatedMetadata);
+        $this->assertEquals(2, $count);
 
-        $updatedDoc = $database->updateDocument($collection, $docId1, $document1);
+        // TEST: Bulk Delete All Documents without passing callbacks
+        $this->assertEquals(8, $database->deleteDocuments('bulk_delete_with_callback'));
 
-        $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']);
+        $docs = $database->find('bulk_delete_with_callback');
+        $this->assertCount(0, $docs);
 
-        // Test 3: Upsert - Create new document (upsertDocument)
-        $docId2 = 'json-doc-2';
-        $newMetadata = [
-            'version' => '1.5.0',
-            'tags' => ['javascript', 'node'],
-            'config' => [
-                'debug' => false,
-                'timeout' => 45
-            ]
-        ];
+        // TEST: Bulk delete documents with queries with callbacks
+        $this->propagateBulkDocuments('bulk_delete_with_callback');
 
-        $document2 = new Document([
-            '$id' => $docId2,
-            'name' => 'New Upsert Document',
-            'metadata' => $newMetadata,
-            '$permissions' => $permissions,
-        ]);
+        $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());
+        });
 
-        $upsertedDoc = $database->upsertDocument($collection, $document2);
+        $this->assertEquals(5, $count);
 
-        $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']);
+        foreach ($results as $document) {
+            $this->assertGreaterThanOrEqual(5, $document->getAttribute('integer'));
+        }
 
-        // 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
-        ]);
+        $docs = $database->find('bulk_delete_with_callback');
+        $this->assertEquals(5, \count($docs));
 
-        $upsertedDoc2 = $database->upsertDocument($collection, $document2);
+        // Teardown
+        $database->deleteCollection('bulk_delete_with_callback');
+    }
 
-        $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']);
+    public function testUpdateDocumentsQueries(): void
+    {
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        // Test 5: Upsert - Bulk upsertDocuments (create and update)
-        $docId3 = 'json-doc-3';
-        $docId4 = 'json-doc-4';
+        if (!$database->getAdapter()->supports(Capability::BatchOperations)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
 
-        $bulkDocuments = [
-            new Document([
-                '$id' => $docId3,
-                'name' => 'Bulk Upsert 1',
-                'metadata' => [
-                    'version' => '3.0.0',
-                    'tags' => ['python', 'flask'],
-                    'config' => ['debug' => false]
-                ],
-                '$permissions' => $permissions,
-            ]),
+        $collection = 'testUpdateDocumentsQueries';
+
+        $database->createCollection($collection, attributes: [
             new Document([
-                '$id' => $docId4,
-                'name' => 'Bulk Upsert 2',
-                'metadata' => [
-                    'version' => '3.1.0',
-                    'tags' => ['go', 'golang'],
-                    'config' => ['debug' => true]
-                ],
-                '$permissions' => $permissions,
+                '$id' => ID::custom('text'),
+                'type' => ColumnType::String,
+                'size' => 64,
+                'required' => true,
             ]),
-            // 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,
+                '$id' => ID::custom('integer'),
+                'type' => ColumnType::Integer,
+                'size' => 64,
+                'required' => true,
             ]),
-        ];
+        ], permissions: [
+            Permission::read(Role::any()),
+            Permission::create(Role::any()),
+            Permission::update(Role::any()),
+            Permission::delete(Role::any())
+        ], documentSecurity: true);
 
-        $count = $database->upsertDocuments($collection, $bulkDocuments);
-        $this->assertEquals(3, $count);
+        // Test limit
+        $this->propagateBulkDocuments($collection, 100);
 
-        // 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']);
+        $this->assertEquals(10, $database->updateDocuments($collection, new Document([
+            'text' => 'text📝 updated',
+        ]), [Query::limit(10)]));
 
-        $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($database->find($collection, [Query::equal('text', ['text📝 updated'])])));
+        $this->assertEquals(100, $database->deleteDocuments($collection));
+        $this->assertEquals(0, \count($database->find($collection)));
 
-        $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']);
+        // Test Offset
+        $this->propagateBulkDocuments($collection, 100);
+        $this->assertEquals(50, $database->updateDocuments($collection, new Document([
+            'text' => 'text📝 updated',
+        ]), [
+            Query::offset(50),
+        ]));
 
-        // Cleanup
-        $database->deleteCollection($collection);
+        $docs = $database->find($collection, [Query::equal('text', ['text📝 updated']), Query::limit(100)]);
+        $this->assertCount(50, $docs);
+
+        $lastDoc = end($docs);
+        $this->assertNotEmpty($lastDoc);
+        $this->assertEquals('doc99', $lastDoc->getId());
+
+        $this->assertEquals(100, $database->deleteDocuments($collection));
     }
 
-    public function testFindRegex(): void
+    public function testEmptyOperatorValues(): void
     {
         /** @var Database $database */
-        $database = static::getDatabase();
+        $database = $this->getDatabase();
 
-        // Skip test if regex is not supported
-        if (!$database->getAdapter()->getSupportForRegex()) {
-            $this->expectNotToPerformAssertions();
-            return;
+        try {
+            $database->findOne($this->getDocumentsCollection(), [
+                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());
         }
 
-        // Determine regex support type
-        $supportsPCRE = $database->getAdapter()->getSupportForPCRERegex();
-        $supportsPOSIX = $database->getAdapter()->getSupportForPOSIXRegex();
-
-        // 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
+        try {
+            $database->findOne($this->getDocumentsCollection(), [
+                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());
         }
+    }
 
-        $database->createCollection('moviesRegex', permissions: [
-            Permission::create(Role::any()),
-            Permission::read(Role::any()),
-            Permission::update(Role::any()),
-            Permission::delete(Role::any()),
-        ]);
+    public function testSingleDocumentDateOperations(): void
+    {
+        /** @var Database $database */
+        $database = $this->getDatabase();
+        $collection = 'normal_date_operations';
+        $database->createCollection($collection);
+        $this->assertEquals(true, $database->createAttribute($collection, new Attribute(key: 'string', type: ColumnType::String, size: 128, required: 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));
-        }
+        $database->setPreserveDates(true);
 
-        if ($database->getAdapter()->getSupportForTrigramIndex()) {
-            $database->createIndex('moviesRegex', 'trigram_name', Database::INDEX_TRIGRAM, ['name']);
-            $database->createIndex('moviesRegex', 'trigram_director', Database::INDEX_TRIGRAM, ['director']);
-        }
+        $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
+        ]));
 
-        // 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($createDate, $doc->getAttribute('$createdAt'));
+        $this->assertNotEquals($createDate, $doc->getAttribute('$updatedAt'));
+
+        // Update with custom updatedAt
+        $doc->setAttribute('string', 'updated');
+        $doc->setAttribute('$updatedAt', $updateDate);
+        $updatedDoc = $database->updateDocument($collection, 'doc1', $doc);
+
+        $this->assertEquals($createDate, $updatedDoc->getAttribute('$createdAt'));
+        $this->assertEquals($updateDate, $updatedDoc->getAttribute('$updatedAt'));
+
+        // 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
+        ]));
+
+        $this->assertEquals($createDate, $doc2->getAttribute('$createdAt'));
+        $this->assertEquals($updateDate, $doc2->getAttribute('$updatedAt'));
+
+        // 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'
+        ]));
+
+        $doc3->setAttribute('string', 'updated_no_dates');
+        $doc3->setAttribute('$createdAt', $createDate);
+        $doc3->setAttribute('$updatedAt', $updateDate);
+        $updatedDoc3 = $database->updateDocument($collection, 'doc3', $doc3);
+
+        $this->assertEquals($createDate, $updatedDoc3->getAttribute('$createdAt'));
+        $this->assertEquals($updateDate, $updatedDoc3->getAttribute('$updatedAt'));
 
-        // 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) . '/';
+        // 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'
+        ]));
 
-            // Get all documents to manually verify
-            $allDocuments = $database->find('moviesRegex');
+        $originalCreatedAt4 = $doc4->getAttribute('$createdAt');
+        $originalUpdatedAt4 = $doc4->getAttribute('$updatedAt');
 
-            // Manually filter documents that match the pattern
-            $expectedMatches = [];
-            foreach ($allDocuments as $doc) {
-                $value = $doc->getAttribute($attribute);
-                if (preg_match($phpPattern, $value)) {
-                    $expectedMatches[] = $doc->getId();
-                }
-            }
+        sleep(1); // Ensure $updatedAt differs when adapter timestamp precision is seconds
 
-            // Get IDs from query results
-            $actualMatches = array_map(fn ($doc) => $doc->getId(), $queryResults);
+        $doc4->setAttribute('$updatedAt', null);
+        $doc4->setAttribute('$createdAt', null);
+        $updatedDoc4 = $database->updateDocument($collection, 'doc4', document: $doc4);
 
-            // 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}'"
-                );
-            }
+        $this->assertEquals($originalCreatedAt4, $updatedDoc4->getAttribute('$createdAt'));
+        $this->assertNotEquals($originalUpdatedAt4, $updatedDoc4->getAttribute('$updatedAt'));
 
-            // 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}'"
-            );
-        };
+        // Test 5: Update only updatedAt
+        $updatedDoc4->setAttribute('$updatedAt', $updateDate);
+        $updatedDoc4->setAttribute('$createdAt', $createDate);
+        $finalDoc4 = $database->updateDocument($collection, 'doc4', $updatedDoc4);
 
-        // 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'),
-        ]);
+        $this->assertEquals($createDate, $finalDoc4->getAttribute('$createdAt'));
+        $this->assertEquals($updateDate, $finalDoc4->getAttribute('$updatedAt'));
 
-        // Verify completeness: all matching documents returned, no extra documents
-        $verifyRegexQuery('name', '^Captain', $documents);
+        // 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
+        ]));
 
-        // 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->assertNotEquals($date2, $doc5->getAttribute('$createdAt'));
+        $this->assertEquals($date2, $doc5->getAttribute('$updatedAt'));
 
-        // Test regex pattern - match movies containing 'Frozen'
-        $pattern = '/Frozen/';
-        $documents = $database->find('moviesRegex', [
-            Query::regex('name', 'Frozen'),
-        ]);
+        $doc5->setAttribute('string', 'doc5_updated');
+        $doc5->setAttribute('$createdAt', $date1);
+        $updatedDoc5 = $database->updateDocument($collection, 'doc5', $doc5);
 
-        // Verify completeness: all matching documents returned, no extra documents
-        $verifyRegexQuery('name', 'Frozen', $documents);
+        $this->assertEquals($date1, $updatedDoc5->getAttribute('$createdAt'));
+        $this->assertEquals($date2, $updatedDoc5->getAttribute('$updatedAt'));
 
-        // 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));
+        // 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
+        ]));
 
-        // Test regex pattern - match movies ending with 'Marvel'
-        $pattern = '/Marvel$/';
-        $documents = $database->find('moviesRegex', [
-            Query::regex('name', 'Marvel$'),
-        ]);
+        $this->assertEquals($date1, $doc6->getAttribute('$createdAt'));
+        $this->assertEquals($date2, $doc6->getAttribute('$updatedAt'));
 
-        // Verify completeness: all matching documents returned, no extra documents
-        $verifyRegexQuery('name', 'Marvel$', $documents);
+        $doc6->setAttribute('string', 'doc6_updated');
+        $doc6->setAttribute('$createdAt', $date3);
+        $doc6->setAttribute('$updatedAt', $date3);
+        $updatedDoc6 = $database->updateDocument($collection, 'doc6', $doc6);
 
-        $this->assertEquals(1, count($documents)); // Only Captain Marvel
-        $this->assertEquals('Captain Marvel', $documents[0]->getAttribute('name'));
+        $this->assertEquals($date3, $updatedDoc6->getAttribute('$createdAt'));
+        $this->assertEquals($date3, $updatedDoc6->getAttribute('$updatedAt'));
 
-        // Test regex pattern - match movies with 'Work' in the name
-        $pattern = '/.*Work.*/';
-        $documents = $database->find('moviesRegex', [
-            Query::regex('name', '.*Work.*'),
-        ]);
+        // Test 8: Preserve dates disabled
+        $database->setPreserveDates(false);
 
-        // Verify completeness: all matching documents returned, no extra documents
-        $verifyRegexQuery('name', '.*Work.*', $documents);
+        $customDate = '2000-01-01T10:00:00.000+00:00';
 
-        // 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));
+        $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
+        ]));
 
-        // Test regex pattern - match movies with 'Buck' in director
-        $pattern = '/.*Buck.*/';
-        $documents = $database->find('moviesRegex', [
-            Query::regex('director', '.*Buck.*'),
-        ]);
+        $this->assertNotEquals($customDate, $doc7->getAttribute('$createdAt'));
+        $this->assertNotEquals($customDate, $doc7->getAttribute('$updatedAt'));
 
-        // Verify completeness: all matching documents returned, no extra documents
-        $verifyRegexQuery('director', '.*Buck.*', $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);
 
-        // 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));
+        $this->assertNotEquals($customDate, $updatedDoc7->getAttribute('$createdAt'));
+        $this->assertNotEquals($customDate, $updatedDoc7->getAttribute('$updatedAt'));
 
-        // 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
+        // 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();
+
+        $newDoc11 = new Document([
+            'string' => 'no_dates_update',
         ]);
+        $updatedDoc7 = $database->updateDocument($collection, 'doc11', $newDoc11);
+        $this->assertNotEquals($newUpdatedAt, $updatedDoc7->getAttribute('$updatedAt'));
 
-        // 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)"
-            );
-        }
+        $database->setPreserveDates(false);
+        $database->deleteCollection($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();
-            }
-        }
+    public function testBulkDocumentDateOperations(): void
+    {
+        /** @var Database $database */
+        $database = $this->getDatabase();
+        $collection = 'bulk_date_operations';
+        $database->createCollection($collection);
+        $this->assertEquals(true, $database->createAttribute($collection, new Attribute(key: 'string', type: ColumnType::String, size: 128, required: false)));
 
-        $actualMatches = array_map(fn ($doc) => $doc->getId(), $documents);
-        sort($actualMatches);
+        $database->setPreserveDates(true);
 
-        // The database might be case-sensitive (MongoDB) or case-insensitive (MySQL/MariaDB)
-        // Check which one matches the actual results
-        sort($expectedMatchesCaseSensitive);
-        sort($expectedMatchesCaseInsensitive);
+        $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())];
 
-        // Verify that actual results match either case-sensitive or case-insensitive expectations
-        $matchesCaseSensitive = ($expectedMatchesCaseSensitive === $actualMatches);
-        $matchesCaseInsensitive = ($expectedMatchesCaseInsensitive === $actualMatches);
+        // 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
+            ])
+        ];
 
-        $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."
-        );
+        $database->createDocuments($collection, $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 initial state
+        foreach (['doc1', 'doc3'] as $id) {
+            $doc = $database->getDocument($collection, $id);
+            $this->assertEquals($createDate, $doc->getAttribute('$createdAt'), "createdAt mismatch for $id");
+        }
 
-        // 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'"
-            );
+        foreach (['doc2', 'doc3'] as $id) {
+            $doc = $database->getDocument($collection, $id);
+            $this->assertEquals($updateDate, $doc->getAttribute('$updatedAt'), "updatedAt mismatch for $id");
         }
 
-        // Verify completeness
-        $allDocuments = $database->find('moviesRegex');
-        $expectedMatches = [];
-        foreach ($allDocuments as $doc) {
-            $name = $doc->getAttribute('name');
-            if (preg_match($pattern, $name)) {
-                $expectedMatches[] = $doc->getId();
-            }
+        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");
         }
-        $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),
+        // Test 2: Bulk update with custom dates
+        $updateDoc = new Document([
+            'string' => 'updated',
+            '$createdAt' => $createDate,
+            '$updatedAt' => $updateDate
         ]);
-
-        // Verify all returned documents match both conditions
+        $ids = [];
         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");
-        }
-
-        // 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();
-            }
+            $ids[] = $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 regex with limit
-        $pattern = '/.*/';
-        $documents = $database->find('moviesRegex', [
-            Query::regex('name', '.*'), // Match all
-            Query::limit(3),
+        $count = $database->updateDocuments($collection, $updateDoc, [
+            Query::equal('$id', $ids)
         ]);
+        $this->assertEquals(6, $count);
 
-        $this->assertEquals(3, count($documents));
+        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");
+        }
 
-        // 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}'"
-            );
+        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");
         }
 
-        // Note: With limit, we can't verify completeness, but we can verify all returned match
+        // Test 3: Bulk update with preserve dates disabled
+        $database->setPreserveDates(false);
 
-        // Test regex with non-matching pattern
-        $pattern = '/^NonExistentPattern$/';
-        $documents = $database->find('moviesRegex', [
-            Query::regex('name', '^NonExistentPattern$'),
+        $customDate = 'should be ignored anyways so no error';
+        $updateDocDisabled = new Document([
+            'string' => 'disabled_update',
+            '$createdAt' => $customDate,
+            '$updatedAt' => $customDate
         ]);
 
-        $this->assertEquals(0, count($documents));
-
-        // 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}'");
+        $countDisabled = $database->updateDocuments($collection, $updateDocDisabled);
+        $this->assertEquals(6, $countDisabled);
 
-        // Verify completeness: no documents should be returned
-        $this->assertEquals([], array_map(fn ($doc) => $doc->getId(), $documents));
+        // Test 4: Bulk update with preserve dates re-enabled
+        $database->setPreserveDates(true);
 
-        // Test regex with special characters (should be escaped or handled properly)
-        $pattern = '/.*:.*/';
-        $documents = $database->find('moviesRegex', [
-            Query::regex('name', '.*:.*'), // Match movies with colon
+        $newDate = '2000-03-01T20:45:00.000+00:00';
+        $updateDocEnabled = new Document([
+            'string' => 'enabled_update',
+            '$createdAt' => $newDate,
+            '$updatedAt' => $newDate
         ]);
 
-        // Verify completeness: all matching documents returned, no extra documents
-        $verifyRegexQuery('name', '.*:.*', $documents);
+        $countEnabled = $database->updateDocuments($collection, $updateDocEnabled);
+        $this->assertEquals(6, $countEnabled);
 
-        // Verify expected document is included
-        $names = array_map(fn ($doc) => $doc->getAttribute('name'), $documents);
-        $this->assertTrue(in_array('Captain America: The First Avenger', $names));
+        $database->setPreserveDates(false);
+        $database->deleteCollection($collection);
+    }
 
-        // 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');
+    public function testCreateUpdateDocumentsMismatch(): void
+    {
+        /** @var Database $database */
+        $database = $this->getDatabase();
 
-        // 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),
-            ]);
+        // with different set of attributes
+        $colName = "docs_with_diff";
+        $database->createCollection($colName);
+        $database->createAttribute($colName, new Attribute(key: 'key', type: ColumnType::String, size: 50, required: true));
+        $database->createAttribute($colName, new Attribute(key: 'value', type: ColumnType::String, size: 50, required: false, 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());
 
-            // 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}'"
-                );
-            }
+        $database->createDocument($colName, new Document([
+            '$id' => 'doc4',
+            '$permissions' => $permissions,
+            'key' => 'doc4'
+        ]));
 
-            // 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}'"
-            );
+        $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'));
+
+        $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);
+    }
 
-        // 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'),
-            ]),
+    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;
+        }
+
+        $collectionId = 'successive_update_single';
+
+        $database->createCollection($collectionId);
+        $database->createAttribute($collectionId, new Attribute(key: 'attrA', type: ColumnType::String, size: 50, required: true));
+        $database->createAttribute($collectionId, new Attribute(key: 'attrB', type: ColumnType::String, size: 50, required: true));
+
+        // bypass required
+        $database->disableValidation();
+
+        $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])
         ]);
 
-        // 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'"
-            );
+        $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();
 
-        // 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();
-            }
+        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);
         }
-        $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');
+
+        $database->deleteCollection($collectionId);
     }
-    public function testRegexInjection(): void
+
+    public function testValidationGuardsWithNullRequired(): 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::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
             return;
         }
 
-        $collectionName = 'injectionTest';
-        $database->createCollection($collectionName, permissions: [
-            Permission::create(Role::any()),
+        // 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, new Attribute(key: 'name', type: ColumnType::String, size: 32, required: true));
+        $database->createAttribute($collection, new Attribute(key: 'age', type: ColumnType::Integer, size: 0, required: true));
+        $database->createAttribute($collection, new Attribute(key: 'value', type: ColumnType::Integer, size: 0, required: false));
 
-        if ($database->getAdapter()->getSupportForAttributes()) {
-            $this->assertEquals(true, $database->createAttribute($collectionName, 'text', Database::VAR_STRING, 1000, true));
+        // 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);
         }
 
-        // 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->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();
 
-        $database->createDocument($collectionName, new Document([
-            '$permissions' => [
-                Permission::read(Role::any()),
-                Permission::create(Role::any()),
-                Permission::update(Role::any()),
-                Permission::delete(Role::any()),
-            ],
-            'text' => 'other',
+        // 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());
 
-        // 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;
-                    }
+        // 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);
+        }
 
-                    // 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."
-                        );
-                    }
-                }
+        $database->disableValidation();
+        $updated = $database->updateDocument($collection, 'valid', new Document([
+            'age' => null,
+        ]));
+        $this->assertNull($updated->getAttribute('age'));
+        $database->enableValidation();
 
-            } 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);
-            }
+        // 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,
+            ]));
         }
 
-        // 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) {
+        // 3) updateDocuments setting required to null should fail when validation enabled, pass when disabled
+        if ($database->getAdapter()->supports(Capability::BatchOperations)) {
             try {
-                $results = $database->find($collectionName, [
-                    Query::regex('text', $pattern),
-                ]);
-
-                $this->assertIsArray($results);
+                $database->updateDocuments($collection, new Document([
+                    'name' => null,
+                ]));
+                $this->fail('Failed to throw exception');
+            } catch (Throwable $e) {
+                $this->assertInstanceOf(StructureException::class, $e);
+            }
 
-                // 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());
+            $database->disableValidation();
+            $count = $database->updateDocuments($collection, new Document([
+                'name' => null,
+            ]));
+            $this->assertGreaterThanOrEqual(3, $count); // at least the seeded docs are updated
+            $database->enableValidation();
+        }
+
+        // 4) upsertDocumentsWithIncrease with null required should fail when validation enabled, pass when disabled
+        if ($database->getAdapter() instanceof Feature\Upserts) {
+            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);
             }
+
+            $database->disableValidation();
+            $ucount = $database->upsertDocumentsWithIncrease(
+                collection: $collection,
+                attribute: 'value',
+                documents: [new Document([
+                    '$id' => 'u1',
+                    'name' => null,
+                    'value' => 1,
+                ])]
+            );
+            $this->assertEquals(1, $ucount);
+            $database->enableValidation();
         }
 
         // Cleanup
-        $database->deleteCollection($collectionName);
+        $database->deleteCollection($collection);
     }
 
-    /**
-     * 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);
-    //    }
+
 }
diff --git a/tests/e2e/Adapter/Scopes/GeneralTests.php b/tests/e2e/Adapter/Scopes/GeneralTests.php
index 6e8677315..f7d7d966e 100644
--- a/tests/e2e/Adapter/Scopes/GeneralTests.php
+++ b/tests/e2e/Adapter/Scopes/GeneralTests.php
@@ -2,26 +2,19 @@
 
 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\Database;
 use Utopia\Database\Document;
-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\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;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\IndexType;
 
 trait GeneralTests
 {
@@ -40,8 +33,9 @@ public function testPing(): void
      */
     public function testQueryTimeout(): void
     {
-        if (!$this->getDatabase()->getAdapter()->getSupportForTimeouts()) {
+        if (! ($this->getDatabase()->getAdapter() instanceof Feature\Timeouts)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -52,23 +46,17 @@ public function testQueryTimeout(): void
 
         $this->assertEquals(
             true,
-            $database->createAttribute(
-                collection: 'global-timeouts',
-                id: 'longtext',
-                type: Database::VAR_STRING,
-                size: 100000000,
-                required: true
-            )
+            $database->createAttribute('global-timeouts', new Attribute(key: 'longtext', type: ColumnType::String, 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,351 +74,62 @@ public function testQueryTimeout(): void
         }
     }
 
-
-
-    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(__FUNCTION__, documentSecurity: false);
 
-    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())
-        ]);
+            $database
+                ->setTenant(1)
+                ->updateDocument(Database::METADATA, __FUNCTION__, new Document([
+                    '$id' => __FUNCTION__,
+                    'name' => 'Scooby Doo',
+                ]));
 
-        $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 */
@@ -440,18 +139,24 @@ 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');
+        $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)
@@ -464,8 +169,8 @@ public function testSharedTablesTenantPerDocument(): void
             Permission::update(Role::any()),
         ], documentSecurity: false);
 
-        $database->createAttribute(__FUNCTION__, 'name', Database::VAR_STRING, 100, false);
-        $database->createIndex(__FUNCTION__, 'nameIndex', Database::INDEX_KEY, ['name']);
+        $database->createAttribute(__FUNCTION__, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: false));
+        $database->createIndex(__FUNCTION__, new Index(key: 'nameIndex', type: IndexType::Key, attributes: ['name']));
 
         $doc1Id = ID::unique();
 
@@ -517,7 +222,7 @@ public function testSharedTablesTenantPerDocument(): void
         $this->assertEquals(1, \count($docs));
         $this->assertEquals($doc1Id, $docs[0]->getId());
 
-        if ($database->getAdapter()->getSupportForUpserts()) {
+        if ($database->getAdapter() instanceof Feature\Upserts) {
             // Test upsert with tenant per doc
             $doc3Id = ID::unique();
             $database
@@ -626,171 +331,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($collection, attributes: [
+            new Attribute(key: 'title', type: ColumnType::String, 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);
-
-        $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',
-            ]));
+        $results = $database->find($collection);
+        $this->assertCount(1, $results);
 
-            $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);
     }
 
     /**
@@ -804,7 +396,7 @@ public function testTransactionAtomicity(): void
         $database = $this->getDatabase();
 
         $database->createCollection('transactionAtomicity');
-        $database->createAttribute('transactionAtomicity', 'title', Database::VAR_STRING, 128, true);
+        $database->createAttribute('transactionAtomicity', new Attribute(key: 'title', type: ColumnType::String, size: 128, required: true));
 
         // Verify a successful transaction commits
         $doc = $database->withTransaction(function () use ($database) {
@@ -855,7 +447,7 @@ public function testTransactionStateAfterKnownException(): void
         $database = $this->getDatabase();
 
         $database->createCollection('txKnownException');
-        $database->createAttribute('txKnownException', 'title', Database::VAR_STRING, 128, true);
+        $database->createAttribute('txKnownException', new Attribute(key: 'title', type: ColumnType::String, size: 128, required: true));
 
         $database->createDocument('txKnownException', new Document([
             '$id' => 'existing_doc',
@@ -906,8 +498,9 @@ public function testTransactionStateAfterRetriesExhausted(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForTransactionRetries()) {
+        if (! $database->getAdapter()->supports(Capability::TransactionRetries)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -944,13 +537,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->createAttribute('txNested', new Attribute(key: 'title', type: ColumnType::String, size: 128, required: true));
 
         $database->createDocument('txNested', new Document([
             '$id' => 'nested_existing',
@@ -1011,17 +605,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 3f5c101f6..e59c5a51c 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\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\OrderDirection;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\IndexType;
 
 trait IndexTests
 {
@@ -27,24 +30,24 @@ public function testCreateIndex(): void
         /**
          * 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', new Attribute(key: 'int', type: ColumnType::Integer, size: 8, required: false, array: true));
+        if ($database->getAdapter()->supports(Capability::IndexArray)) {
+            $database->createIndex('indexes', new Index(key: 'indx8711', type: IndexType::Key, attributes: ['int'], lengths: [255]));
         }
 
-        $database->createAttribute('indexes', 'name', Database::VAR_STRING, 10, false);
+        $database->createAttribute('indexes', new Attribute(key: 'name', type: ColumnType::String, size: 10, required: false));
 
-        $database->createIndex('indexes', 'index_1', Database::INDEX_KEY, ['name']);
+        $database->createIndex('indexes', new Index(key: 'index_1', type: IndexType::Key, attributes: ['name']));
 
         try {
-            $database->createIndex('indexes', 'index3', Database::INDEX_KEY, ['$id', '$id']);
+            $database->createIndex('indexes', new Index(key: 'index3', type: IndexType::Key, 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', new Index(key: 'index4', type: IndexType::Key, attributes: ['name', 'Name']));
         } catch (Throwable $e) {
             self::assertTrue($e instanceof DatabaseException);
             self::assertEquals($e->getMessage(), 'Duplicate attributes provided');
@@ -60,19 +63,19 @@ public function testCreateDeleteIndex(): void
 
         $database->createCollection('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', new Attribute(key: 'string', type: ColumnType::String, size: 128, required: true)));
+        $this->assertEquals(true, $database->createAttribute('indexes', new Attribute(key: 'order', type: ColumnType::String, size: 128, required: true)));
+        $this->assertEquals(true, $database->createAttribute('indexes', new Attribute(key: 'integer', type: ColumnType::Integer, size: 0, required: true)));
+        $this->assertEquals(true, $database->createAttribute('indexes', new Attribute(key: 'float', type: ColumnType::Double, size: 0, required: true)));
+        $this->assertEquals(true, $database->createAttribute('indexes', new Attribute(key: 'boolean', type: ColumnType::Boolean, size: 0, 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', new Index(key: 'index1', type: IndexType::Key, attributes: ['string', 'integer'], lengths: [128], orders: [OrderDirection::Asc->value])));
+        $this->assertEquals(true, $database->createIndex('indexes', new Index(key: 'index2', type: IndexType::Key, attributes: ['float', 'integer'], lengths: [], orders: [OrderDirection::Asc->value, OrderDirection::Desc->value])));
+        $this->assertEquals(true, $database->createIndex('indexes', new Index(key: 'index3', type: IndexType::Key, attributes: ['integer', 'boolean'], lengths: [], orders: [OrderDirection::Asc->value, OrderDirection::Desc->value, OrderDirection::Desc->value])));
+        $this->assertEquals(true, $database->createIndex('indexes', new Index(key: 'index4', type: IndexType::Unique, attributes: ['string'], lengths: [128], orders: [OrderDirection::Asc->value])));
+        $this->assertEquals(true, $database->createIndex('indexes', new Index(key: 'index5', type: IndexType::Unique, attributes: ['$id', 'string'], lengths: [128], orders: [OrderDirection::Asc->value])));
+        $this->assertEquals(true, $database->createIndex('indexes', new Index(key: 'order', type: IndexType::Unique, attributes: ['order'], lengths: [128], orders: [OrderDirection::Asc->value])));
 
         $collection = $database->getCollection('indexes');
         $this->assertCount(6, $collection->getAttribute('indexes'));
@@ -89,290 +92,54 @@ public function testCreateDeleteIndex(): void
         $this->assertCount(0, $collection->getAttribute('indexes'));
 
         // Test non-shared tables duplicates throw duplicate
-        $database->createIndex('indexes', 'duplicate', Database::INDEX_KEY, ['string', 'boolean'], [128], [Database::ORDER_ASC]);
+        $database->createIndex('indexes', new Index(key: 'duplicate', type: IndexType::Key, attributes: ['string', 'boolean'], lengths: [128], orders: [OrderDirection::Asc->value]));
         try {
-            $database->createIndex('indexes', 'duplicate', Database::INDEX_KEY, ['string', 'boolean'], [128], [Database::ORDER_ASC]);
+            $database->createIndex('indexes', new Index(key: 'duplicate', type: IndexType::Key, attributes: ['string', 'boolean'], lengths: [128], orders: [OrderDirection::Asc->value]));
             $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', new Index(key: 'index1', type: IndexType::Key, attributes: ['string', 'integer'], lengths: [128], orders: [OrderDirection::Asc->value])));
         $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', new Index(key: 'index1', type: IndexType::Key, attributes: ['string', 'integer'], lengths: [128], orders: [OrderDirection::Asc->value])));
         $this->assertEquals(true, $database->deleteAttribute('indexes', 'string'));
         $this->assertEquals(true, $database->deleteIndex('indexes', 'index1'));
 
         $database->deleteCollection('indexes');
     }
 
-
-
-    /**
-     * @throws Exception|Throwable
-     */
-    public function testIndexValidation(): 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());
-
-            try {
-                $database->createCollection($collection->getId(), $attributes, $indexes);
-                $this->fail('Failed to throw exception');
-            } catch (Exception $e) {
-                $this->assertEquals($errorMessage, $e->getMessage());
-            }
-        }
-
-        $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' => [],
-            ]),
-        ];
-
-        $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());
-        }
-
-        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());
-            }
-        }
-
-
-        $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 testIndexLengthZero(): 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__, 'title1', Database::VAR_STRING, $database->getAdapter()->getMaxIndexLength() + 300, true);
+        $database->createAttribute(__FUNCTION__, new Attribute(key: 'title1', type: ColumnType::String, size: $database->getAdapter()->getMaxIndexLength() + 300, required: true));
 
         try {
-            $database->createIndex(__FUNCTION__, 'index_title1', Database::INDEX_KEY, ['title1'], [0]);
+            $database->createIndex(__FUNCTION__, new Index(key: 'index_title1', type: IndexType::Key, 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__, 'title2', Database::VAR_STRING, 100, true);
-        $database->createIndex(__FUNCTION__, 'index_title2', Database::INDEX_KEY, ['title2'], [0]);
+        $database->createAttribute(__FUNCTION__, new Attribute(key: 'title2', type: ColumnType::String, size: 100, required: true));
+        $database->createIndex(__FUNCTION__, new Index(key: 'index_title2', type: IndexType::Key, attributes: ['title2'], lengths: [0]));
 
         try {
-            $database->updateAttribute(__FUNCTION__, 'title2', Database::VAR_STRING, $database->getAdapter()->getMaxIndexLength() + 300, true);
+            $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());
@@ -382,85 +149,73 @@ public function testIndexLengthZero(): void
     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($collection);
+        $database->createAttribute($collection, new Attribute(key: 'verbose', type: ColumnType::String, size: 128, required: true));
+        $database->createAttribute($collection, new Attribute(key: 'symbol', type: ColumnType::Integer, size: 0, 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, new Index(key: 'index1', type: IndexType::Key, attributes: ['verbose'], lengths: [128], orders: [OrderDirection::Asc->value]));
+        $database->createIndex($collection, new Index(key: 'index2', type: IndexType::Key, attributes: ['symbol'], lengths: [0], orders: [OrderDirection::Asc->value]));
 
-        $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'));
     }
 
+    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($collection);
+        $database->createAttribute($collection, new Attribute(key: 'verbose', type: ColumnType::String, size: 128, required: true));
+        $database->createAttribute($collection, new Attribute(key: 'symbol', type: ColumnType::Integer, size: 0, required: true));
+        $database->createIndex($collection, new Index(key: 'index1', type: IndexType::Key, attributes: ['verbose'], lengths: [128], orders: [OrderDirection::Asc->value]));
+        $database->createIndex($collection, new Index(key: 'index2', type: IndexType::Key, attributes: ['symbol'], lengths: [0], orders: [OrderDirection::Asc->value]));
+        $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(), new Index(key: 'string', type: IndexType::Fulltext, attributes: ['string']));
+        $database->createDocument($this->getDocumentsCollection(), new Document([
             '$permissions' => [
                 Permission::read(Role::any()),
                 Permission::create(Role::any()),
@@ -482,193 +237,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(), new Index(key: 'string', type: IndexType::Fulltext, 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;
         }
 
@@ -679,21 +297,21 @@ public function testTrigramIndex(): void
         try {
             $database->createCollection($collectionId);
 
-            $database->createAttribute($collectionId, 'name', Database::VAR_STRING, 256, false);
-            $database->createAttribute($collectionId, 'description', Database::VAR_STRING, 512, false);
+            $database->createAttribute($collectionId, new Attribute(key: 'name', type: ColumnType::String, size: 256, required: false));
+            $database->createAttribute($collectionId, new Attribute(key: 'description', type: ColumnType::String, size: 512, required: false));
 
             // Create trigram index on name attribute
-            $this->assertEquals(true, $database->createIndex($collectionId, 'trigram_name', Database::INDEX_TRIGRAM, ['name']));
+            $this->assertEquals(true, $database->createIndex($collectionId, new Index(key: 'trigram_name', type: IndexType::Trigram, attributes: ['name'])));
 
             $collection = $database->getCollection($collectionId);
             $indexes = $collection->getAttribute('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, new Index(key: 'trigram_description', type: IndexType::Trigram, attributes: ['description'])));
 
             $collection = $database->getCollection($collectionId);
             $indexes = $collection->getAttribute('indexes');
@@ -713,111 +331,31 @@ 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->createAttribute($col, 'expiresAt', Database::VAR_DATETIME, 0, false);
+        $database->createAttribute($col, new Attribute(key: 'expiresAt', type: ColumnType::Datetime, size: 0, required: false, 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, new Index(key: 'idx_ttl_valid', type: IndexType::Ttl, attributes: ['expiresAt'], lengths: [], orders: [OrderDirection::Asc->value], ttl: 3600))
         );
 
         $collection = $database->getCollection($col);
@@ -825,7 +363,7 @@ public function testTTLIndexes(): void
         $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();
@@ -848,28 +386,20 @@ 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, new Index(key: 'idx_ttl_min', type: IndexType::Ttl, attributes: ['expiresAt'], lengths: [], orders: [OrderDirection::Asc->value], ttl: 1))
         );
 
         $col2 = uniqid('sl_ttl_collection');
 
         $expiresAtAttr = new Document([
             '$id' => ID::custom('expiresAt'),
-            'type' => Database::VAR_DATETIME,
+            'type' => ColumnType::Datetime->value,
             'size' => 0,
             'signed' => false,
             'required' => false,
@@ -880,11 +410,11 @@ public function testTTLIndexes(): void
 
         $ttlIndexDoc = new Document([
             '$id' => ID::custom('idx_ttl_collection'),
-            'type' => Database::INDEX_TTL,
+            'type' => IndexType::Ttl->value,
             'attributes' => ['expiresAt'],
             'lengths' => [],
-            'orders' => [Database::ORDER_ASC],
-            'ttl' => 7200 // 2 hours
+            'orders' => [OrderDirection::Asc->value],
+            'ttl' => 7200, // 2 hours
         ]);
 
         $database->createCollection($col2, [$expiresAtAttr], [$ttlIndexDoc]);
@@ -900,152 +430,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/JoinTests.php b/tests/e2e/Adapter/Scopes/JoinTests.php
new file mode 100644
index 000000000..d0e1b34d1
--- /dev/null
+++ b/tests/e2e/Adapter/Scopes/JoinTests.php
@@ -0,0 +1,2639 @@
+<?php
+
+namespace Tests\E2E\Adapter\Scopes;
+
+use PHPUnit\Framework\Attributes\DataProvider;
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
+use Utopia\Database\Document;
+use Utopia\Database\Helpers\Permission;
+use Utopia\Database\Helpers\Role;
+use Utopia\Database\Query;
+use Utopia\Query\Schema\ColumnType;
+
+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($pCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($pCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($rCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($rCol, new Attribute(key: 'prod_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($rCol, new Attribute(key: 'score', type: ColumnType::Integer, size: 0, 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($pCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($pCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($rCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($rCol, new Attribute(key: 'prod_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($rCol, new Attribute(key: 'score', type: ColumnType::Integer, size: 0, 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) {
+            $mapped[$doc->getAttribute('name')] = $doc;
+        }
+        $this->assertEquals(3, $mapped['Product p1']->getAttribute('cnt'));
+        $this->assertEqualsWithDelta(4.0, (float) $mapped['Product p1']->getAttribute('avg_score'), 0.1);
+        $this->assertEquals(2, $mapped['Product p2']->getAttribute('cnt'));
+        $this->assertEqualsWithDelta(3.0, (float) $mapped['Product p2']->getAttribute('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($cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($cCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'cust_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'amount', type: ColumnType::Integer, size: 0, 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, (float) $results[0]->getAttribute('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($cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($cCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'cust_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'status', type: ColumnType::String, size: 20, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'amount', type: ColumnType::Integer, size: 0, 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) {
+            $key = $doc->getAttribute('cust_uid') . '_' . $doc->getAttribute('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($cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($cCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'cust_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'amount', type: ColumnType::Integer, size: 0, 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($cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($cCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'cust_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'amount', type: ColumnType::Integer, size: 0, 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'));
+        $this->assertEqualsWithDelta(550.0, (float) $results[0]->getAttribute('avg_amt'), 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($cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($cCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'cust_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'amount', type: ColumnType::Integer, size: 0, 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($cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($cCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'cust_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'amount', type: ColumnType::Integer, size: 0, 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($cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($cCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'cust_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'product', type: ColumnType::String, 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($cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($cCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'cust_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'amount', type: ColumnType::Integer, size: 0, 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) {
+            $mapped[$doc->getAttribute('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($cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($cCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'cust_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'status', type: ColumnType::String, size: 20, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'amount', type: ColumnType::Integer, size: 0, 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) {
+            $mapped[$doc->getAttribute('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($cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($cCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'cust_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'amount', type: ColumnType::Integer, size: 0, 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($cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($cCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'cust_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'amount', type: ColumnType::Integer, size: 0, 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($cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($cCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'cust_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'amount', type: ColumnType::Integer, size: 0, 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($cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($cCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'cust_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'status', type: ColumnType::String, size: 20, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'amount', type: ColumnType::Integer, size: 0, 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($pCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($pCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'prod_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'amount', type: ColumnType::Integer, size: 0, 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) {
+            $mapped[$doc->getAttribute('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($cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($cCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'cust_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'status', type: ColumnType::String, size: 20, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'amount', type: ColumnType::Integer, size: 0, 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($cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($cCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'cust_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'amount', type: ColumnType::Integer, size: 0, 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($cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($cCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'cust_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'status', type: ColumnType::String, size: 20, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'amount', type: ColumnType::Integer, size: 0, 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($cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($cCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'cust_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'tag', type: ColumnType::String, size: 50, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'amount', type: ColumnType::Integer, size: 0, 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($cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($cCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'cust_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'status', type: ColumnType::String, size: 20, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'amount', type: ColumnType::Integer, size: 0, 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) {
+            $mapped[$doc->getAttribute('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($cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($cCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'cust_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'amount', type: ColumnType::Integer, size: 0, 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($pCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($pCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'prod_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'amount', type: ColumnType::Integer, size: 0, 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($cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($cCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'cust_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'amount', type: ColumnType::Integer, size: 0, 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) {
+            $mapped[$doc->getAttribute('cust_uid')] = $doc;
+        }
+
+        $this->assertEquals(3, $mapped['c1']->getAttribute('cnt'));
+        $this->assertEquals(600, $mapped['c1']->getAttribute('total'));
+        $this->assertEqualsWithDelta(200.0, (float) $mapped['c1']->getAttribute('avg_amt'), 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'));
+        $this->assertEqualsWithDelta(100.0, (float) $mapped['c2']->getAttribute('avg_amt'), 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($cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($cCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'cust_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'amount', type: ColumnType::Integer, size: 0, 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) {
+            $mapped[$doc->getAttribute('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';
+        $oCol = 'jtc_o';
+        $cols = [$pCol, $oCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection($pCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($pCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'prod_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'qty', type: ColumnType::Integer, size: 0, 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'),
+        };
+
+        $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';
+        $cCol = 'jat_c';
+        $cols = [$oCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection($cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($cCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'cust_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'amount', type: ColumnType::Integer, size: 0, 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'),
+        };
+
+        $results = $database->find($oCol, [
+            Query::join($cCol, 'cust_uid', '$id'),
+            $aggQuery,
+        ]);
+
+        $this->assertCount(1, $results);
+        if ($aggMethod === 'avg') {
+            $this->assertEqualsWithDelta($expected, (float) $results[0]->getAttribute('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';
+        $cCol = 'jho_c';
+        $cols = [$oCol, $cCol];
+        $this->cleanupAggCollections($database, $cols);
+
+        $database->createCollection($cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($cCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'cust_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'amount', type: ColumnType::Integer, size: 0, 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),
+        };
+
+        $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($cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($cCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'cust_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'amount', type: ColumnType::Integer, size: 0, 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 ($d) => (int) $d->getAttribute('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($cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($cCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'cust_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'amount', type: ColumnType::Integer, size: 0, 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, (int) $results[0]->getAttribute('total'));
+        $this->assertEquals(400, (int) $results[1]->getAttribute('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($cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($cCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'cust_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'amount', type: ColumnType::Integer, size: 0, 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, (int) $results[0]->getAttribute('total'));
+        $this->assertEquals(300, (int) $results[1]->getAttribute('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($cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($cCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'cust_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'amount', type: ColumnType::Integer, size: 0, 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($cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($cCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'cust_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'amount', type: ColumnType::Integer, size: 0, 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($cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($cCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'cust_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'amount', type: ColumnType::Integer, size: 0, 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($cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($cCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'cust_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'amount', type: ColumnType::Integer, size: 0, 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($cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($cCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($pCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($pCol, new Attribute(key: 'title', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'cust_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'prod_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'amount', type: ColumnType::Integer, size: 0, 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) {
+            $mapped[$doc->getAttribute('cust_uid')] = $doc;
+        }
+        $this->assertEquals(3, $mapped['c1']->getAttribute('order_cnt'));
+        $this->assertEquals(600, (int) $mapped['c1']->getAttribute('total'));
+        $this->assertEquals(2, $mapped['c2']->getAttribute('order_cnt'));
+        $this->assertEquals(400, (int) $mapped['c2']->getAttribute('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($cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($cCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'cust_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'amount', type: ColumnType::Integer, size: 0, 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($cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($cCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'cust_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'status', type: ColumnType::String, size: 20, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'amount', type: ColumnType::Integer, size: 0, 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 ($d) => (int) $d->getAttribute('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($cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($cCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'cust_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'amount', type: ColumnType::Integer, size: 0, 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($pCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($pCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'prod_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'qty', type: ColumnType::Integer, size: 0, 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($cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($cCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'cust_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'category', type: ColumnType::String, size: 50, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'amount', type: ColumnType::Integer, size: 0, 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, (int) $results[0]->getAttribute('total'));
+        $this->assertEquals('c1', $results[1]->getAttribute('cust_uid'));
+        $this->assertEquals(500, (int) $results[1]->getAttribute('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, (int) $results[0]->getAttribute('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($cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($cCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'cust_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'status', type: ColumnType::String, size: 20, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'amount', type: ColumnType::Integer, size: 0, 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(fn ($d) => $d->getAttribute('cust_uid') . '_' . $d->getAttribute('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($cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($cCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'cust_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'product', type: ColumnType::String, 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) {
+            $mapped[$doc->getAttribute('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($cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($cCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'cust_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'status', type: ColumnType::String, size: 20, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'amount', type: ColumnType::Integer, size: 0, 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, (int) $results[0]->getAttribute('total'));
+        $this->assertEquals('c3', $results[1]->getAttribute('cust_uid'));
+        $this->assertEquals(900, (int) $results[1]->getAttribute('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($pCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($pCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'prod_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'qty', type: ColumnType::Integer, size: 0, 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 = array_map(fn ($d) => (int) $d->getAttribute('order_cnt'), $results);
+        $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($cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($cCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'cust_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'tag', type: ColumnType::String, size: 50, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'amount', type: ColumnType::Integer, size: 0, 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($cCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($cCol, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: true));
+
+        $database->createCollection($oCol, permissions: [Permission::create(Role::any()), Permission::read(Role::any())]);
+        $database->createAttribute($oCol, new Attribute(key: 'cust_uid', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($oCol, new Attribute(key: 'amount', type: ColumnType::Integer, size: 0, 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'));
+        $this->assertEquals(100, (int) $results[0]->getAttribute('total'));
+        $this->assertEquals('c2', $results[1]->getAttribute('cust_uid'));
+        $this->assertEquals(200, (int) $results[1]->getAttribute('total'));
+
+        $this->cleanupAggCollections($database, $cols);
+    }
+}
diff --git a/tests/e2e/Adapter/Scopes/ObjectAttributeTests.php b/tests/e2e/Adapter/Scopes/ObjectAttributeTests.php
index aacd0c86f..296f5372c 100644
--- a/tests/e2e/Adapter/Scopes/ObjectAttributeTests.php
+++ b/tests/e2e/Adapter/Scopes/ObjectAttributeTests.php
@@ -3,16 +3,21 @@
 namespace Tests\E2E\Adapter\Scopes;
 
 use Exception;
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
 use Utopia\Database\Database;
 use Utopia\Database\Document;
 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\OrderDirection;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\IndexType;
 
 trait ObjectAttributeTests
 {
@@ -20,23 +25,18 @@ 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  string  $type
+     * @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;
     }
 
@@ -46,7 +46,7 @@ public function testObjectAttribute(): void
         $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');
         }
 
@@ -54,7 +54,7 @@ public function testObjectAttribute(): void
         $database->createCollection($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([
@@ -65,10 +65,10 @@ public function testObjectAttribute(): void
                 'skills' => ['react', 'node'],
                 'user' => [
                     'info' => [
-                        'country' => 'IN'
-                    ]
-                ]
-            ]
+                        'country' => 'IN',
+                    ],
+                ],
+            ],
         ]));
 
         $this->assertIsArray($doc1->getAttribute('meta'));
@@ -78,7 +78,7 @@ public function testObjectAttribute(): void
 
         // 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());
@@ -88,17 +88,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());
@@ -112,15 +112,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());
@@ -130,10 +130,10 @@ public function testObjectAttribute(): void
             Query::equal('meta', [[
                 'user' => [
                     'info' => [
-                        'country' => 'US'
-                    ]
-                ]
-            ]])
+                        'country' => 'US',
+                    ],
+                ],
+            ]]),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('doc2', $results[0]->getId());
@@ -147,10 +147,10 @@ public function testObjectAttribute(): void
                 'skills' => ['react', 'node', 'typescript'],
                 'user' => [
                     'info' => [
-                        'country' => 'CA'
-                    ]
-                ]
-            ]
+                        'country' => 'CA',
+                    ],
+                ],
+            ],
         ]));
 
         $this->assertEquals(26, $updatedDoc->getAttribute('meta')['age']);
@@ -159,27 +159,27 @@ public function testObjectAttribute(): void
 
         // 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);
@@ -188,7 +188,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) {
@@ -200,10 +200,10 @@ public function testObjectAttribute(): void
             Query::notEqual('meta', [
                 'user' => [
                     'info' => [
-                        'country' => 'CA'
-                    ]
-                ]
-            ])
+                        'country' => 'CA',
+                    ],
+                ],
+            ]),
         ]);
         // Should return doc2 only
         $this->assertCount(1, $results);
@@ -220,7 +220,7 @@ public function testObjectAttribute(): void
         // 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());
@@ -230,7 +230,7 @@ public function testObjectAttribute(): void
         // 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());
@@ -241,7 +241,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'));
 
@@ -249,7 +249,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'));
@@ -263,12 +263,12 @@ 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']);
 
@@ -279,12 +279,12 @@ public function testObjectAttribute(): void
                     'level2' => [
                         'level3' => [
                             'level4' => [
-                                'level5' => 'deep_value'
-                            ]
-                        ]
-                    ]
-                ]
-            ]])
+                                'level5' => 'deep_value',
+                            ],
+                        ],
+                    ],
+                ],
+            ]]),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('doc5', $results[0]->getId());
@@ -296,12 +296,12 @@ public function testObjectAttribute(): void
                     'level2' => [
                         'level3' => [
                             'level4' => [
-                                'level5' => 'deep_value'
-                            ]
-                        ]
-                    ]
-                ]
-            ]])
+                                'level5' => 'deep_value',
+                            ],
+                        ],
+                    ],
+                ],
+            ]]),
         ]);
         $this->assertCount(1, $results);
 
@@ -316,8 +316,8 @@ 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']);
@@ -327,21 +327,21 @@ public function testObjectAttribute(): void
 
         // 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());
@@ -351,11 +351,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());
@@ -365,24 +365,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));
@@ -401,16 +401,16 @@ 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']);
@@ -418,7 +418,7 @@ public function testObjectAttribute(): void
 
         // 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());
@@ -430,15 +430,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());
@@ -450,15 +450,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']);
 
         // 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());
@@ -470,19 +470,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());
@@ -491,7 +491,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'));
@@ -504,16 +504,16 @@ 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]);
 
         // 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());
@@ -537,12 +537,12 @@ public function testObjectAttribute(): void
                     'level2' => [
                         'level3' => [
                             'level4' => [
-                                'level5' => 'deep_value'
-                            ]
-                        ]
-                    ]
-                ]
-            ]])
+                                'level5' => 'deep_value',
+                            ],
+                        ],
+                    ],
+                ],
+            ]]),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('doc5', $results[0]->getId());
@@ -551,7 +551,7 @@ public function testObjectAttribute(): void
         // 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));
 
@@ -566,7 +566,7 @@ 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'));
@@ -581,7 +581,7 @@ 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');
         }
 
@@ -589,10 +589,10 @@ public function testObjectAttributeGinIndex(): void
         $database->createCollection($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, new Index(key: 'idx_data_gin', type: IndexType::Object, attributes: ['data']));
         $this->assertTrue($ginIndex);
 
         // Test 2: Create documents with JSONB data
@@ -603,10 +603,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([
@@ -616,39 +616,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, new Index(key: 'idx_name_gin', type: IndexType::Object, attributes: ['name']));
         } catch (\Exception $e) {
             $exceptionThrown = true;
             $this->assertInstanceOf(IndexException::class, $e);
@@ -657,11 +657,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, new Index(key: 'idx_multi_gin', type: IndexType::Object, attributes: ['data', 'metadata']));
         } catch (\Exception $e) {
             $exceptionThrown = true;
             $this->assertInstanceOf(IndexException::class, $e);
@@ -672,7 +672,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, new Index(key: 'idx_ordered_gin', type: IndexType::Object, attributes: ['metadata'], lengths: [], orders: [OrderDirection::Asc->value]));
         } catch (\Exception $e) {
             $exceptionThrown = true;
             $this->assertInstanceOf(IndexException::class, $e);
@@ -684,284 +684,7 @@ 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 testMetadataWithVector(): void
     {
@@ -969,8 +692,9 @@ 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;
         }
 
@@ -978,8 +702,8 @@ public function testMetadataWithVector(): void
         $database->createCollection($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([
@@ -991,20 +715,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([
@@ -1016,17 +740,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([
@@ -1038,26 +762,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());
@@ -1068,11 +792,11 @@ public function testMetadataWithVector(): void
                 'profile' => [
                     'user' => [
                         'info' => [
-                            'country' => 'IN'
-                        ]
-                    ]
-                ]
-            ]])
+                            'country' => 'IN',
+                        ],
+                    ],
+                ],
+            ]]),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('vecA', $results[0]->getId());
@@ -1080,8 +804,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
 
@@ -1091,11 +815,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());
@@ -1106,11 +830,11 @@ public function testMetadataWithVector(): void
                 'settings' => [
                     'prefs' => [
                         'features' => [
-                            'experimental' => true
-                        ]
-                    ]
-                ]
-            ]])
+                            'experimental' => true,
+                        ],
+                    ],
+                ],
+            ]]),
         ]);
         $this->assertCount(1, $results);
         $this->assertEquals('vecA', $results[0]->getId());
@@ -1124,11 +848,11 @@ 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');
         }
 
@@ -1136,14 +860,13 @@ public function testNestedObjectAttributeIndexes(): void
         $database->createCollection($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, new Index(key: 'idx_profile_email_unique', type: IndexType::Unique, attributes: ['profile.user.email']));
         $this->assertTrue($created);
 
         $database->createDocument($collectionId, new Document([
@@ -1153,10 +876,10 @@ public function testNestedObjectAttributeIndexes(): void
                 'user' => [
                     'email' => 'a@example.com',
                     'info' => [
-                        'country' => 'IN'
-                    ]
-                ]
-            ]
+                        'country' => 'IN',
+                    ],
+                ],
+            ],
         ]));
 
         try {
@@ -1167,10 +890,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) {
@@ -1179,14 +902,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, new Index(key: 'idx_profile_nested_object', type: IndexType::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, new Index(key: 'idx_name_nested', type: IndexType::Key, attributes: ['name.first']));
             $this->fail('Expected Type exception for nested index on non-object base attribute');
         } catch (Exception $e) {
             $this->assertInstanceOf(IndexException::class, $e);
@@ -1200,11 +923,11 @@ 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');
         }
 
@@ -1212,11 +935,11 @@ public function testQueryNestedAttribute(): void
         $database->createCollection($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, new Index(key: 'idx_profile_email', type: IndexType::Key, attributes: ['profile.user.email']));
         $this->assertTrue($created);
 
         // Seed documents with different nested values
@@ -1229,11 +952,11 @@ public function testQueryNestedAttribute(): void
                         'email' => 'alice@example.com',
                         'info' => [
                             'country' => 'IN',
-                            'city' => 'BLR'
-                        ]
-                    ]
+                            'city' => 'BLR',
+                        ],
+                    ],
                 ],
-                'name' => 'Alice'
+                'name' => 'Alice',
             ]),
             new Document([
                 '$id' => 'd2',
@@ -1243,11 +966,11 @@ public function testQueryNestedAttribute(): void
                         'email' => 'bob@example.com',
                         'info' => [
                             'country' => 'US',
-                            'city' => 'NYC'
-                        ]
-                    ]
+                            'city' => 'NYC',
+                        ],
+                    ],
                 ],
-                'name' => 'Bob'
+                'name' => 'Bob',
             ]),
             new Document([
                 '$id' => 'd3',
@@ -1257,38 +980,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());
@@ -1298,7 +1021,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());
@@ -1308,7 +1031,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);
@@ -1317,7 +1040,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());
@@ -1330,7 +1053,7 @@ 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');
         }
 
@@ -1338,12 +1061,12 @@ public function testNestedObjectAttributeEdgeCases(): void
         $database->createCollection($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, new Index(key: 'idx_deep_nest', type: IndexType::Key, attributes: ['profile.level1.level2.level3.level4.value']));
         $this->assertTrue($created);
 
         $database->createDocuments($collectionId, [
@@ -1355,12 +1078,12 @@ public function testNestedObjectAttributeEdgeCases(): void
                         'level2' => [
                             'level3' => [
                                 'level4' => [
-                                    'value' => 'deep_value_1'
-                                ]
-                            ]
-                        ]
-                    ]
-                ]
+                                    'value' => 'deep_value_1',
+                                ],
+                            ],
+                        ],
+                    ],
+                ],
             ]),
             new Document([
                 '$id' => 'deep2',
@@ -1370,19 +1093,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) {
@@ -1392,17 +1115,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, new Index(key: 'idx_email', type: IndexType::Key, attributes: ['profile.user.email']));
         $this->assertTrue($created);
-        $created = $database->createIndex($collectionId, 'idx_country', Database::INDEX_KEY, ['profile.user.info.country']);
+        $created = $database->createIndex($collectionId, new Index(key: 'idx_country', type: IndexType::Key, 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, new Index(key: 'idx_city', type: IndexType::Key, attributes: ['profile.user.info.city']));
         $this->assertTrue($created);
 
         $database->createDocuments($collectionId, [
@@ -1414,10 +1137,10 @@ public function testNestedObjectAttributeEdgeCases(): void
                         'email' => 'multi1@test.com',
                         'info' => [
                             'country' => 'US',
-                            'city' => 'NYC'
-                        ]
-                    ]
-                ]
+                            'city' => 'NYC',
+                        ],
+                    ],
+                ],
             ]),
             new Document([
                 '$id' => 'multi2',
@@ -1427,30 +1150,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());
@@ -1464,10 +1187,10 @@ public function testNestedObjectAttributeEdgeCases(): void
                     'user' => [
                         'email' => null, // null value
                         'info' => [
-                            'country' => 'US'
-                        ]
-                    ]
-                ]
+                            'country' => 'US',
+                        ],
+                    ],
+                ],
             ]),
             new Document([
                 '$id' => 'null2',
@@ -1476,21 +1199,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) {
@@ -1510,10 +1233,10 @@ public function testNestedObjectAttributeEdgeCases(): void
                     'user' => [
                         'email' => 'alice.mixed@test.com',
                         'info' => [
-                            'country' => 'US'
-                        ]
-                    ]
-                ]
+                            'country' => 'US',
+                        ],
+                    ],
+                ],
             ]),
             new Document([
                 '$id' => 'mixed2',
@@ -1524,21 +1247,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, new Index(key: 'idx_name', type: IndexType::Key, attributes: ['name']));
+        $database->createIndex($collectionId, new Index(key: 'idx_age', type: IndexType::Key, 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());
@@ -1547,8 +1270,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());
@@ -1563,15 +1286,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());
@@ -1579,14 +1302,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
 
@@ -1600,10 +1323,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',
@@ -1613,16 +1336,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());
@@ -1638,10 +1361,10 @@ public function testNestedObjectAttributeEdgeCases(): void
                         'info' => [
                             'country' => 'US',
                             'city' => 'NYC',
-                            'zip' => '10001'
-                        ]
-                    ]
-                ]
+                            'zip' => '10001',
+                        ],
+                    ],
+                ],
             ]),
             new Document([
                 '$id' => 'complex2',
@@ -1652,10 +1375,10 @@ public function testNestedObjectAttributeEdgeCases(): void
                         'info' => [
                             'country' => 'US',
                             'city' => 'LAX',
-                            'zip' => '90001'
-                        ]
-                    ]
-                ]
+                            'zip' => '90001',
+                        ],
+                    ],
+                ],
             ]),
             new Document([
                 '$id' => 'complex3',
@@ -1666,19 +1389,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);
@@ -1687,13 +1410,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, [
@@ -1701,9 +1424,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);
@@ -1719,10 +1442,10 @@ public function testNestedObjectAttributeEdgeCases(): void
                     'user' => [
                         'email' => 'a@order.com',
                         'info' => [
-                            'country' => 'US'
-                        ]
-                    ]
-                ]
+                            'country' => 'US',
+                        ],
+                    ],
+                ],
             ]),
             new Document([
                 '$id' => 'order2',
@@ -1731,10 +1454,10 @@ public function testNestedObjectAttributeEdgeCases(): void
                     'user' => [
                         'email' => 'b@order.com',
                         'info' => [
-                            'country' => 'US'
-                        ]
-                    ]
-                ]
+                            'country' => 'US',
+                        ],
+                    ],
+                ],
             ]),
             new Document([
                 '$id' => 'order3',
@@ -1743,17 +1466,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);
 
@@ -1761,7 +1484,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);
 
@@ -1774,16 +1497,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;
@@ -1800,23 +1523,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, new Index(key: 'idx_email_recreated', type: IndexType::Key, 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, new Index(key: 'idx_unique_email', type: IndexType::Unique, attributes: ['profile.user.email']));
             $this->assertTrue($created);
 
             // Try to create duplicate
@@ -1828,10 +1551,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) {
@@ -1849,10 +1572,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',
@@ -1862,23 +1585,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 3f365ed37..7aa97c7cf 100644
--- a/tests/e2e/Adapter/Scopes/OperatorTests.php
+++ b/tests/e2e/Adapter/Scopes/OperatorTests.php
@@ -2,6 +2,8 @@
 
 namespace Tests\E2E\Adapter\Scopes;
 
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
 use Utopia\Database\Database;
 use Utopia\Database\DateTime;
 use Utopia\Database\Document;
@@ -12,29 +14,29 @@
 use Utopia\Database\Helpers\Role;
 use Utopia\Database\Operator;
 use Utopia\Database\Query;
+use Utopia\Query\Schema\ColumnType;
 
 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->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, new Attribute(key: 'count', type: ColumnType::Integer, size: 0, required: false, default: 0));
+        $database->createAttribute($collectionId, new Attribute(key: 'score', type: ColumnType::Double, size: 0, required: false, default: 0.0));
+        $database->createAttribute($collectionId, new Attribute(key: 'tags', type: ColumnType::String, size: 50, required: false, signed: true, array: true));
+        $database->createAttribute($collectionId, new Attribute(key: 'numbers', type: ColumnType::Integer, size: 0, required: false, signed: true, array: true));
+        $database->createAttribute($collectionId, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: false, default: 'test'));
 
         // Create test document
         $doc = $database->createDocument($collectionId, new Document([
@@ -124,21 +126,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->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, new Attribute(key: 'count', type: ColumnType::Integer, size: 0, required: false, default: 0));
+        $database->createAttribute($collectionId, new Attribute(key: 'tags', type: ColumnType::String, size: 50, required: false, signed: true, array: true));
+        $database->createAttribute($collectionId, new Attribute(key: 'category', type: ColumnType::String, size: 50, required: true));
 
         // Create multiple test documents
         $docs = [];
@@ -201,39 +202,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);
 
         // 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, new Attribute(key: 'counter', type: ColumnType::Integer, size: 0, required: false, default: 10));
+        $database->createAttribute($collectionId, new Attribute(key: 'score', type: ColumnType::Double, size: 0, required: false, default: 5.0));
+        $database->createAttribute($collectionId, new Attribute(key: 'multiplier', type: ColumnType::Double, size: 0, required: false, default: 2.0));
+        $database->createAttribute($collectionId, new Attribute(key: 'divisor', type: ColumnType::Double, size: 0, required: false, default: 100.0));
+        $database->createAttribute($collectionId, new Attribute(key: 'remainder', type: ColumnType::Integer, size: 0, required: false, default: 20));
+        $database->createAttribute($collectionId, new Attribute(key: 'power_val', type: ColumnType::Double, size: 0, required: false, default: 2.0));
+        $database->createAttribute($collectionId, new Attribute(key: 'title', type: ColumnType::String, size: 255, required: false, default: 'Title'));
+        $database->createAttribute($collectionId, new Attribute(key: 'content', type: ColumnType::String, size: 500, required: false, default: 'old content'));
+        $database->createAttribute($collectionId, new Attribute(key: 'tags', type: ColumnType::String, size: 50, required: false, signed: true, array: true));
+        $database->createAttribute($collectionId, new Attribute(key: 'categories', type: ColumnType::String, size: 50, required: false, signed: true, array: true));
+        $database->createAttribute($collectionId, new Attribute(key: 'items', type: ColumnType::String, size: 50, required: false, signed: true, array: true));
+        $database->createAttribute($collectionId, new Attribute(key: 'duplicates', type: ColumnType::String, size: 50, required: false, signed: true, array: true));
+        $database->createAttribute($collectionId, new Attribute(key: 'numbers', type: ColumnType::Integer, size: 0, required: false, signed: true, array: true));
+        $database->createAttribute($collectionId, new Attribute(key: 'intersect_items', type: ColumnType::String, size: 50, required: false, signed: true, array: true));
+        $database->createAttribute($collectionId, new Attribute(key: 'diff_items', type: ColumnType::String, size: 50, required: false, signed: true, array: true));
+        $database->createAttribute($collectionId, new Attribute(key: 'filter_numbers', type: ColumnType::Integer, size: 0, required: false, signed: true, array: true));
+        $database->createAttribute($collectionId, new Attribute(key: 'active', type: ColumnType::Boolean, size: 0, required: false, default: false));
+        $database->createAttribute($collectionId, new Attribute(key: 'last_update', type: ColumnType::Datetime, size: 0, required: false, signed: true, filters: ['datetime']));
+        $database->createAttribute($collectionId, new Attribute(key: 'next_update', type: ColumnType::Datetime, size: 0, required: false, signed: true, filters: ['datetime']));
+        $database->createAttribute($collectionId, new Attribute(key: 'now_field', type: ColumnType::Datetime, size: 0, required: false, signed: true, filters: ['datetime']));
 
         // Create test documents
         $docs = [];
@@ -351,22 +351,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->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, new Attribute(key: 'category', type: ColumnType::String, size: 50, required: true));
+        $database->createAttribute($collectionId, new Attribute(key: 'count', type: ColumnType::Integer, size: 0, required: false, default: 0));
+        $database->createAttribute($collectionId, new Attribute(key: 'score', type: ColumnType::Double, size: 0, required: false, default: 0.0));
+        $database->createAttribute($collectionId, new Attribute(key: 'active', type: ColumnType::Boolean, size: 0, required: false, default: false));
 
         // Create test documents
         for ($i = 1; $i <= 5; $i++) {
@@ -433,21 +432,20 @@ public function testUpdateDocumentsOperatorsWithQueries(): void
     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->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, new Attribute(key: 'text_field', type: ColumnType::String, size: 100, required: true));
+        $database->createAttribute($collectionId, new Attribute(key: 'number_field', type: ColumnType::Integer, size: 0, required: true));
+        $database->createAttribute($collectionId, new Attribute(key: 'array_field', type: ColumnType::String, size: 50, required: false, signed: true, array: true));
 
         // Create test document
         $doc = $database->createDocument($collectionId, new Document([
@@ -472,20 +470,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->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, new Attribute(key: 'text_field', type: ColumnType::String, size: 100, required: true));
+        $database->createAttribute($collectionId, new Attribute(key: 'array_field', type: ColumnType::String, size: 50, required: false, signed: true, array: true));
 
         // Create test document
         $doc = $database->createDocument($collectionId, new Document([
@@ -509,19 +506,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->createAttribute($collectionId, 'array_field', Database::VAR_STRING, 50, false, null, true, true);
+        $database->createAttribute($collectionId, new Attribute(key: 'array_field', type: ColumnType::String, size: 50, required: false, signed: true, array: true));
 
         // Create test document
         $doc = $database->createDocument($collectionId, new Document([
@@ -547,25 +543,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);
 
         // 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, new Attribute(key: 'string_field', type: ColumnType::String, size: 100, required: false, default: 'default'));
+        $database->createAttribute($collectionId, new Attribute(key: 'int_field', type: ColumnType::Integer, size: 0, required: false, default: 10));
+        $database->createAttribute($collectionId, new Attribute(key: 'float_field', type: ColumnType::Double, size: 0, required: false, default: 1.5));
+        $database->createAttribute($collectionId, new Attribute(key: 'bool_field', type: ColumnType::Boolean, size: 0, required: false, default: false));
+        $database->createAttribute($collectionId, new Attribute(key: 'array_field', type: ColumnType::String, size: 50, required: false, signed: true, array: true));
+        $database->createAttribute($collectionId, new Attribute(key: 'date_field', type: ColumnType::Datetime, size: 0, required: false, signed: true, filters: ['datetime']));
 
         // Create test document
         $doc = $database->createDocument($collectionId, new Document([
@@ -636,17 +631,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->createAttribute($collectionId, new Attribute(key: 'number', type: ColumnType::Double, size: 0, required: false, default: 100.0));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$id' => 'zero_test_doc',
@@ -692,17 +686,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->createAttribute($collectionId, new Attribute(key: 'items', type: ColumnType::String, size: 50, required: false, signed: true, array: true));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$id' => 'bounds_test_doc',
@@ -738,18 +731,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->createAttribute($collectionId, new Attribute(key: 'counter', type: ColumnType::Integer, size: 0, required: false, default: 10));
+        $database->createAttribute($collectionId, new Attribute(key: 'score', type: ColumnType::Double, size: 0, required: false, default: 5.0));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$id' => 'limits_test_doc',
@@ -795,18 +787,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->createAttribute($collectionId, new Attribute(key: 'numbers', type: ColumnType::Integer, size: 0, required: false, signed: true, array: true));
+        $database->createAttribute($collectionId, new Attribute(key: 'tags', type: ColumnType::String, size: 50, required: false, signed: true, array: true));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$id' => 'filter_test_doc',
@@ -833,18 +824,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->createAttribute($collectionId, new Attribute(key: 'text', type: ColumnType::String, size: 255, required: false, default: 'default text'));
+        $database->createAttribute($collectionId, new Attribute(key: 'number', type: ColumnType::Integer, size: 0, required: false, default: 0));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$id' => 'replace_test_doc',
@@ -881,19 +871,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->createAttribute($collectionId, new Attribute(key: 'nullable_int', type: ColumnType::Integer, size: 0, required: false, signed: false));
+        $database->createAttribute($collectionId, new Attribute(key: 'nullable_string', type: ColumnType::String, size: 100, required: false, signed: false));
+        $database->createAttribute($collectionId, new Attribute(key: 'nullable_bool', type: ColumnType::Boolean, size: 0, required: false, signed: false));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$id' => 'null_test_doc',
@@ -938,20 +927,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->createAttribute($collectionId, new Attribute(key: 'stats', type: ColumnType::Integer, size: 0, required: false, signed: true, array: true));
+        $database->createAttribute($collectionId, new Attribute(key: 'metadata', type: ColumnType::String, size: 100, required: false, signed: true, array: true));
+        $database->createAttribute($collectionId, new Attribute(key: 'score', type: ColumnType::Double, size: 0, required: false, default: 0.0));
+        $database->createAttribute($collectionId, new Attribute(key: 'name', type: ColumnType::String, size: 255, required: false, default: ''));
 
         // Create document with complex data
         $doc = $database->createDocument($collectionId, new Document([
@@ -998,17 +986,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->createAttribute($collectionId, new Attribute(key: 'count', type: ColumnType::Integer, size: 0, required: false, default: 0));
 
         // Success case
         $doc = $database->createDocument($collectionId, new Document([
@@ -1040,17 +1027,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->createAttribute($collectionId, new Attribute(key: 'title', type: ColumnType::String, size: 255, required: false, default: ''));
 
         // Success case
         $doc = $database->createDocument($collectionId, new Document([
@@ -1082,17 +1068,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->createAttribute($collectionId, new Attribute(key: 'number', type: ColumnType::Integer, size: 0, required: false, default: 0));
 
         // Success case
         $doc = $database->createDocument($collectionId, new Document([
@@ -1112,17 +1097,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->createAttribute($collectionId, new Attribute(key: 'active', type: ColumnType::Boolean, size: 0, required: false, default: false));
 
         // Success case
         $doc = $database->createDocument($collectionId, new Document([
@@ -1146,21 +1130,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->createAttribute($collectionId, new Attribute(key: 'items', type: ColumnType::String, size: 50, required: false, signed: true, array: true));
 
         // Success case
         $doc = $database->createDocument($collectionId, new Document([
@@ -1185,20 +1167,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->createAttribute($collectionId, new Attribute(key: 'count', type: ColumnType::Integer, size: 0, required: false));
+        $database->createAttribute($collectionId, new Attribute(key: 'score', type: ColumnType::Double, size: 0, required: false));
+        $database->createAttribute($collectionId, new Attribute(key: 'text', type: ColumnType::String, size: 255, required: false));
 
         // Success case - integer
         $doc = $database->createDocument($collectionId, new Document([
@@ -1244,17 +1225,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->createAttribute($collectionId, new Attribute(key: 'count', type: ColumnType::Integer, size: 0, required: false));
 
         // Success case
         $doc = $database->createDocument($collectionId, new Document([
@@ -1289,17 +1269,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->createAttribute($collectionId, new Attribute(key: 'value', type: ColumnType::Double, size: 0, required: false));
 
         // Success case
         $doc = $database->createDocument($collectionId, new Document([
@@ -1324,17 +1303,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->createAttribute($collectionId, new Attribute(key: 'value', type: ColumnType::Double, size: 0, required: false));
 
         // Success case
         $doc = $database->createDocument($collectionId, new Document([
@@ -1359,17 +1337,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->createAttribute($collectionId, new Attribute(key: 'number', type: ColumnType::Integer, size: 0, required: false));
 
         // Success case
         $doc = $database->createDocument($collectionId, new Document([
@@ -1388,17 +1365,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->createAttribute($collectionId, new Attribute(key: 'number', type: ColumnType::Double, size: 0, required: false));
 
         // Success case
         $doc = $database->createDocument($collectionId, new Document([
@@ -1423,17 +1399,16 @@ public function testOperatorPowerComprehensive(): 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->createAttribute($collectionId, new Attribute(key: 'text', type: ColumnType::String, size: 255, required: false));
 
         // Success case
         $doc = $database->createDocument($collectionId, new Document([
@@ -1462,17 +1437,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->createAttribute($collectionId, new Attribute(key: 'text', type: ColumnType::String, size: 255, required: false));
 
         // Success case - single replacement
         $doc = $database->createDocument($collectionId, new Document([
@@ -1503,17 +1477,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->createAttribute($collectionId, new Attribute(key: 'tags', type: ColumnType::String, size: 50, required: false, signed: true, array: true));
 
         // Success case
         $doc = $database->createDocument($collectionId, new Document([
@@ -1552,17 +1525,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->createAttribute($collectionId, new Attribute(key: 'items', type: ColumnType::String, size: 50, required: false, signed: true, array: true));
 
         // Success case
         $doc = $database->createDocument($collectionId, new Document([
@@ -1581,17 +1553,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->createAttribute($collectionId, new Attribute(key: 'numbers', type: ColumnType::Integer, size: 0, required: false, signed: true, array: true));
 
         // Success case - middle insertion
         $doc = $database->createDocument($collectionId, new Document([
@@ -1625,17 +1596,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->createAttribute($collectionId, new Attribute(key: 'items', type: ColumnType::String, size: 50, required: false, signed: true, array: true));
 
         // Success case - single occurrence
         $doc = $database->createDocument($collectionId, new Document([
@@ -1673,17 +1643,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->createAttribute($collectionId, new Attribute(key: 'items', type: ColumnType::String, size: 50, required: false, signed: true, array: true));
 
         // Success case - with duplicates
         $doc = $database->createDocument($collectionId, new Document([
@@ -1716,17 +1685,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->createAttribute($collectionId, new Attribute(key: 'items', type: ColumnType::String, size: 50, required: false, signed: true, array: true));
 
         // Success case
         $doc = $database->createDocument($collectionId, new Document([
@@ -1754,17 +1722,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->createAttribute($collectionId, new Attribute(key: 'items', type: ColumnType::String, size: 50, required: false, signed: true, array: true));
 
         // Success case
         $doc = $database->createDocument($collectionId, new Document([
@@ -1794,18 +1761,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->createAttribute($collectionId, new Attribute(key: 'numbers', type: ColumnType::Integer, size: 0, required: false, signed: true, array: true));
+        $database->createAttribute($collectionId, new Attribute(key: 'mixed', type: ColumnType::String, size: 50, required: false, signed: true, array: true));
 
         // Success case - equals condition
         $doc = $database->createDocument($collectionId, new Document([
@@ -1854,18 +1820,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->createAttribute($collectionId, new Attribute(key: 'integers', type: ColumnType::Integer, size: 0, required: false, signed: true, array: true));
+        $database->createAttribute($collectionId, new Attribute(key: 'floats', type: ColumnType::Double, size: 0, required: false, signed: true, array: true));
 
         // Create document with various numeric values
         $doc = $database->createDocument($collectionId, new Document([
@@ -1911,17 +1876,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->createAttribute($collectionId, new Attribute(key: 'active', type: ColumnType::Boolean, size: 0, required: false));
 
         // Success case - true to false
         $doc = $database->createDocument($collectionId, new Document([
@@ -1959,17 +1923,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->createAttribute($collectionId, new Attribute(key: 'date', type: ColumnType::Datetime, size: 0, required: false, signed: true, filters: ['datetime']));
 
         // Success case - positive days
         $doc = $database->createDocument($collectionId, new Document([
@@ -1995,17 +1958,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->createAttribute($collectionId, new Attribute(key: 'date', type: ColumnType::Datetime, size: 0, required: false, signed: true, filters: ['datetime']));
 
         // Success case
         $doc = $database->createDocument($collectionId, new Document([
@@ -2024,17 +1986,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->createAttribute($collectionId, new Attribute(key: 'timestamp', type: ColumnType::Datetime, size: 0, required: false, signed: true, filters: ['datetime']));
 
         // Success case
         $doc = $database->createDocument($collectionId, new Document([
@@ -2058,24 +2019,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->createAttribute($collectionId, new Attribute(key: 'count', type: ColumnType::Integer, size: 0, required: false));
+        $database->createAttribute($collectionId, new Attribute(key: 'score', type: ColumnType::Double, size: 0, required: false));
+        $database->createAttribute($collectionId, new Attribute(key: 'tags', type: ColumnType::String, size: 50, required: false, signed: true, array: true));
+        $database->createAttribute($collectionId, new Attribute(key: 'name', type: ColumnType::String, size: 255, required: false));
+        $database->createAttribute($collectionId, new Attribute(key: 'active', type: ColumnType::Boolean, size: 0, required: false));
 
         // Test multiple operators in one update
         $doc = $database->createDocument($collectionId, new Document([
@@ -2106,18 +2065,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->createAttribute($collectionId, new Attribute(key: 'count', type: ColumnType::Integer, size: 0, required: false));
+        $database->createAttribute($collectionId, new Attribute(key: 'category', type: ColumnType::String, size: 50, required: false));
 
         // Create multiple documents
         $docs = [];
@@ -2158,16 +2116,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->createAttribute($collectionId, new Attribute(key: 'items', type: ColumnType::String, size: 50, required: false, signed: true, array: true));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
@@ -2201,16 +2159,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->createAttribute($collectionId, new Attribute(key: 'items', type: ColumnType::Integer, size: 0, required: false, signed: true, array: true));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
@@ -2244,16 +2202,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->createAttribute($collectionId, new Attribute(key: 'items', type: ColumnType::String, size: 50, required: false, signed: true, array: true));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
@@ -2288,16 +2246,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->createAttribute($collectionId, new Attribute(key: 'numbers', type: ColumnType::Integer, size: 0, required: false, signed: true, array: true));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$permissions' => [Permission::read(Role::any()), Permission::update(Role::any())],
@@ -2365,20 +2323,19 @@ 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);
 
         // 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, new Attribute(key: 'score', type: ColumnType::Integer, size: 4, required: false, default: 0, signed: false));
 
         // Get the collection to verify attribute was created
         $collection = $database->getCollection($collectionId);
@@ -2453,19 +2410,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);
 
         // Create a string attribute with max length of 20 characters
-        $database->createAttribute($collectionId, 'title', Database::VAR_STRING, 20, false, '');
+        $database->createAttribute($collectionId, new Attribute(key: 'title', type: ColumnType::String, size: 20, required: false, default: ''));
 
         // Create a document with a 15-character title (within limit)
         $doc = $database->createDocument($collectionId, new Document([
@@ -2512,19 +2468,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);
 
         // 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, new Attribute(key: 'quantity', type: ColumnType::Integer, size: 4, required: false, default: 1, signed: false));
 
         // Create a document with quantity that when multiplied will exceed MAX_INT
         $doc = $database->createDocument($collectionId, new Document([
@@ -2574,17 +2529,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->createAttribute($collectionId, new Attribute(key: 'value', type: ColumnType::Double, size: 0, required: false));
 
         // Test negative multiplier without max limit
         $doc1 = $database->createDocument($collectionId, new Document([
@@ -2656,17 +2610,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->createAttribute($collectionId, new Attribute(key: 'value', type: ColumnType::Double, size: 0, required: false));
 
         // Test negative divisor without min limit
         $doc1 = $database->createDocument($collectionId, new Document([
@@ -2728,20 +2681,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);
 
         // 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, new Attribute(key: 'numbers', type: ColumnType::Integer, size: 4, required: false, signed: true, array: true));
 
         // Create a document with valid integer array
         $doc = $database->createDocument($collectionId, new Document([
@@ -2835,18 +2787,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->createAttribute($collectionId, new Attribute(key: 'bigint_max', type: ColumnType::Integer, size: 8, required: true));
+        $database->createAttribute($collectionId, new Attribute(key: 'bigint_min', type: ColumnType::Integer, size: 8, required: true));
 
         $maxValue = PHP_INT_MAX - 1000; // Near max but with room
         $minValue = PHP_INT_MIN + 1000; // Near min but with room
@@ -2884,17 +2835,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->createAttribute($collectionId, new Attribute(key: 'value', type: ColumnType::Double, size: 0, required: true));
 
         // Create document with value 8
         $doc = $database->createDocument($collectionId, new Document([
@@ -2920,17 +2870,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->createAttribute($collectionId, new Attribute(key: 'value', type: ColumnType::Double, size: 0, required: true));
 
         // Create document with value 16
         $doc = $database->createDocument($collectionId, new Document([
@@ -2967,17 +2916,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->createAttribute($collectionId, new Attribute(key: 'text', type: ColumnType::String, size: 255, required: false, default: ''));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$id' => 'empty_str_doc',
@@ -3024,17 +2972,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->createAttribute($collectionId, new Attribute(key: 'text', type: ColumnType::String, size: 500, required: false, default: ''));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$id' => 'unicode_doc',
@@ -3074,17 +3021,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->createAttribute($collectionId, new Attribute(key: 'items', type: ColumnType::String, size: 50, required: false, signed: true, array: true));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$id' => 'empty_array_doc',
@@ -3144,17 +3090,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->createAttribute($collectionId, new Attribute(key: 'mixed', type: ColumnType::String, size: 50, required: false, signed: true, array: true));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$id' => 'special_values_doc',
@@ -3192,17 +3137,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->createAttribute($collectionId, new Attribute(key: 'value', type: ColumnType::Integer, size: 0, required: true));
 
         // Test -17 % 5 (different languages handle this differently)
         $doc = $database->createDocument($collectionId, new Document([
@@ -3240,17 +3184,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->createAttribute($collectionId, new Attribute(key: 'value', type: ColumnType::Double, size: 0, required: true));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$id' => 'precision_doc',
@@ -3292,17 +3235,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->createAttribute($collectionId, new Attribute(key: 'text', type: ColumnType::String, size: 70000, required: false, default: ''));
 
         // Create a long string (10k characters)
         $longString = str_repeat('A', 10000);
@@ -3342,17 +3284,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->createAttribute($collectionId, new Attribute(key: 'date', type: ColumnType::Datetime, size: 0, required: false, signed: true, filters: ['datetime']));
 
         // Test date at end of year
         $doc = $database->createDocument($collectionId, new Document([
@@ -3415,17 +3356,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->createAttribute($collectionId, new Attribute(key: 'items', type: ColumnType::String, size: 50, required: false, signed: true, array: true));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$id' => 'boundary_insert_doc',
@@ -3459,18 +3399,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->createAttribute($collectionId, new Attribute(key: 'counter', type: ColumnType::Integer, size: 0, required: false, default: 0));
+        $database->createAttribute($collectionId, new Attribute(key: 'text', type: ColumnType::String, size: 255, required: false, default: ''));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$id' => 'sequential_doc',
@@ -3526,17 +3465,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->createAttribute($collectionId, new Attribute(key: 'value', type: ColumnType::Double, size: 0, required: true));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$id' => 'zero_doc',
@@ -3582,17 +3520,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->createAttribute($collectionId, new Attribute(key: 'items', type: ColumnType::String, size: 50, required: false, signed: true, array: true));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$id' => 'empty_result_doc',
@@ -3632,17 +3569,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->createAttribute($collectionId, new Attribute(key: 'text', type: ColumnType::String, size: 255, required: false, default: ''));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$id' => 'replace_multi_doc',
@@ -3676,17 +3612,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->createAttribute($collectionId, new Attribute(key: 'value', type: ColumnType::Double, size: 0, required: true));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$id' => 'precise_doc',
@@ -3720,17 +3655,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->createAttribute($collectionId, new Attribute(key: 'items', type: ColumnType::String, size: 50, required: false, signed: true, array: true));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$id' => 'single_elem_doc',
@@ -3780,17 +3714,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->createAttribute($collectionId, new Attribute(key: 'flag', type: ColumnType::Boolean, size: 0, required: false, default: false));
 
         // Create doc without setting flag (should use default false)
         $doc = $database->createDocument($collectionId, new Document([
@@ -3823,18 +3756,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);
         // Integer with size 0 (32-bit INT)
-        $database->createAttribute($collectionId, 'small_int', Database::VAR_INTEGER, 0, true);
+        $database->createAttribute($collectionId, new Attribute(key: 'small_int', type: ColumnType::Integer, size: 0, required: true));
 
         $doc = $database->createDocument($collectionId, new Document([
             '$id' => 'constraint_doc',
@@ -3864,21 +3796,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->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, new Attribute(key: 'count', type: ColumnType::Integer, size: 0, required: false, default: 0));
+        $database->createAttribute($collectionId, new Attribute(key: 'score', type: ColumnType::Double, size: 0, required: false, default: 0.0));
+        $database->createAttribute($collectionId, new Attribute(key: 'tags', type: ColumnType::String, size: 50, required: false, signed: true, array: true));
 
         // Create multiple test documents
         for ($i = 1; $i <= 5; $i++) {
@@ -3930,21 +3861,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->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, new Attribute(key: 'count', type: ColumnType::Integer, size: 0, required: false, default: 0));
+        $database->createAttribute($collectionId, new Attribute(key: 'value', type: ColumnType::Double, size: 0, required: false, default: 0.0));
+        $database->createAttribute($collectionId, new Attribute(key: 'items', type: ColumnType::String, size: 50, required: false, signed: true, array: true));
 
         // Create existing documents
         $database->createDocument($collectionId, new Document([
@@ -4027,21 +3957,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->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, new Attribute(key: 'count', type: ColumnType::Integer, size: 0, required: false, default: 0));
+        $database->createAttribute($collectionId, new Attribute(key: 'score', type: ColumnType::Double, size: 0, required: false, default: 0.0));
+        $database->createAttribute($collectionId, new Attribute(key: 'tags', type: ColumnType::String, size: 50, required: false, signed: true, array: true));
 
         // Test upsert with operators on new document (insert)
         $doc = $database->upsertDocument($collectionId, new Document([
@@ -4094,25 +4023,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->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, new Attribute(key: 'counter', type: ColumnType::Integer, size: 0, required: false, default: 0));
+        $database->createAttribute($collectionId, new Attribute(key: 'score', type: ColumnType::Double, size: 0, required: false, default: 0.0));
+        $database->createAttribute($collectionId, new Attribute(key: 'price', type: ColumnType::Double, size: 0, required: false, default: 0.0));
+        $database->createAttribute($collectionId, new Attribute(key: 'quantity', type: ColumnType::Integer, size: 0, required: false, default: 0));
+        $database->createAttribute($collectionId, new Attribute(key: 'tags', type: ColumnType::String, size: 50, required: false, signed: true, array: true));
+        $database->createAttribute($collectionId, new Attribute(key: 'numbers', type: ColumnType::Integer, size: 0, required: false, signed: true, array: true));
+        $database->createAttribute($collectionId, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: false, default: ''));
 
         // Test 1: INCREMENT on new document (should use 0 as default)
         $doc1 = $database->upsertDocument($collectionId, new Document([
@@ -4227,35 +4155,35 @@ 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']]),
+            new Attribute(key: 'counter', type: ColumnType::Integer, size: 0, required: false, default: 10),
+            new Attribute(key: 'score', type: ColumnType::Double, size: 0, required: false, default: 5.0),
+            new Attribute(key: 'multiplier', type: ColumnType::Double, size: 0, required: false, default: 2.0),
+            new Attribute(key: 'divisor', type: ColumnType::Double, size: 0, required: false, default: 100.0),
+            new Attribute(key: 'remainder', type: ColumnType::Integer, size: 0, required: false, default: 20),
+            new Attribute(key: 'power_val', type: ColumnType::Double, size: 0, required: false, default: 2.0),
+            new Attribute(key: 'title', type: ColumnType::String, size: 255, required: false, default: 'Title'),
+            new Attribute(key: 'content', type: ColumnType::String, size: 500, required: false, default: 'old content'),
+            new Attribute(key: 'tags', type: ColumnType::String, size: 50, required: false, array: true),
+            new Attribute(key: 'categories', type: ColumnType::String, size: 50, required: false, array: true),
+            new Attribute(key: 'items', type: ColumnType::String, size: 50, required: false, array: true),
+            new Attribute(key: 'duplicates', type: ColumnType::String, size: 50, required: false, array: true),
+            new Attribute(key: 'numbers', type: ColumnType::Integer, size: 0, required: false, array: true),
+            new Attribute(key: 'intersect_items', type: ColumnType::String, size: 50, required: false, array: true),
+            new Attribute(key: 'diff_items', type: ColumnType::String, size: 50, required: false, array: true),
+            new Attribute(key: 'filter_numbers', type: ColumnType::Integer, size: 0, required: false, array: true),
+            new Attribute(key: 'active', type: ColumnType::Boolean, size: 0, required: false, default: false),
+            new Attribute(key: 'date_field1', type: ColumnType::Datetime, size: 0, required: false, filters: ['datetime']),
+            new Attribute(key: 'date_field2', type: ColumnType::Datetime, size: 0, required: false, filters: ['datetime']),
+            new Attribute(key: 'date_field3', type: ColumnType::Datetime, size: 0, required: false, filters: ['datetime']),
         ];
         $database->createCollection($collectionId, $attributes);
 
@@ -4458,17 +4386,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->createAttribute($collectionId, new Attribute(key: 'items', type: ColumnType::String, size: 50, required: false, signed: true, array: true));
 
         // Test ARRAY_UNIQUE on empty array returns [] not NULL
         $doc1 = $database->createDocument($collectionId, new Document([
@@ -4520,17 +4447,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->createAttribute($collectionId, new Attribute(key: 'counter', type: ColumnType::Integer, size: 0, required: false, 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 c3af74495..244d2f3e1 100644
--- a/tests/e2e/Adapter/Scopes/PermissionTests.php
+++ b/tests/e2e/Adapter/Scopes/PermissionTests.php
@@ -3,6 +3,9 @@
 namespace Tests\E2E\Adapter\Scopes;
 
 use Exception;
+use Utopia\Database\Adapter\Feature;
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
 use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Exception as DatabaseException;
@@ -10,22 +13,340 @@
 use Utopia\Database\Helpers\ID;
 use Utopia\Database\Helpers\Permission;
 use Utopia\Database\Helpers\Role;
+use Utopia\Database\Relationship;
+use Utopia\Database\RelationType;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\ForeignKeyAction;
 
 trait PermissionTests
 {
+    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($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(), new Attribute(key: 'test', type: ColumnType::String, size: 255, required: false));
+
+        $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($this->getCollSecurityParentCollection(), permissions: [
+            Permission::create(Role::users()),
+            Permission::read(Role::users()),
+            Permission::update(Role::users()),
+            Permission::delete(Role::users()),
+        ], documentSecurity: true);
+
+        $database->createAttribute($collection->getId(), new Attribute(key: 'test', type: ColumnType::String, size: 255, required: false));
+
+        $collectionOneToOne = $database->createCollection($this->getCollSecurityOneToOneCollection(), permissions: [
+            Permission::create(Role::users()),
+            Permission::read(Role::users()),
+            Permission::update(Role::users()),
+            Permission::delete(Role::users()),
+        ], documentSecurity: true);
+
+        $database->createAttribute($collectionOneToOne->getId(), new Attribute(key: 'test', type: ColumnType::String, size: 255, required: false));
+
+        $database->createRelationship(new Relationship(collection: $collection->getId(), relatedCollection: $collectionOneToOne->getId(), type: RelationType::OneToOne, key: RelationType::OneToOne->value, onDelete: ForeignKeyAction::Cascade));
+
+        $collectionOneToMany = $database->createCollection($this->getCollSecurityOneToManyCollection(), permissions: [
+            Permission::create(Role::users()),
+            Permission::read(Role::users()),
+            Permission::update(Role::users()),
+            Permission::delete(Role::users()),
+        ], documentSecurity: true);
+
+        $database->createAttribute($collectionOneToMany->getId(), new Attribute(key: 'test', type: ColumnType::String, size: 255, required: false));
+
+        $database->createRelationship(new Relationship(collection: $collection->getId(), relatedCollection: $collectionOneToMany->getId(), type: RelationType::OneToMany, 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($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() instanceof Feature\Relationships)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        /** @var Database $database */
+        $database = $this->getDatabase();
+
+        $collection = $database->createCollection($this->getCollSecurityParentCollection(), 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->getId(), new Attribute(key: 'test', type: ColumnType::String, size: 255, required: false)));
+
+        $collectionOneToOne = $database->createCollection($this->getCollSecurityOneToOneCollection(), 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($collectionOneToOne->getId(), new Attribute(key: 'test', type: ColumnType::String, size: 255, required: false)));
+
+        $this->assertTrue($database->createRelationship(new Relationship(collection: $collection->getId(), relatedCollection: $collectionOneToOne->getId(), type: RelationType::OneToOne, key: RelationType::OneToOne->value, onDelete: ForeignKeyAction::Cascade)));
+
+        $collectionOneToMany = $database->createCollection($this->getCollSecurityOneToManyCollection(), 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($collectionOneToMany->getId(), new Attribute(key: 'test', type: ColumnType::String, size: 255, required: false)));
+
+        $this->assertTrue($database->createRelationship(new Relationship(collection: $collection->getId(), relatedCollection: $collectionOneToMany->getId(), type: RelationType::OneToMany, 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
-        ));
+        $this->assertTrue($database->createAttribute(__FUNCTION__, new Attribute(key: 'president', type: ColumnType::String, size: 255, required: false)));
 
         $permissions = [
             Permission::read(Role::any()),
@@ -201,15 +522,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')),
@@ -234,16 +556,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())
@@ -260,7 +582,7 @@ public function testNoChangeUpdateDocumentWithoutPermission(): Document
         ]));
 
         $updatedDocument = $database->updateDocument(
-            'documents',
+            $this->getDocumentsCollection(),
             $document->getId(),
             $document
         );
@@ -269,7 +591,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📝',
@@ -286,15 +608,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
@@ -302,7 +622,7 @@ public function testUpdateDocumentsPermissions(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForBatchOperations()) {
+        if (!$database->getAdapter()->supports(Capability::BatchOperations)) {
             $this->expectNotToPerformAssertions();
             return;
         }
@@ -312,7 +632,7 @@ public function testUpdateDocumentsPermissions(): void
         $database->createCollection($collection, attributes: [
             new Document([
                 '$id' => ID::custom('string'),
-                'type' => Database::VAR_STRING,
+                'type' => ColumnType::String->value,
                 'size' => 767,
                 'required' => true,
             ])
@@ -421,12 +741,12 @@ 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($this->getCollSecurityCollection(), permissions: [
             Permission::create(Role::users()),
             Permission::read(Role::users()),
             Permission::update(Role::users()),
@@ -435,24 +755,13 @@ public function testCollectionPermissions(): Document
 
         $this->assertInstanceOf(Document::class, $collection);
 
-        $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(), new Attribute(key: 'test', type: ColumnType::String, size: 255, required: false)));
     }
 
-    /**
-     * @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());
@@ -461,21 +770,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());
@@ -484,19 +789,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);
@@ -504,7 +805,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()),
@@ -516,18 +817,19 @@ 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')),
@@ -538,16 +840,14 @@ public function testCollectionPermissionsCreateWorks(Document $collection): arra
         ]));
         $this->assertInstanceOf(Document::class, $document);
 
-        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());
@@ -558,18 +858,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());
@@ -578,8 +876,8 @@ public function testCollectionPermissionsDeleteWorks(array $data): void
         $database = $this->getDatabase();
 
         $this->assertTrue($database->deleteDocument(
-            $collection->getId(),
-            $document->getId()
+            $collectionId,
+            $docId
         ));
     }
 
@@ -589,18 +887,15 @@ public function testCollectionPermissionsExceptions(): void
         $database = $this->getDatabase();
 
         $this->expectException(DatabaseException::class);
-        $database->createCollection('collectionSecurity', permissions: [
+        $database->createCollection($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());
@@ -610,17 +905,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());
@@ -628,28 +919,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());
@@ -658,21 +945,18 @@ 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());
@@ -681,100 +965,22 @@ 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
-        ));
-
-        return [$collection, $collectionOneToOne, $collectionOneToMany];
-    }
+        if (! ($this->getDatabase()->getAdapter() instanceof Feature\Relationships)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
 
-    /**
-     * @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());
@@ -783,7 +989,7 @@ public function testCollectionPermissionsRelationshipsCountWorks(array $data): v
         $database = $this->getDatabase();
 
         $documents = $database->count(
-            $collection->getId()
+            $collectionId
         );
 
         $this->assertEquals(1, $documents);
@@ -792,7 +998,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);
@@ -801,19 +1007,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() instanceof Feature\Relationships)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $data = $this->initRelationshipPermissionFixture();
+        $collectionId = $data['collectionId'];
 
         $this->getDatabase()->getAuthorization()->cleanRoles();
         $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
@@ -822,7 +1030,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()),
@@ -832,13 +1040,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() instanceof Feature\Relationships)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $data = $this->initRelationshipPermissionFixture();
+        $collectionId = $data['collectionId'];
+        $docId = $data['docId'];
 
         $this->getDatabase()->getAuthorization()->cleanRoles();
         $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
@@ -848,27 +1059,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() instanceof Feature\Relationships)) {
+            $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')),
@@ -876,7 +1089,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')),
@@ -885,7 +1098,7 @@ public function testCollectionPermissionsRelationshipsCreateWorks(array $data):
                 ],
                 'test' => 'lorem ipsum'
             ],
-            Database::RELATION_ONE_TO_MANY => [
+            RelationType::OneToMany->value => [
                 [
                     '$id' => ID::unique(),
                     '$permissions' => [
@@ -907,16 +1120,19 @@ public function testCollectionPermissionsRelationshipsCreateWorks(array $data):
         ]));
         $this->assertInstanceOf(Document::class, $document);
 
-        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() instanceof Feature\Relationships)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $data = $this->initRelationshipPermissionFixture();
+        $collectionId = $data['collectionId'];
+        $docId = $data['docId'];
 
         $this->getDatabase()->getAuthorization()->cleanRoles();
         $this->getDatabase()->getAuthorization()->addRole(Role::users()->toString());
@@ -925,18 +1141,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() instanceof Feature\Relationships)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $data = $this->initRelationshipPermissionFixture();
+        $collectionId = $data['collectionId'];
 
         $this->getDatabase()->getAuthorization()->cleanRoles();
         $this->getDatabase()->getAuthorization()->addRole(Role::users()->toString());
@@ -944,58 +1162,56 @@ 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->assertInstanceOf(Document::class, $document->getAttribute(RelationType::OneToOne->value));
+        $this->assertIsArray($document->getAttribute(RelationType::OneToMany->value));
+        $this->assertCount(2, $document->getAttribute(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->assertInstanceOf(Document::class, $document->getAttribute(RelationType::OneToOne->value));
+        $this->assertIsArray($document->getAttribute(RelationType::OneToMany->value));
+        $this->assertCount(1, $document->getAttribute(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() instanceof Feature\Relationships)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $data = $this->initRelationshipPermissionFixture();
+        $collectionId = $data['collectionId'];
+        $docId = $data['docId'];
 
         $this->getDatabase()->getAuthorization()->cleanRoles();
         $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
@@ -1004,21 +1220,23 @@ 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() instanceof Feature\Relationships)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $data = $this->initRelationshipPermissionFixture();
+        $collectionId = $data['collectionId'];
+        $docId = $data['docId'];
 
         $this->getDatabase()->getAuthorization()->cleanRoles();
         $this->getDatabase()->getAuthorization()->addRole(Role::users()->toString());
@@ -1026,70 +1244,71 @@ 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->assertInstanceOf(Document::class, $document->getAttribute(RelationType::OneToOne->value));
+        $this->assertIsArray($document->getAttribute(RelationType::OneToMany->value));
+        $this->assertCount(2, $document->getAttribute(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->assertInstanceOf(Document::class, $document->getAttribute(RelationType::OneToOne->value));
+        $this->assertIsArray($document->getAttribute(RelationType::OneToMany->value));
+        $this->assertCount(1, $document->getAttribute(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;
+        if (! ($this->getDatabase()->getAdapter() instanceof Feature\Relationships)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
 
-        $this->getDatabase()->getAuthorization()->cleanRoles();
-        $this->getDatabase()->getAuthorization()->addRole(Role::any()->toString());
-
-        $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(),
+        $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);
+
+        $database->updateDocument(
+            $collectionId,
+            $docId,
             $document->setAttribute('test', $document->getAttribute('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() instanceof Feature\Relationships)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $data = $this->initRelationshipPermissionFixture();
+        $collectionId = $data['collectionId'];
+        $docId = $data['docId'];
 
         $this->getDatabase()->getAuthorization()->cleanRoles();
         $this->getDatabase()->getAuthorization()->addRole(Role::users()->toString());
@@ -1097,9 +1316,11 @@ public function testCollectionPermissionsRelationshipsUpdateWorks(array $data):
         /** @var Database $database */
         $database = $this->getDatabase();
 
+        $document = $database->getDocument($collectionId, $docId);
+
         $database->updateDocument(
-            $collection->getId(),
-            $document->getId(),
+            $collectionId,
+            $docId,
             $document
         );
 
@@ -1109,46 +1330,43 @@ public function testCollectionPermissionsRelationshipsUpdateWorks(array $data):
         $this->getDatabase()->getAuthorization()->addRole(Role::user('random')->toString());
 
         $database->updateDocument(
-            $collection->getId(),
-            $document->getId(),
+            $collectionId,
+            $docId,
             $document->setAttribute('test', 'ipsum')
         );
 
         $this->assertTrue(true);
-
-        return $data;
     }
 
-    /**
-     * @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());
@@ -1156,26 +1374,24 @@ public function testCollectionPermissionsUpdateWorks(array $data): array
         /** @var Database $database */
         $database = $this->getDatabase();
 
+        $document = $database->getDocument($collectionId, $docId);
+
         $this->assertInstanceOf(Document::class, $database->updateDocument(
-            $collection->getId(),
-            $document->getId(),
+            $collectionId,
+            $docId,
             $document->setAttribute('test', 'ipsum')
         ));
-
-        return $data;
     }
-
-    /**
-     * @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);
     }
@@ -1189,7 +1405,7 @@ public function testWritePermissions(): void
             Permission::create(Role::any()),
         ], documentSecurity: true);
 
-        $database->createAttribute('animals', 'type', Database::VAR_STRING, 128, true);
+        $database->createAttribute('animals', new Attribute(key: 'type', type: ColumnType::String, size: 128, required: true));
 
         $dog = $database->createDocument('animals', new Document([
             '$id' => 'dog',
@@ -1259,7 +1475,7 @@ public function testCreateRelationDocumentWithoutUpdatePermission(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (!($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
             return;
         }
@@ -1277,15 +1493,10 @@ public function testCreateRelationDocumentWithoutUpdatePermission(): void
             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', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: false));
+        $database->createAttribute('childRelationTest', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: false));
+
+        $database->createRelationship(new Relationship(collection: 'parentRelationTest', relatedCollection: 'childRelationTest', type: RelationType::OneToMany, key: 'children'));
 
         // Create document with relationship with nested data
         $parent = $database->createDocument('parentRelationTest', new Document([
@@ -1311,5 +1522,4 @@ public function testCreateRelationDocumentWithoutUpdatePermission(): void
         $database->deleteCollection('parentRelationTest');
         $database->deleteCollection('childRelationTest');
     }
-
 }
diff --git a/tests/e2e/Adapter/Scopes/RelationshipTests.php b/tests/e2e/Adapter/Scopes/RelationshipTests.php
index 9182b8b8b..76cf7c8a7 100644
--- a/tests/e2e/Adapter/Scopes/RelationshipTests.php
+++ b/tests/e2e/Adapter/Scopes/RelationshipTests.php
@@ -7,92 +7,68 @@
 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\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\Database\RelationType;
+use Utopia\Query\Schema\ColumnType;
+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() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $database->createCollection('zoo');
-        $database->createAttribute('zoo', 'name', Database::VAR_STRING, 256, true);
+        $database->createAttribute('zoo', new Attribute(key: 'name', type: ColumnType::String, size: 256, required: true));
 
         $database->createCollection('veterinarians');
-        $database->createAttribute('veterinarians', 'fullname', Database::VAR_STRING, 256, true);
+        $database->createAttribute('veterinarians', new Attribute(key: 'fullname', type: ColumnType::String, 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(
-            collection: 'presidents',
-            relatedCollection: 'veterinarians',
-            type: Database::RELATION_MANY_TO_MANY,
-            twoWay: true,
-            id: 'votes',
-            twoWayKey: 'presidents'
-        );
+        $database->createAttribute('presidents', new Attribute(key: 'firstName', type: ColumnType::String, size: 256, required: true));
+        $database->createAttribute('presidents', new Attribute(key: 'lastName', type: ColumnType::String, size: 256, required: true));
+        $database->createRelationship(new Relationship(collection: 'presidents', relatedCollection: 'veterinarians', type: RelationType::ManyToMany, twoWay: true, 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(
-            collection: 'presidents',
-            relatedCollection: '__animals',
-            type: Database::RELATION_ONE_TO_ONE,
-            twoWay: true,
-            id: 'animal',
-            twoWayKey: 'president'
-        );
+        $database->createAttribute('__animals', new Attribute(key: 'name', type: ColumnType::String, size: 256, required: true));
+        $database->createAttribute('__animals', new Attribute(key: 'age', type: ColumnType::Integer, size: 0, required: false));
+        $database->createAttribute('__animals', new Attribute(key: 'price', type: ColumnType::Double, size: 0, required: false));
+        $database->createAttribute('__animals', new Attribute(key: 'dateOfBirth', type: ColumnType::Datetime, size: 0, required: true, filters: ['datetime']));
+        $database->createAttribute('__animals', new Attribute(key: 'longtext', type: ColumnType::String, size: 100000000, required: false));
+        $database->createAttribute('__animals', new Attribute(key: 'isActive', type: ColumnType::Boolean, size: 0, required: false, default: true));
+        $database->createAttribute('__animals', new Attribute(key: 'integers', type: ColumnType::Integer, size: 0, required: false, array: true));
+        $database->createAttribute('__animals', new Attribute(key: 'email', type: ColumnType::String, size: 255, required: false));
+        $database->createAttribute('__animals', new Attribute(key: 'ip', type: ColumnType::String, size: 255, required: false));
+        $database->createAttribute('__animals', new Attribute(key: 'url', type: ColumnType::String, size: 255, required: false));
+        $database->createAttribute('__animals', new Attribute(key: 'enum', type: ColumnType::String, size: 255, required: false));
 
-        $database->createRelationship(
-            collection: 'veterinarians',
-            relatedCollection: '__animals',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-            id: 'animals',
-            twoWayKey: 'veterinarian'
-        );
+        $database->createRelationship(new Relationship(collection: 'presidents', relatedCollection: '__animals', type: RelationType::OneToOne, twoWay: true, key: 'animal', twoWayKey: 'president'));
 
-        $database->createRelationship(
-            collection: '__animals',
-            relatedCollection: 'zoo',
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: true,
-            id: 'zoo',
-            twoWayKey: 'animals'
-        );
+        $database->createRelationship(new Relationship(collection: 'veterinarians', relatedCollection: '__animals', type: RelationType::OneToMany, twoWay: true, key: 'animals', twoWayKey: 'veterinarian'));
+
+        $database->createRelationship(new Relationship(collection: '__animals', relatedCollection: 'zoo', type: RelationType::ManyToOne, twoWay: true, key: 'zoo', twoWayKey: 'animals'));
 
         $zoo = $database->createDocument('zoo', new Document([
             '$id' => 'zoo1',
@@ -100,7 +76,7 @@ public function testZoo(): void
                 Permission::read(Role::any()),
                 Permission::update(Role::any()),
             ],
-            'name' => 'Bronx Zoo'
+            'name' => 'Bronx Zoo',
         ]));
 
         $this->assertEquals('zoo1', $zoo->getId());
@@ -257,7 +233,7 @@ public function testZoo(): void
         $this->assertArrayHasKey('president', $veterinarian->getAttribute('animals')[0]);
 
         $veterinarian = $database->findOne('veterinarians', [
-            Query::equal('$id', ['dr.pol'])
+            Query::equal('$id', ['dr.pol']),
         ]);
 
         $this->assertEquals('dr.pol', $veterinarian->getId());
@@ -284,7 +260,7 @@ public function testZoo(): void
         $this->assertEquals('bush', $animal['president']->getId());
 
         $animal = $database->findOne('__animals', [
-            Query::equal('$id', ['tiger'])
+            Query::equal('$id', ['tiger']),
         ]);
 
         $this->assertEquals('tiger', $animal->getId());
@@ -310,7 +286,7 @@ public function testZoo(): void
          * Check President data
          */
         $president = $database->findOne('presidents', [
-            Query::equal('$id', ['bush'])
+            Query::equal('$id', ['bush']),
         ]);
 
         $this->assertEquals('bush', $president->getId());
@@ -323,7 +299,7 @@ public function testZoo(): void
                 '*',
                 'votes.*',
             ]),
-            Query::equal('$id', ['trump'])
+            Query::equal('$id', ['trump']),
         ]);
 
         $this->assertEquals('trump', $president->getId());
@@ -337,7 +313,7 @@ public function testZoo(): void
                 'votes.*',
                 'votes.animals.*',
             ]),
-            Query::equal('$id', ['trump'])
+            Query::equal('$id', ['trump']),
         ]);
 
         $this->assertEquals('trump', $president->getId());
@@ -362,7 +338,7 @@ public function testZoo(): void
             [
                 Query::select([
                     'animals.*',
-                ])
+                ]),
             ]
         );
 
@@ -384,7 +360,7 @@ public function testZoo(): void
                     'animals.*',
                     'animals.zoo.*',
                     'animals.president.*',
-                ])
+                ]),
             ]
         );
 
@@ -405,8 +381,9 @@ public function testSimpleRelationshipPopulation(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -414,17 +391,10 @@ public function testSimpleRelationshipPopulation(): void
         $database->createCollection('usersSimple');
         $database->createCollection('postsSimple');
 
-        $database->createAttribute('usersSimple', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('postsSimple', 'title', Database::VAR_STRING, 255, true);
+        $database->createAttribute('usersSimple', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('postsSimple', new Attribute(key: 'title', type: ColumnType::String, size: 255, required: true));
 
-        $database->createRelationship(
-            collection: 'usersSimple',
-            relatedCollection: 'postsSimple',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-            id: 'posts',
-            twoWayKey: 'author'
-        );
+        $database->createRelationship(new Relationship(collection: 'usersSimple', relatedCollection: 'postsSimple', type: RelationType::OneToMany, twoWay: true, key: 'posts', twoWayKey: 'author'));
 
         // Create some data
         $user = $database->createDocument('usersSimple', new Document([
@@ -455,7 +425,7 @@ public function testSimpleRelationshipPopulation(): void
         $this->assertIsArray($posts, 'Posts should be an array');
         $this->assertCount(2, $posts, 'Should have 2 posts');
 
-        if (!empty($posts)) {
+        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');
         }
@@ -465,7 +435,7 @@ public function testSimpleRelationshipPopulation(): void
 
         $this->assertCount(2, $fetchedPosts, 'Should fetch 2 posts');
 
-        if (!empty($fetchedPosts)) {
+        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');
@@ -477,8 +447,9 @@ public function testDeleteRelatedCollection(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -486,11 +457,7 @@ public function testDeleteRelatedCollection(): void
         $database->createCollection('c2');
 
         // ONE_TO_ONE
-        $database->createRelationship(
-            collection: 'c1',
-            relatedCollection: 'c2',
-            type: Database::RELATION_ONE_TO_ONE,
-        );
+        $database->createRelationship(new Relationship(collection: 'c1', relatedCollection: 'c2', type: RelationType::OneToOne));
 
         $this->assertEquals(true, $database->deleteCollection('c1'));
         $collection = $database->getCollection('c2');
@@ -498,11 +465,7 @@ public function testDeleteRelatedCollection(): void
         $this->assertCount(0, $collection->getAttribute('indexes'));
 
         $database->createCollection('c1');
-        $database->createRelationship(
-            collection: 'c1',
-            relatedCollection: 'c2',
-            type: Database::RELATION_ONE_TO_ONE,
-        );
+        $database->createRelationship(new Relationship(collection: 'c1', relatedCollection: 'c2', type: RelationType::OneToOne));
 
         $this->assertEquals(true, $database->deleteCollection('c2'));
         $collection = $database->getCollection('c1');
@@ -510,12 +473,7 @@ public function testDeleteRelatedCollection(): void
         $this->assertCount(0, $collection->getAttribute('indexes'));
 
         $database->createCollection('c2');
-        $database->createRelationship(
-            collection: 'c1',
-            relatedCollection: 'c2',
-            type: Database::RELATION_ONE_TO_ONE,
-            twoWay: true
-        );
+        $database->createRelationship(new Relationship(collection: 'c1', relatedCollection: 'c2', type: RelationType::OneToOne, twoWay: true));
 
         $this->assertEquals(true, $database->deleteCollection('c1'));
         $collection = $database->getCollection('c2');
@@ -523,12 +481,7 @@ public function testDeleteRelatedCollection(): void
         $this->assertCount(0, $collection->getAttribute('indexes'));
 
         $database->createCollection('c1');
-        $database->createRelationship(
-            collection: 'c1',
-            relatedCollection: 'c2',
-            type: Database::RELATION_ONE_TO_ONE,
-            twoWay: true
-        );
+        $database->createRelationship(new Relationship(collection: 'c1', relatedCollection: 'c2', type: RelationType::OneToOne, twoWay: true));
 
         $this->assertEquals(true, $database->deleteCollection('c2'));
         $collection = $database->getCollection('c1');
@@ -537,11 +490,7 @@ public function testDeleteRelatedCollection(): void
 
         // ONE_TO_MANY
         $database->createCollection('c2');
-        $database->createRelationship(
-            collection: 'c1',
-            relatedCollection: 'c2',
-            type: Database::RELATION_ONE_TO_MANY,
-        );
+        $database->createRelationship(new Relationship(collection: 'c1', relatedCollection: 'c2', type: RelationType::OneToMany));
 
         $this->assertEquals(true, $database->deleteCollection('c1'));
         $collection = $database->getCollection('c2');
@@ -549,11 +498,7 @@ public function testDeleteRelatedCollection(): void
         $this->assertCount(0, $collection->getAttribute('indexes'));
 
         $database->createCollection('c1');
-        $database->createRelationship(
-            collection: 'c1',
-            relatedCollection: 'c2',
-            type: Database::RELATION_ONE_TO_MANY,
-        );
+        $database->createRelationship(new Relationship(collection: 'c1', relatedCollection: 'c2', type: RelationType::OneToMany));
 
         $this->assertEquals(true, $database->deleteCollection('c2'));
         $collection = $database->getCollection('c1');
@@ -561,12 +506,7 @@ public function testDeleteRelatedCollection(): void
         $this->assertCount(0, $collection->getAttribute('indexes'));
 
         $database->createCollection('c2');
-        $database->createRelationship(
-            collection: 'c1',
-            relatedCollection: 'c2',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true
-        );
+        $database->createRelationship(new Relationship(collection: 'c1', relatedCollection: 'c2', type: RelationType::OneToMany, twoWay: true));
 
         $this->assertEquals(true, $database->deleteCollection('c1'));
         $collection = $database->getCollection('c2');
@@ -574,12 +514,7 @@ public function testDeleteRelatedCollection(): void
         $this->assertCount(0, $collection->getAttribute('indexes'));
 
         $database->createCollection('c1');
-        $database->createRelationship(
-            collection: 'c1',
-            relatedCollection: 'c2',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true
-        );
+        $database->createRelationship(new Relationship(collection: 'c1', relatedCollection: 'c2', type: RelationType::OneToMany, twoWay: true));
 
         $this->assertEquals(true, $database->deleteCollection('c2'));
         $collection = $database->getCollection('c1');
@@ -588,11 +523,7 @@ public function testDeleteRelatedCollection(): void
 
         // RELATION_MANY_TO_ONE
         $database->createCollection('c2');
-        $database->createRelationship(
-            collection: 'c1',
-            relatedCollection: 'c2',
-            type: Database::RELATION_MANY_TO_ONE,
-        );
+        $database->createRelationship(new Relationship(collection: 'c1', relatedCollection: 'c2', type: RelationType::ManyToOne));
 
         $this->assertEquals(true, $database->deleteCollection('c1'));
         $collection = $database->getCollection('c2');
@@ -600,11 +531,7 @@ public function testDeleteRelatedCollection(): void
         $this->assertCount(0, $collection->getAttribute('indexes'));
 
         $database->createCollection('c1');
-        $database->createRelationship(
-            collection: 'c1',
-            relatedCollection: 'c2',
-            type: Database::RELATION_MANY_TO_ONE,
-        );
+        $database->createRelationship(new Relationship(collection: 'c1', relatedCollection: 'c2', type: RelationType::ManyToOne));
 
         $this->assertEquals(true, $database->deleteCollection('c2'));
         $collection = $database->getCollection('c1');
@@ -612,12 +539,7 @@ public function testDeleteRelatedCollection(): void
         $this->assertCount(0, $collection->getAttribute('indexes'));
 
         $database->createCollection('c2');
-        $database->createRelationship(
-            collection: 'c1',
-            relatedCollection: 'c2',
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: true
-        );
+        $database->createRelationship(new Relationship(collection: 'c1', relatedCollection: 'c2', type: RelationType::ManyToOne, twoWay: true));
 
         $this->assertEquals(true, $database->deleteCollection('c1'));
         $collection = $database->getCollection('c2');
@@ -625,12 +547,7 @@ public function testDeleteRelatedCollection(): void
         $this->assertCount(0, $collection->getAttribute('indexes'));
 
         $database->createCollection('c1');
-        $database->createRelationship(
-            collection: 'c1',
-            relatedCollection: 'c2',
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: true
-        );
+        $database->createRelationship(new Relationship(collection: 'c1', relatedCollection: 'c2', type: RelationType::ManyToOne, twoWay: true));
 
         $this->assertEquals(true, $database->deleteCollection('c2'));
         $collection = $database->getCollection('c1');
@@ -643,8 +560,9 @@ public function testVirtualRelationsAttributes(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -655,12 +573,7 @@ public function testVirtualRelationsAttributes(): void
          * 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(new Relationship(collection: 'v1', relatedCollection: 'v2', type: RelationType::OneToOne, twoWay: false));
 
         try {
             $database->createDocument('v2', new Document([
@@ -680,7 +593,7 @@ public function testVirtualRelationsAttributes(): void
                 'v1' => [
                     '$id' => 'test',
                     '$permissions' => [],
-                ]
+                ],
             ]));
             $this->fail('Failed to throw exception');
         } catch (Exception $e) {
@@ -709,9 +622,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 +634,8 @@ public function testVirtualRelationsAttributes(): void
                 '$permissions' => [],
                 'v2' => [[
                     '$id' => 'woman',
-                    '$permissions' => []
-                ]]
+                    '$permissions' => [],
+                ]],
             ]));
             $this->fail('Failed to throw exception');
         } catch (Exception $e) {
@@ -735,12 +648,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(new Relationship(collection: 'v1', relatedCollection: 'v2', type: RelationType::OneToMany, twoWay: true));
 
         try {
             $database->createDocument('v1', new Document([
@@ -749,7 +657,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 +681,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 +699,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 +709,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 +725,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 +738,7 @@ public function testVirtualRelationsAttributes(): void
                 'v1' => [
                     '$id' => null, // Invalid value
                     '$permissions' => [],
-                ]
+                ],
             ]));
             $this->fail('Failed to throw exception');
         } catch (Exception $e) {
@@ -844,7 +751,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 +774,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(new Relationship(collection: 'v1', relatedCollection: 'v2', type: RelationType::ManyToOne, twoWay: true));
 
         try {
             $database->createDocument('v1', new Document([
@@ -881,7 +783,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 +807,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 +838,7 @@ public function testVirtualRelationsAttributes(): void
                     Permission::update(Role::any()),
                     Permission::read(Role::any()),
                 ],
-            ]
+            ],
         ]));
 
         $this->assertEquals('doc1', $doc->getId());
@@ -957,7 +859,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 +872,7 @@ public function testVirtualRelationsAttributes(): void
          * RELATION_MANY_TO_MANY
          * No attribute on V1/v2 collections only on junction table
          */
-        $database->createRelationship(
-            collection: 'v1',
-            relatedCollection: 'v2',
-            type: Database::RELATION_MANY_TO_MANY,
-            twoWay: true,
-            id: 'students',
-            twoWayKey: 'classes'
-        );
+        $database->createRelationship(new Relationship(collection: 'v1', relatedCollection: 'v2', type: RelationType::ManyToMany, twoWay: true, key: 'students', twoWayKey: 'classes'));
 
         try {
             $database->createDocument('v1', new Document([
@@ -1006,7 +901,7 @@ public function testVirtualRelationsAttributes(): void
                 'classes' => [ // Expected array, object provided
                     '$id' => 'test',
                     '$permissions' => [],
-                ]
+                ],
             ]));
             $this->fail('Failed to throw exception');
         } catch (Exception $e) {
@@ -1034,7 +929,6 @@ public function testVirtualRelationsAttributes(): void
         /**
          * Success for later test update
          */
-
         $doc = $database->createDocument('v1', new Document([
             '$id' => 'class1',
             '$permissions' => [
@@ -1046,17 +940,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 +965,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 +980,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 +988,28 @@ 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() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $database->createCollection('rnRsTestA');
         $database->createCollection('rnRsTestB');
 
-        $database->createAttribute('rnRsTestB', 'name', Database::VAR_STRING, 255, true);
+        $database->createAttribute('rnRsTestB', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
 
-        $database->createRelationship(
-            'rnRsTestA',
-            'rnRsTestB',
-            Database::RELATION_ONE_TO_ONE,
-            true
-        );
+        $database->createRelationship(new Relationship(
+            collection: 'rnRsTestA',
+            relatedCollection: 'rnRsTestB',
+            type: RelationType::OneToOne,
+            twoWay: true
+        ));
 
         $docA = $database->createDocument('rnRsTestA', new Document([
             '$permissions' => [
@@ -1265,8 +1020,8 @@ public function testUpdateAttributeRenameRelationshipTwoWay(): void
             ],
             'rnRsTestB' => [
                 '$id' => 'b1',
-                'name' => 'B1'
-            ]
+                'name' => 'B1',
+            ],
         ]));
 
         $docB = $database->getDocument('rnRsTestB', 'b1');
@@ -1293,107 +1048,26 @@ public function testUpdateAttributeRenameRelationshipTwoWay(): void
         $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);
-    }
-
     public function testSelectRelationshipAttributes(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $database->createCollection('make');
         $database->createCollection('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->createRelationship(
-            collection: 'make',
-            relatedCollection: 'model',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-            id: 'models',
-            twoWayKey: 'make',
-        );
+        $database->createAttribute('make', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('make', new Attribute(key: 'origin', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('model', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('model', new Attribute(key: 'year', type: ColumnType::Integer, size: 0, required: true));
+
+        $database->createRelationship(new Relationship(collection: 'make', relatedCollection: 'model', type: RelationType::OneToMany, twoWay: true, key: 'models', twoWayKey: 'make'));
 
         $database->createDocument('make', new Document([
             '$id' => 'ford',
@@ -1562,692 +1236,175 @@ public function testSelectRelationshipAttributes(): void
             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.');
+        if ($make->isEmpty()) {
+            throw new Exception('Make not found');
+        }
 
-        $database->createDocument('invalid1', new Document([
-            '$id' => ID::unique(),
-            'invalid3' => [10],
-        ]));
-    }
+        $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']);
 
-    public function testCreateEmptyValueRelationship(): void
-    {
-        /** @var Database $database */
-        $database = $this->getDatabase();
+        // Select all parent attributes, all child attributes
+        // Must select parent if selecting children
+        $make = $database->findOne('make', [
+            Query::select(['models.*']),
+        ]);
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
-            $this->expectNotToPerformAssertions();
-            return;
+        if ($make->isEmpty()) {
+            throw new Exception('Make not found');
         }
 
-        $database->createCollection('null1');
-        $database->createCollection('null2');
-
-        $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',
-        );
-
-        $document = $database->createDocument('null1', new Document([
-            '$id' => ID::unique(),
-            'null2' => null,
-        ]));
+        $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']);
 
-        $this->assertEquals(null, $document->getAttribute('null2'));
+        // Select all parent attributes, no child attributes
+        $make = $database->findOne('make', [
+            Query::select(['name']),
+        ]);
 
-        $document = $database->createDocument('null2', new Document([
-            '$id' => ID::unique(),
-            'null1' => null,
-        ]));
+        if ($make->isEmpty()) {
+            throw new Exception('Make not found');
+        }
+        $this->assertEquals('Ford', $make['name']);
+        $this->assertArrayNotHasKey('models', $make);
 
-        $this->assertEquals(null, $document->getAttribute('null1'));
+        // Select some parent attributes, all child attributes
+        $make = $database->findOne('make', [
+            Query::select(['name', 'models.*']),
+        ]);
 
-        $document = $database->createDocument('null1', new Document([
-            '$id' => ID::unique(),
-            'null3' => null,
-        ]));
+        $this->assertEquals('Ford', $make['name']);
+        $this->assertEquals(2, \count($make['models']));
 
-        // One to many will be empty array instead of null
-        $this->assertEquals([], $document->getAttribute('null3'));
+        /*
+         * FROM CHILD TO PARENT
+         */
 
-        $document = $database->createDocument('null2', new Document([
-            '$id' => ID::unique(),
-            'null4' => null,
-        ]));
+        // Select some parent attributes, some child attributes
+        $model = $database->findOne('model', [
+            Query::select(['name', 'make.name']),
+        ]);
 
-        $this->assertEquals(null, $document->getAttribute('null4'));
+        $this->assertEquals('Fiesta', $model['name']);
+        $this->assertEquals('Ford', $model['make']['name']);
+        $this->assertArrayNotHasKey('origin', $model['make']);
+        $this->assertArrayNotHasKey('year', $model);
+        $this->assertArrayHasKey('name', $model);
 
-        $document = $database->createDocument('null1', new Document([
-            '$id' => ID::unique(),
-            'null4' => null,
-        ]));
+        // Select all parent attributes, some child attributes
+        $model = $database->findOne('model', [
+            Query::select(['*', 'make.name']),
+        ]);
 
-        $this->assertEquals(null, $document->getAttribute('null4'));
+        $this->assertEquals('Fiesta', $model['name']);
+        $this->assertEquals('Ford', $model['make']['name']);
+        $this->assertArrayHasKey('year', $model);
 
-        $document = $database->createDocument('null2', new Document([
-            '$id' => ID::unique(),
-            'null5' => null,
-        ]));
+        // Select all parent attributes, all child attributes
+        $model = $database->findOne('model', [
+            Query::select(['*', 'make.*']),
+        ]);
 
-        $this->assertEquals([], $document->getAttribute('null5'));
+        $this->assertEquals('Fiesta', $model['name']);
+        $this->assertEquals('Ford', $model['make']['name']);
+        $this->assertArrayHasKey('year', $model);
+        $this->assertArrayHasKey('name', $model['make']);
 
-        $document = $database->createDocument('null1', new Document([
-            '$id' => ID::unique(),
-            'null6' => null,
-        ]));
+        // Select all parent attributes, no child attributes
+        $model = $database->findOne('model', [
+            Query::select(['*']),
+        ]);
 
-        $this->assertEquals([], $document->getAttribute('null6'));
+        $this->assertEquals('Fiesta', $model['name']);
+        $this->assertArrayHasKey('make', $model);
+        $this->assertArrayHasKey('year', $model);
 
-        $document = $database->createDocument('null2', new Document([
-            '$id' => ID::unique(),
-            'null7' => null,
-        ]));
+        // 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['make']['name']);
+        $this->assertEquals('USA', $model['make']['origin']);
     }
 
-    public function testUpdateRelationshipToExistingKey(): void
+    public function testInheritRelationshipPermissions(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('ovens');
-        $database->createCollection('cakes');
-
-        $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->createRelationship(
-            collection: 'ovens',
-            relatedCollection: 'cakes',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-            id: 'cakes',
-            twoWayKey: 'oven'
-        );
+        $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);
 
-        try {
-            $database->updateRelationship('ovens', 'cakes', newKey: 'owner');
-            $this->fail('Failed to throw exception');
-        } catch (DuplicateException $e) {
-            $this->assertEquals('Relationship already exists', $e->getMessage());
-        }
+        $database->createAttribute('lawns', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('trees', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('birds', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
 
-        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->createRelationship(new Relationship(collection: 'lawns', relatedCollection: 'trees', type: RelationType::OneToMany, twoWay: true, twoWayKey: 'lawn', onDelete: ForeignKeyAction::Cascade));
+        $database->createRelationship(new Relationship(collection: 'trees', relatedCollection: 'birds', type: RelationType::ManyToMany, twoWay: true, onDelete: ForeignKeyAction::SetNull));
+
+        $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());
     }
 
     public function testUpdateDocumentsRelationships(): void
     {
-        if (!$this->getDatabase()->getAdapter()->getSupportForBatchOperations() || !$this->getDatabase()->getAdapter()->getSupportForRelationships()) {
+        if (! $this->getDatabase()->getAdapter()->supports(Capability::BatchOperations) || ! ($this->getDatabase()->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -2255,39 +1412,24 @@ public function testUpdateDocumentsRelationships(): void
         $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,
-            ])
+            new Attribute(key: 'string', type: ColumnType::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,
-            ])
+            new Attribute(key: 'string', type: ColumnType::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(new Relationship(collection: 'testUpdateDocumentsRelationships1', relatedCollection: 'testUpdateDocumentsRelationships2', type: RelationType::OneToOne, twoWay: true));
 
         $this->getDatabase()->createDocument('testUpdateDocumentsRelationships1', new Document([
             '$id' => 'doc1',
@@ -2297,7 +1439,7 @@ public function testUpdateDocumentsRelationships(): void
         $this->getDatabase()->createDocument('testUpdateDocumentsRelationships2', new Document([
             '$id' => 'doc1',
             'string' => 'text📝',
-            'testUpdateDocumentsRelationships1' => 'doc1'
+            'testUpdateDocumentsRelationships1' => 'doc1',
         ]));
 
         $sisterDocument = $this->getDatabase()->getDocument('testUpdateDocumentsRelationships2', 'doc1');
@@ -2321,32 +1463,27 @@ public function testUpdateDocumentsRelationships(): void
         // 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(new Relationship(collection: 'testUpdateDocumentsRelationships1', relatedCollection: 'testUpdateDocumentsRelationships2', type: RelationType::OneToMany, 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');
@@ -2361,205 +1498,89 @@ public function testUpdateDocumentWithRelationships(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $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' => [],
-            ]),
+            new Attribute(key: 'username', type: ColumnType::String, size: 700, required: false, default: null, signed: true, array: false, format: '', filters: []),
         ], [], [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(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' => [],
-            ]),
+            new Attribute(key: 'title', type: ColumnType::String, size: 700, required: false, default: null, signed: true, array: false, format: '', filters: []),
         ], [], [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(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' => [],
-            ]),
+            new Attribute(key: 'title', type: ColumnType::String, size: 700, required: false, default: null, signed: true, array: false, format: '', filters: []),
         ], [], [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(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' => [],
-            ]),
+            new Attribute(key: 'title', type: ColumnType::String, size: 700, required: false, default: null, signed: true, array: false, format: '', filters: []),
         ], [], [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(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' => [],
-            ]),
+            new Attribute(key: 'metaTitle', type: ColumnType::String, size: 700, required: false, default: null, signed: true, array: false, format: '', filters: []),
         ], [], [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(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' => [],
-            ]),
+            new Attribute(key: 'metaTitle', type: ColumnType::String, size: 700, required: false, default: null, signed: true, array: false, format: '', filters: []),
         ], [], [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(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' => [],
-            ]),
+            new Attribute(key: 'name', type: ColumnType::String, size: 700, required: false, default: null, signed: true, array: false, format: '', filters: []),
         ], [], [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(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' => [],
-            ]),
+            new Attribute(key: 'name', type: ColumnType::String, size: 700, required: false, default: null, signed: true, array: false, format: '', filters: []),
         ], [], [
             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(new Relationship(collection: 'userProfiles', relatedCollection: 'links', type: RelationType::OneToMany, key: 'links'));
 
-        $database->createRelationship(
-            collection: 'userProfiles',
-            relatedCollection: 'videos',
-            type: Database::RELATION_ONE_TO_MANY,
-            id: 'videos'
-        );
+        $database->createRelationship(new Relationship(collection: 'userProfiles', relatedCollection: 'videos', type: RelationType::OneToMany, key: 'videos'));
 
-        $database->createRelationship(
-            collection: 'userProfiles',
-            relatedCollection: 'products',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-            id: 'products',
-            twoWayKey: 'userProfile',
-        );
+        $database->createRelationship(new Relationship(collection: 'userProfiles', relatedCollection: 'products', type: RelationType::OneToMany, twoWay: true, key: 'products', twoWayKey: 'userProfile'));
 
-        $database->createRelationship(
-            collection: 'userProfiles',
-            relatedCollection: 'settings',
-            type: Database::RELATION_ONE_TO_ONE,
-            id: 'settings'
-        );
+        $database->createRelationship(new Relationship(collection: 'userProfiles', relatedCollection: 'settings', type: RelationType::OneToOne, key: 'settings'));
 
-        $database->createRelationship(
-            collection: 'userProfiles',
-            relatedCollection: 'appearance',
-            type: Database::RELATION_ONE_TO_ONE,
-            id: 'appearance'
-        );
+        $database->createRelationship(new Relationship(collection: 'userProfiles', relatedCollection: 'appearance', type: RelationType::OneToOne, key: 'appearance'));
 
-        $database->createRelationship(
-            collection: 'userProfiles',
-            relatedCollection: 'group',
-            type: Database::RELATION_MANY_TO_ONE,
-            id: 'group'
-        );
+        $database->createRelationship(new Relationship(collection: 'userProfiles', relatedCollection: 'group', type: RelationType::ManyToOne, key: 'group'));
 
-        $database->createRelationship(
-            collection: 'userProfiles',
-            relatedCollection: 'community',
-            type: Database::RELATION_MANY_TO_ONE,
-            id: 'community'
-        );
+        $database->createRelationship(new Relationship(collection: 'userProfiles', relatedCollection: 'community', type: RelationType::ManyToOne, key: 'community'));
 
         $profile = $database->createDocument('userProfiles', new Document([
             '$id' => '1',
@@ -2667,39 +1688,28 @@ public function testMultiDocumentNestedRelationships(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         // Create collections: car -> customer -> inspection
         $database->createCollection('car');
-        $database->createAttribute('car', 'plateNumber', Database::VAR_STRING, 255, true);
+        $database->createAttribute('car', new Attribute(key: 'plateNumber', type: ColumnType::String, size: 255, required: true));
 
         $database->createCollection('customer');
-        $database->createAttribute('customer', 'name', Database::VAR_STRING, 255, true);
+        $database->createAttribute('customer', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
 
         $database->createCollection('inspection');
-        $database->createAttribute('inspection', 'type', Database::VAR_STRING, 255, true);
+        $database->createAttribute('inspection', new Attribute(key: 'type', type: ColumnType::String, size: 255, 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(new Relationship(collection: 'car', relatedCollection: 'customer', type: RelationType::ManyToOne, twoWay: false, 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(new Relationship(collection: 'customer', relatedCollection: 'inspection', type: RelationType::OneToMany, twoWay: false, key: 'inspections'));
 
         // Create test data - customers with inspections first
         $database->createDocument('inspection', new Document([
@@ -2887,8 +1897,9 @@ public function testNestedDocumentCreationWithDepthHandling(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -2897,29 +1908,15 @@ public function testNestedDocumentCreationWithDepthHandling(): void
         $database->createCollection('productDepthTest');
         $database->createCollection('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', new Attribute(key: 'orderNumber', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('productDepthTest', new Attribute(key: 'productName', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('storeDepthTest', new Attribute(key: 'storeName', type: ColumnType::String, size: 255, required: true));
 
         // Order -> Product (many-to-one)
-        $database->createRelationship(
-            collection: 'orderDepthTest',
-            relatedCollection: 'productDepthTest',
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: true,
-            id: 'product',
-            twoWayKey: 'orders'
-        );
+        $database->createRelationship(new Relationship(collection: 'orderDepthTest', relatedCollection: 'productDepthTest', type: RelationType::ManyToOne, twoWay: true, key: 'product', twoWayKey: 'orders'));
 
         // Product -> Store (many-to-one)
-        $database->createRelationship(
-            collection: 'productDepthTest',
-            relatedCollection: 'storeDepthTest',
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: true,
-            id: 'store',
-            twoWayKey: 'products'
-        );
+        $database->createRelationship(new Relationship(collection: 'productDepthTest', relatedCollection: 'storeDepthTest', type: RelationType::ManyToOne, twoWay: true, key: 'store', twoWayKey: 'products'));
 
         // First, create a store that will be referenced by the nested product
         $store = $database->createDocument('storeDepthTest', new Document([
@@ -3022,8 +2019,9 @@ public function testRelationshipTypeQueries(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -3031,19 +2029,12 @@ public function testRelationshipTypeQueries(): void
         $database->createCollection('authorsFilter');
         $database->createCollection('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->createRelationship(
-            collection: 'authorsFilter',
-            relatedCollection: 'postsFilter',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-            id: 'posts',
-            twoWayKey: 'author'
-        );
+        $database->createAttribute('authorsFilter', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('authorsFilter', new Attribute(key: 'age', type: ColumnType::Integer, size: 0, required: true));
+        $database->createAttribute('postsFilter', new Attribute(key: 'title', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('postsFilter', new Attribute(key: 'published', type: ColumnType::Boolean, size: 0, required: true));
+
+        $database->createRelationship(new Relationship(collection: 'authorsFilter', relatedCollection: 'postsFilter', type: RelationType::OneToMany, twoWay: true, key: 'posts', twoWayKey: 'author'));
 
         // Create test data
         $author1 = $database->createDocument('authorsFilter', new Document([
@@ -3112,18 +2103,11 @@ public function testRelationshipTypeQueries(): void
         $database->createCollection('usersOto');
         $database->createCollection('profilesOto');
 
-        $database->createAttribute('usersOto', 'username', Database::VAR_STRING, 255, true);
-        $database->createAttribute('profilesOto', 'bio', Database::VAR_STRING, 255, true);
+        $database->createAttribute('usersOto', new Attribute(key: 'username', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('profilesOto', new Attribute(key: 'bio', type: ColumnType::String, size: 255, required: true));
 
         // ONE_TO_ONE with twoWay=true
-        $database->createRelationship(
-            collection: 'usersOto',
-            relatedCollection: 'profilesOto',
-            type: Database::RELATION_ONE_TO_ONE,
-            twoWay: true,
-            id: 'profile',
-            twoWayKey: 'user'
-        );
+        $database->createRelationship(new Relationship(collection: 'usersOto', relatedCollection: 'profilesOto', type: RelationType::OneToOne, twoWay: true, key: 'profile', twoWayKey: 'user'));
 
         $user1 = $database->createDocument('usersOto', new Document([
             '$id' => 'user1',
@@ -3159,18 +2143,11 @@ public function testRelationshipTypeQueries(): void
         $database->createCollection('commentsMto');
         $database->createCollection('usersMto');
 
-        $database->createAttribute('commentsMto', 'content', Database::VAR_STRING, 255, true);
-        $database->createAttribute('usersMto', 'name', Database::VAR_STRING, 255, true);
+        $database->createAttribute('commentsMto', new Attribute(key: 'content', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('usersMto', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
 
         // MANY_TO_ONE with twoWay=true
-        $database->createRelationship(
-            collection: 'commentsMto',
-            relatedCollection: 'usersMto',
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: true,
-            id: 'commenter',
-            twoWayKey: 'comments'
-        );
+        $database->createRelationship(new Relationship(collection: 'commentsMto', relatedCollection: 'usersMto', type: RelationType::ManyToOne, twoWay: true, key: 'commenter', twoWayKey: 'comments'));
 
         $userA = $database->createDocument('usersMto', new Document([
             '$id' => 'userA',
@@ -3212,18 +2189,11 @@ public function testRelationshipTypeQueries(): void
         $database->createCollection('studentsMtm');
         $database->createCollection('coursesMtm');
 
-        $database->createAttribute('studentsMtm', 'studentName', Database::VAR_STRING, 255, true);
-        $database->createAttribute('coursesMtm', 'courseName', Database::VAR_STRING, 255, true);
+        $database->createAttribute('studentsMtm', new Attribute(key: 'studentName', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('coursesMtm', new Attribute(key: 'courseName', type: ColumnType::String, size: 255, required: true));
 
         // MANY_TO_MANY
-        $database->createRelationship(
-            collection: 'studentsMtm',
-            relatedCollection: 'coursesMtm',
-            type: Database::RELATION_MANY_TO_MANY,
-            twoWay: true,
-            id: 'enrolledCourses',
-            twoWayKey: 'students'
-        );
+        $database->createRelationship(new Relationship(collection: 'studentsMtm', relatedCollection: 'coursesMtm', type: RelationType::ManyToMany, twoWay: true, key: 'enrolledCourses', twoWayKey: 'students'));
 
         $student1 = $database->createDocument('studentsMtm', new Document([
             '$id' => 'student1',
@@ -3265,25 +2235,19 @@ public function testQueryByRelationshipId(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $database->createCollection('usersRelId');
         $database->createCollection('postsRelId');
 
-        $database->createAttribute('usersRelId', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('postsRelId', 'title', Database::VAR_STRING, 255, true);
+        $database->createAttribute('usersRelId', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('postsRelId', new Attribute(key: 'title', type: ColumnType::String, size: 255, required: true));
 
-        $database->createRelationship(
-            collection: 'postsRelId',
-            relatedCollection: 'usersRelId',
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: true,
-            id: 'user',
-            twoWayKey: 'posts'
-        );
+        $database->createRelationship(new Relationship(collection: 'postsRelId', relatedCollection: 'usersRelId', type: RelationType::ManyToOne, twoWay: true, key: 'user', twoWayKey: 'posts'));
 
         // Create test users
         $user1 = $database->createDocument('usersRelId', new Document([
@@ -3371,17 +2335,10 @@ public function testQueryByRelationshipId(): void
         $database->createCollection('usersOtoId');
         $database->createCollection('profilesOtoId');
 
-        $database->createAttribute('usersOtoId', 'username', Database::VAR_STRING, 255, true);
-        $database->createAttribute('profilesOtoId', 'bio', Database::VAR_STRING, 255, true);
+        $database->createAttribute('usersOtoId', new Attribute(key: 'username', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('profilesOtoId', new Attribute(key: 'bio', type: ColumnType::String, size: 255, required: true));
 
-        $database->createRelationship(
-            collection: 'usersOtoId',
-            relatedCollection: 'profilesOtoId',
-            type: Database::RELATION_ONE_TO_ONE,
-            twoWay: true,
-            id: 'profile',
-            twoWayKey: 'user'
-        );
+        $database->createRelationship(new Relationship(collection: 'usersOtoId', relatedCollection: 'profilesOtoId', type: RelationType::OneToOne, twoWay: true, key: 'profile', twoWayKey: 'user'));
 
         $userOto1 = $database->createDocument('usersOtoId', new Document([
             '$id' => 'userOto1',
@@ -3424,17 +2381,10 @@ public function testQueryByRelationshipId(): void
         $database->createCollection('developersMtmId');
         $database->createCollection('projectsMtmId');
 
-        $database->createAttribute('developersMtmId', 'devName', Database::VAR_STRING, 255, true);
-        $database->createAttribute('projectsMtmId', 'projectName', Database::VAR_STRING, 255, true);
+        $database->createAttribute('developersMtmId', new Attribute(key: 'devName', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('projectsMtmId', new Attribute(key: 'projectName', type: ColumnType::String, size: 255, required: true));
 
-        $database->createRelationship(
-            collection: 'developersMtmId',
-            relatedCollection: 'projectsMtmId',
-            type: Database::RELATION_MANY_TO_MANY,
-            twoWay: true,
-            id: 'projects',
-            twoWayKey: 'developers'
-        );
+        $database->createRelationship(new Relationship(collection: 'developersMtmId', relatedCollection: 'projectsMtmId', type: RelationType::ManyToMany, twoWay: true, key: 'projects', twoWayKey: 'developers'));
 
         $dev1 = $database->createDocument('developersMtmId', new Document([
             '$id' => 'dev1',
@@ -3573,8 +2523,9 @@ public function testRelationshipFilterQueries(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -3582,21 +2533,14 @@ public function testRelationshipFilterQueries(): void
         $database->createCollection('productsQt');
         $database->createCollection('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->createRelationship(
-            collection: 'productsQt',
-            relatedCollection: 'vendorsQt',
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: true,
-            id: 'vendor',
-            twoWayKey: 'products'
-        );
+        $database->createAttribute('productsQt', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('productsQt', new Attribute(key: 'price', type: ColumnType::Double, size: 0, required: true));
+        $database->createAttribute('vendorsQt', new Attribute(key: 'company', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('vendorsQt', new Attribute(key: 'rating', type: ColumnType::Double, size: 0, required: true));
+        $database->createAttribute('vendorsQt', new Attribute(key: 'email', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('vendorsQt', new Attribute(key: 'verified', type: ColumnType::Boolean, size: 0, required: true));
+
+        $database->createRelationship(new Relationship(collection: 'productsQt', relatedCollection: 'vendorsQt', type: RelationType::ManyToOne, twoWay: true, key: 'vendor', twoWayKey: 'products'));
 
         // Create test vendors
         $database->createDocument('vendorsQt', new Document([
@@ -3653,70 +2597,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 +2669,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,13 +2684,15 @@ public function testRelationshipSpatialQueries(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        if (!$database->getAdapter()->getSupportForSpatialAttributes()) {
+        if (! ($database->getAdapter() instanceof Feature\Spatial)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -3754,22 +2700,15 @@ public function testRelationshipSpatialQueries(): void
         $database->createCollection('restaurantsSpatial');
         $database->createCollection('suppliersSpatial');
 
-        $database->createAttribute('restaurantsSpatial', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('restaurantsSpatial', 'location', Database::VAR_POINT, 0, 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->createRelationship(
-            collection: 'restaurantsSpatial',
-            relatedCollection: 'suppliersSpatial',
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: true,
-            id: 'supplier',
-            twoWayKey: 'restaurants'
-        );
+        $database->createAttribute('restaurantsSpatial', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('restaurantsSpatial', new Attribute(key: 'location', type: ColumnType::Point, size: 0, required: true));
+
+        $database->createAttribute('suppliersSpatial', new Attribute(key: 'company', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('suppliersSpatial', new Attribute(key: 'warehouseLocation', type: ColumnType::Point, size: 0, required: true));
+        $database->createAttribute('suppliersSpatial', new Attribute(key: 'deliveryArea', type: ColumnType::Polygon, size: 0, required: true));
+        $database->createAttribute('suppliersSpatial', new Attribute(key: 'deliveryRoute', type: ColumnType::Linestring, size: 0, required: true));
+
+        $database->createRelationship(new Relationship(collection: 'restaurantsSpatial', relatedCollection: 'suppliersSpatial', type: RelationType::ManyToOne, twoWay: true, key: 'supplier', twoWayKey: 'restaurants'));
 
         // Create suppliers with spatial data (coordinates are [longitude, latitude])
         $supplier1 = $database->createDocument('suppliersSpatial', new Document([
@@ -3782,13 +2721,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 +2740,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 +2759,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 +2774,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 +2782,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 +2790,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 +2840,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 +2852,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 +2863,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 +2876,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 +2890,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 +2901,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 +2909,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,8 +2933,9 @@ public function testRelationshipVirtualQueries(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -4003,20 +2943,13 @@ public function testRelationshipVirtualQueries(): void
         $database->createCollection('teamsParent');
         $database->createCollection('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->createRelationship(
-            collection: 'teamsParent',
-            relatedCollection: 'membersParent',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-            id: 'members',
-            twoWayKey: 'team'
-        );
+        $database->createAttribute('teamsParent', new Attribute(key: 'teamName', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('teamsParent', new Attribute(key: 'active', type: ColumnType::Boolean, size: 0, required: true));
+        $database->createAttribute('membersParent', new Attribute(key: 'memberName', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('membersParent', new Attribute(key: 'role', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('membersParent', new Attribute(key: 'senior', type: ColumnType::Boolean, size: 0, required: true));
+
+        $database->createRelationship(new Relationship(collection: 'teamsParent', relatedCollection: 'membersParent', type: RelationType::OneToMany, twoWay: true, key: 'members', twoWayKey: 'team'));
 
         // Create teams
         $database->createDocument('teamsParent', new Document([
@@ -4064,21 +2997,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 +3019,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,8 +3036,9 @@ public function testRelationshipQueryEdgeCases(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -4112,19 +3046,12 @@ public function testRelationshipQueryEdgeCases(): void
         $database->createCollection('ordersEdge');
         $database->createCollection('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->createRelationship(
-            collection: 'ordersEdge',
-            relatedCollection: 'customersEdge',
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: true,
-            id: 'customer',
-            twoWayKey: 'orders'
-        );
+        $database->createAttribute('ordersEdge', new Attribute(key: 'orderNumber', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('ordersEdge', new Attribute(key: 'total', type: ColumnType::Double, size: 0, required: true));
+        $database->createAttribute('customersEdge', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('customersEdge', new Attribute(key: 'age', type: ColumnType::Integer, size: 0, required: true));
+
+        $database->createRelationship(new Relationship(collection: 'ordersEdge', relatedCollection: 'customersEdge', type: RelationType::ManyToOne, twoWay: true, key: 'customer', twoWayKey: 'orders'));
 
         // Create customer
         $database->createDocument('customersEdge', new Document([
@@ -4145,21 +3072,21 @@ 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
@@ -4176,14 +3103,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 +3119,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,8 +3135,9 @@ public function testRelationshipManyToManyComplex(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -4217,20 +3145,13 @@ public function testRelationshipManyToManyComplex(): void
         $database->createCollection('developersMtm');
         $database->createCollection('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->createRelationship(
-            collection: 'developersMtm',
-            relatedCollection: 'projectsMtm',
-            type: Database::RELATION_MANY_TO_MANY,
-            twoWay: true,
-            id: 'assignedProjects',
-            twoWayKey: 'assignedDevelopers'
-        );
+        $database->createAttribute('developersMtm', new Attribute(key: 'devName', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('developersMtm', new Attribute(key: 'experience', type: ColumnType::Integer, size: 0, required: true));
+        $database->createAttribute('projectsMtm', new Attribute(key: 'projectName', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('projectsMtm', new Attribute(key: 'budget', type: ColumnType::Double, size: 0, required: true));
+        $database->createAttribute('projectsMtm', new Attribute(key: 'priority', type: ColumnType::String, size: 50, required: true));
+
+        $database->createRelationship(new Relationship(collection: 'developersMtm', relatedCollection: 'projectsMtm', type: RelationType::ManyToMany, twoWay: true, key: 'assignedProjects', twoWayKey: 'assignedDevelopers'));
 
         // Create developers
         $dev1 = $database->createDocument('developersMtm', new Document([
@@ -4268,33 +3189,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 +3230,9 @@ public function testNestedRelationshipQueriesMultipleDepths(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -4320,70 +3242,42 @@ public function testNestedRelationshipQueriesMultipleDepths(): void
 
         // 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->createAttribute('companiesNested', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('companiesNested', new Attribute(key: 'industry', type: ColumnType::String, size: 255, 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->createAttribute('employeesNested', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('employeesNested', new Attribute(key: 'role', type: ColumnType::String, size: 255, 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->createAttribute('departmentsNested', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('departmentsNested', new Attribute(key: 'budget', type: ColumnType::Integer, size: 0, 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->createAttribute('projectsNested', new Attribute(key: 'title', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('projectsNested', new Attribute(key: 'status', type: ColumnType::String, size: 255, 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->createAttribute('tasksNested', new Attribute(key: 'description', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('tasksNested', new Attribute(key: 'priority', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('tasksNested', new Attribute(key: 'completed', type: ColumnType::Boolean, size: 0, required: true));
 
         // Create relationships
         // Companies -> Employees (ONE_TO_MANY)
-        $database->createRelationship(
-            collection: 'companiesNested',
-            relatedCollection: 'employeesNested',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-            id: 'employees',
-            twoWayKey: 'company'
-        );
+        $database->createRelationship(new Relationship(collection: 'companiesNested', relatedCollection: 'employeesNested', type: RelationType::OneToMany, twoWay: true, key: 'employees', twoWayKey: 'company'));
 
         // Employees -> Department (MANY_TO_ONE)
-        $database->createRelationship(
-            collection: 'employeesNested',
-            relatedCollection: 'departmentsNested',
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: true,
-            id: 'department',
-            twoWayKey: 'employees'
-        );
+        $database->createRelationship(new Relationship(collection: 'employeesNested', relatedCollection: 'departmentsNested', type: RelationType::ManyToOne, twoWay: true, key: 'department', twoWayKey: 'employees'));
 
         // Employees -> Projects (ONE_TO_MANY)
-        $database->createRelationship(
-            collection: 'employeesNested',
-            relatedCollection: 'projectsNested',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-            id: 'projects',
-            twoWayKey: 'employee'
-        );
+        $database->createRelationship(new Relationship(collection: 'employeesNested', relatedCollection: 'projectsNested', type: RelationType::OneToMany, twoWay: true, key: 'projects', twoWayKey: 'employee'));
 
         // Projects -> Tasks (ONE_TO_MANY)
-        $database->createRelationship(
-            collection: 'projectsNested',
-            relatedCollection: 'tasksNested',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-            id: 'tasks',
-            twoWayKey: 'project'
-        );
+        $database->createRelationship(new Relationship(collection: 'projectsNested', relatedCollection: 'tasksNested', type: RelationType::OneToMany, twoWay: true, key: 'tasks', twoWayKey: 'project'));
 
         // Create test data
         $dept1 = $database->createDocument('departmentsNested', new Document([
@@ -4565,8 +3459,9 @@ public function testCountAndSumWithRelationshipQueries(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -4574,20 +3469,13 @@ public function testCountAndSumWithRelationshipQueries(): void
         $database->createCollection('authorsCount');
         $database->createCollection('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->createRelationship(
-            collection: 'authorsCount',
-            relatedCollection: 'postsCount',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-            id: 'posts',
-            twoWayKey: 'author'
-        );
+        $database->createAttribute('authorsCount', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('authorsCount', new Attribute(key: 'age', type: ColumnType::Integer, size: 0, required: true));
+        $database->createAttribute('postsCount', new Attribute(key: 'title', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('postsCount', new Attribute(key: 'views', type: ColumnType::Integer, size: 0, required: true));
+        $database->createAttribute('postsCount', new Attribute(key: 'published', type: ColumnType::Boolean, size: 0, required: true));
+
+        $database->createRelationship(new Relationship(collection: 'authorsCount', relatedCollection: 'postsCount', type: RelationType::OneToMany, twoWay: true, key: 'posts', twoWayKey: 'author'));
 
         // Create test data
         $author1 = $database->createDocument('authorsCount', new Document([
@@ -4723,26 +3611,24 @@ public function testCountAndSumWithRelationshipQueries(): void
      */
     public function testOrderAndCursorWithRelationshipQueries(): void
     {
+        if (! ($this->getDatabase()->getAdapter() instanceof Feature\Relationships)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
         /** @var Database $database */
         $database = $this->getDatabase();
 
         $database->createCollection('authorsOrder');
         $database->createCollection('postsOrder');
 
-        $database->createAttribute('authorsOrder', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('authorsOrder', 'age', Database::VAR_INTEGER, 0, true);
+        $database->createAttribute('authorsOrder', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('authorsOrder', new Attribute(key: 'age', type: ColumnType::Integer, size: 0, required: true));
 
-        $database->createAttribute('postsOrder', 'title', Database::VAR_STRING, 255, true);
-        $database->createAttribute('postsOrder', 'views', Database::VAR_INTEGER, 0, true);
+        $database->createAttribute('postsOrder', new Attribute(key: 'title', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('postsOrder', new Attribute(key: 'views', type: ColumnType::Integer, size: 0, required: true));
 
-        $database->createRelationship(
-            collection: 'postsOrder',
-            relatedCollection: 'authorsOrder',
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: true,
-            id: 'author',
-            twoWayKey: 'postsOrder'
-        );
+        $database->createRelationship(new Relationship(collection: 'postsOrder', relatedCollection: 'authorsOrder', type: RelationType::ManyToOne, twoWay: true, key: 'author', twoWayKey: 'postsOrder'));
 
         // Create authors
         $alice = $database->createDocument('authorsOrder', new Document([
@@ -4787,7 +3673,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 +3685,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 +3698,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 73783270e..1d48fba9c 100644
--- a/tests/e2e/Adapter/Scopes/Relationships/ManyToManyTests.php
+++ b/tests/e2e/Adapter/Scopes/Relationships/ManyToManyTests.php
@@ -3,6 +3,9 @@
 namespace Tests\E2E\Adapter\Scopes\Relationships;
 
 use Exception;
+use Utopia\Database\Adapter\Feature;
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
 use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Exception\Restricted as RestrictedException;
@@ -11,6 +14,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,36 +26,33 @@ public function testManyToManyOneWayRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $database->createCollection('playlist');
         $database->createCollection('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', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('song', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('song', new Attribute(key: 'length', type: ColumnType::Integer, size: 0, required: true));
 
-        $database->createRelationship(
-            collection: 'playlist',
-            relatedCollection: 'song',
-            type: Database::RELATION_MANY_TO_MANY,
-            id: 'songs'
-        );
+        $database->createRelationship(new Relationship(collection: 'playlist', relatedCollection: 'song', type: RelationType::ManyToMany, key: 'songs'));
 
         // Check metadata for collection
         $collection = $database->getCollection('playlist');
         $attributes = $collection->getAttribute('attributes', []);
 
+        /** @var array<mixed> $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(RelationType::ManyToMany->value, $attribute['options']['relationType']);
                 $this->assertEquals(false, $attribute['options']['twoWay']);
                 $this->assertEquals('playlist', $attribute['options']['twoWayKey']);
             }
@@ -97,31 +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')));
+        /** @var array<mixed> $_cnt_songs_111 */
+        $_cnt_songs_111 = $playlist1Document->getAttribute('songs');
+        $this->assertEquals(1, \count($_cnt_songs_111));
 
         $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');
+        /** @var array<array<string, mixed>> $songs */
         $songs = $playlist->getAttribute('songs', []);
         $this->assertEquals('song1', $songs[0]['$id']);
         $this->assertArrayNotHasKey('playlist', $songs[0]);
 
         $playlist = $database->getDocument('playlist', 'playlist2');
+        /** @var array<array<string, mixed>> $songs */
         $songs = $playlist->getAttribute('songs', []);
         $this->assertEquals('song2', $songs[0]['$id']);
         $this->assertArrayNotHasKey('playlist', $songs[0]);
@@ -139,22 +147,30 @@ 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]);
+        /** @var array<Document> $_rel_songs_151 */
+        $_rel_songs_151 = $playlist->getAttribute('songs');
+        $this->assertEquals('Song 1', $_rel_songs_151[0]->getAttribute('name'));
+        /** @var array<mixed> $_arr_songs_152 */
+        $_arr_songs_152 = $playlist->getAttribute('songs');
+        $this->assertArrayNotHasKey('length', $_arr_songs_152[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]);
+        /** @var array<Document> $_rel_songs_158 */
+        $_rel_songs_158 = $playlist->getAttribute('songs');
+        $this->assertEquals('Song 1', $_rel_songs_158[0]->getAttribute('name'));
+        /** @var array<mixed> $_arr_songs_159 */
+        $_arr_songs_159 = $playlist->getAttribute('songs');
+        $this->assertArrayNotHasKey('length', $_arr_songs_159[0]);
 
         // Update root document attribute without altering relationship
         $playlist1 = $database->updateDocument(
@@ -168,6 +184,7 @@ public function testManyToManyOneWayRelationship(): void
         $this->assertEquals('Playlist 1 Updated', $playlist1->getAttribute('name'));
 
         // Update nested document attribute
+        /** @var array<\Utopia\Database\Document> $songs */
         $songs = $playlist1->getAttribute('songs', []);
         $songs[0]->setAttribute('name', 'Song 1 Updated');
 
@@ -177,9 +194,13 @@ public function testManyToManyOneWayRelationship(): void
             $playlist1->setAttribute('songs', $songs)
         );
 
-        $this->assertEquals('Song 1 Updated', $playlist1->getAttribute('songs')[0]->getAttribute('name'));
+        /** @var array<Document> $_rel_songs_182 */
+        $_rel_songs_182 = $playlist1->getAttribute('songs');
+        $this->assertEquals('Song 1 Updated', $_rel_songs_182[0]->getAttribute('name'));
         $playlist1 = $database->getDocument('playlist', 'playlist1');
-        $this->assertEquals('Song 1 Updated', $playlist1->getAttribute('songs')[0]->getAttribute('name'));
+        /** @var array<Document> $_rel_songs_184 */
+        $_rel_songs_184 = $playlist1->getAttribute('songs');
+        $this->assertEquals('Song 1 Updated', $_rel_songs_184[0]->getAttribute('name'));
 
         // Create new document with no relationship
         $playlist5 = $database->createDocument('playlist', new Document([
@@ -220,13 +241,17 @@ public function testManyToManyOneWayRelationship(): void
             'songs' => [
                 'song1',
                 'song2',
-                'song5'
-            ]
+                'song5',
+            ],
         ]));
 
-        $this->assertEquals('Song 5', $playlist5->getAttribute('songs')[0]->getAttribute('name'));
+        /** @var array<Document> $_rel_songs_229 */
+        $_rel_songs_229 = $playlist5->getAttribute('songs');
+        $this->assertEquals('Song 5', $_rel_songs_229[0]->getAttribute('name'));
         $playlist5 = $database->getDocument('playlist', 'playlist5');
-        $this->assertEquals('Song 5', $playlist5->getAttribute('songs')[0]->getAttribute('name'));
+        /** @var array<Document> $_rel_songs_231 */
+        $_rel_songs_231 = $playlist5->getAttribute('songs');
+        $this->assertEquals('Song 5', $_rel_songs_231[0]->getAttribute('name'));
 
         // Update document with new related document
         $database->updateDocument(
@@ -244,6 +269,7 @@ public function testManyToManyOneWayRelationship(): void
 
         // Get document with new relationship key
         $playlist = $database->getDocument('playlist', 'playlist1');
+        /** @var array<array<string, mixed>> $songs */
         $songs = $playlist->getAttribute('newSongs');
         $this->assertEquals('song2', $songs[0]['$id']);
 
@@ -277,7 +303,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 +320,15 @@ public function testManyToManyOneWayRelationship(): void
 
         // Check relation was set to null
         $playlist1 = $database->getDocument('playlist', 'playlist1');
-        $this->assertEquals(0, \count($playlist1->getAttribute('newSongs')));
+        /** @var array<mixed> $_cnt_newSongs_299 */
+        $_cnt_newSongs_299 = $playlist1->getAttribute('newSongs');
+        $this->assertEquals(0, \count($_cnt_newSongs_299));
 
         // 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,35 +358,32 @@ public function testManyToManyTwoWayRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $database->createCollection('students');
         $database->createCollection('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', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('classes', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('classes', new Attribute(key: 'number', type: ColumnType::Integer, size: 0, required: true));
 
-        $database->createRelationship(
-            collection: 'students',
-            relatedCollection: 'classes',
-            type: Database::RELATION_MANY_TO_MANY,
-            twoWay: true,
-        );
+        $database->createRelationship(new Relationship(collection: 'students', relatedCollection: 'classes', type: RelationType::ManyToMany, twoWay: true));
 
         // Check metadata for collection
         $collection = $database->getCollection('students');
         $attributes = $collection->getAttribute('attributes', []);
+        /** @var array<mixed> $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(RelationType::ManyToMany->value, $attribute['options']['relationType']);
                 $this->assertEquals(true, $attribute['options']['twoWay']);
                 $this->assertEquals('classes', $attribute['options']['twoWayKey']);
             }
@@ -367,13 +392,14 @@ public function testManyToManyTwoWayRelationship(): void
         // Check metadata for related collection
         $collection = $database->getCollection('classes');
         $attributes = $collection->getAttribute('attributes', []);
+        /** @var array<mixed> $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(RelationType::ManyToMany->value, $attribute['options']['relationType']);
                 $this->assertEquals(true, $attribute['options']['twoWay']);
                 $this->assertEquals('students', $attribute['options']['twoWayKey']);
             }
@@ -407,7 +433,9 @@ 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')));
+        /** @var array<mixed> $_cnt_classes_408 */
+        $_cnt_classes_408 = $student1Document->getAttribute('classes');
+        $this->assertEquals(1, \count($_cnt_classes_408));
 
         // Create document with relationship with related ID
         $database->createDocument('classes', new Document([
@@ -430,7 +458,7 @@ public function testManyToManyTwoWayRelationship(): void
             ],
             'name' => 'Student 2',
             'classes' => [
-                'class2'
+                'class2',
             ],
         ]));
 
@@ -453,7 +481,7 @@ public function testManyToManyTwoWayRelationship(): void
                         Permission::delete(Role::any()),
                     ],
                     'name' => 'Student 3',
-                ]
+                ],
             ],
         ]));
         $database->createDocument('students', new Document([
@@ -463,7 +491,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 +504,86 @@ public function testManyToManyTwoWayRelationship(): void
             'name' => 'Class 4',
             'number' => 4,
             'students' => [
-                'student4'
+                'student4',
             ],
         ]));
 
         // Get document with relationship
         $student = $database->getDocument('students', 'student1');
+        /** @var array<array<string, mixed>> $classes */
         $classes = $student->getAttribute('classes', []);
         $this->assertEquals('class1', $classes[0]['$id']);
         $this->assertArrayNotHasKey('students', $classes[0]);
 
         $student = $database->getDocument('students', 'student2');
+        /** @var array<array<string, mixed>> $classes */
         $classes = $student->getAttribute('classes', []);
         $this->assertEquals('class2', $classes[0]['$id']);
         $this->assertArrayNotHasKey('students', $classes[0]);
 
         $student = $database->getDocument('students', 'student3');
+        /** @var array<array<string, mixed>> $classes */
         $classes = $student->getAttribute('classes', []);
         $this->assertEquals('class3', $classes[0]['$id']);
         $this->assertArrayNotHasKey('students', $classes[0]);
 
         $student = $database->getDocument('students', 'student4');
+        /** @var array<array<string, mixed>> $classes */
         $classes = $student->getAttribute('classes', []);
         $this->assertEquals('class4', $classes[0]['$id']);
         $this->assertArrayNotHasKey('students', $classes[0]);
 
         // Get related document
         $class = $database->getDocument('classes', 'class1');
+        /** @var array<array<string, mixed>> $student */
         $student = $class->getAttribute('students');
         $this->assertEquals('student1', $student[0]['$id']);
         $this->assertArrayNotHasKey('classes', $student[0]);
 
         $class = $database->getDocument('classes', 'class2');
+        /** @var array<array<string, mixed>> $student */
         $student = $class->getAttribute('students');
         $this->assertEquals('student2', $student[0]['$id']);
         $this->assertArrayNotHasKey('classes', $student[0]);
 
         $class = $database->getDocument('classes', 'class3');
+        /** @var array<array<string, mixed>> $student */
         $student = $class->getAttribute('students');
         $this->assertEquals('student3', $student[0]['$id']);
         $this->assertArrayNotHasKey('classes', $student[0]);
 
         $class = $database->getDocument('classes', 'class4');
+        /** @var array<array<string, mixed>> $student */
         $student = $class->getAttribute('students');
         $this->assertEquals('student4', $student[0]['$id']);
         $this->assertArrayNotHasKey('classes', $student[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]);
+        /** @var array<Document> $_rel_classes_532 */
+        $_rel_classes_532 = $student->getAttribute('classes');
+        $this->assertEquals('Class 1', $_rel_classes_532[0]->getAttribute('name'));
+        /** @var array<mixed> $_arr_classes_533 */
+        $_arr_classes_533 = $student->getAttribute('classes');
+        $this->assertArrayNotHasKey('number', $_arr_classes_533[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]);
+        /** @var array<Document> $_rel_classes_539 */
+        $_rel_classes_539 = $student->getAttribute('classes');
+        $this->assertEquals('Class 1', $_rel_classes_539[0]->getAttribute('name'));
+        /** @var array<mixed> $_arr_classes_540 */
+        $_arr_classes_540 = $student->getAttribute('classes');
+        $this->assertArrayNotHasKey('number', $_arr_classes_540[0]);
 
         // Update root document attribute without altering relationship
         $student1 = $database->updateDocument(
@@ -565,6 +609,7 @@ public function testManyToManyTwoWayRelationship(): void
         $this->assertEquals('Class 2 Updated', $class2->getAttribute('name'));
 
         // Update nested document attribute
+        /** @var array<\Utopia\Database\Document> $classes */
         $classes = $student1->getAttribute('classes', []);
         $classes[0]->setAttribute('name', 'Class 1 Updated');
 
@@ -574,11 +619,16 @@ public function testManyToManyTwoWayRelationship(): void
             $student1->setAttribute('classes', $classes)
         );
 
-        $this->assertEquals('Class 1 Updated', $student1->getAttribute('classes')[0]->getAttribute('name'));
+        /** @var array<Document> $_rel_classes_575 */
+        $_rel_classes_575 = $student1->getAttribute('classes');
+        $this->assertEquals('Class 1 Updated', $_rel_classes_575[0]->getAttribute('name'));
         $student1 = $database->getDocument('students', 'student1');
-        $this->assertEquals('Class 1 Updated', $student1->getAttribute('classes')[0]->getAttribute('name'));
+        /** @var array<Document> $_rel_classes_577 */
+        $_rel_classes_577 = $student1->getAttribute('classes');
+        $this->assertEquals('Class 1 Updated', $_rel_classes_577[0]->getAttribute('name'));
 
         // Update inverse nested document attribute
+        /** @var array<\Utopia\Database\Document> $students */
         $students = $class2->getAttribute('students', []);
         $students[0]->setAttribute('name', 'Student 2 Updated');
 
@@ -588,9 +638,13 @@ public function testManyToManyTwoWayRelationship(): void
             $class2->setAttribute('students', $students)
         );
 
-        $this->assertEquals('Student 2 Updated', $class2->getAttribute('students')[0]->getAttribute('name'));
+        /** @var array<Document> $_rel_students_589 */
+        $_rel_students_589 = $class2->getAttribute('students');
+        $this->assertEquals('Student 2 Updated', $_rel_students_589[0]->getAttribute('name'));
         $class2 = $database->getDocument('classes', 'class2');
-        $this->assertEquals('Student 2 Updated', $class2->getAttribute('students')[0]->getAttribute('name'));
+        /** @var array<Document> $_rel_students_591 */
+        $_rel_students_591 = $class2->getAttribute('students');
+        $this->assertEquals('Student 2 Updated', $_rel_students_591[0]->getAttribute('name'));
 
         // Create new document with no relationship
         $student5 = $database->createDocument('students', new Document([
@@ -619,9 +673,13 @@ public function testManyToManyTwoWayRelationship(): void
             ])])
         );
 
-        $this->assertEquals('Class 5', $student5->getAttribute('classes')[0]->getAttribute('name'));
+        /** @var array<Document> $_rel_classes_620 */
+        $_rel_classes_620 = $student5->getAttribute('classes');
+        $this->assertEquals('Class 5', $_rel_classes_620[0]->getAttribute('name'));
         $student5 = $database->getDocument('students', 'student5');
-        $this->assertEquals('Class 5', $student5->getAttribute('classes')[0]->getAttribute('name'));
+        /** @var array<Document> $_rel_classes_622 */
+        $_rel_classes_622 = $student5->getAttribute('classes');
+        $this->assertEquals('Class 5', $_rel_classes_622[0]->getAttribute('name'));
 
         // Create child document with no relationship
         $class6 = $database->createDocument('classes', new Document([
@@ -650,9 +708,13 @@ public function testManyToManyTwoWayRelationship(): void
             ])])
         );
 
-        $this->assertEquals('Student 6', $class6->getAttribute('students')[0]->getAttribute('name'));
+        /** @var array<Document> $_rel_students_651 */
+        $_rel_students_651 = $class6->getAttribute('students');
+        $this->assertEquals('Student 6', $_rel_students_651[0]->getAttribute('name'));
         $class6 = $database->getDocument('classes', 'class6');
-        $this->assertEquals('Student 6', $class6->getAttribute('students')[0]->getAttribute('name'));
+        /** @var array<Document> $_rel_students_653 */
+        $_rel_students_653 = $class6->getAttribute('students');
+        $this->assertEquals('Student 6', $_rel_students_653[0]->getAttribute('name'));
 
         // Update document with new related document
         $database->updateDocument(
@@ -680,11 +742,13 @@ public function testManyToManyTwoWayRelationship(): void
 
         // Get document with new relationship key
         $students = $database->getDocument('students', 'student1');
+        /** @var array<array<string, mixed>> $classes */
         $classes = $students->getAttribute('newClasses');
         $this->assertEquals('class2', $classes[0]['$id']);
 
         // Get inverse document with new relationship key
         $class = $database->getDocument('classes', 'class1');
+        /** @var array<array<string, mixed>> $students */
         $students = $class->getAttribute('newStudents');
         $this->assertEquals('student1', $students[0]['$id']);
 
@@ -718,7 +782,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 +799,15 @@ public function testManyToManyTwoWayRelationship(): void
 
         // Check relation was set to null
         $student1 = $database->getDocument('students', 'student1');
-        $this->assertEquals(0, \count($student1->getAttribute('newClasses')));
+        /** @var array<mixed> $_cnt_newClasses_736 */
+        $_cnt_newClasses_736 = $student1->getAttribute('newClasses');
+        $this->assertEquals(0, \count($_cnt_newClasses_736));
 
         // 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,8 +850,9 @@ public function testNestedManyToMany_OneToOneRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -793,24 +860,12 @@ public function testNestedManyToMany_OneToOneRelationship(): void
         $database->createCollection('hearths');
         $database->createCollection('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', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('hearths', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('plots', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
 
-        $database->createRelationship(
-            collection: 'stones',
-            relatedCollection: 'hearths',
-            type: Database::RELATION_MANY_TO_MANY,
-            twoWay: true,
-        );
-        $database->createRelationship(
-            collection: 'hearths',
-            relatedCollection: 'plots',
-            type: Database::RELATION_ONE_TO_ONE,
-            twoWay: true,
-            id: 'plot',
-            twoWayKey: 'hearth'
-        );
+        $database->createRelationship(new Relationship(collection: 'stones', relatedCollection: 'hearths', type: RelationType::ManyToMany, twoWay: true));
+        $database->createRelationship(new Relationship(collection: 'hearths', relatedCollection: 'plots', type: RelationType::OneToOne, twoWay: true, key: 'plot', twoWayKey: 'hearth'));
 
         $database->createDocument('stones', new Document([
             '$id' => 'stone1',
@@ -895,8 +950,9 @@ public function testNestedManyToMany_OneToManyRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -904,24 +960,12 @@ public function testNestedManyToMany_OneToManyRelationship(): void
         $database->createCollection('tounaments');
         $database->createCollection('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', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('tounaments', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('prizes', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
 
-        $database->createRelationship(
-            collection: 'groups',
-            relatedCollection: 'tounaments',
-            type: Database::RELATION_MANY_TO_MANY,
-            twoWay: true,
-        );
-        $database->createRelationship(
-            collection: 'tounaments',
-            relatedCollection: 'prizes',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-            id: 'prizes',
-            twoWayKey: 'tounament'
-        );
+        $database->createRelationship(new Relationship(collection: 'groups', relatedCollection: 'tounaments', type: RelationType::ManyToMany, twoWay: true));
+        $database->createRelationship(new Relationship(collection: 'tounaments', relatedCollection: 'prizes', type: RelationType::OneToMany, twoWay: true, key: 'prizes', twoWayKey: 'tounament'));
 
         $database->createDocument('groups', new Document([
             '$id' => 'group1',
@@ -995,8 +1039,9 @@ public function testNestedManyToMany_ManyToOneRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -1004,24 +1049,12 @@ public function testNestedManyToMany_ManyToOneRelationship(): void
         $database->createCollection('games');
         $database->createCollection('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', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('games', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('publishers', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
 
-        $database->createRelationship(
-            collection: 'platforms',
-            relatedCollection: 'games',
-            type: Database::RELATION_MANY_TO_MANY,
-            twoWay: true,
-        );
-        $database->createRelationship(
-            collection: 'games',
-            relatedCollection: 'publishers',
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: true,
-            id: 'publisher',
-            twoWayKey: 'games'
-        );
+        $database->createRelationship(new Relationship(collection: 'platforms', relatedCollection: 'games', type: RelationType::ManyToMany, twoWay: true));
+        $database->createRelationship(new Relationship(collection: 'games', relatedCollection: 'publishers', type: RelationType::ManyToOne, twoWay: true, key: 'publisher', twoWayKey: 'games'));
 
         $database->createDocument('platforms', new Document([
             '$id' => 'platform1',
@@ -1058,7 +1091,7 @@ public function testNestedManyToMany_ManyToOneRelationship(): void
                         'name' => 'Publisher 2',
                     ],
                 ],
-            ]
+            ],
         ]));
 
         $platform1 = $database->getDocument('platforms', 'platform1');
@@ -1090,7 +1123,7 @@ public function testNestedManyToMany_ManyToOneRelationship(): void
                                 Permission::read(Role::any()),
                             ],
                             'name' => 'Platform 2',
-                        ]
+                        ],
                     ],
                 ],
             ],
@@ -1109,8 +1142,9 @@ public function testNestedManyToMany_ManyToManyRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -1118,24 +1152,12 @@ public function testNestedManyToMany_ManyToManyRelationship(): void
         $database->createCollection('pizzas');
         $database->createCollection('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', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('pizzas', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('toppings', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
 
-        $database->createRelationship(
-            collection: 'sauces',
-            relatedCollection: 'pizzas',
-            type: Database::RELATION_MANY_TO_MANY,
-            twoWay: true,
-        );
-        $database->createRelationship(
-            collection: 'pizzas',
-            relatedCollection: 'toppings',
-            type: Database::RELATION_MANY_TO_MANY,
-            twoWay: true,
-            id: 'toppings',
-            twoWayKey: 'pizzas'
-        );
+        $database->createRelationship(new Relationship(collection: 'sauces', relatedCollection: 'pizzas', type: RelationType::ManyToMany, twoWay: true));
+        $database->createRelationship(new Relationship(collection: 'pizzas', relatedCollection: 'toppings', type: RelationType::ManyToMany, twoWay: true, key: 'toppings', twoWayKey: 'pizzas'));
 
         $database->createDocument('sauces', new Document([
             '$id' => 'sauce1',
@@ -1190,7 +1212,7 @@ public function testNestedManyToMany_ManyToManyRelationship(): void
                         ],
                     ],
                 ],
-            ]
+            ],
         ]));
 
         $sauce1 = $database->getDocument('sauces', 'sauce1');
@@ -1213,42 +1235,42 @@ public function testManyToManyRelationshipKeyWithSymbols(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $database->createCollection('$symbols_coll.ection7');
         $database->createCollection('$symbols_coll.ection8');
 
-        $database->createRelationship(
-            collection: '$symbols_coll.ection7',
-            relatedCollection: '$symbols_coll.ection8',
-            type: Database::RELATION_MANY_TO_MANY,
-            twoWay: true,
-        );
+        $database->createRelationship(new Relationship(collection: '$symbols_coll.ection7', relatedCollection: '$symbols_coll.ection8', type: RelationType::ManyToMany, 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());
+        /** @var array<Document> $_arr_symbols_collection7_1200 */
+        $_arr_symbols_collection7_1200 = $doc1->getAttribute('symbols_collection7');
+        $this->assertEquals($doc2->getId(), $_arr_symbols_collection7_1200[0]->getId());
+        /** @var array<Document> $_arr_symbols_collection8_1201 */
+        $_arr_symbols_collection8_1201 = $doc2->getAttribute('symbols_collection8');
+        $this->assertEquals($doc1->getId(), $_arr_symbols_collection8_1201[0]->getId());
     }
 
     public function testRecreateManyToManyOneWayRelationshipFromChild(): void
@@ -1256,65 +1278,42 @@ public function testRecreateManyToManyOneWayRelationshipFromChild(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $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($one, [
+            new Attribute(key: 'name', type: ColumnType::String, size: 100, required: false, default: null, signed: true, array: false, format: '', filters: []),
         ], [], [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(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' => [],
-            ]),
+        $database->createCollection($two, [
+            new Attribute(key: 'name', type: ColumnType::String, size: 100, required: false, default: null, signed: true, array: false, format: '', filters: []),
         ], [], [
             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(new Relationship(collection: $one, relatedCollection: $two, type: RelationType::ManyToMany));
 
-        $database->deleteRelationship('two', 'one');
+        $database->deleteRelationship($two, $one);
 
-        $result = $database->createRelationship(
-            collection: 'one',
-            relatedCollection: 'two',
-            type: Database::RELATION_MANY_TO_MANY,
-        );
+        $result = $database->createRelationship(new Relationship(collection: $one, relatedCollection: $two, type: RelationType::ManyToMany));
 
         $this->assertTrue($result);
 
-        $database->deleteCollection('one');
-        $database->deleteCollection('two');
+        $database->deleteCollection($one);
+        $database->deleteCollection($two);
     }
 
     public function testRecreateManyToManyTwoWayRelationshipFromParent(): void
@@ -1322,67 +1321,42 @@ public function testRecreateManyToManyTwoWayRelationshipFromParent(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $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($one, [
+            new Attribute(key: 'name', type: ColumnType::String, size: 100, required: false, default: null, signed: true, array: false, format: '', filters: []),
         ], [], [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(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' => [],
-            ]),
+        $database->createCollection($two, [
+            new Attribute(key: 'name', type: ColumnType::String, size: 100, required: false, default: null, signed: true, array: false, format: '', filters: []),
         ], [], [
             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(new Relationship(collection: $one, relatedCollection: $two, type: RelationType::ManyToMany, 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(new Relationship(collection: $one, relatedCollection: $two, type: RelationType::ManyToMany, twoWay: true));
 
         $this->assertTrue($result);
 
-        $database->deleteCollection('one');
-        $database->deleteCollection('two');
+        $database->deleteCollection($one);
+        $database->deleteCollection($two);
     }
 
     public function testRecreateManyToManyTwoWayRelationshipFromChild(): void
@@ -1390,67 +1364,42 @@ public function testRecreateManyToManyTwoWayRelationshipFromChild(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $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($one, [
+            new Attribute(key: 'name', type: ColumnType::String, size: 100, required: false, default: null, signed: true, array: false, format: '', filters: []),
         ], [], [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(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' => [],
-            ]),
+        $database->createCollection($two, [
+            new Attribute(key: 'name', type: ColumnType::String, size: 100, required: false, default: null, signed: true, array: false, format: '', filters: []),
         ], [], [
             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(new Relationship(collection: $one, relatedCollection: $two, type: RelationType::ManyToMany, 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(new Relationship(collection: $one, relatedCollection: $two, type: RelationType::ManyToMany, twoWay: true));
 
         $this->assertTrue($result);
 
-        $database->deleteCollection('one');
-        $database->deleteCollection('two');
+        $database->deleteCollection($one);
+        $database->deleteCollection($two);
     }
 
     public function testRecreateManyToManyOneWayRelationshipFromParent(): void
@@ -1458,65 +1407,42 @@ public function testRecreateManyToManyOneWayRelationshipFromParent(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $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($one, [
+            new Attribute(key: 'name', type: ColumnType::String, size: 100, required: false, default: null, signed: true, array: false, format: '', filters: []),
         ], [], [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(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' => [],
-            ]),
+        $database->createCollection($two, [
+            new Attribute(key: 'name', type: ColumnType::String, size: 100, required: false, default: null, signed: true, array: false, format: '', filters: []),
         ], [], [
             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(new Relationship(collection: $one, relatedCollection: $two, type: RelationType::ManyToMany));
 
-        $database->deleteRelationship('one', 'two');
+        $database->deleteRelationship($one, $two);
 
-        $result = $database->createRelationship(
-            collection: 'one',
-            relatedCollection: 'two',
-            type: Database::RELATION_MANY_TO_MANY,
-        );
+        $result = $database->createRelationship(new Relationship(collection: $one, relatedCollection: $two, type: RelationType::ManyToMany));
 
         $this->assertTrue($result);
 
-        $database->deleteCollection('one');
-        $database->deleteCollection('two');
+        $database->deleteCollection($one);
+        $database->deleteCollection($two);
     }
 
     public function testSelectManyToMany(): void
@@ -1524,26 +1450,22 @@ public function testSelectManyToMany(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $database->createCollection('select_m2m_collection1');
         $database->createCollection('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', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('select_m2m_collection1', new Attribute(key: 'type', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('select_m2m_collection2', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('select_m2m_collection2', new Attribute(key: 'type', type: ColumnType::String, size: 255, 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(new Relationship(collection: 'select_m2m_collection1', relatedCollection: 'select_m2m_collection2', type: RelationType::ManyToMany, twoWay: true));
 
         // Create documents in the first collection
         $doc1 = $database->createDocument('select_m2m_collection1', new Document([
@@ -1602,8 +1524,9 @@ public function testSelectAcrossMultipleCollections(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -1612,41 +1535,31 @@ public function testSelectAcrossMultipleCollections(): void
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
+            Permission::delete(Role::any()),
         ], documentSecurity: false);
         $database->createCollection('albums', permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
+            Permission::delete(Role::any()),
         ], documentSecurity: false);
         $database->createCollection('tracks', permissions: [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
+            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', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('albums', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('tracks', new Attribute(key: 'title', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('tracks', new Attribute(key: 'duration', type: ColumnType::Integer, size: 0, required: true));
 
         // Create relationships
-        $database->createRelationship(
-            collection: 'artists',
-            relatedCollection: 'albums',
-            type: Database::RELATION_MANY_TO_MANY,
-            twoWay: true
-        );
+        $database->createRelationship(new Relationship(collection: 'artists', relatedCollection: 'albums', type: RelationType::ManyToMany, twoWay: true));
 
-        $database->createRelationship(
-            collection: 'albums',
-            relatedCollection: 'tracks',
-            type: Database::RELATION_MANY_TO_MANY,
-            twoWay: true
-        );
+        $database->createRelationship(new Relationship(collection: 'albums', relatedCollection: 'tracks', type: RelationType::ManyToMany, twoWay: true));
 
         // Create documents
         $database->createDocument('artists', new Document([
@@ -1666,8 +1579,8 @@ public function testSelectAcrossMultipleCollections(): void
                             '$id' => 'track2',
                             'title' => 'Hit Song 2',
                             'duration' => 220,
-                        ]
-                    ]
+                        ],
+                    ],
                 ],
                 [
                     '$id' => 'album2',
@@ -1677,15 +1590,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,6 +1606,7 @@ public function testSelectAcrossMultipleCollections(): void
         $this->assertEquals('The Great Artist', $artist->getAttribute('name'));
         $this->assertArrayHasKey('albums', $artist->getArrayCopy());
 
+        /** @var array<array<string, mixed>> $albums */
         $albums = $artist->getAttribute('albums');
         $this->assertCount(2, $albums);
 
@@ -1705,6 +1619,7 @@ public function testSelectAcrossMultipleCollections(): void
         $this->assertEquals('Second Album', $album2->getAttribute('name'));
         $this->assertArrayHasKey('tracks', $album2->getArrayCopy());
 
+        /** @var array<\Utopia\Database\Document> $album1Tracks */
         $album1Tracks = $album1->getAttribute('tracks');
         $this->assertCount(2, $album1Tracks);
         $this->assertEquals('Hit Song 1', $album1Tracks[0]->getAttribute('title'));
@@ -1712,6 +1627,7 @@ public function testSelectAcrossMultipleCollections(): void
         $this->assertEquals('Hit Song 2', $album1Tracks[1]->getAttribute('title'));
         $this->assertArrayNotHasKey('duration', $album1Tracks[1]->getArrayCopy());
 
+        /** @var array<\Utopia\Database\Document> $album2Tracks */
         $album2Tracks = $album2->getAttribute('tracks');
         $this->assertCount(1, $album2Tracks);
         $this->assertEquals('Ballad 3', $album2Tracks[0]->getAttribute('title'));
@@ -1723,25 +1639,21 @@ public function testDeleteBulkDocumentsManyToManyRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships() || !$database->getAdapter()->getSupportForBatchOperations()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships) || ! $database->getAdapter()->supports(Capability::BatchOperations)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $this->getDatabase()->createCollection('bulk_delete_person_m2m');
         $this->getDatabase()->createCollection('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', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $this->getDatabase()->createAttribute('bulk_delete_library_m2m', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $this->getDatabase()->createAttribute('bulk_delete_library_m2m', new Attribute(key: 'area', type: ColumnType::String, size: 255, 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(new Relationship(collection: 'bulk_delete_person_m2m', relatedCollection: 'bulk_delete_library_m2m', type: RelationType::ManyToMany, onDelete: ForeignKeyAction::Restrict));
 
         $person1 = $this->getDatabase()->createDocument('bulk_delete_person_m2m', new Document([
             '$id' => 'person1',
@@ -1795,16 +1707,18 @@ 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() instanceof Feature\Relationships) ||
+            ! $database->getAdapter()->supports(Capability::BatchOperations)
         ) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -1814,17 +1728,11 @@ public function testUpdateParentAndChild_ManyToMany(): void
         $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->createAttribute($parentCollection, new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($childCollection, new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($childCollection, new Attribute(key: 'parentNumber', type: ColumnType::Integer, size: 0, required: false));
 
-
-        $database->createRelationship(
-            collection: $parentCollection,
-            relatedCollection: $childCollection,
-            type: Database::RELATION_MANY_TO_MANY,
-            id: 'parentNumber'
-        );
+        $database->createRelationship(new Relationship(collection: $parentCollection, relatedCollection: $childCollection, type: RelationType::ManyToMany, key: 'parentNumber'));
 
         $database->createDocument($parentCollection, new Document([
             '$id' => 'parent1',
@@ -1879,14 +1787,14 @@ 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() instanceof Feature\Relationships) || ! $database->getAdapter()->supports(Capability::BatchOperations)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -1895,15 +1803,10 @@ public function testDeleteDocumentsRelationshipErrorDoesNotDeleteParent_ManyToMa
 
         $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->createRelationship(
-            collection: $parentCollection,
-            relatedCollection: $childCollection,
-            type: Database::RELATION_MANY_TO_MANY,
-            onDelete: Database::RELATION_MUTATE_RESTRICT
-        );
+        $database->createAttribute($parentCollection, new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($childCollection, new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+
+        $database->createRelationship(new Relationship(collection: $parentCollection, relatedCollection: $childCollection, type: RelationType::ManyToMany, onDelete: ForeignKeyAction::Restrict));
 
         $parent = $database->createDocument($parentCollection, new Document([
             '$id' => 'parent1',
@@ -1922,8 +1825,8 @@ public function testDeleteDocumentsRelationshipErrorDoesNotDeleteParent_ManyToMa
                         Permission::delete(Role::any()),
                     ],
                     'name' => 'Child 1',
-                ]
-            ]
+                ],
+            ],
         ]));
 
         try {
@@ -1945,27 +1848,21 @@ public function testPartialUpdateManyToManyBothSides(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $database->createCollection('partial_students');
         $database->createCollection('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->createRelationship(
-            collection: 'partial_students',
-            relatedCollection: 'partial_courses',
-            type: Database::RELATION_MANY_TO_MANY,
-            twoWay: true,
-            id: 'partial_courses',
-            twoWayKey: 'partial_students'
-        );
+        $database->createAttribute('partial_students', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('partial_students', new Attribute(key: 'grade', type: ColumnType::String, size: 10, required: false));
+        $database->createAttribute('partial_courses', new Attribute(key: 'title', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('partial_courses', new Attribute(key: 'credits', type: ColumnType::Integer, size: 0, required: false));
+
+        $database->createRelationship(new Relationship(collection: 'partial_students', relatedCollection: 'partial_courses', type: RelationType::ManyToMany, twoWay: true, key: 'partial_courses', twoWayKey: 'partial_students'));
 
         // Create student with courses
         $database->createDocument('partial_students', new Document([
@@ -2014,27 +1911,21 @@ public function testPartialUpdateManyToManyWithStringIdsAndDocuments(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $database->createCollection('tags');
         $database->createCollection('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->createRelationship(
-            collection: 'articles',
-            relatedCollection: 'tags',
-            type: Database::RELATION_MANY_TO_MANY,
-            twoWay: true,
-            id: 'tags',
-            twoWayKey: 'articles'
-        );
+        $database->createAttribute('tags', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('tags', new Attribute(key: 'color', type: ColumnType::String, size: 50, required: false));
+        $database->createAttribute('articles', new Attribute(key: 'title', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('articles', new Attribute(key: 'published', type: ColumnType::Boolean, size: 0, required: false));
+
+        $database->createRelationship(new Relationship(collection: 'articles', relatedCollection: 'tags', type: RelationType::ManyToMany, twoWay: true, key: 'tags', twoWayKey: 'articles'));
 
         // Create article with tags
         $database->createDocument('articles', new Document([
@@ -2065,7 +1956,9 @@ 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'));
+        /** @var array<mixed> $_ac_tags_1868 */
+        $_ac_tags_1868 = $article->getAttribute('tags');
+        $this->assertCount(2, $_ac_tags_1868);
 
         // Update from tag side using DOCUMENT objects
         $database->createDocument('articles', new Document([
@@ -2088,169 +1981,14 @@ 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'));
+        /** @var array<mixed> $_ac_articles_1891 */
+        $_ac_articles_1891 = $tag->getAttribute('articles');
+        $this->assertCount(2, $_ac_articles_1891);
 
         $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 +1999,32 @@ public function testNestedManyToManyRelationshipQueries(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $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->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->createRelationship(
-            collection: 'brands',
-            relatedCollection: 'products',
-            type: Database::RELATION_MANY_TO_MANY,
-            twoWay: true,
-            id: 'products',
-            twoWayKey: 'brands',
-        );
+        $database->createAttribute('brands', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('products', new Attribute(key: 'title', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('tags', new Attribute(key: 'label', type: ColumnType::String, size: 255, required: true));
 
-        $database->createRelationship(
-            collection: 'products',
-            relatedCollection: 'tags',
-            type: Database::RELATION_MANY_TO_MANY,
-            twoWay: true,
-            id: 'tags',
-            twoWayKey: 'products',
-        );
+        $database->createRelationship(new Relationship(collection: 'brands', relatedCollection: 'products', type: RelationType::ManyToMany, twoWay: true, key: 'products', twoWayKey: 'brands'));
+
+        $database->createRelationship(new Relationship(collection: 'products', relatedCollection: 'tags', type: RelationType::ManyToMany, twoWay: true, key: 'tags', twoWayKey: 'products'));
 
         // Seed data
         $database->createDocument('tags', new Document([
@@ -2342,14 +2075,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 +2106,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 +2122,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 e62ff735c..f2c7c6114 100644
--- a/tests/e2e/Adapter/Scopes/Relationships/ManyToOneTests.php
+++ b/tests/e2e/Adapter/Scopes/Relationships/ManyToOneTests.php
@@ -3,6 +3,9 @@
 namespace Tests\E2E\Adapter\Scopes\Relationships;
 
 use Exception;
+use Utopia\Database\Adapter\Feature;
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
 use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Exception\Restricted as RestrictedException;
@@ -11,6 +14,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,36 +26,33 @@ public function testManyToOneOneWayRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $database->createCollection('review');
         $database->createCollection('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', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('movie', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('movie', new Attribute(key: 'length', type: ColumnType::Integer, size: 0, required: true, formatOptions: ['min' => 0, 'max' => 999]));
+        $database->createAttribute('movie', new Attribute(key: 'date', type: ColumnType::Datetime, size: 0, required: false, filters: ['datetime']));
+        $database->createAttribute('review', new Attribute(key: 'date', type: ColumnType::Datetime, size: 0, required: false, filters: ['datetime']));
+        $database->createRelationship(new Relationship(collection: 'review', relatedCollection: 'movie', type: RelationType::ManyToOne, twoWayKey: 'reviews'));
 
         // Check metadata for collection
         $collection = $database->getCollection('review');
         $attributes = $collection->getAttribute('attributes', []);
+        /** @var array<mixed> $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(RelationType::ManyToOne->value, $attribute['options']['relationType']);
                 $this->assertEquals(false, $attribute['options']['twoWay']);
                 $this->assertEquals('reviews', $attribute['options']['twoWayKey']);
             }
@@ -57,13 +61,14 @@ public function testManyToOneOneWayRelationship(): void
         // Check metadata for related collection
         $collection = $database->getCollection('movie');
         $attributes = $collection->getAttribute('attributes', []);
+        /** @var array<mixed> $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(RelationType::ManyToOne->value, $attribute['options']['relationType']);
                 $this->assertEquals(false, $attribute['options']['twoWay']);
                 $this->assertEquals('movie', $attribute['options']['twoWayKey']);
             }
@@ -145,7 +150,7 @@ public function testManyToOneOneWayRelationship(): void
         $this->assertArrayNotHasKey('reviews', $movie);
 
         $documents = $database->find('review', [
-            Query::select(['date', 'movie.date'])
+            Query::select(['date', 'movie.date']),
         ]);
 
         $this->assertCount(3, $documents);
@@ -153,7 +158,9 @@ public function testManyToOneOneWayRelationship(): void
         $document = $documents[0];
         $this->assertArrayHasKey('date', $document);
         $this->assertArrayHasKey('movie', $document);
-        $this->assertArrayHasKey('date', $document->getAttribute('movie'));
+        /** @var array<string, mixed> $_arr_movie_158 */
+        $_arr_movie_158 = $document->getAttribute('movie');
+        $this->assertArrayHasKey('date', $_arr_movie_158);
         $this->assertArrayNotHasKey('name', $document);
         $this->assertEquals(29, strlen($document['date'])); // checks filter
         $this->assertEquals(29, strlen($document['movie']['date']));
@@ -176,22 +183,30 @@ 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'));
+        /** @var \Utopia\Database\Document $_doc_movie_188 */
+        $_doc_movie_188 = $review->getAttribute('movie');
+        $this->assertEquals('Movie 1', $_doc_movie_188->getAttribute('name'));
+        /** @var array<string, mixed> $_arr_movie_189 */
+        $_arr_movie_189 = $review->getAttribute('movie');
+        $this->assertArrayNotHasKey('length', $_arr_movie_189);
 
         $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'));
+        /** @var \Utopia\Database\Document $_doc_movie_195 */
+        $_doc_movie_195 = $review->getAttribute('movie');
+        $this->assertEquals('Movie 1', $_doc_movie_195->getAttribute('name'));
+        /** @var array<string, mixed> $_arr_movie_196 */
+        $_arr_movie_196 = $review->getAttribute('movie');
+        $this->assertArrayNotHasKey('length', $_arr_movie_196);
 
         // Update root document attribute without altering relationship
         $review1 = $database->updateDocument(
@@ -214,9 +229,13 @@ public function testManyToOneOneWayRelationship(): void
             $review1->setAttribute('movie', $movie)
         );
 
-        $this->assertEquals('Movie 1 Updated', $review1->getAttribute('movie')->getAttribute('name'));
+        /** @var \Utopia\Database\Document $_doc_movie_219 */
+        $_doc_movie_219 = $review1->getAttribute('movie');
+        $this->assertEquals('Movie 1 Updated', $_doc_movie_219->getAttribute('name'));
         $review1 = $database->getDocument('review', 'review1');
-        $this->assertEquals('Movie 1 Updated', $review1->getAttribute('movie')->getAttribute('name'));
+        /** @var \Utopia\Database\Document $_doc_movie_221 */
+        $_doc_movie_221 = $review1->getAttribute('movie');
+        $this->assertEquals('Movie 1 Updated', $_doc_movie_221->getAttribute('name'));
 
         // Create new document with no relationship
         $review5 = $database->createDocument('review', new Document([
@@ -245,9 +264,13 @@ public function testManyToOneOneWayRelationship(): void
             ]))
         );
 
-        $this->assertEquals('Movie 5', $review5->getAttribute('movie')->getAttribute('name'));
+        /** @var \Utopia\Database\Document $_doc_movie_250 */
+        $_doc_movie_250 = $review5->getAttribute('movie');
+        $this->assertEquals('Movie 5', $_doc_movie_250->getAttribute('name'));
         $review5 = $database->getDocument('review', 'review5');
-        $this->assertEquals('Movie 5', $review5->getAttribute('movie')->getAttribute('name'));
+        /** @var \Utopia\Database\Document $_doc_movie_252 */
+        $_doc_movie_252 = $review5->getAttribute('movie');
+        $this->assertEquals('Movie 5', $_doc_movie_252->getAttribute('name'));
 
         // Update document with new related document
         $database->updateDocument(
@@ -308,7 +331,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 +345,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 +358,6 @@ public function testManyToOneOneWayRelationship(): void
         $library = $database->getDocument('review', 'review2');
         $this->assertEquals(true, $library->isEmpty());
 
-
         // Delete relationship
         $database->deleteRelationship(
             'review',
@@ -353,43 +375,33 @@ public function testManyToOneTwoWayRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $database->createCollection('product');
         $database->createCollection('store');
 
-        $database->createAttribute('store', 'name', Database::VAR_STRING, 255, true);
-        $database->createAttribute('store', 'opensAt', Database::VAR_STRING, 5, true);
+        $database->createAttribute('store', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('store', new Attribute(key: 'opensAt', type: ColumnType::String, size: 5, required: true));
 
-        $database->createAttribute(
-            collection: 'product',
-            id: 'name',
-            type: Database::VAR_STRING,
-            size: 255,
-            required: true
-        );
+        $database->createAttribute('product', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
 
-        $database->createRelationship(
-            collection: 'product',
-            relatedCollection: 'store',
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: true,
-            twoWayKey: 'products'
-        );
+        $database->createRelationship(new Relationship(collection: 'product', relatedCollection: 'store', type: RelationType::ManyToOne, twoWay: true, twoWayKey: 'products'));
 
         // Check metadata for collection
         $collection = $database->getCollection('product');
         $attributes = $collection->getAttribute('attributes', []);
+        /** @var array<mixed> $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(RelationType::ManyToOne->value, $attribute['options']['relationType']);
                 $this->assertEquals(true, $attribute['options']['twoWay']);
                 $this->assertEquals('products', $attribute['options']['twoWayKey']);
             }
@@ -398,13 +410,14 @@ public function testManyToOneTwoWayRelationship(): void
         // Check metadata for related collection
         $collection = $database->getCollection('store');
         $attributes = $collection->getAttribute('attributes', []);
+        /** @var array<mixed> $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(RelationType::ManyToOne->value, $attribute['options']['relationType']);
                 $this->assertEquals(true, $attribute['options']['twoWay']);
                 $this->assertEquals('store', $attribute['options']['twoWayKey']);
             }
@@ -531,21 +544,25 @@ public function testManyToOneTwoWayRelationship(): void
 
         // Get related document
         $store = $database->getDocument('store', 'store1');
+        /** @var array<array<string, mixed>> $products */
         $products = $store->getAttribute('products');
         $this->assertEquals('product1', $products[0]['$id']);
         $this->assertArrayNotHasKey('store', $products[0]);
 
         $store = $database->getDocument('store', 'store2');
+        /** @var array<array<string, mixed>> $products */
         $products = $store->getAttribute('products');
         $this->assertEquals('product2', $products[0]['$id']);
         $this->assertArrayNotHasKey('store', $products[0]);
 
         $store = $database->getDocument('store', 'store3');
+        /** @var array<array<string, mixed>> $products */
         $products = $store->getAttribute('products');
         $this->assertEquals('product3', $products[0]['$id']);
         $this->assertArrayNotHasKey('store', $products[0]);
 
         $store = $database->getDocument('store', 'store4');
+        /** @var array<array<string, mixed>> $products */
         $products = $store->getAttribute('products');
         $this->assertEquals('product4', $products[0]['$id']);
         $this->assertArrayNotHasKey('store', $products[0]);
@@ -556,22 +573,30 @@ 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'));
+        /** @var \Utopia\Database\Document $_doc_store_556 */
+        $_doc_store_556 = $product->getAttribute('store');
+        $this->assertEquals('Store 1', $_doc_store_556->getAttribute('name'));
+        /** @var array<string, mixed> $_arr_store_557 */
+        $_arr_store_557 = $product->getAttribute('store');
+        $this->assertArrayNotHasKey('opensAt', $_arr_store_557);
 
         $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'));
+        /** @var \Utopia\Database\Document $_doc_store_563 */
+        $_doc_store_563 = $product->getAttribute('store');
+        $this->assertEquals('Store 1', $_doc_store_563->getAttribute('name'));
+        /** @var array<string, mixed> $_arr_store_564 */
+        $_arr_store_564 = $product->getAttribute('store');
+        $this->assertArrayNotHasKey('opensAt', $_arr_store_564);
 
         // Update root document attribute without altering relationship
         $product1 = $database->updateDocument(
@@ -606,9 +631,13 @@ public function testManyToOneTwoWayRelationship(): void
             $product1->setAttribute('store', $store)
         );
 
-        $this->assertEquals('Store 1 Updated', $product1->getAttribute('store')->getAttribute('name'));
+        /** @var \Utopia\Database\Document $_doc_store_599 */
+        $_doc_store_599 = $product1->getAttribute('store');
+        $this->assertEquals('Store 1 Updated', $_doc_store_599->getAttribute('name'));
         $product1 = $database->getDocument('product', 'product1');
-        $this->assertEquals('Store 1 Updated', $product1->getAttribute('store')->getAttribute('name'));
+        /** @var \Utopia\Database\Document $_doc_store_601 */
+        $_doc_store_601 = $product1->getAttribute('store');
+        $this->assertEquals('Store 1 Updated', $_doc_store_601->getAttribute('name'));
 
         // Update inverse nested document attribute
         $product = $store1->getAttribute('products')[0];
@@ -620,9 +649,13 @@ public function testManyToOneTwoWayRelationship(): void
             $store1->setAttribute('products', [$product])
         );
 
-        $this->assertEquals('Product 1 Updated', $store1->getAttribute('products')[0]->getAttribute('name'));
+        /** @var array<Document> $_rel_products_613 */
+        $_rel_products_613 = $store1->getAttribute('products');
+        $this->assertEquals('Product 1 Updated', $_rel_products_613[0]->getAttribute('name'));
         $store1 = $database->getDocument('store', 'store1');
-        $this->assertEquals('Product 1 Updated', $store1->getAttribute('products')[0]->getAttribute('name'));
+        /** @var array<Document> $_rel_products_615 */
+        $_rel_products_615 = $store1->getAttribute('products');
+        $this->assertEquals('Product 1 Updated', $_rel_products_615[0]->getAttribute('name'));
 
         // Create new document with no relationship
         $product5 = $database->createDocument('product', new Document([
@@ -651,9 +684,13 @@ public function testManyToOneTwoWayRelationship(): void
             ]))
         );
 
-        $this->assertEquals('Store 5', $product5->getAttribute('store')->getAttribute('name'));
+        /** @var \Utopia\Database\Document $_doc_store_644 */
+        $_doc_store_644 = $product5->getAttribute('store');
+        $this->assertEquals('Store 5', $_doc_store_644->getAttribute('name'));
         $product5 = $database->getDocument('product', 'product5');
-        $this->assertEquals('Store 5', $product5->getAttribute('store')->getAttribute('name'));
+        /** @var \Utopia\Database\Document $_doc_store_646 */
+        $_doc_store_646 = $product5->getAttribute('store');
+        $this->assertEquals('Store 5', $_doc_store_646->getAttribute('name'));
 
         // Create new child document with no relationship
         $store6 = $database->createDocument('store', new Document([
@@ -682,9 +719,13 @@ public function testManyToOneTwoWayRelationship(): void
             ])])
         );
 
-        $this->assertEquals('Product 6', $store6->getAttribute('products')[0]->getAttribute('name'));
+        /** @var array<Document> $_rel_products_675 */
+        $_rel_products_675 = $store6->getAttribute('products');
+        $this->assertEquals('Product 6', $_rel_products_675[0]->getAttribute('name'));
         $store6 = $database->getDocument('store', 'store6');
-        $this->assertEquals('Product 6', $store6->getAttribute('products')[0]->getAttribute('name'));
+        /** @var array<Document> $_rel_products_677 */
+        $_rel_products_677 = $store6->getAttribute('products');
+        $this->assertEquals('Product 6', $_rel_products_677[0]->getAttribute('name'));
 
         // Update document with new related document
         $database->updateDocument(
@@ -721,6 +762,7 @@ public function testManyToOneTwoWayRelationship(): void
 
         // Get document with new relationship key
         $store = $database->getDocument('store', 'store2');
+        /** @var array<array<string, mixed>> $products */
         $products = $store->getAttribute('newProducts');
         $this->assertEquals('product1', $products[0]['$id']);
 
@@ -772,7 +814,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 +828,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,8 +863,9 @@ public function testNestedManyToOne_OneToOneRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -830,25 +873,12 @@ public function testNestedManyToOne_OneToOneRelationship(): void
         $database->createCollection('homelands');
         $database->createCollection('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', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('homelands', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('capitals', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
 
-        $database->createRelationship(
-            collection: 'towns',
-            relatedCollection: 'homelands',
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: true,
-            id: 'homeland'
-        );
-        $database->createRelationship(
-            collection: 'homelands',
-            relatedCollection: 'capitals',
-            type: Database::RELATION_ONE_TO_ONE,
-            twoWay: true,
-            id: 'capital',
-            twoWayKey: 'homeland'
-        );
+        $database->createRelationship(new Relationship(collection: 'towns', relatedCollection: 'homelands', type: RelationType::ManyToOne, twoWay: true, key: 'homeland'));
+        $database->createRelationship(new Relationship(collection: 'homelands', relatedCollection: 'capitals', type: RelationType::OneToOne, twoWay: true, key: 'capital', twoWayKey: 'homeland'));
 
         $database->createDocument('towns', new Document([
             '$id' => 'town1',
@@ -922,8 +952,9 @@ public function testNestedManyToOne_OneToManyRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -931,25 +962,12 @@ public function testNestedManyToOne_OneToManyRelationship(): void
         $database->createCollection('teams');
         $database->createCollection('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', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('teams', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('supporters', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
 
-        $database->createRelationship(
-            collection: 'players',
-            relatedCollection: 'teams',
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: true,
-            id: 'team'
-        );
-        $database->createRelationship(
-            collection: 'teams',
-            relatedCollection: 'supporters',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-            id: 'supporters',
-            twoWayKey: 'team'
-        );
+        $database->createRelationship(new Relationship(collection: 'players', relatedCollection: 'teams', type: RelationType::ManyToOne, twoWay: true, key: 'team'));
+        $database->createRelationship(new Relationship(collection: 'teams', relatedCollection: 'supporters', type: RelationType::OneToMany, twoWay: true, key: 'supporters', twoWayKey: 'team'));
 
         $database->createDocument('players', new Document([
             '$id' => 'player1',
@@ -1033,8 +1051,9 @@ public function testNestedManyToOne_ManyToOne(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -1042,24 +1061,12 @@ public function testNestedManyToOne_ManyToOne(): void
         $database->createCollection('farms');
         $database->createCollection('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', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('farms', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('farmer', new Attribute(key: 'name', type: ColumnType::String, size: 255, 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(new Relationship(collection: 'cows', relatedCollection: 'farms', type: RelationType::ManyToOne, twoWay: true, key: 'farm'));
+        $database->createRelationship(new Relationship(collection: 'farms', relatedCollection: 'farmer', type: RelationType::ManyToOne, twoWay: true, key: 'farmer'));
 
         $database->createDocument('cows', new Document([
             '$id' => 'cow1',
@@ -1135,8 +1142,9 @@ public function testNestedManyToOne_ManyToManyRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -1144,23 +1152,12 @@ public function testNestedManyToOne_ManyToManyRelationship(): void
         $database->createCollection('entrants');
         $database->createCollection('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', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('entrants', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('rooms', new Attribute(key: 'name', type: ColumnType::String, size: 255, 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(new Relationship(collection: 'books', relatedCollection: 'entrants', type: RelationType::ManyToOne, twoWay: true, key: 'entrant'));
+        $database->createRelationship(new Relationship(collection: 'entrants', relatedCollection: 'rooms', type: RelationType::ManyToMany, twoWay: true));
 
         $database->createDocument('books', new Document([
             '$id' => 'book1',
@@ -1206,8 +1203,9 @@ public function testExceedMaxDepthManyToOneParent(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -1221,24 +1219,9 @@ public function testExceedMaxDepthManyToOneParent(): void
         $database->createCollection($level3Collection);
         $database->createCollection($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(new Relationship(collection: $level1Collection, relatedCollection: $level2Collection, type: RelationType::ManyToOne, twoWay: true));
+        $database->createRelationship(new Relationship(collection: $level2Collection, relatedCollection: $level3Collection, type: RelationType::ManyToOne, twoWay: true));
+        $database->createRelationship(new Relationship(collection: $level3Collection, relatedCollection: $level4Collection, type: RelationType::ManyToOne, twoWay: true));
 
         $level1 = $database->createDocument($level1Collection, new Document([
             '$id' => 'level1',
@@ -1289,109 +1272,83 @@ public function testManyToOneRelationshipKeyWithSymbols(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $database->createCollection('$symbols_coll.ection5');
         $database->createCollection('$symbols_coll.ection6');
 
-        $database->createRelationship(
-            collection: '$symbols_coll.ection5',
-            relatedCollection: '$symbols_coll.ection6',
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: true,
-        );
+        $database->createRelationship(new Relationship(collection: '$symbols_coll.ection5', relatedCollection: '$symbols_coll.ection6', type: RelationType::ManyToOne, 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());
+        /** @var array<Document> $_arr_symbols_collection5_1253 */
+        $_arr_symbols_collection5_1253 = $doc1->getAttribute('symbols_collection5');
+        $this->assertEquals($doc2->getId(), $_arr_symbols_collection5_1253[0]->getId());
+        $this->assertEquals($doc1->getId(), $doc2->getAttribute('symbols_collection6')->getId());
     }
 
-
     public function testRecreateManyToOneOneWayRelationshipFromParent(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $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($one, [
+            new Attribute(key: 'name', type: ColumnType::String, size: 100, required: false, default: null, signed: true, array: false, format: '', filters: []),
         ], [], [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(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' => [],
-            ]),
+        $database->createCollection($two, [
+            new Attribute(key: 'name', type: ColumnType::String, size: 100, required: false, default: null, signed: true, array: false, format: '', filters: []),
         ], [], [
             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(new Relationship(collection: $one, relatedCollection: $two, type: RelationType::ManyToOne));
 
-        $database->deleteRelationship('one', 'two');
+        $database->deleteRelationship($one, $two);
 
-        $result = $database->createRelationship(
-            collection: 'one',
-            relatedCollection: 'two',
-            type: Database::RELATION_MANY_TO_ONE,
-        );
+        $result = $database->createRelationship(new Relationship(collection: $one, relatedCollection: $two, type: RelationType::ManyToOne));
 
         $this->assertTrue($result);
 
-        $database->deleteCollection('one');
-        $database->deleteCollection('two');
+        $database->deleteCollection($one);
+        $database->deleteCollection($two);
     }
 
     public function testRecreateManyToOneOneWayRelationshipFromChild(): void
@@ -1399,65 +1356,42 @@ public function testRecreateManyToOneOneWayRelationshipFromChild(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $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($one, [
+            new Attribute(key: 'name', type: ColumnType::String, size: 100, required: false, default: null, signed: true, array: false, format: '', filters: []),
         ], [], [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(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' => [],
-            ]),
+        $database->createCollection($two, [
+            new Attribute(key: 'name', type: ColumnType::String, size: 100, required: false, default: null, signed: true, array: false, format: '', filters: []),
         ], [], [
             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(new Relationship(collection: $one, relatedCollection: $two, type: RelationType::ManyToOne));
 
-        $database->deleteRelationship('two', 'one');
+        $database->deleteRelationship($two, $one);
 
-        $result = $database->createRelationship(
-            collection: 'one',
-            relatedCollection: 'two',
-            type: Database::RELATION_MANY_TO_ONE,
-        );
+        $result = $database->createRelationship(new Relationship(collection: $one, relatedCollection: $two, type: RelationType::ManyToOne));
 
         $this->assertTrue($result);
 
-        $database->deleteCollection('one');
-        $database->deleteCollection('two');
+        $database->deleteCollection($one);
+        $database->deleteCollection($two);
     }
 
     public function testRecreateManyToOneTwoWayRelationshipFromParent(): void
@@ -1465,134 +1399,85 @@ public function testRecreateManyToOneTwoWayRelationshipFromParent(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $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($one, [
+            new Attribute(key: 'name', type: ColumnType::String, size: 100, required: false, default: null, signed: true, array: false, format: '', filters: []),
         ], [], [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(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' => [],
-            ]),
+        $database->createCollection($two, [
+            new Attribute(key: 'name', type: ColumnType::String, size: 100, required: false, default: null, signed: true, array: false, format: '', filters: []),
         ], [], [
             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(new Relationship(collection: $one, relatedCollection: $two, type: RelationType::ManyToOne, 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(new Relationship(collection: $one, relatedCollection: $two, type: RelationType::ManyToOne, 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() instanceof Feature\Relationships)) {
             $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($one, [
+            new Attribute(key: 'name', type: ColumnType::String, size: 100, required: false, default: null, signed: true, array: false, format: '', filters: []),
         ], [], [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(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' => [],
-            ]),
+        $database->createCollection($two, [
+            new Attribute(key: 'name', type: ColumnType::String, size: 100, required: false, default: null, signed: true, array: false, format: '', filters: []),
         ], [], [
             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(new Relationship(collection: $one, relatedCollection: $two, type: RelationType::ManyToOne, 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(new Relationship(collection: $one, relatedCollection: $two, type: RelationType::ManyToOne, twoWay: true));
 
         $this->assertTrue($result);
 
-        $database->deleteCollection('one');
-        $database->deleteCollection('two');
+        $database->deleteCollection($one);
+        $database->deleteCollection($two);
     }
 
     public function testDeleteBulkDocumentsManyToOneRelationship(): void
@@ -1600,25 +1485,21 @@ public function testDeleteBulkDocumentsManyToOneRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships() || !$database->getAdapter()->getSupportForBatchOperations()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships) || ! $database->getAdapter()->supports(Capability::BatchOperations)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $this->getDatabase()->createCollection('bulk_delete_person_m2o');
         $this->getDatabase()->createCollection('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', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $this->getDatabase()->createAttribute('bulk_delete_library_m2o', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $this->getDatabase()->createAttribute('bulk_delete_library_m2o', new Attribute(key: 'area', type: ColumnType::String, size: 255, 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(new Relationship(collection: 'bulk_delete_person_m2o', relatedCollection: 'bulk_delete_library_m2o', type: RelationType::ManyToOne, onDelete: ForeignKeyAction::Restrict));
 
         $person1 = $this->getDatabase()->createDocument('bulk_delete_person_m2o', new Document([
             '$id' => 'person1',
@@ -1650,7 +1531,7 @@ public function testDeleteBulkDocumentsManyToOneRelationship(): void
             'name' => 'Person 2',
             'bulk_delete_library_m2o' => [
                 '$id' => 'library1',
-            ]
+            ],
         ]));
 
         $person1 = $this->getDatabase()->getDocument('bulk_delete_person_m2o', 'person1');
@@ -1678,16 +1559,18 @@ 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() instanceof Feature\Relationships) ||
+            ! $database->getAdapter()->supports(Capability::BatchOperations)
         ) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -1697,15 +1580,11 @@ public function testUpdateParentAndChild_ManyToOne(): void
         $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->createAttribute($parentCollection, new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($childCollection, new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($childCollection, new Attribute(key: 'parentNumber', type: ColumnType::Integer, size: 0, required: false));
 
-        $database->createRelationship(
-            collection: $childCollection,
-            relatedCollection: $parentCollection,
-            type: Database::RELATION_MANY_TO_ONE,
-        );
+        $database->createRelationship(new Relationship(collection: $childCollection, relatedCollection: $parentCollection, type: RelationType::ManyToOne));
 
         $database->createDocument($parentCollection, new Document([
             '$id' => 'parent1',
@@ -1765,8 +1644,9 @@ public function testDeleteDocumentsRelationshipErrorDoesNotDeleteParent_ManyToOn
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships() || !$database->getAdapter()->getSupportForBatchOperations()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships) || ! $database->getAdapter()->supports(Capability::BatchOperations)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -1775,15 +1655,10 @@ public function testDeleteDocumentsRelationshipErrorDoesNotDeleteParent_ManyToOn
 
         $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->createRelationship(
-            collection: $childCollection,
-            relatedCollection: $parentCollection,
-            type: Database::RELATION_MANY_TO_ONE,
-            onDelete: Database::RELATION_MUTATE_RESTRICT
-        );
+        $database->createAttribute($parentCollection, new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($childCollection, new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+
+        $database->createRelationship(new Relationship(collection: $childCollection, relatedCollection: $parentCollection, type: RelationType::ManyToOne, onDelete: ForeignKeyAction::Restrict));
 
         $parent = $database->createDocument($parentCollection, new Document([
             '$id' => 'parent1',
@@ -1803,7 +1678,7 @@ public function testDeleteDocumentsRelationshipErrorDoesNotDeleteParent_ManyToOn
                 Permission::delete(Role::any()),
             ],
             'name' => 'Child 1',
-            $parentCollection => 'parent1'
+            $parentCollection => 'parent1',
         ]));
 
         try {
@@ -1825,26 +1700,20 @@ public function testPartialUpdateManyToOneParentSide(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $database->createCollection('companies');
         $database->createCollection('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->createRelationship(
-            collection: 'employees',
-            relatedCollection: 'companies',
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: true,
-            id: 'company',
-            twoWayKey: 'employees'
-        );
+        $database->createAttribute('companies', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('employees', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('employees', new Attribute(key: 'salary', type: ColumnType::Integer, size: 0, required: false));
+
+        $database->createRelationship(new Relationship(collection: 'employees', relatedCollection: 'companies', type: RelationType::ManyToOne, twoWay: true, key: 'company', twoWayKey: 'employees'));
 
         // Create company
         $database->createDocument('companies', new Document([
@@ -1903,26 +1772,20 @@ public function testPartialUpdateManyToOneChildSide(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $database->createCollection('departments');
         $database->createCollection('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->createRelationship(
-            collection: 'staff',
-            relatedCollection: 'departments',
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: true,
-            id: 'department',
-            twoWayKey: 'staff'
-        );
+        $database->createAttribute('departments', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('departments', new Attribute(key: 'budget', type: ColumnType::Integer, size: 0, required: false));
+        $database->createAttribute('staff', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+
+        $database->createRelationship(new Relationship(collection: 'staff', relatedCollection: 'departments', type: RelationType::ManyToOne, twoWay: true, key: 'department', twoWayKey: 'staff'));
 
         // Create department with staff
         $database->createDocument('departments', new Document([
diff --git a/tests/e2e/Adapter/Scopes/Relationships/OneToManyTests.php b/tests/e2e/Adapter/Scopes/Relationships/OneToManyTests.php
index 7923191cd..22ca72fb1 100644
--- a/tests/e2e/Adapter/Scopes/Relationships/OneToManyTests.php
+++ b/tests/e2e/Adapter/Scopes/Relationships/OneToManyTests.php
@@ -3,6 +3,9 @@
 namespace Tests\E2E\Adapter\Scopes\Relationships;
 
 use Exception;
+use Utopia\Database\Adapter\Feature;
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
 use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Exception\Restricted as RestrictedException;
@@ -11,6 +14,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,36 +26,33 @@ public function testOneToManyOneWayRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $database->createCollection('artist');
         $database->createCollection('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', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('album', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('album', new Attribute(key: 'price', type: ColumnType::Double, size: 0, required: true));
 
-        $database->createRelationship(
-            collection: 'artist',
-            relatedCollection: 'album',
-            type: Database::RELATION_ONE_TO_MANY,
-            id: 'albums'
-        );
+        $database->createRelationship(new Relationship(collection: 'artist', relatedCollection: 'album', type: RelationType::OneToMany, key: 'albums'));
 
         // Check metadata for collection
         $collection = $database->getCollection('artist');
         $attributes = $collection->getAttribute('attributes', []);
 
+        /** @var array<mixed> $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(RelationType::OneToMany->value, $attribute['options']['relationType']);
                 $this->assertEquals(false, $attribute['options']['twoWay']);
                 $this->assertEquals('artist', $attribute['options']['twoWayKey']);
             }
@@ -68,7 +72,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 +85,9 @@ 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')));
+        /** @var array<mixed> $_cnt_albums_86 */
+        $_cnt_albums_86 = $artist1Document->getAttribute('albums');
+        $this->assertEquals(1, \count($_cnt_albums_86));
 
         // Create document with relationship with related ID
         $database->createDocument('album', new Document([
@@ -112,23 +118,25 @@ 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');
+        /** @var array<array<string, mixed>> $albums */
         $albums = $artist->getAttribute('albums', []);
         $this->assertEquals('album1', $albums[0]['$id']);
         $this->assertArrayNotHasKey('artist', $albums[0]);
 
         $artist = $database->getDocument('artist', 'artist2');
+        /** @var array<array<string, mixed>> $albums */
         $albums = $artist->getAttribute('albums', []);
         $this->assertEquals('album2', $albums[0]['$id']);
         $this->assertArrayNotHasKey('artist', $albums[0]);
@@ -148,22 +156,30 @@ 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]);
+        /** @var array<Document> $_rel_albums_160 */
+        $_rel_albums_160 = $artist->getAttribute('albums');
+        $this->assertEquals('Album 1', $_rel_albums_160[0]->getAttribute('name'));
+        /** @var array<mixed> $_arr_albums_161 */
+        $_arr_albums_161 = $artist->getAttribute('albums');
+        $this->assertArrayNotHasKey('price', $_arr_albums_161[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]);
+        /** @var array<Document> $_rel_albums_167 */
+        $_rel_albums_167 = $artist->getAttribute('albums');
+        $this->assertEquals('Album 1', $_rel_albums_167[0]->getAttribute('name'));
+        /** @var array<mixed> $_arr_albums_168 */
+        $_arr_albums_168 = $artist->getAttribute('albums');
+        $this->assertArrayNotHasKey('price', $_arr_albums_168[0]);
 
         // Update root document attribute without altering relationship
         $artist1 = $database->updateDocument(
@@ -177,6 +193,7 @@ public function testOneToManyOneWayRelationship(): void
         $this->assertEquals('Artist 1 Updated', $artist1->getAttribute('name'));
 
         // Update nested document attribute
+        /** @var array<\Utopia\Database\Document> $albums */
         $albums = $artist1->getAttribute('albums', []);
         $albums[0]->setAttribute('name', 'Album 1 Updated');
 
@@ -186,9 +203,13 @@ public function testOneToManyOneWayRelationship(): void
             $artist1->setAttribute('albums', $albums)
         );
 
-        $this->assertEquals('Album 1 Updated', $artist1->getAttribute('albums')[0]->getAttribute('name'));
+        /** @var array<Document> $_rel_albums_191 */
+        $_rel_albums_191 = $artist1->getAttribute('albums');
+        $this->assertEquals('Album 1 Updated', $_rel_albums_191[0]->getAttribute('name'));
         $artist1 = $database->getDocument('artist', 'artist1');
-        $this->assertEquals('Album 1 Updated', $artist1->getAttribute('albums')[0]->getAttribute('name'));
+        /** @var array<Document> $_rel_albums_193 */
+        $_rel_albums_193 = $artist1->getAttribute('albums');
+        $this->assertEquals('Album 1 Updated', $_rel_albums_193[0]->getAttribute('name'));
 
         $albumId = $artist1->getAttribute('albums')[0]->getAttribute('$id');
         $albumDocument = $database->getDocument('album', $albumId);
@@ -198,7 +219,9 @@ public function testOneToManyOneWayRelationship(): void
         $artist1 = $database->getDocument('artist', $artist1->getId());
 
         $this->assertEquals('Album 1 Updated!!!', $albumDocument['name']);
-        $this->assertEquals($albumDocument->getId(), $artist1->getAttribute('albums')[0]->getId());
+        /** @var array<Document> $_arr_albums_203 */
+        $_arr_albums_203 = $artist1->getAttribute('albums');
+        $this->assertEquals($albumDocument->getId(), $_arr_albums_203[0]->getId());
         $this->assertEquals($albumDocument->getAttribute('name'), $artist1->getAttribute('albums')[0]->getAttribute('name'));
 
         // Create new document with no relationship
@@ -228,9 +251,13 @@ public function testOneToManyOneWayRelationship(): void
             ])])
         );
 
-        $this->assertEquals('Album 3', $artist3->getAttribute('albums')[0]->getAttribute('name'));
+        /** @var array<Document> $_rel_albums_233 */
+        $_rel_albums_233 = $artist3->getAttribute('albums');
+        $this->assertEquals('Album 3', $_rel_albums_233[0]->getAttribute('name'));
         $artist3 = $database->getDocument('artist', 'artist3');
-        $this->assertEquals('Album 3', $artist3->getAttribute('albums')[0]->getAttribute('name'));
+        /** @var array<Document> $_rel_albums_235 */
+        $_rel_albums_235 = $artist3->getAttribute('albums');
+        $this->assertEquals('Album 3', $_rel_albums_235[0]->getAttribute('name'));
 
         // Update document with new related documents, will remove existing relations
         $database->updateDocument(
@@ -255,6 +282,7 @@ public function testOneToManyOneWayRelationship(): void
 
         // Get document with new relationship key
         $artist = $database->getDocument('artist', 'artist1');
+        /** @var array<array<string, mixed>> $albums */
         $albums = $artist->getAttribute('newAlbums');
         $this->assertEquals('album1', $albums[0]['$id']);
 
@@ -288,7 +316,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 +337,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 +351,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 +370,17 @@ 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'));
+        /** @var array<mixed> $_ac_newAlbums_351 */
+        $_ac_newAlbums_351 = $artist->getAttribute('newAlbums');
+        $this->assertCount(50, $_ac_newAlbums_351);
 
         $albums = $database->find('album', [
             Query::equal('artist', [$artist->getId()]),
-            Query::limit(999)
+            Query::limit(999),
         ]);
 
         $this->assertCount(50, $albums);
@@ -363,13 +393,15 @@ public function testOneToManyOneWayRelationship(): void
 
         $database->deleteDocument('album', 'album_1');
         $artist = $database->getDocument('artist', $artist->getId());
-        $this->assertCount(49, $artist->getAttribute('newAlbums'));
+        /** @var array<mixed> $_ac_newAlbums_368 */
+        $_ac_newAlbums_368 = $artist->getAttribute('newAlbums');
+        $this->assertCount(49, $_ac_newAlbums_368);
 
         $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,36 +423,32 @@ public function testOneToManyTwoWayRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $database->createCollection('customer');
         $database->createCollection('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', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('account', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('account', new Attribute(key: 'number', type: ColumnType::String, size: 255, required: true));
 
-        $database->createRelationship(
-            collection: 'customer',
-            relatedCollection: 'account',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-            id: 'accounts'
-        );
+        $database->createRelationship(new Relationship(collection: 'customer', relatedCollection: 'account', type: RelationType::OneToMany, twoWay: true, key: 'accounts'));
 
         // Check metadata for collection
         $collection = $database->getCollection('customer');
         $attributes = $collection->getAttribute('attributes', []);
+        /** @var array<mixed> $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(RelationType::OneToMany->value, $attribute['options']['relationType']);
                 $this->assertEquals(true, $attribute['options']['twoWay']);
                 $this->assertEquals('customer', $attribute['options']['twoWayKey']);
             }
@@ -429,13 +457,14 @@ public function testOneToManyTwoWayRelationship(): void
         // Check metadata for related collection
         $collection = $database->getCollection('account');
         $attributes = $collection->getAttribute('attributes', []);
+        /** @var array<mixed> $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(RelationType::OneToMany->value, $attribute['options']['relationType']);
                 $this->assertEquals(true, $attribute['options']['twoWay']);
                 $this->assertEquals('accounts', $attribute['options']['twoWayKey']);
             }
@@ -465,11 +494,13 @@ 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')));
+        /** @var array<mixed> $_cnt_accounts_469 */
+        $_cnt_accounts_469 = $customer1Document->getAttribute('accounts');
+        $this->assertEquals(1, \count($_cnt_accounts_469));
 
         // Create document with relationship with related ID
         $account2 = $database->createDocument('account', new Document([
@@ -491,8 +522,8 @@ public function testOneToManyTwoWayRelationship(): void
             ],
             'name' => 'Customer 2',
             'accounts' => [
-                'account2'
-            ]
+                'account2',
+            ],
         ]));
 
         // Create from child side
@@ -512,8 +543,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,26 +564,30 @@ public function testOneToManyTwoWayRelationship(): void
             ],
             'name' => 'Account 4',
             'number' => '123456789',
-            'customer' => 'customer4'
+            'customer' => 'customer4',
         ]));
 
         // Get documents with relationship
         $customer = $database->getDocument('customer', 'customer1');
+        /** @var array<array<string, mixed>> $accounts */
         $accounts = $customer->getAttribute('accounts', []);
         $this->assertEquals('account1', $accounts[0]['$id']);
         $this->assertArrayNotHasKey('customer', $accounts[0]);
 
         $customer = $database->getDocument('customer', 'customer2');
+        /** @var array<array<string, mixed>> $accounts */
         $accounts = $customer->getAttribute('accounts', []);
         $this->assertEquals('account2', $accounts[0]['$id']);
         $this->assertArrayNotHasKey('customer', $accounts[0]);
 
         $customer = $database->getDocument('customer', 'customer3');
+        /** @var array<array<string, mixed>> $accounts */
         $accounts = $customer->getAttribute('accounts', []);
         $this->assertEquals('account3', $accounts[0]['$id']);
         $this->assertArrayNotHasKey('customer', $accounts[0]);
 
         $customer = $database->getDocument('customer', 'customer4');
+        /** @var array<array<string, mixed>> $accounts */
         $accounts = $customer->getAttribute('accounts', []);
         $this->assertEquals('account4', $accounts[0]['$id']);
         $this->assertArrayNotHasKey('customer', $accounts[0]);
@@ -584,22 +619,30 @@ 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]);
+        /** @var array<Document> $_rel_accounts_591 */
+        $_rel_accounts_591 = $customer->getAttribute('accounts');
+        $this->assertEquals('Account 1', $_rel_accounts_591[0]->getAttribute('name'));
+        /** @var array<mixed> $_arr_accounts_592 */
+        $_arr_accounts_592 = $customer->getAttribute('accounts');
+        $this->assertArrayNotHasKey('number', $_arr_accounts_592[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]);
+        /** @var array<Document> $_rel_accounts_598 */
+        $_rel_accounts_598 = $customer->getAttribute('accounts');
+        $this->assertEquals('Account 1', $_rel_accounts_598[0]->getAttribute('name'));
+        /** @var array<mixed> $_arr_accounts_599 */
+        $_arr_accounts_599 = $customer->getAttribute('accounts');
+        $this->assertArrayNotHasKey('number', $_arr_accounts_599[0]);
 
         // Update root document attribute without altering relationship
         $customer1 = $database->updateDocument(
@@ -626,6 +669,7 @@ public function testOneToManyTwoWayRelationship(): void
         $this->assertEquals('Account 2 Updated', $account2->getAttribute('name'));
 
         // Update nested document attribute
+        /** @var array<\Utopia\Database\Document> $accounts */
         $accounts = $customer1->getAttribute('accounts', []);
         $accounts[0]->setAttribute('name', 'Account 1 Updated');
 
@@ -635,9 +679,13 @@ public function testOneToManyTwoWayRelationship(): void
             $customer1->setAttribute('accounts', $accounts)
         );
 
-        $this->assertEquals('Account 1 Updated', $customer1->getAttribute('accounts')[0]->getAttribute('name'));
+        /** @var array<Document> $_rel_accounts_635 */
+        $_rel_accounts_635 = $customer1->getAttribute('accounts');
+        $this->assertEquals('Account 1 Updated', $_rel_accounts_635[0]->getAttribute('name'));
         $customer1 = $database->getDocument('customer', 'customer1');
-        $this->assertEquals('Account 1 Updated', $customer1->getAttribute('accounts')[0]->getAttribute('name'));
+        /** @var array<Document> $_rel_accounts_637 */
+        $_rel_accounts_637 = $customer1->getAttribute('accounts');
+        $this->assertEquals('Account 1 Updated', $_rel_accounts_637[0]->getAttribute('name'));
 
         // Update inverse nested document attribute
         $account2 = $database->updateDocument(
@@ -651,9 +699,13 @@ public function testOneToManyTwoWayRelationship(): void
             )
         );
 
-        $this->assertEquals('Customer 2 Updated', $account2->getAttribute('customer')->getAttribute('name'));
+        /** @var \Utopia\Database\Document $_doc_customer_651 */
+        $_doc_customer_651 = $account2->getAttribute('customer');
+        $this->assertEquals('Customer 2 Updated', $_doc_customer_651->getAttribute('name'));
         $account2 = $database->getDocument('account', 'account2');
-        $this->assertEquals('Customer 2 Updated', $account2->getAttribute('customer')->getAttribute('name'));
+        /** @var \Utopia\Database\Document $_doc_customer_653 */
+        $_doc_customer_653 = $account2->getAttribute('customer');
+        $this->assertEquals('Customer 2 Updated', $_doc_customer_653->getAttribute('name'));
 
         // Create new document with no relationship
         $customer5 = $database->createDocument('customer', new Document([
@@ -682,9 +734,13 @@ public function testOneToManyTwoWayRelationship(): void
             ])])
         );
 
-        $this->assertEquals('Account 5', $customer5->getAttribute('accounts')[0]->getAttribute('name'));
+        /** @var array<Document> $_rel_accounts_682 */
+        $_rel_accounts_682 = $customer5->getAttribute('accounts');
+        $this->assertEquals('Account 5', $_rel_accounts_682[0]->getAttribute('name'));
         $customer5 = $database->getDocument('customer', 'customer5');
-        $this->assertEquals('Account 5', $customer5->getAttribute('accounts')[0]->getAttribute('name'));
+        /** @var array<Document> $_rel_accounts_684 */
+        $_rel_accounts_684 = $customer5->getAttribute('accounts');
+        $this->assertEquals('Account 5', $_rel_accounts_684[0]->getAttribute('name'));
 
         // Create new child document with no relationship
         $account6 = $database->createDocument('account', new Document([
@@ -713,9 +769,13 @@ public function testOneToManyTwoWayRelationship(): void
             ]))
         );
 
-        $this->assertEquals('Customer 6', $account6->getAttribute('customer')->getAttribute('name'));
+        /** @var \Utopia\Database\Document $_doc_customer_713 */
+        $_doc_customer_713 = $account6->getAttribute('customer');
+        $this->assertEquals('Customer 6', $_doc_customer_713->getAttribute('name'));
         $account6 = $database->getDocument('account', 'account6');
-        $this->assertEquals('Customer 6', $account6->getAttribute('customer')->getAttribute('name'));
+        /** @var \Utopia\Database\Document $_doc_customer_715 */
+        $_doc_customer_715 = $account6->getAttribute('customer');
+        $this->assertEquals('Customer 6', $_doc_customer_715->getAttribute('name'));
 
         // Update document with new related document, will remove existing relations
         $database->updateDocument(
@@ -748,6 +808,7 @@ public function testOneToManyTwoWayRelationship(): void
 
         // Get document with new relationship key
         $customer = $database->getDocument('customer', 'customer1');
+        /** @var array<array<string, mixed>> $accounts */
         $accounts = $customer->getAttribute('newAccounts');
         $this->assertEquals('account1', $accounts[0]['$id']);
 
@@ -786,7 +847,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 +868,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,8 +903,9 @@ public function testNestedOneToMany_OneToOneRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -851,25 +913,12 @@ public function testNestedOneToMany_OneToOneRelationship(): void
         $database->createCollection('cities');
         $database->createCollection('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', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('countries', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('mayors', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
 
-        $database->createRelationship(
-            collection: 'countries',
-            relatedCollection: 'cities',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-            twoWayKey: 'country'
-        );
-        $database->createRelationship(
-            collection: 'cities',
-            relatedCollection: 'mayors',
-            type: Database::RELATION_ONE_TO_ONE,
-            twoWay: true,
-            id: 'mayor',
-            twoWayKey: 'city'
-        );
+        $database->createRelationship(new Relationship(collection: 'countries', relatedCollection: 'cities', type: RelationType::OneToMany, twoWay: true, twoWayKey: 'country'));
+        $database->createRelationship(new Relationship(collection: 'cities', relatedCollection: 'mayors', type: RelationType::OneToOne, twoWay: true, key: 'mayor', twoWayKey: 'city'));
 
         $database->createDocument('countries', new Document([
             '$id' => 'country1',
@@ -913,27 +962,27 @@ 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']);
 
         $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']);
@@ -1001,8 +1050,9 @@ public function testNestedOneToMany_OneToManyRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -1010,24 +1060,12 @@ public function testNestedOneToMany_OneToManyRelationship(): void
         $database->createCollection('occupants');
         $database->createCollection('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', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('occupants', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('pets', new Attribute(key: 'name', type: ColumnType::String, size: 255, 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(new Relationship(collection: 'dormitories', relatedCollection: 'occupants', type: RelationType::OneToMany, twoWay: true, twoWayKey: 'dormitory'));
+        $database->createRelationship(new Relationship(collection: 'occupants', relatedCollection: 'pets', type: RelationType::OneToMany, twoWay: true, twoWayKey: 'occupant'));
 
         $database->createDocument('dormitories', new Document([
             '$id' => 'dormitory1',
@@ -1133,8 +1171,9 @@ public function testNestedOneToMany_ManyToOneRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -1142,23 +1181,12 @@ public function testNestedOneToMany_ManyToOneRelationship(): void
         $database->createCollection('renters');
         $database->createCollection('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', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('renters', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('floors', new Attribute(key: 'name', type: ColumnType::String, size: 255, 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(new Relationship(collection: 'home', relatedCollection: 'renters', type: RelationType::OneToMany, twoWay: true));
+        $database->createRelationship(new Relationship(collection: 'renters', relatedCollection: 'floors', type: RelationType::ManyToOne, twoWay: true, key: 'floor'));
 
         $database->createDocument('home', new Document([
             '$id' => 'home1',
@@ -1226,8 +1254,9 @@ public function testNestedOneToMany_ManyToManyRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -1235,23 +1264,12 @@ public function testNestedOneToMany_ManyToManyRelationship(): void
         $database->createCollection('cats');
         $database->createCollection('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', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('cats', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('toys', new Attribute(key: 'name', type: ColumnType::String, size: 255, 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(new Relationship(collection: 'owners', relatedCollection: 'cats', type: RelationType::OneToMany, twoWay: true, twoWayKey: 'owner'));
+        $database->createRelationship(new Relationship(collection: 'cats', relatedCollection: 'toys', type: RelationType::ManyToMany, twoWay: true));
 
         $database->createDocument('owners', new Document([
             '$id' => 'owner1',
@@ -1321,8 +1339,9 @@ public function testExceedMaxDepthOneToMany(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -1336,24 +1355,9 @@ public function testExceedMaxDepthOneToMany(): void
         $database->createCollection($level3Collection);
         $database->createCollection($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(new Relationship(collection: $level1Collection, relatedCollection: $level2Collection, type: RelationType::OneToMany, twoWay: true));
+        $database->createRelationship(new Relationship(collection: $level2Collection, relatedCollection: $level3Collection, type: RelationType::OneToMany, twoWay: true));
+        $database->createRelationship(new Relationship(collection: $level3Collection, relatedCollection: $level4Collection, type: RelationType::OneToMany, twoWay: true));
 
         // Exceed create depth
         $level1 = $database->createDocument($level1Collection, new Document([
@@ -1398,7 +1402,6 @@ public function testExceedMaxDepthOneToMany(): void
         $this->assertEquals('level3', $level1[$level2Collection][0][$level3Collection][0]->getId());
         $this->assertArrayNotHasKey($level4Collection, $level1[$level2Collection][0][$level3Collection][0]);
 
-
         // Exceed update depth
         $level1 = $database->updateDocument(
             $level1Collection,
@@ -1430,13 +1433,15 @@ public function testExceedMaxDepthOneToMany(): void
         $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() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -1450,24 +1455,9 @@ public function testExceedMaxDepthOneToManyChild(): void
         $database->createCollection($level3Collection);
         $database->createCollection($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(new Relationship(collection: $level1Collection, relatedCollection: $level2Collection, type: RelationType::OneToMany, twoWay: true));
+        $database->createRelationship(new Relationship(collection: $level2Collection, relatedCollection: $level3Collection, type: RelationType::OneToMany, twoWay: true));
+        $database->createRelationship(new Relationship(collection: $level3Collection, relatedCollection: $level4Collection, type: RelationType::OneToMany, twoWay: true));
 
         $level1 = $database->createDocument($level1Collection, new Document([
             '$id' => 'level1',
@@ -1485,7 +1475,7 @@ public function testExceedMaxDepthOneToManyChild(): void
                                 [
                                     '$id' => 'level4',
                                 ],
-                            ]
+                            ],
                         ],
                     ],
                 ],
@@ -1527,42 +1517,40 @@ public function testOneToManyRelationshipKeyWithSymbols(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $database->createCollection('$symbols_coll.ection3');
         $database->createCollection('$symbols_coll.ection4');
 
-        $database->createRelationship(
-            collection: '$symbols_coll.ection3',
-            relatedCollection: '$symbols_coll.ection4',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-        );
+        $database->createRelationship(new Relationship(collection: '$symbols_coll.ection3', relatedCollection: '$symbols_coll.ection4', type: RelationType::OneToMany, 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->getAttribute('symbols_collection3')->getId());
+        /** @var array<Document> $_arr_symbols_collection4_1487 */
+        $_arr_symbols_collection4_1487 = $doc2->getAttribute('symbols_collection4');
+        $this->assertEquals($doc1->getId(), $_arr_symbols_collection4_1487[0]->getId());
     }
 
     public function testRecreateOneToManyOneWayRelationshipFromChild(): void
@@ -1570,65 +1558,42 @@ public function testRecreateOneToManyOneWayRelationshipFromChild(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $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($one, [
+            new Attribute(key: 'name', type: ColumnType::String, size: 100, required: false, default: null, signed: true, array: false, format: '', filters: []),
         ], [], [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(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' => [],
-            ]),
+        $database->createCollection($two, [
+            new Attribute(key: 'name', type: ColumnType::String, size: 100, required: false, default: null, signed: true, array: false, format: '', filters: []),
         ], [], [
             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(new Relationship(collection: $one, relatedCollection: $two, type: RelationType::OneToMany));
 
-        $database->deleteRelationship('two', 'one');
+        $database->deleteRelationship($two, $one);
 
-        $result = $database->createRelationship(
-            collection: 'one',
-            relatedCollection: 'two',
-            type: Database::RELATION_ONE_TO_MANY,
-        );
+        $result = $database->createRelationship(new Relationship(collection: $one, relatedCollection: $two, type: RelationType::OneToMany));
 
         $this->assertTrue($result);
 
-        $database->deleteCollection('one');
-        $database->deleteCollection('two');
+        $database->deleteCollection($one);
+        $database->deleteCollection($two);
     }
 
     public function testRecreateOneToManyTwoWayRelationshipFromParent(): void
@@ -1636,67 +1601,42 @@ public function testRecreateOneToManyTwoWayRelationshipFromParent(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $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($one, [
+            new Attribute(key: 'name', type: ColumnType::String, size: 100, required: false, default: null, signed: true, array: false, format: '', filters: []),
         ], [], [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(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' => [],
-            ]),
+        $database->createCollection($two, [
+            new Attribute(key: 'name', type: ColumnType::String, size: 100, required: false, default: null, signed: true, array: false, format: '', filters: []),
         ], [], [
             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(new Relationship(collection: $one, relatedCollection: $two, type: RelationType::OneToMany, 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(new Relationship(collection: $one, relatedCollection: $two, type: RelationType::OneToMany, twoWay: true));
 
         $this->assertTrue($result);
 
-        $database->deleteCollection('one');
-        $database->deleteCollection('two');
+        $database->deleteCollection($one);
+        $database->deleteCollection($two);
     }
 
     public function testRecreateOneToManyTwoWayRelationshipFromChild(): void
@@ -1704,67 +1644,42 @@ public function testRecreateOneToManyTwoWayRelationshipFromChild(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $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($one, [
+            new Attribute(key: 'name', type: ColumnType::String, size: 100, required: false, default: null, signed: true, array: false, format: '', filters: []),
         ], [], [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(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' => [],
-            ]),
+        $database->createCollection($two, [
+            new Attribute(key: 'name', type: ColumnType::String, size: 100, required: false, default: null, signed: true, array: false, format: '', filters: []),
         ], [], [
             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(new Relationship(collection: $one, relatedCollection: $two, type: RelationType::OneToMany, 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(new Relationship(collection: $one, relatedCollection: $two, type: RelationType::OneToMany, twoWay: true));
 
         $this->assertTrue($result);
 
-        $database->deleteCollection('one');
-        $database->deleteCollection('two');
+        $database->deleteCollection($one);
+        $database->deleteCollection($two);
     }
 
     public function testRecreateOneToManyOneWayRelationshipFromParent(): void
@@ -1772,65 +1687,42 @@ public function testRecreateOneToManyOneWayRelationshipFromParent(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $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($one, [
+            new Attribute(key: 'name', type: ColumnType::String, size: 100, required: false, default: null, signed: true, array: false, format: '', filters: []),
         ], [], [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(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' => [],
-            ]),
+        $database->createCollection($two, [
+            new Attribute(key: 'name', type: ColumnType::String, size: 100, required: false, default: null, signed: true, array: false, format: '', filters: []),
         ], [], [
             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(new Relationship(collection: $one, relatedCollection: $two, type: RelationType::OneToMany));
 
-        $database->deleteRelationship('one', 'two');
+        $database->deleteRelationship($one, $two);
 
-        $result = $database->createRelationship(
-            collection: 'one',
-            relatedCollection: 'two',
-            type: Database::RELATION_ONE_TO_MANY,
-        );
+        $result = $database->createRelationship(new Relationship(collection: $one, relatedCollection: $two, type: RelationType::OneToMany));
 
         $this->assertTrue($result);
 
-        $database->deleteCollection('one');
-        $database->deleteCollection('two');
+        $database->deleteCollection($one);
+        $database->deleteCollection($two);
     }
 
     public function testDeleteBulkDocumentsOneToManyRelationship(): void
@@ -1838,25 +1730,21 @@ public function testDeleteBulkDocumentsOneToManyRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships() || !$database->getAdapter()->getSupportForBatchOperations()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships) || ! $database->getAdapter()->supports(Capability::BatchOperations)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $this->getDatabase()->createCollection('bulk_delete_person_o2m');
         $this->getDatabase()->createCollection('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', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $this->getDatabase()->createAttribute('bulk_delete_library_o2m', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $this->getDatabase()->createAttribute('bulk_delete_library_o2m', new Attribute(key: 'area', type: ColumnType::String, size: 255, 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(new Relationship(collection: 'bulk_delete_person_o2m', relatedCollection: 'bulk_delete_library_o2m', type: RelationType::OneToMany, onDelete: ForeignKeyAction::Restrict));
 
         $person1 = $this->getDatabase()->createDocument('bulk_delete_person_o2m', new Document([
             '$id' => 'person1',
@@ -1913,7 +1801,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([
@@ -1963,12 +1851,11 @@ public function testDeleteBulkDocumentsOneToManyRelationship(): void
         $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([
@@ -2015,74 +1902,106 @@ public function testDeleteBulkDocumentsOneToManyRelationship(): void
         $this->assertEmpty($libraries);
     }
 
-
     public function testOneToManyAndManyToOneDeleteRelationship(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('relation1');
-        $database->createCollection('relation2');
-
-        $database->createRelationship(
-            collection: 'relation1',
-            relatedCollection: 'relation2',
-            type: Database::RELATION_ONE_TO_MANY,
-        );
-
-        $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,
-        );
-
-        $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'));
+        $relation1 = 'relation1_' . uniqid();
+        $relation2 = 'relation2_' . uniqid();
+
+        $database->createCollection($relation1);
+        $database->createCollection($relation2);
+
+        $database->createRelationship(new Relationship(collection: $relation1, relatedCollection: $relation2, type: RelationType::OneToMany));
+
+        $relation1Col = $database->getCollection($relation1);
+        /** @var array<mixed> $_ac_attributes_1840 */
+        $_ac_attributes_1840 = $relation1Col->getAttribute('attributes');
+        $this->assertCount(1, $_ac_attributes_1840);
+        /** @var array<mixed> $_ac_indexes_1841 */
+        $_ac_indexes_1841 = $relation1Col->getAttribute('indexes');
+        $this->assertCount(0, $_ac_indexes_1841);
+        $relation2Col = $database->getCollection($relation2);
+        /** @var array<mixed> $_ac_attributes_1843 */
+        $_ac_attributes_1843 = $relation2Col->getAttribute('attributes');
+        $this->assertCount(1, $_ac_attributes_1843);
+        /** @var array<mixed> $_ac_indexes_1844 */
+        $_ac_indexes_1844 = $relation2Col->getAttribute('indexes');
+        $this->assertCount(1, $_ac_indexes_1844);
+
+        $database->deleteRelationship($relation2, $relation1);
+
+        $relation1Col = $database->getCollection($relation1);
+        /** @var array<mixed> $_ac_attributes_1849 */
+        $_ac_attributes_1849 = $relation1Col->getAttribute('attributes');
+        $this->assertCount(0, $_ac_attributes_1849);
+        /** @var array<mixed> $_ac_indexes_1850 */
+        $_ac_indexes_1850 = $relation1Col->getAttribute('indexes');
+        $this->assertCount(0, $_ac_indexes_1850);
+        $relation2Col = $database->getCollection($relation2);
+        /** @var array<mixed> $_ac_attributes_1852 */
+        $_ac_attributes_1852 = $relation2Col->getAttribute('attributes');
+        $this->assertCount(0, $_ac_attributes_1852);
+        /** @var array<mixed> $_ac_indexes_1853 */
+        $_ac_indexes_1853 = $relation2Col->getAttribute('indexes');
+        $this->assertCount(0, $_ac_indexes_1853);
+
+        $database->createRelationship(new Relationship(collection: $relation1, relatedCollection: $relation2, type: RelationType::ManyToOne));
+
+        $relation1Col = $database->getCollection($relation1);
+        /** @var array<mixed> $_ac_attributes_1858 */
+        $_ac_attributes_1858 = $relation1Col->getAttribute('attributes');
+        $this->assertCount(1, $_ac_attributes_1858);
+        /** @var array<mixed> $_ac_indexes_1859 */
+        $_ac_indexes_1859 = $relation1Col->getAttribute('indexes');
+        $this->assertCount(1, $_ac_indexes_1859);
+        $relation2Col = $database->getCollection($relation2);
+        /** @var array<mixed> $_ac_attributes_1861 */
+        $_ac_attributes_1861 = $relation2Col->getAttribute('attributes');
+        $this->assertCount(1, $_ac_attributes_1861);
+        /** @var array<mixed> $_ac_indexes_1862 */
+        $_ac_indexes_1862 = $relation2Col->getAttribute('indexes');
+        $this->assertCount(0, $_ac_indexes_1862);
+
+        $database->deleteRelationship($relation1, $relation2);
+
+        $relation1Col = $database->getCollection($relation1);
+        /** @var array<mixed> $_ac_attributes_1867 */
+        $_ac_attributes_1867 = $relation1Col->getAttribute('attributes');
+        $this->assertCount(0, $_ac_attributes_1867);
+        /** @var array<mixed> $_ac_indexes_1868 */
+        $_ac_indexes_1868 = $relation1Col->getAttribute('indexes');
+        $this->assertCount(0, $_ac_indexes_1868);
+        $relation2Col = $database->getCollection($relation2);
+        /** @var array<mixed> $_ac_attributes_1870 */
+        $_ac_attributes_1870 = $relation2Col->getAttribute('attributes');
+        $this->assertCount(0, $_ac_attributes_1870);
+        /** @var array<mixed> $_ac_indexes_1871 */
+        $_ac_indexes_1871 = $relation2Col->getAttribute('indexes');
+        $this->assertCount(0, $_ac_indexes_1871);
+
+        $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() instanceof Feature\Relationships) ||
+            ! $database->getAdapter()->supports(Capability::BatchOperations)
         ) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -2092,16 +2011,11 @@ public function testUpdateParentAndChild_OneToMany(): void
         $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->createAttribute($parentCollection, new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($childCollection, new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($childCollection, new Attribute(key: 'parentNumber', type: ColumnType::Integer, size: 0, required: false));
 
-        $database->createRelationship(
-            collection: $parentCollection,
-            relatedCollection: $childCollection,
-            type: Database::RELATION_ONE_TO_MANY,
-            id: 'parentNumber'
-        );
+        $database->createRelationship(new Relationship(collection: $parentCollection, relatedCollection: $childCollection, type: RelationType::OneToMany, key: 'parentNumber'));
 
         $database->createDocument($parentCollection, new Document([
             '$id' => 'parent1',
@@ -2155,13 +2069,15 @@ 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() instanceof Feature\Relationships) || ! $database->getAdapter()->supports(Capability::BatchOperations)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -2170,15 +2086,10 @@ public function testDeleteDocumentsRelationshipErrorDoesNotDeleteParent_OneToMan
 
         $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->createRelationship(
-            collection: $parentCollection,
-            relatedCollection: $childCollection,
-            type: Database::RELATION_ONE_TO_MANY,
-            onDelete: Database::RELATION_MUTATE_RESTRICT
-        );
+        $database->createAttribute($parentCollection, new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($childCollection, new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+
+        $database->createRelationship(new Relationship(collection: $parentCollection, relatedCollection: $childCollection, type: RelationType::OneToMany, onDelete: ForeignKeyAction::Restrict));
 
         $parent = $database->createDocument($parentCollection, new Document([
             '$id' => 'parent1',
@@ -2197,8 +2108,8 @@ public function testDeleteDocumentsRelationshipErrorDoesNotDeleteParent_OneToMan
                         Permission::delete(Role::any()),
                     ],
                     'name' => 'Child 1',
-                ]
-            ]
+                ],
+            ],
         ]));
 
         try {
@@ -2220,30 +2131,26 @@ public function testPartialBatchUpdateWithRelationships(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships() || !$database->getAdapter()->getSupportForBatchOperations()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships) || ! $database->getAdapter()->supports(Capability::BatchOperations)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        // Setup collections with relationships
-        $database->createCollection('products');
-        $database->createCollection('categories');
-
-        $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->createRelationship(
-            collection: 'categories',
-            relatedCollection: 'products',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-            id: 'products',
-            twoWayKey: 'category'
-        );
+        $products = 'products_' . uniqid();
+        $categories = 'categories_' . uniqid();
+
+        $database->createCollection($products);
+        $database->createCollection($categories);
+
+        $database->createAttribute($products, new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($products, new Attribute(key: 'price', type: ColumnType::Double, size: 0, required: true));
+        $database->createAttribute($categories, new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+
+        $database->createRelationship(new Relationship(collection: $categories, relatedCollection: $products, type: RelationType::OneToMany, twoWay: true, 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,29 +2180,27 @@ 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());
 
-        $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());
 
         // 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');
 
@@ -2304,20 +2209,21 @@ public function testPartialBatchUpdateWithRelationships(): void
         $this->assertNotNull($categoryAfter, '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');
 
         // 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');
+        /** @var array<\Utopia\Database\Document> $productsArr */
+        $productsArr = $category->getAttribute('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 +2231,26 @@ public function testPartialUpdateOnlyRelationship(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        // Setup collections
-        $database->createCollection('authors');
-        $database->createCollection('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->createRelationship(
-            collection: 'authors',
-            relatedCollection: 'books',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-            id: 'books',
-            twoWayKey: 'author'
-        );
+        $authors = 'authors_' . uniqid();
+        $books = 'books_' . uniqid();
+
+        $database->createCollection($authors);
+        $database->createCollection($books);
+
+        $database->createAttribute($authors, new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($authors, new Attribute(key: 'bio', type: ColumnType::String, size: 1000, required: false));
+        $database->createAttribute($books, new Attribute(key: 'title', type: ColumnType::String, size: 255, required: true));
+
+        $database->createRelationship(new Relationship(collection: $authors, relatedCollection: $books, type: RelationType::OneToMany, twoWay: true, 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 +2271,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 +2281,21 @@ 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());
+        /** @var array<mixed> $_ac_books_2164 */
+        $_ac_books_2164 = $author->getAttribute('books');
+        $this->assertCount(1, $_ac_books_2164);
+        /** @var array<Document> $_arr_books_2165 */
+        $_arr_books_2165 = $author->getAttribute('books');
+        $this->assertEquals('book1', $_arr_books_2165[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 +2303,26 @@ 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');
 
-        $bookIds = array_map(fn ($book) => $book->getId(), $authorAfter->getAttribute('books'));
+        /** @var array<Document> $_map_books_2186 */
+        $_map_books_2186 = $authorAfter->getAttribute('books');
+        $bookIds = \array_map(fn ($book) => $book->getId(), $_map_books_2186);
         $this->assertContains('book1', $bookIds);
         $this->assertContains('book2', $bookIds);
 
         // Verify reverse relationships
-        $book1 = $database->getDocument('books', 'book1');
+        $book1 = $database->getDocument($books, 'book1');
         $this->assertEquals('author1', $book1->getAttribute('author')->getId());
 
-        $book2 = $database->getDocument('books', 'book2');
+        $book2 = $database->getDocument($books, 'book2');
         $this->assertEquals('author1', $book2->getAttribute('author')->getId());
 
-        $database->deleteCollection('authors');
-        $database->deleteCollection('books');
+        $database->deleteCollection($authors);
+        $database->deleteCollection($books);
     }
 
     public function testPartialUpdateBothDataAndRelationship(): void
@@ -2424,31 +2330,27 @@ public function testPartialUpdateBothDataAndRelationship(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        // Setup collections
-        $database->createCollection('teams');
-        $database->createCollection('players');
-
-        $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->createRelationship(
-            collection: 'teams',
-            relatedCollection: 'players',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-            id: 'players',
-            twoWayKey: 'team'
-        );
+        $teams = 'teams_' . uniqid();
+        $players = 'players_' . uniqid();
+
+        $database->createCollection($teams);
+        $database->createCollection($players);
+
+        $database->createAttribute($teams, new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($teams, new Attribute(key: 'city', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($teams, new Attribute(key: 'founded', type: ColumnType::Integer, size: 0, required: false));
+        $database->createAttribute($players, new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+
+        $database->createRelationship(new Relationship(collection: $teams, relatedCollection: $players, type: RelationType::OneToMany, twoWay: true, 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 +2380,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 +2390,19 @@ 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'));
+        /** @var array<mixed> $_ac_players_2268 */
+        $_ac_players_2268 = $team->getAttribute('players');
+        $this->assertCount(2, $_ac_players_2268);
 
         // 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 +2413,31 @@ 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');
 
-        $playerIds = array_map(fn ($player) => $player->getId(), $teamAfter->getAttribute('players'));
+        /** @var array<Document> $_map_players_2291 */
+        $_map_players_2291 = $teamAfter->getAttribute('players');
+        $playerIds = \array_map(fn ($player) => $player->getId(), $_map_players_2291);
         $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');
+        $player1 = $database->getDocument($players, 'player1');
         $this->assertEquals('team1', $player1->getAttribute('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');
+        $player3 = $database->getDocument($players, 'player3');
         $this->assertEquals('team1', $player3->getAttribute('team')->getId());
 
-        $database->deleteCollection('teams');
-        $database->deleteCollection('players');
+        $database->deleteCollection($teams);
+        $database->deleteCollection($players);
     }
 
     public function testPartialUpdateOneToManyChildSide(): void
@@ -2539,30 +2445,27 @@ public function testPartialUpdateOneToManyChildSide(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        $database->createCollection('blogs');
-        $database->createCollection('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->createRelationship(
-            collection: 'blogs',
-            relatedCollection: 'posts',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-            id: 'posts',
-            twoWayKey: 'blog'
-        );
+        $blogs = 'blogs_' . uniqid();
+        $posts = 'posts_' . uniqid();
+
+        $database->createCollection($blogs);
+        $database->createCollection($posts);
+
+        $database->createAttribute($blogs, new Attribute(key: 'title', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($blogs, new Attribute(key: 'description', type: ColumnType::String, size: 1000, required: false));
+        $database->createAttribute($posts, new Attribute(key: 'title', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($posts, new Attribute(key: 'views', type: ColumnType::Integer, size: 0, required: false));
+
+        $database->createRelationship(new Relationship(collection: $blogs, relatedCollection: $posts, type: RelationType::OneToMany, twoWay: true, 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 +2476,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');
 
-        $database->deleteCollection('blogs');
-        $database->deleteCollection('posts');
+        $database->deleteCollection($blogs);
+        $database->deleteCollection($posts);
     }
 
     public function testPartialUpdateWithStringIdsVsDocuments(): void
@@ -2594,29 +2497,26 @@ public function testPartialUpdateWithStringIdsVsDocuments(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $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($libraries);
+        $database->createCollection($booksLib);
 
-        $database->createRelationship(
-            collection: 'libraries',
-            relatedCollection: 'books_lib',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-            id: 'books',
-            twoWayKey: 'library'
-        );
+        $database->createAttribute($libraries, new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($libraries, new Attribute(key: 'location', type: ColumnType::String, size: 255, required: false));
+        $database->createAttribute($booksLib, new Attribute(key: 'title', type: ColumnType::String, size: 255, required: true));
+
+        $database->createRelationship(new Relationship(collection: $libraries, relatedCollection: $booksLib, type: RelationType::OneToMany, twoWay: true, 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 +2527,55 @@ 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');
 
         // 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');
 
-        $bookIds = array_map(fn ($book) => $book->getId(), $lib->getAttribute('books'));
+        /** @var array<Document> $_map_books_2433 */
+        $_map_books_2433 = $lib->getAttribute('books');
+        $bookIds = \array_map(fn ($book) => $book->getId(), $_map_books_2433);
         $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 e67c41138..7d6274b21 100644
--- a/tests/e2e/Adapter/Scopes/Relationships/OneToOneTests.php
+++ b/tests/e2e/Adapter/Scopes/Relationships/OneToOneTests.php
@@ -3,6 +3,9 @@
 namespace Tests\E2E\Adapter\Scopes\Relationships;
 
 use Exception;
+use Utopia\Database\Adapter\Feature;
+use Utopia\Database\Attribute;
+use Utopia\Database\Capability;
 use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Exception\Authorization as AuthorizationException;
@@ -14,6 +17,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,35 +29,33 @@ public function testOneToOneOneWayRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $database->createCollection('person');
         $database->createCollection('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', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('library', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('library', new Attribute(key: 'area', type: ColumnType::String, size: 255, required: true));
 
-        $database->createRelationship(
-            collection: 'person',
-            relatedCollection: 'library',
-            type: Database::RELATION_ONE_TO_ONE
-        );
+        $database->createRelationship(new Relationship(collection: 'person', relatedCollection: 'library', type: RelationType::OneToOne));
 
         // Check metadata for collection
         $collection = $database->getCollection('person');
         $attributes = $collection->getAttribute('attributes', []);
 
+        /** @var array<mixed> $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(RelationType::OneToOne->value, $attribute['options']['relationType']);
                 $this->assertEquals(false, $attribute['options']['twoWay']);
                 $this->assertEquals('person', $attribute['options']['twoWayKey']);
             }
@@ -125,7 +130,9 @@ public function testOneToOneOneWayRelationship(): void
                 'area' => 'Area 10 Updated',
             ],
         ]));
-        $this->assertEquals('Library 10 Updated', $person10->getAttribute('library')->getAttribute('name'));
+        /** @var \Utopia\Database\Document $_doc_library_131 */
+        $_doc_library_131 = $person10->getAttribute('library');
+        $this->assertEquals('Library 10 Updated', $_doc_library_131->getAttribute('name'));
         $library10 = $database->getDocument('library', $library10->getId());
         $this->assertEquals('Library 10 Updated', $library10->getAttribute('name'));
 
@@ -169,7 +176,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 +186,30 @@ 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'));
+        /** @var \Utopia\Database\Document $_doc_library_192 */
+        $_doc_library_192 = $person->getAttribute('library');
+        $this->assertEquals('Library 1', $_doc_library_192->getAttribute('name'));
+        /** @var array<string, mixed> $_arr_library_193 */
+        $_arr_library_193 = $person->getAttribute('library');
+        $this->assertArrayNotHasKey('area', $_arr_library_193);
 
         $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'));
-
-
+        /** @var \Utopia\Database\Document $_doc_library_199 */
+        $_doc_library_199 = $person->getAttribute('library');
+        $this->assertEquals('Library 1', $_doc_library_199->getAttribute('name'));
+        /** @var array<string, mixed> $_arr_library_200 */
+        $_arr_library_200 = $person->getAttribute('library');
+        $this->assertArrayNotHasKey('area', $_arr_library_200);
 
         $document = $database->getDocument('person', $person->getId(), [
             Query::select(['name']),
@@ -238,9 +251,13 @@ public function testOneToOneOneWayRelationship(): void
             )
         );
 
-        $this->assertEquals('Library 1 Updated', $person1->getAttribute('library')->getAttribute('name'));
+        /** @var \Utopia\Database\Document $_doc_library_242 */
+        $_doc_library_242 = $person1->getAttribute('library');
+        $this->assertEquals('Library 1 Updated', $_doc_library_242->getAttribute('name'));
         $person1 = $database->getDocument('person', 'person1');
-        $this->assertEquals('Library 1 Updated', $person1->getAttribute('library')->getAttribute('name'));
+        /** @var \Utopia\Database\Document $_doc_library_244 */
+        $_doc_library_244 = $person1->getAttribute('library');
+        $this->assertEquals('Library 1 Updated', $_doc_library_244->getAttribute('name'));
 
         // Create new document with no relationship
         $person3 = $database->createDocument('person', new Document([
@@ -386,7 +403,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 +427,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,34 +464,31 @@ public function testOneToOneTwoWayRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $database->createCollection('country');
         $database->createCollection('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', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('city', new Attribute(key: 'code', type: ColumnType::String, size: 3, required: true));
+        $database->createAttribute('city', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
 
-        $database->createRelationship(
-            collection: 'country',
-            relatedCollection: 'city',
-            type: Database::RELATION_ONE_TO_ONE,
-            twoWay: true
-        );
+        $database->createRelationship(new Relationship(collection: 'country', relatedCollection: 'city', type: RelationType::OneToOne, twoWay: true));
 
         $collection = $database->getCollection('country');
         $attributes = $collection->getAttribute('attributes', []);
+        /** @var array<mixed> $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(RelationType::OneToOne->value, $attribute['options']['relationType']);
                 $this->assertEquals(true, $attribute['options']['twoWay']);
                 $this->assertEquals('country', $attribute['options']['twoWayKey']);
             }
@@ -482,13 +496,14 @@ public function testOneToOneTwoWayRelationship(): void
 
         $collection = $database->getCollection('city');
         $attributes = $collection->getAttribute('attributes', []);
+        /** @var array<mixed> $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(RelationType::OneToOne->value, $attribute['options']['relationType']);
                 $this->assertEquals(true, $attribute['options']['twoWay']);
                 $this->assertEquals('city', $attribute['options']['twoWayKey']);
             }
@@ -517,7 +532,9 @@ public function testOneToOneTwoWayRelationship(): void
 
         $database->createDocument('country', new Document($doc->getArrayCopy()));
         $country1 = $database->getDocument('country', 'country1');
-        $this->assertEquals('London', $country1->getAttribute('city')->getAttribute('name'));
+        /** @var \Utopia\Database\Document $_doc_city_517 */
+        $_doc_city_517 = $country1->getAttribute('city');
+        $this->assertEquals('London', $_doc_city_517->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'));
@@ -545,7 +562,9 @@ public function testOneToOneTwoWayRelationship(): void
 
         $database->createDocument('country', new Document($doc->getArrayCopy()));
         $country1 = $database->getDocument('country', 'country1');
-        $this->assertEquals('London', $country1->getAttribute('city')->getAttribute('name'));
+        /** @var \Utopia\Database\Document $_doc_city_545 */
+        $_doc_city_545 = $country1->getAttribute('city');
+        $this->assertEquals('London', $_doc_city_545->getAttribute('name'));
 
         // Create document with relationship with related ID
         $database->createDocument('city', new Document([
@@ -658,22 +677,30 @@ 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'));
+        /** @var \Utopia\Database\Document $_doc_city_665 */
+        $_doc_city_665 = $country->getAttribute('city');
+        $this->assertEquals('London', $_doc_city_665->getAttribute('name'));
+        /** @var array<string, mixed> $_arr_city_666 */
+        $_arr_city_666 = $country->getAttribute('city');
+        $this->assertArrayNotHasKey('code', $_arr_city_666);
 
         $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'));
+        /** @var \Utopia\Database\Document $_doc_city_672 */
+        $_doc_city_672 = $country->getAttribute('city');
+        $this->assertEquals('London', $_doc_city_672->getAttribute('name'));
+        /** @var array<string, mixed> $_arr_city_673 */
+        $_arr_city_673 = $country->getAttribute('city');
+        $this->assertArrayNotHasKey('code', $_arr_city_673);
 
         $country1 = $database->getDocument('country', 'country1');
 
@@ -713,9 +740,13 @@ public function testOneToOneTwoWayRelationship(): void
             )
         );
 
-        $this->assertEquals('City 1 Updated', $country1->getAttribute('city')->getAttribute('name'));
+        /** @var \Utopia\Database\Document $_doc_city_713 */
+        $_doc_city_713 = $country1->getAttribute('city');
+        $this->assertEquals('City 1 Updated', $_doc_city_713->getAttribute('name'));
         $country1 = $database->getDocument('country', 'country1');
-        $this->assertEquals('City 1 Updated', $country1->getAttribute('city')->getAttribute('name'));
+        /** @var \Utopia\Database\Document $_doc_city_715 */
+        $_doc_city_715 = $country1->getAttribute('city');
+        $this->assertEquals('City 1 Updated', $_doc_city_715->getAttribute('name'));
 
         // Update inverse nested document attribute
         $city2 = $database->updateDocument(
@@ -729,9 +760,13 @@ public function testOneToOneTwoWayRelationship(): void
             )
         );
 
-        $this->assertEquals('Country 2 Updated', $city2->getAttribute('country')->getAttribute('name'));
+        /** @var \Utopia\Database\Document $_doc_country_729 */
+        $_doc_country_729 = $city2->getAttribute('country');
+        $this->assertEquals('Country 2 Updated', $_doc_country_729->getAttribute('name'));
         $city2 = $database->getDocument('city', 'city2');
-        $this->assertEquals('Country 2 Updated', $city2->getAttribute('country')->getAttribute('name'));
+        /** @var \Utopia\Database\Document $_doc_country_731 */
+        $_doc_country_731 = $city2->getAttribute('country');
+        $this->assertEquals('Country 2 Updated', $_doc_country_731->getAttribute('name'));
 
         // Create new document with no relationship
         $country5 = $database->createDocument('country', new Document([
@@ -852,7 +887,7 @@ public function testOneToOneTwoWayRelationship(): void
                 Permission::update(Role::any()),
                 Permission::delete(Role::any()),
             ],
-            'name' => 'Denmark'
+            'name' => 'Denmark',
         ]));
 
         // Update inverse document with new related document
@@ -888,7 +923,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 +933,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 +945,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 +982,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 +1017,8 @@ public function testOneToOneTwoWayRelationship(): void
             'code' => 'MUC',
             'newCountry' => [
                 '$id' => 'country7',
-                'name' => 'Germany'
-            ]
+                'name' => 'Germany',
+            ],
         ]));
 
         // Delete relationship
@@ -1009,43 +1043,29 @@ public function testIdenticalTwoWayKeyRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $database->createCollection('parent');
         $database->createCollection('child');
 
-        $database->createRelationship(
-            collection: 'parent',
-            relatedCollection: 'child',
-            type: Database::RELATION_ONE_TO_ONE,
-            id: 'child1'
-        );
+        $database->createRelationship(new Relationship(collection: 'parent', relatedCollection: 'child', type: RelationType::OneToOne, key: 'child1'));
 
         try {
-            $database->createRelationship(
-                collection: 'parent',
-                relatedCollection: 'child',
-                type: Database::RELATION_ONE_TO_MANY,
-                id: 'children',
-            );
+            $database->createRelationship(new Relationship(collection: 'parent', relatedCollection: 'child', type: RelationType::OneToMany, 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(new Relationship(collection: 'parent', relatedCollection: 'child', type: RelationType::OneToMany, key: 'children', twoWayKey: 'parent_id'));
 
         $collection = $database->getCollection('parent');
         $attributes = $collection->getAttribute('attributes', []);
+        /** @var array<mixed> $attributes */
         foreach ($attributes as $attribute) {
             if ($attribute['key'] === 'child1') {
                 $this->assertEquals('parent', $attribute['options']['twoWayKey']);
@@ -1075,11 +1095,13 @@ public function testIdenticalTwoWayKeyRelationship(): void
         ]));
 
         $documents = $database->find('parent', []);
-        $document  = array_pop($documents);
+        $document = array_pop($documents);
         $this->assertArrayHasKey('child1', $document);
         $this->assertEquals('foo', $document->getAttribute('child1')->getId());
         $this->assertArrayHasKey('children', $document);
-        $this->assertEquals('bar', $document->getAttribute('children')[0]->getId());
+        /** @var array<Document> $_arr_children_1063 */
+        $_arr_children_1063 = $document->getAttribute('children');
+        $this->assertEquals('bar', $_arr_children_1063[0]->getId());
 
         try {
             $database->updateRelationship(
@@ -1109,8 +1131,9 @@ public function testNestedOneToOne_OneToOneRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -1118,26 +1141,12 @@ public function testNestedOneToOne_OneToOneRelationship(): void
         $database->createCollection('shirt');
         $database->createCollection('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->createRelationship(
-            collection: 'pattern',
-            relatedCollection: 'shirt',
-            type: Database::RELATION_ONE_TO_ONE,
-            twoWay: true,
-            id: 'shirt',
-            twoWayKey: 'pattern'
-        );
-        $database->createRelationship(
-            collection: 'shirt',
-            relatedCollection: 'team',
-            type: Database::RELATION_ONE_TO_ONE,
-            twoWay: true,
-            id: 'team',
-            twoWayKey: 'shirt'
-        );
+        $database->createAttribute('pattern', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('shirt', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('team', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+
+        $database->createRelationship(new Relationship(collection: 'pattern', relatedCollection: 'shirt', type: RelationType::OneToOne, twoWay: true, key: 'shirt', twoWayKey: 'pattern'));
+        $database->createRelationship(new Relationship(collection: 'shirt', relatedCollection: 'team', type: RelationType::OneToOne, twoWay: true, key: 'team', twoWayKey: 'shirt'));
 
         $database->createDocument('pattern', new Document([
             '$id' => 'stripes',
@@ -1201,8 +1210,9 @@ public function testNestedOneToOne_OneToManyRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -1210,25 +1220,12 @@ public function testNestedOneToOne_OneToManyRelationship(): void
         $database->createCollection('classrooms');
         $database->createCollection('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->createRelationship(
-            collection: 'teachers',
-            relatedCollection: 'classrooms',
-            type: Database::RELATION_ONE_TO_ONE,
-            twoWay: true,
-            id: 'classroom',
-            twoWayKey: 'teacher'
-        );
-        $database->createRelationship(
-            collection: 'classrooms',
-            relatedCollection: 'children',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-            twoWayKey: 'classroom'
-        );
+        $database->createAttribute('children', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('teachers', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('classrooms', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+
+        $database->createRelationship(new Relationship(collection: 'teachers', relatedCollection: 'classrooms', type: RelationType::OneToOne, twoWay: true, key: 'classroom', twoWayKey: 'teacher'));
+        $database->createRelationship(new Relationship(collection: 'classrooms', relatedCollection: 'children', type: RelationType::OneToMany, twoWay: true, twoWayKey: 'classroom'));
 
         $database->createDocument('teachers', new Document([
             '$id' => 'teacher1',
@@ -1302,8 +1299,9 @@ public function testNestedOneToOne_ManyToOneRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -1311,25 +1309,12 @@ public function testNestedOneToOne_ManyToOneRelationship(): void
         $database->createCollection('profiles');
         $database->createCollection('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->createRelationship(
-            collection: 'users',
-            relatedCollection: 'profiles',
-            type: Database::RELATION_ONE_TO_ONE,
-            twoWay: true,
-            id: 'profile',
-            twoWayKey: 'user'
-        );
-        $database->createRelationship(
-            collection: 'profiles',
-            relatedCollection: 'avatars',
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: true,
-            id: 'avatar',
-        );
+        $database->createAttribute('users', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('profiles', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('avatars', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+
+        $database->createRelationship(new Relationship(collection: 'users', relatedCollection: 'profiles', type: RelationType::OneToOne, twoWay: true, key: 'profile', twoWayKey: 'user'));
+        $database->createRelationship(new Relationship(collection: 'profiles', relatedCollection: 'avatars', type: RelationType::ManyToOne, twoWay: true, key: 'avatar'));
 
         $database->createDocument('users', new Document([
             '$id' => 'user1',
@@ -1379,7 +1364,7 @@ public function testNestedOneToOne_ManyToOneRelationship(): void
                         ],
                         'name' => 'User 2',
                     ],
-                ]
+                ],
             ],
         ]));
 
@@ -1395,8 +1380,9 @@ public function testNestedOneToOne_ManyToManyRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -1404,24 +1390,12 @@ public function testNestedOneToOne_ManyToManyRelationship(): void
         $database->createCollection('houses');
         $database->createCollection('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->createRelationship(
-            collection: 'addresses',
-            relatedCollection: 'houses',
-            type: Database::RELATION_ONE_TO_ONE,
-            twoWay: true,
-            id: 'house',
-            twoWayKey: 'address'
-        );
-        $database->createRelationship(
-            collection: 'houses',
-            relatedCollection: 'buildings',
-            type: Database::RELATION_MANY_TO_MANY,
-            twoWay: true,
-        );
+        $database->createAttribute('addresses', new Attribute(key: 'street', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('houses', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('buildings', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+
+        $database->createRelationship(new Relationship(collection: 'addresses', relatedCollection: 'houses', type: RelationType::OneToOne, twoWay: true, key: 'house', twoWayKey: 'address'));
+        $database->createRelationship(new Relationship(collection: 'houses', relatedCollection: 'buildings', type: RelationType::ManyToMany, twoWay: true));
 
         $database->createDocument('addresses', new Document([
             '$id' => 'address1',
@@ -1492,8 +1466,9 @@ public function testExceedMaxDepthOneToOne(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -1507,24 +1482,9 @@ public function testExceedMaxDepthOneToOne(): void
         $database->createCollection($level3Collection);
         $database->createCollection($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(new Relationship(collection: $level1Collection, relatedCollection: $level2Collection, type: RelationType::OneToOne, twoWay: true));
+        $database->createRelationship(new Relationship(collection: $level2Collection, relatedCollection: $level3Collection, type: RelationType::OneToOne, twoWay: true));
+        $database->createRelationship(new Relationship(collection: $level3Collection, relatedCollection: $level4Collection, type: RelationType::OneToOne, twoWay: true));
 
         // Exceed create depth
         $level1 = $database->createDocument($level1Collection, new Document([
@@ -1574,8 +1534,9 @@ public function testExceedMaxDepthOneToOneNull(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -1589,24 +1550,9 @@ public function testExceedMaxDepthOneToOneNull(): void
         $database->createCollection($level3Collection);
         $database->createCollection($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(new Relationship(collection: $level1Collection, relatedCollection: $level2Collection, type: RelationType::OneToOne, twoWay: true));
+        $database->createRelationship(new Relationship(collection: $level2Collection, relatedCollection: $level3Collection, type: RelationType::OneToOne, twoWay: true));
+        $database->createRelationship(new Relationship(collection: $level3Collection, relatedCollection: $level4Collection, type: RelationType::OneToOne, twoWay: true));
 
         $level1 = $database->createDocument($level1Collection, new Document([
             '$id' => 'level1',
@@ -1657,42 +1603,38 @@ public function testOneToOneRelationshipKeyWithSymbols(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $database->createCollection('$symbols_coll.ection1');
         $database->createCollection('$symbols_coll.ection2');
 
-        $database->createRelationship(
-            collection: '$symbols_coll.ection1',
-            relatedCollection: '$symbols_coll.ection2',
-            type: Database::RELATION_ONE_TO_ONE,
-            twoWay: true,
-        );
+        $database->createRelationship(new Relationship(collection: '$symbols_coll.ection1', relatedCollection: '$symbols_coll.ection2', type: RelationType::OneToOne, 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->getAttribute('symbols_collection1')->getId());
+        $this->assertEquals($doc1->getId(), $doc2->getAttribute('symbols_collection2')->getId());
     }
 
     public function testRecreateOneToOneOneWayRelationshipFromChild(): void
@@ -1700,65 +1642,42 @@ public function testRecreateOneToOneOneWayRelationshipFromChild(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $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($one, [
+            new Attribute(key: 'name', type: ColumnType::String, size: 100, required: false, default: null, signed: true, array: false, format: '', filters: []),
         ], [], [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(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' => [],
-            ]),
+        $database->createCollection($two, [
+            new Attribute(key: 'name', type: ColumnType::String, size: 100, required: false, default: null, signed: true, array: false, format: '', filters: []),
         ], [], [
             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(new Relationship(collection: $one, relatedCollection: $two, type: RelationType::OneToOne));
 
-        $database->deleteRelationship('two', 'one');
+        $database->deleteRelationship($two, $one);
 
-        $result = $database->createRelationship(
-            collection: 'one',
-            relatedCollection: 'two',
-            type: Database::RELATION_ONE_TO_ONE,
-        );
+        $result = $database->createRelationship(new Relationship(collection: $one, relatedCollection: $two, type: RelationType::OneToOne));
 
         $this->assertTrue($result);
 
-        $database->deleteCollection('one');
-        $database->deleteCollection('two');
+        $database->deleteCollection($one);
+        $database->deleteCollection($two);
     }
 
     public function testRecreateOneToOneTwoWayRelationshipFromParent(): void
@@ -1766,67 +1685,42 @@ public function testRecreateOneToOneTwoWayRelationshipFromParent(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $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($one, [
+            new Attribute(key: 'name', type: ColumnType::String, size: 100, required: false, default: null, signed: true, array: false, format: '', filters: []),
         ], [], [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(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' => [],
-            ]),
+        $database->createCollection($two, [
+            new Attribute(key: 'name', type: ColumnType::String, size: 100, required: false, default: null, signed: true, array: false, format: '', filters: []),
         ], [], [
             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(new Relationship(collection: $one, relatedCollection: $two, type: RelationType::OneToOne, 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(new Relationship(collection: $one, relatedCollection: $two, type: RelationType::OneToOne, twoWay: true));
 
         $this->assertTrue($result);
 
-        $database->deleteCollection('one');
-        $database->deleteCollection('two');
+        $database->deleteCollection($one);
+        $database->deleteCollection($two);
     }
 
     public function testRecreateOneToOneTwoWayRelationshipFromChild(): void
@@ -1834,67 +1728,42 @@ public function testRecreateOneToOneTwoWayRelationshipFromChild(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $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($one, [
+            new Attribute(key: 'name', type: ColumnType::String, size: 100, required: false, default: null, signed: true, array: false, format: '', filters: []),
         ], [], [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(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' => [],
-            ]),
+        $database->createCollection($two, [
+            new Attribute(key: 'name', type: ColumnType::String, size: 100, required: false, default: null, signed: true, array: false, format: '', filters: []),
         ], [], [
             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(new Relationship(collection: $one, relatedCollection: $two, type: RelationType::OneToOne, 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(new Relationship(collection: $one, relatedCollection: $two, type: RelationType::OneToOne, twoWay: true));
 
         $this->assertTrue($result);
 
-        $database->deleteCollection('one');
-        $database->deleteCollection('two');
+        $database->deleteCollection($one);
+        $database->deleteCollection($two);
     }
 
     public function testRecreateOneToOneOneWayRelationshipFromParent(): void
@@ -1902,65 +1771,42 @@ public function testRecreateOneToOneOneWayRelationshipFromParent(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $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($one, [
+            new Attribute(key: 'name', type: ColumnType::String, size: 100, required: false, default: null, signed: true, array: false, format: '', filters: []),
         ], [], [
             Permission::read(Role::any()),
             Permission::create(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(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' => [],
-            ]),
+        $database->createCollection($two, [
+            new Attribute(key: 'name', type: ColumnType::String, size: 100, required: false, default: null, signed: true, array: false, format: '', filters: []),
         ], [], [
             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(new Relationship(collection: $one, relatedCollection: $two, type: RelationType::OneToOne));
 
-        $database->deleteRelationship('one', 'two');
+        $database->deleteRelationship($one, $two);
 
-        $result = $database->createRelationship(
-            collection: 'one',
-            relatedCollection: 'two',
-            type: Database::RELATION_ONE_TO_ONE,
-        );
+        $result = $database->createRelationship(new Relationship(collection: $one, relatedCollection: $two, type: RelationType::OneToOne));
 
         $this->assertTrue($result);
 
-        $database->deleteCollection('one');
-        $database->deleteCollection('two');
+        $database->deleteCollection($one);
+        $database->deleteCollection($two);
     }
 
     public function testDeleteBulkDocumentsOneToOneRelationship(): void
@@ -1968,25 +1814,21 @@ public function testDeleteBulkDocumentsOneToOneRelationship(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships() || !$database->getAdapter()->getSupportForBatchOperations()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships) || ! $database->getAdapter()->supports(Capability::BatchOperations)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $this->getDatabase()->createCollection('bulk_delete_person_o2o');
         $this->getDatabase()->createCollection('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', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $this->getDatabase()->createAttribute('bulk_delete_library_o2o', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $this->getDatabase()->createAttribute('bulk_delete_library_o2o', new Attribute(key: 'area', type: ColumnType::String, size: 255, 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(new Relationship(collection: 'bulk_delete_person_o2o', relatedCollection: 'bulk_delete_library_o2o', type: RelationType::OneToOne, onDelete: ForeignKeyAction::Restrict));
 
         $person1 = $this->getDatabase()->createDocument('bulk_delete_person_o2o', new Document([
             '$id' => 'person1',
@@ -2041,7 +1883,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([
@@ -2089,7 +1931,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([
@@ -2167,114 +2009,147 @@ public function testDeleteTwoWayRelationshipFromChild(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $database->createCollection('drivers');
         $database->createCollection('licenses');
 
-        $database->createRelationship(
-            collection: 'drivers',
-            relatedCollection: 'licenses',
-            type: Database::RELATION_ONE_TO_ONE,
-            twoWay: true,
-            id: 'license',
-            twoWayKey: 'driver'
-        );
+        $database->createRelationship(new Relationship(collection: 'drivers', relatedCollection: 'licenses', type: RelationType::OneToOne, twoWay: true, 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')));
+        /** @var array<mixed> $_cnt_attributes_1969 */
+        $_cnt_attributes_1969 = $drivers->getAttribute('attributes');
+        $this->assertEquals(1, \count($_cnt_attributes_1969));
+        /** @var array<mixed> $_cnt_indexes_1970 */
+        $_cnt_indexes_1970 = $drivers->getAttribute('indexes');
+        $this->assertEquals(1, \count($_cnt_indexes_1970));
+        /** @var array<mixed> $_cnt_attributes_1971 */
+        $_cnt_attributes_1971 = $licenses->getAttribute('attributes');
+        $this->assertEquals(1, \count($_cnt_attributes_1971));
+        /** @var array<mixed> $_cnt_indexes_1972 */
+        $_cnt_indexes_1972 = $licenses->getAttribute('indexes');
+        $this->assertEquals(1, \count($_cnt_indexes_1972));
 
         $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')));
-
-        $database->createRelationship(
-            collection: 'drivers',
-            relatedCollection: 'licenses',
-            type: Database::RELATION_ONE_TO_MANY,
-            twoWay: true,
-            id: 'licenses',
-            twoWayKey: 'driver'
-        );
+        /** @var array<mixed> $_cnt_attributes_1979 */
+        $_cnt_attributes_1979 = $drivers->getAttribute('attributes');
+        $this->assertEquals(0, \count($_cnt_attributes_1979));
+        /** @var array<mixed> $_cnt_indexes_1980 */
+        $_cnt_indexes_1980 = $drivers->getAttribute('indexes');
+        $this->assertEquals(0, \count($_cnt_indexes_1980));
+        /** @var array<mixed> $_cnt_attributes_1981 */
+        $_cnt_attributes_1981 = $licenses->getAttribute('attributes');
+        $this->assertEquals(0, \count($_cnt_attributes_1981));
+        /** @var array<mixed> $_cnt_indexes_1982 */
+        $_cnt_indexes_1982 = $licenses->getAttribute('indexes');
+        $this->assertEquals(0, \count($_cnt_indexes_1982));
+
+        $database->createRelationship(new Relationship(collection: 'drivers', relatedCollection: 'licenses', type: RelationType::OneToMany, twoWay: true, 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')));
+        /** @var array<mixed> $_cnt_attributes_1989 */
+        $_cnt_attributes_1989 = $drivers->getAttribute('attributes');
+        $this->assertEquals(1, \count($_cnt_attributes_1989));
+        /** @var array<mixed> $_cnt_indexes_1990 */
+        $_cnt_indexes_1990 = $drivers->getAttribute('indexes');
+        $this->assertEquals(0, \count($_cnt_indexes_1990));
+        /** @var array<mixed> $_cnt_attributes_1991 */
+        $_cnt_attributes_1991 = $licenses->getAttribute('attributes');
+        $this->assertEquals(1, \count($_cnt_attributes_1991));
+        /** @var array<mixed> $_cnt_indexes_1992 */
+        $_cnt_indexes_1992 = $licenses->getAttribute('indexes');
+        $this->assertEquals(1, \count($_cnt_indexes_1992));
 
         $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')));
-
-        $database->createRelationship(
-            collection: 'licenses',
-            relatedCollection: 'drivers',
-            type: Database::RELATION_MANY_TO_ONE,
-            twoWay: true,
-            id: 'driver',
-            twoWayKey: 'licenses'
-        );
+        /** @var array<mixed> $_cnt_attributes_1999 */
+        $_cnt_attributes_1999 = $drivers->getAttribute('attributes');
+        $this->assertEquals(0, \count($_cnt_attributes_1999));
+        /** @var array<mixed> $_cnt_indexes_2000 */
+        $_cnt_indexes_2000 = $drivers->getAttribute('indexes');
+        $this->assertEquals(0, \count($_cnt_indexes_2000));
+        /** @var array<mixed> $_cnt_attributes_2001 */
+        $_cnt_attributes_2001 = $licenses->getAttribute('attributes');
+        $this->assertEquals(0, \count($_cnt_attributes_2001));
+        /** @var array<mixed> $_cnt_indexes_2002 */
+        $_cnt_indexes_2002 = $licenses->getAttribute('indexes');
+        $this->assertEquals(0, \count($_cnt_indexes_2002));
+
+        $database->createRelationship(new Relationship(collection: 'licenses', relatedCollection: 'drivers', type: RelationType::ManyToOne, twoWay: true, 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')));
+        /** @var array<mixed> $_cnt_attributes_2009 */
+        $_cnt_attributes_2009 = $drivers->getAttribute('attributes');
+        $this->assertEquals(1, \count($_cnt_attributes_2009));
+        /** @var array<mixed> $_cnt_indexes_2010 */
+        $_cnt_indexes_2010 = $drivers->getAttribute('indexes');
+        $this->assertEquals(0, \count($_cnt_indexes_2010));
+        /** @var array<mixed> $_cnt_attributes_2011 */
+        $_cnt_attributes_2011 = $licenses->getAttribute('attributes');
+        $this->assertEquals(1, \count($_cnt_attributes_2011));
+        /** @var array<mixed> $_cnt_indexes_2012 */
+        $_cnt_indexes_2012 = $licenses->getAttribute('indexes');
+        $this->assertEquals(1, \count($_cnt_indexes_2012));
 
         $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')));
-
-        $database->createRelationship(
-            collection: 'licenses',
-            relatedCollection: 'drivers',
-            type: Database::RELATION_MANY_TO_MANY,
-            twoWay: true,
-            id: 'drivers',
-            twoWayKey: 'licenses'
-        );
+        /** @var array<mixed> $_cnt_attributes_2019 */
+        $_cnt_attributes_2019 = $drivers->getAttribute('attributes');
+        $this->assertEquals(0, \count($_cnt_attributes_2019));
+        /** @var array<mixed> $_cnt_indexes_2020 */
+        $_cnt_indexes_2020 = $drivers->getAttribute('indexes');
+        $this->assertEquals(0, \count($_cnt_indexes_2020));
+        /** @var array<mixed> $_cnt_attributes_2021 */
+        $_cnt_attributes_2021 = $licenses->getAttribute('attributes');
+        $this->assertEquals(0, \count($_cnt_attributes_2021));
+        /** @var array<mixed> $_cnt_indexes_2022 */
+        $_cnt_indexes_2022 = $licenses->getAttribute('indexes');
+        $this->assertEquals(0, \count($_cnt_indexes_2022));
+
+        $database->createRelationship(new Relationship(collection: 'licenses', relatedCollection: 'drivers', type: RelationType::ManyToMany, twoWay: true, key: 'drivers', twoWayKey: 'licenses'));
 
         $drivers = $database->getCollection('drivers');
         $licenses = $database->getCollection('licenses');
-        $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')));
+        $junction = $database->getCollection('_'.$licenses->getSequence().'_'.$drivers->getSequence());
+
+        /** @var array<mixed> $_cnt_attributes_2030 */
+        $_cnt_attributes_2030 = $drivers->getAttribute('attributes');
+        $this->assertEquals(1, \count($_cnt_attributes_2030));
+        /** @var array<mixed> $_cnt_indexes_2031 */
+        $_cnt_indexes_2031 = $drivers->getAttribute('indexes');
+        $this->assertEquals(0, \count($_cnt_indexes_2031));
+        /** @var array<mixed> $_cnt_attributes_2032 */
+        $_cnt_attributes_2032 = $licenses->getAttribute('attributes');
+        $this->assertEquals(1, \count($_cnt_attributes_2032));
+        /** @var array<mixed> $_cnt_indexes_2033 */
+        $_cnt_indexes_2033 = $licenses->getAttribute('indexes');
+        $this->assertEquals(0, \count($_cnt_indexes_2033));
+        /** @var array<mixed> $_cnt_attributes_2034 */
+        $_cnt_attributes_2034 = $junction->getAttribute('attributes');
+        $this->assertEquals(2, \count($_cnt_attributes_2034));
+        /** @var array<mixed> $_cnt_indexes_2035 */
+        $_cnt_indexes_2035 = $junction->getAttribute('indexes');
+        $this->assertEquals(2, \count($_cnt_indexes_2035));
 
         $database->deleteRelationship('drivers', 'licenses');
 
@@ -2282,23 +2157,33 @@ 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')));
+        /** @var array<mixed> $_cnt_attributes_2043 */
+        $_cnt_attributes_2043 = $drivers->getAttribute('attributes');
+        $this->assertEquals(0, \count($_cnt_attributes_2043));
+        /** @var array<mixed> $_cnt_indexes_2044 */
+        $_cnt_indexes_2044 = $drivers->getAttribute('indexes');
+        $this->assertEquals(0, \count($_cnt_indexes_2044));
+        /** @var array<mixed> $_cnt_attributes_2045 */
+        $_cnt_attributes_2045 = $licenses->getAttribute('attributes');
+        $this->assertEquals(0, \count($_cnt_attributes_2045));
+        /** @var array<mixed> $_cnt_indexes_2046 */
+        $_cnt_indexes_2046 = $licenses->getAttribute('indexes');
+        $this->assertEquals(0, \count($_cnt_indexes_2046));
 
         $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() instanceof Feature\Relationships) ||
+            ! $database->getAdapter()->supports(Capability::BatchOperations)
         ) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -2308,16 +2193,11 @@ public function testUpdateParentAndChild_OneToOne(): void
         $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->createAttribute($parentCollection, new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($childCollection, new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($childCollection, new Attribute(key: 'parentNumber', type: ColumnType::Integer, size: 0, required: false));
 
-        $database->createRelationship(
-            collection: $parentCollection,
-            relatedCollection: $childCollection,
-            type: Database::RELATION_ONE_TO_ONE,
-            id: 'parentNumber'
-        );
+        $database->createRelationship(new Relationship(collection: $parentCollection, relatedCollection: $childCollection, type: RelationType::OneToOne, key: 'parentNumber'));
 
         $database->createDocument($parentCollection, new Document([
             '$id' => 'parent1',
@@ -2377,8 +2257,9 @@ public function testDeleteDocumentsRelationshipErrorDoesNotDeleteParent_OneToOne
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships() || !$database->getAdapter()->getSupportForBatchOperations()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships) || ! $database->getAdapter()->supports(Capability::BatchOperations)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -2387,15 +2268,10 @@ public function testDeleteDocumentsRelationshipErrorDoesNotDeleteParent_OneToOne
 
         $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->createRelationship(
-            collection: $parentCollection,
-            relatedCollection: $childCollection,
-            type: Database::RELATION_ONE_TO_ONE,
-            onDelete: Database::RELATION_MUTATE_RESTRICT
-        );
+        $database->createAttribute($parentCollection, new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute($childCollection, new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+
+        $database->createRelationship(new Relationship(collection: $parentCollection, relatedCollection: $childCollection, type: RelationType::OneToOne, onDelete: ForeignKeyAction::Restrict));
 
         $parent = $database->createDocument($parentCollection, new Document([
             '$id' => 'parent1',
@@ -2413,7 +2289,7 @@ public function testDeleteDocumentsRelationshipErrorDoesNotDeleteParent_OneToOne
                     Permission::delete(Role::any()),
                 ],
                 'name' => 'Child 1',
-            ]
+            ],
         ]));
 
         try {
@@ -2435,8 +2311,9 @@ public function testPartialUpdateOneToOneWithRelationships(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -2444,18 +2321,11 @@ public function testPartialUpdateOneToOneWithRelationships(): void
         $database->createCollection('cities_partial');
         $database->createCollection('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->createRelationship(
-            collection: 'cities_partial',
-            relatedCollection: 'mayors_partial',
-            type: Database::RELATION_ONE_TO_ONE,
-            twoWay: true,
-            id: 'mayor',
-            twoWayKey: 'city'
-        );
+        $database->createAttribute('cities_partial', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('cities_partial', new Attribute(key: 'population', type: ColumnType::Integer, size: 0, required: false));
+        $database->createAttribute('mayors_partial', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+
+        $database->createRelationship(new Relationship(collection: 'cities_partial', relatedCollection: 'mayors_partial', type: RelationType::OneToOne, twoWay: true, key: 'mayor', twoWayKey: 'city'));
 
         // Create a city with a mayor
         $database->createDocument('cities_partial', new Document([
@@ -2522,8 +2392,9 @@ public function testPartialUpdateOneToOneWithoutRelationshipField(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -2531,17 +2402,10 @@ public function testPartialUpdateOneToOneWithoutRelationshipField(): void
         $database->createCollection('cities_strict');
         $database->createCollection('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', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('mayors_strict', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
 
-        $database->createRelationship(
-            collection: 'cities_strict',
-            relatedCollection: 'mayors_strict',
-            type: Database::RELATION_ONE_TO_ONE,
-            twoWay: true,
-            id: 'mayor',
-            twoWayKey: 'city'
-        );
+        $database->createRelationship(new Relationship(collection: 'cities_strict', relatedCollection: 'mayors_strict', type: RelationType::OneToOne, twoWay: true, key: 'mayor', twoWayKey: 'city'));
 
         // Create city with mayor
         $database->createDocument('cities_strict', new Document([
@@ -2597,80 +2461,4 @@ public function testPartialUpdateOneToOneWithoutRelationshipField(): void
         $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 9f8d150bf..f2429d944 100644
--- a/tests/e2e/Adapter/Scopes/SchemalessTests.php
+++ b/tests/e2e/Adapter/Scopes/SchemalessTests.php
@@ -3,18 +3,21 @@
 namespace Tests\E2E\Adapter\Scopes;
 
 use Exception;
-use Throwable;
+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\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\Helpers\ID;
 use Utopia\Database\Helpers\Permission;
 use Utopia\Database\Helpers\Role;
+use Utopia\Database\Index;
 use Utopia\Database\Query;
+use Utopia\Query\OrderDirection;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\IndexType;
 
 trait SchemalessTests
 {
@@ -23,15 +26,16 @@ 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->createAttribute($colName, new Attribute(key: 'key', type: ColumnType::String, size: 50, required: true));
+        $database->createAttribute($colName, new Attribute(key: 'value', type: ColumnType::String, size: 50, required: false, default: 'value'));
 
         $permissions = [Permission::read(Role::any()), Permission::write(Role::any()), Permission::update(Role::any()), Permission::delete(Role::any())];
 
@@ -115,52 +119,15 @@ 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;
         }
 
@@ -180,7 +147,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 +157,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,19 +173,20 @@ 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");
+        $colName = uniqid('schemaless_increment');
         $database->createCollection($colName);
 
         $permissions = [
             Permission::read(Role::any()),
             Permission::write(Role::any()),
             Permission::update(Role::any()),
-            Permission::delete(Role::any())
+            Permission::delete(Role::any()),
         ];
 
         $docs = [
@@ -260,19 +228,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");
+        $colName = uniqid('schemaless_decrement');
         $database->createCollection($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 +283,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");
+        $colName = uniqid('schemaless_update');
         $database->createCollection($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 +310,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 +326,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 +342,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");
+        $colName = uniqid('schemaless_delete');
         $database->createCollection($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 +386,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");
+        $colName = uniqid('schemaless_bulk_update');
         $database->createCollection($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 +416,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 +424,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 +452,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 +462,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 +483,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");
+        $colName = uniqid('schemaless_bulk_delete');
         $database->createCollection($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 +514,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 +541,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 +567,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");
+        $colName = uniqid('schemaless_callbacks');
         $database->createCollection($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 +596,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));
@@ -652,7 +629,7 @@ public function testSchemalessOperationsWithCallback(): void
                 $deleteResults[] = [
                     'id' => $doc->getId(),
                     'value' => $doc->getAttribute('value'),
-                    'customData' => $doc->getAttribute('customData')
+                    'customData' => $doc->getAttribute('customData'),
                 ];
             }
         );
@@ -680,8 +657,9 @@ public function testSchemalessIndexCreateListDelete(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if ($database->getAdapter()->getSupportForAttributes()) {
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -702,8 +680,8 @@ 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, new Index(key: 'idx_title_unique', type: IndexType::Unique, attributes: ['title'], lengths: [128], orders: [OrderDirection::Asc->value])));
+        $this->assertTrue($database->createIndex($col, new Index(key: 'idx_rank_key', type: IndexType::Key, attributes: ['rank'], lengths: [0], orders: [OrderDirection::Asc->value])));
 
         $collection = $database->getCollection($col);
         $indexes = $collection->getAttribute('indexes');
@@ -721,36 +699,6 @@ public function testSchemalessIndexCreateListDelete(): void
         $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
     {
@@ -758,8 +706,9 @@ public function testSchemalessObjectIndexes(): void
         $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;
         }
 
@@ -767,31 +716,17 @@ public function testSchemalessObjectIndexes(): void
         $database->createCollection($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, new Attribute(key: 'meta', type: ColumnType::Object, size: 0, required: false));
+        $database->createAttribute($col, new Attribute(key: 'meta2', type: ColumnType::Object, size: 0, required: false));
 
         // 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, new Index(key: 'idx_meta_key', type: IndexType::Key, attributes: ['meta'], lengths: [0], orders: [OrderDirection::Asc->value]))
         );
 
         // 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, new Index(key: 'idx_meta_unique', type: IndexType::Unique, attributes: ['meta2'], lengths: [0], orders: [OrderDirection::Asc->value]))
         );
 
         // Verify index metadata is stored on the collection
@@ -813,8 +748,9 @@ public function testSchemalessPermissions(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if ($database->getAdapter()->getSupportForAttributes()) {
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -825,9 +761,9 @@ public function testSchemalessPermissions(): void
         $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 +794,7 @@ public function testSchemalessPermissions(): void
                 '$permissions' => [
                     Permission::read(Role::any()),
                     Permission::update(Role::any()),
-                ]
+                ],
             ]));
         });
 
@@ -869,7 +805,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,123 +816,15 @@ 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;
         }
 
@@ -1007,13 +835,13 @@ public function testSchemalessDates(): void
             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) {
@@ -1063,11 +891,11 @@ public function testSchemalessDates(): void
         // 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, [
@@ -1118,7 +946,7 @@ public function testSchemalessDates(): void
         $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) {
             return $database->updateDocument($col, 'd1', new Document([
@@ -1143,7 +971,7 @@ public function testSchemalessDates(): void
         $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(
@@ -1176,7 +1004,7 @@ 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';
+        $curDate4 = '2003-03-05T05:05:05.000+00:00';
         $up1 = $database->withPreserveDates(function () use ($database, $col, $permissions, $createdAt4, $updatedAt4, $curDate4) {
             return $database->upsertDocument($col, new Document([
                 '$id' => 'd4',
@@ -1201,7 +1029,7 @@ 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';
+        $curDate4b = '2003-03-07T07:07:07.000+00:00';
         $up2 = $database->withPreserveDates(function () use ($database, $col, $updatedAt4b, $curDate4b) {
             return $database->upsertDocument($col, new Document([
                 '$id' => 'd4',
@@ -1228,9 +1056,9 @@ public function testSchemalessDates(): void
         // 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, [
@@ -1307,8 +1135,9 @@ public function testSchemalessExists(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if ($database->getAdapter()->getSupportForAttributes()) {
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -1319,7 +1148,7 @@ public function testSchemalessExists(): void
             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,8 +1253,9 @@ public function testSchemalessNotExists(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if ($database->getAdapter()->getSupportForAttributes()) {
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -1436,7 +1266,7 @@ public function testSchemalessNotExists(): void
             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,8 +1364,9 @@ 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();
@@ -1548,7 +1379,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 +1388,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 +1396,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 +1404,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 +1414,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 +1423,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 +1435,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 +1448,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 +1458,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 +1468,7 @@ public function testElemMatch(): void
             Query::elemMatch('items', [
                 Query::equal('sku', ['ABC']),
                 Query::greaterThanEqual('qty', 1),
-            ])
+            ]),
         ]);
         $this->assertCount(2, $results);
 
@@ -1645,7 +1476,7 @@ public function testElemMatch(): void
         $results = $database->find($collectionId, [
             Query::elemMatch('items', [
                 Query::equal('sku', ['NONEXISTENT']),
-            ])
+            ]),
         ]);
         $this->assertCount(0, $results);
 
@@ -1654,7 +1485,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 +1497,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,8 +1518,9 @@ 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();
@@ -1701,7 +1533,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 +1542,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 +1552,7 @@ public function testElemMatchComplex(): void
                 Query::greaterThan('stock', 50),
                 Query::equal('category', ['A']),
                 Query::equal('active', [true]),
-            ])
+            ]),
         ]);
         $this->assertCount(2, $results);
 
@@ -1729,7 +1561,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 +1574,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 +1595,7 @@ public function testElemMatchComplex(): void
                     ]),
                 ]),
                 Query::equal('active', [true]),
-            ])
+            ]),
         ]);
         // Only store2 matches:
         // - Widget with stock 200 (>150) and active true
@@ -1782,8 +1614,9 @@ public function testSchemalessNestedObjectAttributeQueries(): void
 
         /** @var Database $database */
         $database = static::getDatabase();
-        if ($database->getAdapter()->getSupportForAttributes()) {
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -1794,7 +1627,7 @@ public function testSchemalessNestedObjectAttributeQueries(): void
             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,7 +1793,7 @@ 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.');
         }
 
@@ -1990,8 +1823,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 +1884,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 +1899,7 @@ public function testUpsertFieldRemoval(): void
             'name' => 'Updated Product',
             'specs' => [
                 'cpu' => 'AMD',
-                'ram' => '16GB'
+                'ram' => '16GB',
             ],
             // details is removed
         ]));
@@ -2084,7 +1917,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,8 +2078,9 @@ public function testSchemalessTTLIndexes(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if ($database->getAdapter()->getSupportForAttributes()) {
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -2257,19 +2091,11 @@ public function testSchemalessTTLIndexes(): void
             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, new Index(key: 'idx_ttl_valid', type: IndexType::Ttl, attributes: ['expiresAt'], lengths: [], orders: [OrderDirection::Asc->value], ttl: 3600))
         );
 
         $collection = $database->getCollection($col);
@@ -2277,7 +2103,7 @@ public function testSchemalessTTLIndexes(): void
         $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 +2115,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,22 +2140,14 @@ 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, new Index(key: 'idx_ttl_min', type: IndexType::Ttl, attributes: ['expiresAt'], lengths: [], orders: [OrderDirection::Asc->value], ttl: 1))
         );
 
         $col2 = uniqid('sl_ttl_collection');
 
         $expiresAtAttr = new Document([
             '$id' => ID::custom('expiresAt'),
-            'type' => Database::VAR_DATETIME,
+            'type' => ColumnType::Datetime->value,
             'size' => 0,
             'signed' => false,
             'required' => false,
@@ -2340,11 +2158,11 @@ public function testSchemalessTTLIndexes(): void
 
         $ttlIndexDoc = new Document([
             '$id' => ID::custom('idx_ttl_collection'),
-            'type' => Database::INDEX_TTL,
+            'type' => IndexType::Ttl->value,
             'attributes' => ['expiresAt'],
             'lengths' => [],
-            'orders' => [Database::ORDER_ASC],
-            'ttl' => 7200 // 2 hours
+            'orders' => [OrderDirection::Asc->value],
+            'ttl' => 7200, // 2 hours
         ]);
 
         $database->createCollection($col2, [$expiresAtAttr], [$ttlIndexDoc]);
@@ -2360,158 +2178,15 @@ 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;
         }
 
@@ -2522,7 +2197,7 @@ public function testSchemalessDatetimeCreationAndFetching(): void
             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 +2210,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
@@ -2601,7 +2276,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));
@@ -2623,13 +2298,15 @@ 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;
         }
 
@@ -2640,20 +2317,12 @@ public function testSchemalessTTLExpiry(): void
             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, new Index(key: 'idx_ttl_expiresAt', type: IndexType::Ttl, attributes: ['expiresAt'], lengths: [], orders: [OrderDirection::Asc->value], ttl: 10))
         );
 
         $now = new \DateTime();
@@ -2666,7 +2335,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 +2343,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
@@ -2718,7 +2387,7 @@ public function testSchemalessTTLExpiry(): void
             $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,13 +2434,15 @@ 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;
         }
 
@@ -2782,20 +2453,12 @@ public function testSchemalessTTLWithCacheExpiry(): void
             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, new Index(key: 'idx_ttl_expiresAt', type: IndexType::Ttl, attributes: ['expiresAt'], lengths: [], orders: [OrderDirection::Asc->value], ttl: 10))
         );
 
         $now = new \DateTime();
@@ -2858,8 +2521,9 @@ public function testStringAndDatetime(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if ($database->getAdapter()->getSupportForAttributes()) {
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -2870,7 +2534,7 @@ public function testStringAndDatetime(): void
             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 +2544,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
             ]),
         ];
 
@@ -2988,13 +2652,15 @@ 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;
         }
 
@@ -3005,20 +2671,12 @@ public function testStringAndDateWithTTL(): void
             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, new Index(key: 'idx_ttl_expiresAt', type: IndexType::Ttl, attributes: ['expiresAt'], lengths: [], orders: [OrderDirection::Asc->value], ttl: 10))
         );
 
         $now = new \DateTime();
@@ -3032,35 +2690,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',
             ]),
         ];
 
@@ -3113,7 +2771,7 @@ public function testStringAndDateWithTTL(): void
             $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,8 +2816,9 @@ 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;
         }
 
@@ -3167,7 +2826,7 @@ public function testSchemalessMongoDotNotationIndexes(): void
         $database->createCollection($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, new Attribute(key: 'profile', type: ColumnType::Object, size: 0, required: false));
 
         // Seed documents
         $database->createDocuments($col, [
@@ -3177,9 +2836,9 @@ public function testSchemalessMongoDotNotationIndexes(): void
                 'profile' => [
                     'user' => [
                         'email' => 'alice@example.com',
-                        'id' => 'alice'
-                    ]
-                ]
+                        'id' => 'alice',
+                    ],
+                ],
             ]),
             new Document([
                 '$id' => 'u2',
@@ -3187,34 +2846,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, new Index(key: 'idx_profile_user_email_key', type: IndexType::Key, attributes: ['profile.user.email'], lengths: [0], orders: [OrderDirection::Asc->value]))
         );
 
         // 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, new Index(key: 'idx_profile_user_id_unique', type: IndexType::Unique, attributes: ['profile.user.id'], lengths: [0], orders: [OrderDirection::Asc->value]))
         );
 
         try {
@@ -3224,9 +2869,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 +2880,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,8 +2893,9 @@ public function testQueryWithDatetime(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if ($database->getAdapter()->getSupportForAttributes()) {
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -3260,7 +2906,7 @@ public function testQueryWithDatetime(): void
             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 +2916,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 +2930,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 +2951,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 +2959,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 +2969,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 +2978,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 +2989,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 +3000,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 +3010,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,8 +3022,9 @@ public function testSchemalessCreatedAndUpdatedAtQuery(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if ($database->getAdapter()->getSupportForAttributes()) {
+        if ($database->getAdapter()->supports(Capability::DefinedAttributes)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -3400,7 +3047,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 +3060,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 +3073,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 +3086,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 +3099,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 +3124,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 5ee56e68d..26accaec0 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\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\Database\RelationType;
+use Utopia\Query\OrderDirection;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\IndexType;
 
 trait SpatialTests
 {
@@ -19,15 +27,16 @@ 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() instanceof Feature\Spatial)) {
             $this->expectNotToPerformAssertions();
+
             return;
-        };
+        }
         $attributes = [
             new Document([
                 '$id' => ID::custom('attribute1'),
-                'type' => Database::VAR_STRING,
+                'type' => ColumnType::String->value,
                 'size' => 256,
                 'required' => false,
                 'signed' => true,
@@ -36,33 +45,33 @@ public function testSpatialCollection(): void
             ]),
             new Document([
                 '$id' => ID::custom('attribute2'),
-                'type' => Database::VAR_POINT,
+                'type' => ColumnType::Point->value,
                 'size' => 0,
                 'required' => true,
                 'signed' => true,
                 'array' => false,
                 'filters' => [],
-            ])
+            ]),
         ];
 
         $indexes = [
             new Document([
                 '$id' => ID::custom('index1'),
-                'type' => Database::INDEX_KEY,
+                'type' => IndexType::Key->value,
                 'attributes' => ['attribute1'],
                 'lengths' => [256],
                 'orders' => [],
             ]),
             new Document([
                 '$id' => ID::custom('index2'),
-                'type' => Database::INDEX_SPATIAL,
+                'type' => IndexType::Spatial->value,
                 'attributes' => ['attribute2'],
                 'lengths' => [],
                 'orders' => [],
             ]),
         ];
 
-        $col =  $database->createCollection($collectionName, $attributes, $indexes);
+        $col = $database->createCollection($collectionName, $attributes, $indexes);
 
         $this->assertIsArray($col->getAttribute('attributes'));
         $this->assertCount(2, $col->getAttribute('attributes'));
@@ -77,8 +86,8 @@ public function testSpatialCollection(): void
         $this->assertIsArray($col->getAttribute('indexes'));
         $this->assertCount(2, $col->getAttribute('indexes'));
 
-        $database->createAttribute($collectionName, 'attribute3', Database::VAR_POINT, 0, true);
-        $database->createIndex($collectionName, ID::custom("index3"), Database::INDEX_SPATIAL, ['attribute3']);
+        $database->createAttribute($collectionName, new Attribute(key: 'attribute3', type: ColumnType::Point, size: 0, required: true));
+        $database->createIndex($collectionName, new Index(key: ID::custom('index3'), type: IndexType::Spatial, attributes: ['attribute3']));
 
         $col = $database->getCollection($collectionName);
         $this->assertIsArray($col->getAttribute('attributes'));
@@ -94,8 +103,9 @@ public function testSpatialTypeDocuments(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
-        if (!$database->getAdapter()->getSupportForSpatialAttributes()) {
+        if (! ($database->getAdapter() instanceof Feature\Spatial)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -106,14 +116,14 @@ public function testSpatialTypeDocuments(): void
             $database->createCollection($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, new Attribute(key: 'pointAttr', type: ColumnType::Point, size: 0, required: $database->getAdapter()->supports(Capability::SpatialIndexNull) ? false : true)));
+            $this->assertEquals(true, $database->createAttribute($collectionName, new Attribute(key: 'lineAttr', type: ColumnType::Linestring, size: 0, required: $database->getAdapter()->supports(Capability::SpatialIndexNull) ? false : true)));
+            $this->assertEquals(true, $database->createAttribute($collectionName, new Attribute(key: 'polyAttr', type: ColumnType::Polygon, size: 0, 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, new Index(key: 'point_spatial', type: IndexType::Spatial, attributes: ['pointAttr'])));
+            $this->assertEquals(true, $database->createIndex($collectionName, new Index(key: 'line_spatial', type: IndexType::Spatial, attributes: ['lineAttr'])));
+            $this->assertEquals(true, $database->createIndex($collectionName, new Index(key: 'poly_spatial', type: IndexType::Spatial, attributes: ['polyAttr'])));
 
             $point = [5.0, 5.0];
             $linestring = [[1.0, 2.0], [3.0, 4.0]];
@@ -125,7 +135,7 @@ 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);
@@ -145,7 +155,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 +163,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 +196,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 +217,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 +239,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 +257,22 @@ public function testSpatialRelationshipOneToOne(): void
         /** @var Database $database */
         $database = $this->getDatabase();
 
-        if (!$database->getAdapter()->getSupportForRelationships() || !$database->getAdapter()->getSupportForSpatialAttributes()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships) || ! ($database->getAdapter() instanceof Feature\Spatial)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
         $database->createCollection('location');
         $database->createCollection('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', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('location', new Attribute(key: 'coordinates', type: ColumnType::Point, size: 0, required: true));
+        $database->createAttribute('building', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('building', new Attribute(key: 'area', type: ColumnType::String, size: 255, required: true));
 
         // Create spatial indexes
-        $database->createIndex('location', 'coordinates_spatial', Database::INDEX_SPATIAL, ['coordinates']);
+        $database->createIndex('location', new Index(key: 'coordinates_spatial', type: IndexType::Spatial, attributes: ['coordinates']));
 
         // Create building document first
         $building1 = $database->createDocument('building', new Document([
@@ -276,13 +286,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(new Relationship(collection: 'location', relatedCollection: 'building', type: RelationType::OneToOne, key: 'building', twoWay: false));
 
         // Create location with spatial data and relationship
         $location1 = $database->createDocument('location', new Document([
@@ -311,8 +315,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,8 +329,8 @@ 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());
@@ -352,8 +356,9 @@ public function testSpatialAttributes(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
-        if (!$database->getAdapter()->getSupportForSpatialAttributes()) {
+        if (! ($database->getAdapter() instanceof Feature\Spatial)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -361,20 +366,20 @@ public function testSpatialAttributes(): void
         try {
             $database->createCollection($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, new Attribute(key: 'pointAttr', type: ColumnType::Point, size: 0, required: $required)));
+            $this->assertEquals(true, $database->createAttribute($collectionName, new Attribute(key: 'lineAttr', type: ColumnType::Linestring, size: 0, required: $required)));
+            $this->assertEquals(true, $database->createAttribute($collectionName, new Attribute(key: 'polyAttr', type: ColumnType::Polygon, size: 0, 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, new Index(key: 'idx_point', type: IndexType::Spatial, attributes: ['pointAttr'])));
+            if ($database->getAdapter()->supports(Capability::SpatialIndexNull)) {
+                $this->assertEquals(true, $database->createIndex($collectionName, new Index(key: 'idx_line', type: IndexType::Spatial, 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, new Index(key: 'idx_line', type: IndexType::Spatial, attributes: ['lineAttr'])));
             }
-            $this->assertEquals(true, $database->createIndex($collectionName, 'idx_poly', Database::INDEX_SPATIAL, ['polyAttr']));
+            $this->assertEquals(true, $database->createIndex($collectionName, new Index(key: 'idx_poly', type: IndexType::Spatial, attributes: ['polyAttr'])));
 
             $collection = $database->getCollection($collectionName);
             $this->assertIsArray($collection->getAttribute('attributes'));
@@ -388,7 +393,7 @@ 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 {
@@ -400,8 +405,9 @@ public function testSpatialOneToMany(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
-        if (!$database->getAdapter()->getSupportForRelationships() || !$database->getAdapter()->getSupportForSpatialAttributes()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships) || ! ($database->getAdapter() instanceof Feature\Spatial)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -411,24 +417,17 @@ public function testSpatialOneToMany(): void
             $database->createCollection($parent);
             $database->createCollection($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, new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+            $database->createAttribute($child, new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+            $database->createAttribute($child, new Attribute(key: 'coord', type: ColumnType::Point, size: 0, required: true));
+            $database->createIndex($child, new Index(key: 'coord_spatial', type: IndexType::Spatial, attributes: ['coord']));
 
-            $database->createRelationship(
-                collection: $parent,
-                relatedCollection: $child,
-                type: Database::RELATION_ONE_TO_MANY,
-                twoWay: true,
-                id: 'places',
-                twoWayKey: 'region'
-            );
+            $database->createRelationship(new Relationship(collection: $parent, relatedCollection: $child, type: RelationType::OneToMany, twoWay: true, key: 'places', twoWayKey: 'region'));
 
             $r1 = $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);
 
@@ -437,65 +436,65 @@ public function testSpatialOneToMany(): void
                 '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([
                 '$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());
 
@@ -512,8 +511,9 @@ public function testSpatialManyToOne(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
-        if (!$database->getAdapter()->getSupportForRelationships() || !$database->getAdapter()->getSupportForSpatialAttributes()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships) || ! ($database->getAdapter() instanceof Feature\Spatial)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -523,24 +523,17 @@ public function testSpatialManyToOne(): void
             $database->createCollection($parent);
             $database->createCollection($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, new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+            $database->createAttribute($child, new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+            $database->createAttribute($child, new Attribute(key: 'coord', type: ColumnType::Point, size: 0, required: true));
+            $database->createIndex($child, new Index(key: 'coord_spatial', type: IndexType::Spatial, attributes: ['coord']));
 
-            $database->createRelationship(
-                collection: $child,
-                relatedCollection: $parent,
-                type: Database::RELATION_MANY_TO_ONE,
-                twoWay: true,
-                id: 'city',
-                twoWayKey: 'stops'
-            );
+            $database->createRelationship(new Relationship(collection: $child, relatedCollection: $parent, type: RelationType::ManyToOne, twoWay: true, key: 'city', twoWayKey: 'stops'));
 
             $c1 = $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([
@@ -548,59 +541,59 @@ public function testSpatialManyToOne(): void
                 '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([
                 '$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());
 
@@ -617,8 +610,9 @@ public function testSpatialManyToMany(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
-        if (!$database->getAdapter()->getSupportForRelationships() || !$database->getAdapter()->getSupportForSpatialAttributes()) {
+        if (! ($database->getAdapter() instanceof Feature\Relationships) || ! ($database->getAdapter() instanceof Feature\Spatial)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -628,21 +622,14 @@ public function testSpatialManyToMany(): void
             $database->createCollection($a);
             $database->createCollection($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->createRelationship(
-                collection: $a,
-                relatedCollection: $b,
-                type: Database::RELATION_MANY_TO_MANY,
-                twoWay: true,
-                id: 'routes',
-                twoWayKey: 'drivers'
-            );
+            $database->createAttribute($a, new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+            $database->createAttribute($a, new Attribute(key: 'home', type: ColumnType::Point, size: 0, required: true));
+            $database->createIndex($a, new Index(key: 'home_spatial', type: IndexType::Spatial, attributes: ['home']));
+            $database->createAttribute($b, new Attribute(key: 'title', type: ColumnType::String, size: 255, required: true));
+            $database->createAttribute($b, new Attribute(key: 'area', type: ColumnType::Polygon, size: 0, required: true));
+            $database->createIndex($b, new Index(key: 'area_spatial', type: IndexType::Spatial, attributes: ['area']));
+
+            $database->createRelationship(new Relationship(collection: $a, relatedCollection: $b, type: RelationType::ManyToMany, twoWay: true, key: 'routes', twoWayKey: 'drivers'));
 
             $d1 = $database->createDocument($a, new Document([
                 '$id' => 'd1',
@@ -652,60 +639,60 @@ 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
@@ -722,8 +709,9 @@ public function testSpatialIndex(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
-        if (!$database->getAdapter()->getSupportForSpatialAttributes()) {
+        if (! ($database->getAdapter() instanceof Feature\Spatial)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -731,14 +719,14 @@ public function testSpatialIndex(): void
         $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->createAttribute($collectionName, new Attribute(key: 'loc', type: ColumnType::Point, size: 0, required: true));
+            $this->assertEquals(true, $database->createIndex($collectionName, new Index(key: 'loc_spatial', type: IndexType::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']);
+            $this->assertEquals(IndexType::Spatial->value, $collection->getAttribute('indexes')[0]['type']);
 
             $this->assertEquals(true, $database->deleteIndex($collectionName, 'loc_spatial'));
             $collection = $database->getCollection($collectionName);
@@ -748,14 +736,14 @@ public function testSpatialIndex(): void
         }
 
         // 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,
+                'type' => ColumnType::Point->value,
                 'size' => 0,
                 'required' => true,
                 'signed' => true,
@@ -764,10 +752,10 @@ public function testSpatialIndex(): void
             ])];
             $indexes = [new Document([
                 '$id' => ID::custom('idx_loc'),
-                'type' => Database::INDEX_SPATIAL,
+                'type' => IndexType::Spatial->value,
                 'attributes' => ['loc'],
                 'lengths' => [],
-                'orders' => $orderSupported ? [Database::ORDER_ASC] : ['ASC'],
+                'orders' => $orderSupported ? [OrderDirection::Asc->value] : ['ASC'],
             ])];
 
             if ($orderSupported) {
@@ -789,15 +777,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->createAttribute($collOrderIndex, new Attribute(key: 'loc', type: ColumnType::Point, size: 0, required: true));
             if ($orderSupported) {
-                $this->assertTrue($database->createIndex($collOrderIndex, 'idx_loc', Database::INDEX_SPATIAL, ['loc'], [], [Database::ORDER_DESC]));
+                $this->assertTrue($database->createIndex($collOrderIndex, new Index(key: 'idx_loc', type: IndexType::Spatial, attributes: ['loc'], lengths: [], orders: [OrderDirection::Desc->value])));
             } else {
                 try {
-                    $database->createIndex($collOrderIndex, 'idx_loc', Database::INDEX_SPATIAL, ['loc'], [], ['DESC']);
+                    $database->createIndex($collOrderIndex, new Index(key: 'idx_loc', type: IndexType::Spatial, attributes: ['loc'], lengths: [], orders: ['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,14 +796,14 @@ 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,
+                'type' => ColumnType::Point->value,
                 'size' => 0,
                 'required' => false, // edge case
                 'signed' => true,
@@ -824,7 +812,7 @@ public function testSpatialIndex(): void
             ])];
             $indexes = [new Document([
                 '$id' => ID::custom('idx_loc'),
-                'type' => Database::INDEX_SPATIAL,
+                'type' => IndexType::Spatial->value,
                 'attributes' => ['loc'],
                 'lengths' => [],
                 'orders' => [],
@@ -849,15 +837,15 @@ 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->createAttribute($collNullIndex, new Attribute(key: 'loc', type: ColumnType::Point, size: 0, required: false));
             if ($nullSupported) {
-                $this->assertTrue($database->createIndex($collNullIndex, 'idx_loc', Database::INDEX_SPATIAL, ['loc']));
+                $this->assertTrue($database->createIndex($collNullIndex, new Index(key: 'idx_loc', type: IndexType::Spatial, attributes: ['loc'])));
             } else {
                 try {
-                    $database->createIndex($collNullIndex, 'idx_loc', Database::INDEX_SPATIAL, ['loc']);
+                    $database->createIndex($collNullIndex, new Index(key: 'idx_loc', type: IndexType::Spatial, 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
@@ -871,45 +859,44 @@ public function testSpatialIndex(): void
         try {
             $database->createCollection($collUpdateNull);
 
-            $database->createAttribute($collUpdateNull, 'loc', Database::VAR_POINT, 0, false);
-            if (!$nullSupported) {
+            $database->createAttribute($collUpdateNull, new Attribute(key: 'loc', type: ColumnType::Point, size: 0, required: false));
+            if (! $nullSupported) {
                 try {
-                    $database->createIndex($collUpdateNull, 'idx_loc_required', Database::INDEX_SPATIAL, ['loc']);
+                    $database->createIndex($collUpdateNull, new Index(key: 'idx_loc_required', type: IndexType::Spatial, 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, new Index(key: 'idx_loc', type: IndexType::Spatial, 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, new Index(key: 'idx_loc_req', type: IndexType::Spatial, attributes: ['loc'])));
         } finally {
             $database->deleteCollection($collUpdateNull);
         }
 
-
         $collUpdateNull = 'spatial_idx_index_null_required_true';
         try {
             $database->createCollection($collUpdateNull);
 
-            $database->createAttribute($collUpdateNull, 'loc', Database::VAR_POINT, 0, false);
-            if (!$nullSupported) {
+            $database->createAttribute($collUpdateNull, new Attribute(key: 'loc', type: ColumnType::Point, size: 0, required: false));
+            if (! $nullSupported) {
                 try {
-                    $database->createIndex($collUpdateNull, 'idx_loc', Database::INDEX_SPATIAL, ['loc']);
+                    $database->createIndex($collUpdateNull, new Index(key: 'idx_loc', type: IndexType::Spatial, 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, new Index(key: 'idx_loc', type: IndexType::Spatial, attributes: ['loc'])));
             }
 
             $database->updateAttribute($collUpdateNull, 'loc', required: true);
 
-            $this->assertTrue($database->createIndex($collUpdateNull, 'new index', Database::INDEX_SPATIAL, ['loc']));
+            $this->assertTrue($database->createIndex($collUpdateNull, new Index(key: 'new index', type: IndexType::Spatial, attributes: ['loc'])));
         } finally {
             $database->deleteCollection($collUpdateNull);
         }
@@ -919,8 +906,9 @@ public function testComplexGeometricShapes(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
-        if (!$database->getAdapter()->getSupportForSpatialAttributes()) {
+        if (! ($database->getAdapter() instanceof Feature\Spatial)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -929,20 +917,20 @@ public function testComplexGeometricShapes(): void
             $database->createCollection($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, new Attribute(key: 'rectangle', type: ColumnType::Polygon, size: 0, required: true)));
+            $this->assertEquals(true, $database->createAttribute($collectionName, new Attribute(key: 'square', type: ColumnType::Polygon, size: 0, required: true)));
+            $this->assertEquals(true, $database->createAttribute($collectionName, new Attribute(key: 'triangle', type: ColumnType::Polygon, size: 0, required: true)));
+            $this->assertEquals(true, $database->createAttribute($collectionName, new Attribute(key: 'circle_center', type: ColumnType::Point, size: 0, required: true)));
+            $this->assertEquals(true, $database->createAttribute($collectionName, new Attribute(key: 'complex_polygon', type: ColumnType::Polygon, size: 0, required: true)));
+            $this->assertEquals(true, $database->createAttribute($collectionName, new Attribute(key: 'multi_linestring', type: ColumnType::Linestring, size: 0, 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, new Index(key: 'idx_rectangle', type: IndexType::Spatial, attributes: ['rectangle'])));
+            $this->assertEquals(true, $database->createIndex($collectionName, new Index(key: 'idx_square', type: IndexType::Spatial, attributes: ['square'])));
+            $this->assertEquals(true, $database->createIndex($collectionName, new Index(key: 'idx_triangle', type: IndexType::Spatial, attributes: ['triangle'])));
+            $this->assertEquals(true, $database->createIndex($collectionName, new Index(key: 'idx_circle_center', type: IndexType::Spatial, attributes: ['circle_center'])));
+            $this->assertEquals(true, $database->createIndex($collectionName, new Index(key: 'idx_complex_polygon', type: IndexType::Spatial, attributes: ['complex_polygon'])));
+            $this->assertEquals(true, $database->createIndex($collectionName, new Index(key: 'idx_multi_linestring', type: IndexType::Spatial, attributes: ['multi_linestring'])));
 
             // Create documents with different geometric shapes
             $doc1 = new Document([
@@ -953,7 +941,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,7 +952,7 @@ 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);
@@ -974,35 +962,35 @@ public function testComplexGeometricShapes(): void
             $this->assertInstanceOf(Document::class, $createdDoc2);
 
             // 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 +998,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,8 +1337,9 @@ public function testSpatialQueryCombinations(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
-        if (!$database->getAdapter()->getSupportForSpatialAttributes()) {
+        if (! ($database->getAdapter() instanceof Feature\Spatial)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -1360,15 +1348,15 @@ public function testSpatialQueryCombinations(): void
             $database->createCollection($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, new Attribute(key: 'location', type: ColumnType::Point, size: 0, required: true)));
+            $this->assertEquals(true, $database->createAttribute($collectionName, new Attribute(key: 'area', type: ColumnType::Polygon, size: 0, required: true)));
+            $this->assertEquals(true, $database->createAttribute($collectionName, new Attribute(key: 'route', type: ColumnType::Linestring, size: 0, required: true)));
+            $this->assertEquals(true, $database->createAttribute($collectionName, new Attribute(key: 'name', type: ColumnType::String, size: 255, 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, new Index(key: 'idx_location', type: IndexType::Spatial, attributes: ['location'])));
+            $this->assertEquals(true, $database->createIndex($collectionName, new Index(key: 'idx_area', type: IndexType::Spatial, attributes: ['area'])));
+            $this->assertEquals(true, $database->createIndex($collectionName, new Index(key: 'idx_route', type: IndexType::Spatial, attributes: ['route'])));
 
             // Create test documents
             $doc1 = new Document([
@@ -1377,7 +1365,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 +1374,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 +1383,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 +1392,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 +1407,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 +1456,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,8 +1469,9 @@ public function testSpatialBulkOperation(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
-        if (!$database->getAdapter()->getSupportForSpatialAttributes()) {
+        if (! ($database->getAdapter() instanceof Feature\Spatial)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -1492,7 +1481,7 @@ public function testSpatialBulkOperation(): void
         $attributes = [
             new Document([
                 '$id' => ID::custom('name'),
-                'type' => Database::VAR_STRING,
+                'type' => ColumnType::String->value,
                 'size' => 256,
                 'required' => true,
                 'signed' => true,
@@ -1500,7 +1489,7 @@ public function testSpatialBulkOperation(): void
             ]),
             new Document([
                 '$id' => ID::custom('location'),
-                'type' => Database::VAR_POINT,
+                'type' => ColumnType::Point->value,
                 'size' => 0,
                 'required' => true,
                 'signed' => true,
@@ -1508,22 +1497,22 @@ public function testSpatialBulkOperation(): void
             ]),
             new Document([
                 '$id' => ID::custom('area'),
-                'type' => Database::VAR_POLYGON,
+                'type' => ColumnType::Polygon->value,
                 'size' => 0,
                 'required' => false,
                 'signed' => true,
                 'array' => false,
-            ])
+            ]),
         ];
 
         $indexes = [
             new Document([
                 '$id' => ID::custom('spatial_idx'),
-                'type' => Database::INDEX_SPATIAL,
+                'type' => IndexType::Spatial->value,
                 'attributes' => ['location'],
                 'lengths' => [],
                 'orders' => [],
-            ])
+            ]),
         ];
 
         $database->createCollection($collectionName, $attributes, $indexes);
@@ -1538,15 +1527,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
             ]);
         }
 
@@ -1592,17 +1581,17 @@ public function testSpatialBulkOperation(): void
             $this->assertGreaterThan(1, count($document->getAttribute('area')[0])); // POLYGON has multiple points
         }
 
-        $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
         }
 
-        $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
@@ -1618,10 +1607,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;
         });
@@ -1631,9 +1620,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);
 
@@ -1650,7 +1639,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'));
         }
 
@@ -1671,8 +1660,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',
@@ -1689,9 +1678,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 = [];
@@ -1712,65 +1701,65 @@ public function testSpatialBulkOperation(): void
 
         // 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);
@@ -1784,22 +1773,23 @@ public function testSptialAggregation(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
-        if (!$database->getAdapter()->getSupportForSpatialAttributes()) {
+        if (! ($database->getAdapter() instanceof Feature\Spatial)) {
             $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->createAttribute($collectionName, new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+            $database->createAttribute($collectionName, new Attribute(key: 'loc', type: ColumnType::Point, size: 0, required: true));
+            $database->createAttribute($collectionName, new Attribute(key: 'area', type: ColumnType::Polygon, size: 0, required: true));
+            $database->createAttribute($collectionName, new Attribute(key: 'score', type: ColumnType::Integer, size: 0, 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, new Index(key: 'idx_loc', type: IndexType::Spatial, attributes: ['loc']));
+            $database->createIndex($collectionName, new Index(key: 'idx_area', type: IndexType::Spatial, attributes: ['area']));
 
             // Seed documents
             $a = $database->createDocument($collectionName, new Document([
@@ -1808,7 +1798,7 @@ public function testSptialAggregation(): void
                 '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([
                 '$id' => 'b',
@@ -1816,7 +1806,7 @@ public function testSptialAggregation(): void
                 '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([
                 '$id' => 'c',
@@ -1824,7 +1814,7 @@ public function testSptialAggregation(): void
                 '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);
@@ -1833,7 +1823,7 @@ public function testSptialAggregation(): void
 
             // 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));
@@ -1844,21 +1834,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));
@@ -1872,8 +1862,9 @@ public function testUpdateSpatialAttributes(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
-        if (!$database->getAdapter()->getSupportForSpatialAttributes()) {
+        if (! ($database->getAdapter() instanceof Feature\Spatial)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -1883,22 +1874,22 @@ public function testUpdateSpatialAttributes(): void
 
             // 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, new Attribute(key: 'geom_bad_size', type: ColumnType::Point, 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, new Attribute(key: 'geom_bad_array', type: ColumnType::Point, size: 0, 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, new Attribute(key: 'geom', type: ColumnType::Point, size: 0, required: true)));
+            $this->assertEquals(true, $database->createIndex($collectionName, new Index(key: 'idx_geom', type: IndexType::Spatial, attributes: ['geom'])));
 
             // 1) Disallow size and array updates on spatial attributes: expect DatabaseException
             try {
@@ -1916,7 +1907,7 @@ 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);
@@ -1937,14 +1928,14 @@ public function testUpdateSpatialAttributes(): void
             }
 
             // 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, new Index(key: 'idx_geom_desc', type: IndexType::Spatial, attributes: ['geom'], lengths: [], orders: [OrderDirection::Desc->value])));
                 // 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, new Index(key: 'idx_geom_desc', type: IndexType::Spatial, attributes: ['geom'], lengths: [], orders: ['DESC']));
                     $this->fail('Expected error when providing orders for spatial index on adapter without order support');
                 } catch (\Throwable $e) {
                     $this->assertTrue(true);
@@ -1955,242 +1946,34 @@ 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() instanceof Feature\Spatial)) {
             $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']));
+            $this->assertEquals(true, $database->createAttribute($collectionName, new Attribute(key: 'loc', type: ColumnType::Point, size: 0, required: true)));
+            $this->assertEquals(true, $database->createIndex($collectionName, new Index(key: 'idx_loc', type: IndexType::Spatial, attributes: ['loc'])));
 
             // Two points roughly ~1000 meters apart by latitude delta (~0.009 deg ≈ 1km)
             $p0 = $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([
                 '$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);
@@ -2198,38 +1981,38 @@ public function testSpatialDistanceInMeter(): void
 
             // 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 {
@@ -2241,13 +2024,15 @@ public function testSpatialDistanceInMeterForMultiDimensionGeometry(): void
     {
         /** @var Database $database */
         $database = $this->getDatabase();
-        if (!$database->getAdapter()->getSupportForSpatialAttributes()) {
+        if (! ($database->getAdapter() instanceof Feature\Spatial)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
-        if (!$database->getAdapter()->getSupportForDistanceBetweenMultiDimensionGeometryInMeters()) {
+        if (! $database->getAdapter()->supports(Capability::MultiDimensionDistance)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -2256,14 +2041,14 @@ public function testSpatialDistanceInMeterForMultiDimensionGeometry(): void
             $database->createCollection($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, new Attribute(key: 'loc', type: ColumnType::Point, size: 0, required: true)));
+            $this->assertEquals(true, $database->createAttribute($multiCollection, new Attribute(key: 'line', type: ColumnType::Linestring, size: 0, required: true)));
+            $this->assertEquals(true, $database->createAttribute($multiCollection, new Attribute(key: 'poly', type: ColumnType::Polygon, size: 0, 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, new Index(key: 'idx_loc', type: IndexType::Spatial, attributes: ['loc'])));
+            $this->assertEquals(true, $database->createIndex($multiCollection, new Index(key: 'idx_line', type: IndexType::Spatial, attributes: ['line'])));
+            $this->assertEquals(true, $database->createIndex($multiCollection, new Index(key: 'idx_poly', type: IndexType::Spatial, attributes: ['poly'])));
 
             // Geometry sets: near origin and far east
             $docNear = $database->createDocument($multiCollection, new Document([
@@ -2273,11 +2058,11 @@ public function testSpatialDistanceInMeterForMultiDimensionGeometry(): void
                 '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([
@@ -2289,9 +2074,9 @@ 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);
@@ -2304,9 +2089,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());
 
@@ -2316,9 +2101,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());
 
@@ -2327,10 +2112,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());
 
@@ -2338,17 +2123,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());
 
@@ -2356,11 +2141,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());
 
@@ -2369,63 +2154,7 @@ 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([
@@ -2435,41 +2164,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() instanceof Feature\Spatial)) {
             $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);
 
@@ -2477,87 +2207,37 @@ 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() instanceof Feature\Spatial)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
-        if ($database->getAdapter()->getSupportForSpatialIndexNull()) {
+        if ($database->getAdapter()->supports(Capability::SpatialIndexNull)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -2565,15 +2245,15 @@ public function testSpatialIndexRequiredToggling(): void
             $collUpdateNull = 'spatial_idx_toggle';
             $database->createCollection($collUpdateNull);
 
-            $database->createAttribute($collUpdateNull, 'loc', Database::VAR_POINT, 0, false);
+            $database->createAttribute($collUpdateNull, new Attribute(key: 'loc', type: ColumnType::Point, size: 0, required: false));
             try {
-                $database->createIndex($collUpdateNull, 'idx_loc', Database::INDEX_SPATIAL, ['loc']);
+                $database->createIndex($collUpdateNull, new Index(key: 'idx_loc', type: IndexType::Spatial, 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, new Index(key: 'new index', type: IndexType::Spatial, attributes: ['loc'])));
             $this->assertTrue($database->deleteIndex($collUpdateNull, 'new index'));
             $database->updateAttribute($collUpdateNull, 'loc', required: false);
 
@@ -2583,74 +2263,14 @@ 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() instanceof Feature\Spatial)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -2659,14 +2279,14 @@ public function testSpatialDocOrder(): void
         $database->createCollection($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, new Attribute(key: 'pointAttr', type: ColumnType::Point, size: 0, 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);
@@ -2677,113 +2297,25 @@ public function testSpatialDocOrder(): void
         $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() instanceof Feature\Spatial)) {
             $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;
         }
 
@@ -2791,10 +2323,10 @@ public function testCreateSpatialColumnWithExistingData(): void
         try {
             $database->createCollection($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, new Attribute(key: 'name', type: ColumnType::String, size: 40, required: false));
+            $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, new Attribute(key: 'loc', type: ColumnType::Point, size: 0, required: true));
             } catch (\Throwable $e) {
                 $this->assertInstanceOf(StructureException::class, $e);
             }
@@ -2812,8 +2344,9 @@ public function testSpatialArrayWKTConversionInUpdateDocument(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForSpatialAttributes()) {
+        if (! ($database->getAdapter() instanceof Feature\Spatial)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -2822,15 +2355,15 @@ public function testSpatialArrayWKTConversionInUpdateDocument(): void
         try {
             $database->createCollection($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, new Attribute(key: 'location', type: ColumnType::Point, size: 0, required: true));
+            $database->createAttribute($collectionName, new Attribute(key: 'route', type: ColumnType::Linestring, size: 0, required: $database->getAdapter()->supports(Capability::SpatialIndexNull) ? false : true));
+            $database->createAttribute($collectionName, new Attribute(key: 'area', type: ColumnType::Polygon, size: 0, required: $database->getAdapter()->supports(Capability::SpatialIndexNull) ? false : true));
+            $database->createAttribute($collectionName, new Attribute(key: 'name', type: ColumnType::String, size: 100, required: false));
 
             // 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, new Index(key: 'location_idx', type: IndexType::Spatial, attributes: ['location']));
+            $database->createIndex($collectionName, new Index(key: 'route_idx', type: IndexType::Spatial, attributes: ['route']));
+            $database->createIndex($collectionName, new Index(key: 'area_idx', type: IndexType::Spatial, attributes: ['area']));
 
             // Create initial document with spatial arrays
             $initialPoint = [10.0, 20.0];
@@ -2843,7 +2376,7 @@ public function testSpatialArrayWKTConversionInUpdateDocument(): void
                 'location' => $initialPoint,
                 'route' => $initialLine,
                 'area' => $initialPolygon,
-                'name' => 'Original'
+                'name' => 'Original',
             ]));
 
             // Verify initial values
@@ -2860,7 +2393,7 @@ public function testSpatialArrayWKTConversionInUpdateDocument(): void
                 'location' => $newPoint,
                 'route' => $newLine,
                 'area' => $newPolygon,
-                'name' => 'Updated'
+                'name' => 'Updated',
             ]));
 
             // Verify updated spatial values are correctly stored and retrieved
@@ -2877,7 +2410,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());
@@ -2885,7 +2418,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 8d84de940..cf08a2a13 100644
--- a/tests/e2e/Adapter/Scopes/VectorTests.php
+++ b/tests/e2e/Adapter/Scopes/VectorTests.php
@@ -2,13 +2,19 @@
 
 namespace Tests\E2E\Adapter\Scopes;
 
+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\Database\Validator\Authorization;
+use Utopia\Database\Relationship;
+use Utopia\Database\RelationType;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\IndexType;
 
 trait VectorTests
 {
@@ -17,8 +23,9 @@ public function testVectorAttributes(): void
         /** @var Database $database */
         $database = static::getDatabase();
 
-        if (!$database->getAdapter()->getSupportForVectors()) {
+        if (! $database->getAdapter()->supports(Capability::Vectors)) {
             $this->expectNotToPerformAssertions();
+
             return;
         }
 
@@ -26,10 +33,10 @@ public function testVectorAttributes(): void
         $database->createCollection('vectorCollection');
 
         // Create a vector attribute with 3 dimensions
-        $database->createAttribute('vectorCollection', 'embedding', Database::VAR_VECTOR, 3, true);
+        $database->createAttribute('vectorCollection', new Attribute(key: 'embedding', type: ColumnType::Vector, 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', new Attribute(key: 'large_embedding', type: ColumnType::Vector, size: 128, required: false, default: null));
 
         // Verify the attributes were created
         $collection = $database->getCollection('vectorCollection');
@@ -48,94 +55,55 @@ public function testVectorAttributes(): void
 
         $this->assertNotNull($embeddingAttr);
         $this->assertNotNull($largeEmbeddingAttr);
-        $this->assertEquals(Database::VAR_VECTOR, $embeddingAttr['type']);
+        $this->assertEquals(ColumnType::Vector->value, $embeddingAttr['type']);
         $this->assertEquals(3, $embeddingAttr['size']);
-        $this->assertEquals(Database::VAR_VECTOR, $largeEmbeddingAttr['type']);
+        $this->assertEquals(ColumnType::Vector->value, $largeEmbeddingAttr['type']);
         $this->assertEquals(128, $largeEmbeddingAttr['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->createAttribute('vectorDocuments', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('vectorDocuments', new Attribute(key: 'embedding', type: ColumnType::Vector, 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 +123,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->createAttribute('vectorQueries', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('vectorQueries', new Attribute(key: 'embedding', type: ColumnType::Vector, 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 +165,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 +178,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 +186,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 +194,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 +204,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 +213,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 +225,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 +235,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 +245,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 +255,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,52 +271,30 @@ public function testVectorQueries(): void
         $database->deleteCollection('vectorQueries');
     }
 
-    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->createAttribute('vectorIndexes', new Attribute(key: 'embedding', type: ColumnType::Vector, 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', new Index(key: 'embedding_euclidean', type: IndexType::HnswEuclidean, attributes: ['embedding']));
 
         // Cosine distance index
-        $database->createIndex('vectorIndexes', 'embedding_cosine', Database::INDEX_HNSW_COSINE, ['embedding']);
+        $database->createIndex('vectorIndexes', new Index(key: 'embedding_cosine', type: IndexType::HnswCosine, attributes: ['embedding']));
 
         // Inner product (dot product) index
-        $database->createIndex('vectorIndexes', 'embedding_dot', Database::INDEX_HNSW_DOT, ['embedding']);
+        $database->createIndex('vectorIndexes', new Index(key: 'embedding_dot', type: IndexType::HnswDot, attributes: ['embedding']));
 
         // Verify indexes were created
         $collection = $database->getCollection('vectorIndexes');
@@ -358,22 +305,22 @@ public function testVectorIndexes(): void
         // 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);
@@ -382,96 +329,28 @@ 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->createAttribute('vectorNullEmpty', new Attribute(key: 'embedding', type: ColumnType::Vector, size: 3, required: false)); // 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'));
@@ -480,9 +359,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) {
@@ -498,14 +377,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->createAttribute('vectorLarge', new Attribute(key: 'embedding', type: ColumnType::Vector, size: 1536, required: true)); // Common embedding size
 
         // Create a large vector
         $largeVector = array_fill(0, 1536, 0.1);
@@ -513,9 +393,9 @@ 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'));
@@ -526,7 +406,7 @@ public function testLargeVectors(): void
         $searchVector[0] = 1.0;
 
         $results = $database->find('vectorLarge', [
-            Query::vectorCosine('embedding', $searchVector)
+            Query::vectorCosine('embedding', $searchVector),
         ]);
 
         $this->assertCount(1, $results);
@@ -540,35 +420,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->createAttribute('vectorUpdates', new Attribute(key: 'embedding', type: ColumnType::Vector, 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'));
@@ -582,38 +463,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->createAttribute('multiVector', new Attribute(key: 'embedding1', type: ColumnType::Vector, size: 3, required: true));
+        $database->createAttribute('multiVector', new Attribute(key: 'embedding2', type: ColumnType::Vector, size: 5, required: true));
+        $database->createAttribute('multiVector', new Attribute(key: 'name', type: ColumnType::String, size: 255, 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);
@@ -621,7 +503,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);
@@ -636,27 +518,28 @@ 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->createAttribute('vectorPagination', new Attribute(key: 'embedding', type: ColumnType::Vector, size: 3, required: true));
+        $database->createAttribute('vectorPagination', new Attribute(key: 'index', type: ColumnType::Integer, size: 0, required: true));
 
         // Create 10 documents
         for ($i = 0; $i < 10; $i++) {
             $database->createDocument('vectorPagination', new Document([
                 '$permissions' => [
-                    Permission::read(Role::any())
+                    Permission::read(Role::any()),
                 ],
                 'index' => $i,
                 'embedding' => [
                     cos($i * M_PI / 10),
                     sin($i * M_PI / 10),
-                    0.0
-                ]
+                    0.0,
+                ],
             ]));
         }
 
@@ -667,7 +550,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);
@@ -676,7 +559,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);
@@ -689,7 +572,7 @@ public function testVectorQueriesWithPagination(): void
         // Test with cursor pagination
         $firstBatch = $database->find('vectorPagination', [
             Query::vectorCosine('embedding', $searchVector),
-            Query::limit(5)
+            Query::limit(5),
         ]);
 
         $this->assertCount(5, $firstBatch);
@@ -698,7 +581,7 @@ 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);
@@ -713,18 +596,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->createAttribute('vectorTextSearch', new Attribute(key: 'title', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('vectorTextSearch', new Attribute(key: 'category', type: ColumnType::String, size: 50, required: true));
+        $database->createAttribute('vectorTextSearch', new Attribute(key: 'embedding', type: ColumnType::Vector, size: 3, required: true));
 
         // Create fulltext index for title
-        $database->createIndex('vectorTextSearch', 'title_fulltext', Database::INDEX_FULLTEXT, ['title']);
+        $database->createIndex('vectorTextSearch', new Index(key: 'title_fulltext', type: IndexType::Fulltext, attributes: ['title']));
 
         // Create test documents
         $docs = [
@@ -738,9 +622,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,
             ]));
         }
 
@@ -748,7 +632,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);
@@ -759,7 +643,7 @@ 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);
@@ -771,7 +655,7 @@ public function testCombinedVectorAndTextSearch(): void
         $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);
@@ -788,20 +672,21 @@ 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->createAttribute('vectorSpecialFloats', new Attribute(key: 'embedding', type: ColumnType::Vector, 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());
@@ -809,9 +694,9 @@ public function testVectorSpecialFloatValues(): void
         // 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());
@@ -819,9 +704,9 @@ public function testVectorSpecialFloatValues(): void
         // 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());
@@ -829,16 +714,16 @@ public function testVectorSpecialFloatValues(): void
         // 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());
 
         // 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));
@@ -852,14 +737,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->createAttribute('vectorPerf', new Attribute(key: 'embedding', type: ColumnType::Vector, size: 128, required: true));
+        $database->createAttribute('vectorPerf', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
 
         // Create documents
         $numDocs = 100;
@@ -871,10 +757,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,
             ]));
         }
 
@@ -884,20 +770,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', new Index(key: 'embedding_hnsw', type: IndexType::HnswCosine, 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;
 
@@ -913,83 +799,39 @@ 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->createAttribute('vectorNorm', new Attribute(key: 'embedding', type: ColumnType::Vector, 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);
@@ -1007,21 +849,22 @@ 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->createAttribute('vectorInfinity', new Attribute(key: 'embedding', type: ColumnType::Vector, 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) {
@@ -1032,9 +875,9 @@ public function testVectorWithInfinityValues(): void
         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) {
@@ -1050,21 +893,22 @@ 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('vectorNaN');
-        $database->createAttribute('vectorNaN', 'embedding', Database::VAR_VECTOR, 3, true);
+        $database->createAttribute('vectorNaN', new Attribute(key: 'embedding', type: ColumnType::Vector, size: 3, required: true));
 
         // Test with NaN value - should fail
         try {
             $database->createDocument('vectorNaN', new Document([
                 '$permissions' => [
-                    Permission::read(Role::any())
+                    Permission::read(Role::any()),
                 ],
-                'embedding' => [NAN, 0.0, 0.0]
+                'embedding' => [NAN, 0.0, 0.0],
             ]));
             $this->fail('Should have thrown exception for NaN value');
         } catch (DatabaseException $e) {
@@ -1075,229 +919,76 @@ public function testVectorWithNaNValues(): void
         $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;
-        }
-
-        $database->createCollection('vectorBooleans');
-        $database->createAttribute('vectorBooleans', 'embedding', Database::VAR_VECTOR, 3, true);
-
-        // Test with boolean values - should fail
-        try {
-            $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()));
-        }
-
-        // Cleanup
-        $database->deleteCollection('vectorBooleans');
-    }
-
-    public function testVectorWithStringNumbers(): void
-    {
-        /** @var Database $database */
-        $database = static::getDatabase();
-
-        if (!$database->getAdapter()->getSupportForVectors()) {
-            $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()));
-        }
 
-        // Test with strings containing spaces
-        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 with spaces');
-        } catch (DatabaseException $e) {
-            $this->assertStringContainsString('numeric', strtolower($e->getMessage()));
-        }
 
-        // Cleanup
-        $database->deleteCollection('vectorStringNums');
-    }
 
     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->createAttribute('vectorParent', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('vectorParent', new Attribute(key: 'embedding', type: ColumnType::Vector, 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->createAttribute('vectorChild', new Attribute(key: 'title', type: ColumnType::String, size: 255, required: true));
+        $database->createRelationship(new Relationship(
+            collection: 'vectorChild',
+            relatedCollection: 'vectorParent',
+            type: RelationType::ManyToOne,
+            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);
@@ -1312,7 +1003,7 @@ public function testVectorWithRelationships(): void
         // 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);
@@ -1327,52 +1018,60 @@ 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->createAttribute('vectorAuthors', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('vectorAuthors', new Attribute(key: 'embedding', type: ColumnType::Vector, size: 3, required: 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->createAttribute('vectorBooks', new Attribute(key: 'title', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('vectorBooks', new Attribute(key: 'embedding', type: ColumnType::Vector, size: 3, required: true));
+        $database->createRelationship(new Relationship(
+            collection: 'vectorBooks',
+            relatedCollection: 'vectorAuthors',
+            type: RelationType::ManyToOne,
+            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);
@@ -1393,20 +1092,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->createAttribute('vectorZeros', new Attribute(key: 'embedding', type: ColumnType::Vector, 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'));
@@ -1414,14 +1114,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
@@ -1429,7 +1129,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);
@@ -1438,67 +1138,29 @@ 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->createAttribute('vectorDeleteAttr', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('vectorDeleteAttr', new Attribute(key: 'embedding', type: ColumnType::Vector, 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'));
@@ -1527,24 +1189,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->createAttribute('vectorDeleteIndexedAttr', new Attribute(key: 'embedding', type: ColumnType::Vector, 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', new Index(key: 'idx1', type: IndexType::HnswCosine, attributes: ['embedding']));
+        $database->createIndex('vectorDeleteIndexedAttr', new Index(key: 'idx2', type: IndexType::HnswEuclidean, 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
@@ -1560,156 +1223,38 @@ public function testDeleteAttributeWithVectorIndexes(): void
         $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->createAttribute('vectorCursorBefore', new Attribute(key: 'index', type: ColumnType::Integer, size: 0, required: true));
+        $database->createAttribute('vectorCursorBefore', new Attribute(key: 'embedding', type: ColumnType::Vector, 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);
@@ -1719,7 +1264,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
@@ -1736,30 +1281,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->createAttribute('vectorBackward', new Attribute(key: 'value', type: ColumnType::Integer, size: 0, required: true));
+        $database->createAttribute('vectorBackward', new Attribute(key: 'embedding', type: ColumnType::Vector, 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
@@ -1767,7 +1313,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);
@@ -1777,7 +1323,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)
@@ -1793,27 +1339,28 @@ 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->createAttribute('vectorDimUpdate', new Attribute(key: 'embedding', type: ColumnType::Vector, 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'));
 
         // 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)
@@ -1824,81 +1371,41 @@ public function testVectorDimensionUpdate(): void
         $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->createAttribute('vectorConcurrent', new Attribute(key: 'embedding', type: ColumnType::Vector, size: 3, required: true));
+        $database->createAttribute('vectorConcurrent', new Attribute(key: 'version', type: ColumnType::Integer, size: 0, 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
@@ -1915,16 +1422,17 @@ 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->createAttribute('vectorDeleteIdx', new Attribute(key: 'embedding', type: ColumnType::Vector, size: 3, required: true));
 
         // Create index
-        $database->createIndex('vectorDeleteIdx', 'idx_cosine', Database::INDEX_HNSW_COSINE, ['embedding']);
+        $database->createIndex('vectorDeleteIdx', new Index(key: 'idx_cosine', type: IndexType::HnswCosine, attributes: ['embedding']));
 
         // Verify index exists
         $collection = $database->getCollection('vectorDeleteIdx');
@@ -1934,9 +1442,9 @@ public function testDeleteVectorIndexes(): void
         // 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
@@ -1950,7 +1458,7 @@ public function testDeleteVectorIndexes(): void
 
         // 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);
@@ -1964,18 +1472,19 @@ 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->createAttribute('vectorMultiIdx', new Attribute(key: 'embedding1', type: ColumnType::Vector, size: 3, required: true));
+        $database->createAttribute('vectorMultiIdx', new Attribute(key: 'embedding2', type: ColumnType::Vector, 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', new Index(key: 'idx1_cosine', type: IndexType::HnswCosine, attributes: ['embedding1']));
+        $database->createIndex('vectorMultiIdx', new Index(key: 'idx2_euclidean', type: IndexType::HnswEuclidean, attributes: ['embedding2']));
 
         // Verify both indexes exist
         $collection = $database->getCollection('vectorMultiIdx');
@@ -1985,21 +1494,21 @@ public function testMultipleVectorIndexes(): void
         // 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);
 
@@ -2007,72 +1516,39 @@ 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->createAttribute('vectorNoIndex', new Attribute(key: 'embedding', type: ColumnType::Vector, 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);
@@ -2086,17 +1562,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->createAttribute('vectorEmptyQuery', new Attribute(key: 'embedding', type: ColumnType::Vector, 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);
@@ -2110,27 +1587,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->createAttribute('vectorSingleDim', new Attribute(key: 'embedding', type: ColumnType::Vector, 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'));
@@ -2138,7 +1616,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);
@@ -2152,32 +1630,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->createAttribute('vectorLongResults', new Attribute(key: 'embedding', type: ColumnType::Vector, 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);
@@ -2191,42 +1670,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->createAttribute('vectorMultiQuery', new Attribute(key: 'embedding', type: ColumnType::Vector, 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
@@ -2244,75 +1724,34 @@ 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->createAttribute('vectorLargeVals', new Attribute(key: 'embedding', type: ColumnType::Vector, 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());
 
         // Query should work
         $results = $database->find('vectorLargeVals', [
-            Query::vectorCosine('embedding', [1e38, -1e38, 1e37])
+            Query::vectorCosine('embedding', [1e38, -1e38, 1e37]),
         ]);
 
         $this->assertCount(1, $results);
@@ -2326,21 +1765,22 @@ 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->createAttribute('vectorPrecision', new Attribute(key: 'embedding', type: ColumnType::Vector, 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)
@@ -2361,14 +1801,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->createAttribute('vector16000', new Attribute(key: 'embedding', type: ColumnType::Vector, size: 16000, required: true));
 
         // Create a vector with exactly 16000 dimensions
         $largeVector = array_fill(0, 16000, 0.1);
@@ -2376,9 +1817,9 @@ 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'));
@@ -2389,7 +1830,7 @@ public function testVector16000DimensionsBoundary(): void
 
         $results = $database->find('vector16000', [
             Query::vectorCosine('embedding', $searchVector),
-            Query::limit(1)
+            Query::limit(1),
         ]);
 
         $this->assertCount(1, $results);
@@ -2403,13 +1844,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->createAttribute('vectorLargeDataset', new Attribute(key: 'embedding', type: ColumnType::Vector, size: 128, required: true));
 
         // Create 200 documents
         for ($i = 0; $i < 200; $i++) {
@@ -2420,20 +1862,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', new Index(key: 'idx_hnsw', type: IndexType::HnswCosine, 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);
@@ -2447,44 +1889,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->createAttribute('vectorFilterDisabled', new Attribute(key: 'status', type: ColumnType::String, size: 50, required: true));
+        $database->createAttribute('vectorFilterDisabled', new Attribute(key: 'embedding', type: ColumnType::Vector, 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);
@@ -2501,25 +1944,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->createAttribute('vectorFilterOverride', new Attribute(key: 'category', type: ColumnType::String, size: 50, required: true));
+        $database->createAttribute('vectorFilterOverride', new Attribute(key: 'priority', type: ColumnType::Integer, size: 0, required: true));
+        $database->createAttribute('vectorFilterOverride', new Attribute(key: 'embedding', type: ColumnType::Vector, 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],
             ]));
         }
 
@@ -2528,7 +1972,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
@@ -2547,31 +1991,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->createAttribute('vectorMultiFilters', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('vectorMultiFilters', new Attribute(key: 'embedding1', type: ColumnType::Vector, size: 3, required: true));
+        $database->createAttribute('vectorMultiFilters', new Attribute(key: 'embedding2', type: ColumnType::Vector, 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) {
@@ -2587,24 +2032,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->createAttribute('vectorNested', new Attribute(key: 'name', type: ColumnType::String, size: 255, required: true));
+        $database->createAttribute('vectorNested', new Attribute(key: 'embedding1', type: ColumnType::Vector, size: 3, required: true));
+        $database->createAttribute('vectorNested', new Attribute(key: 'embedding2', type: ColumnType::Vector, 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
@@ -2613,8 +2059,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) {
@@ -2630,17 +2076,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->createAttribute('vectorCount', new Attribute(key: 'embedding', type: ColumnType::Vector, 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],
         ]));
@@ -2659,38 +2106,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->createAttribute('vectorSum', new Attribute(key: 'embedding', type: ColumnType::Vector, size: 3, required: true));
+        $database->createAttribute('vectorSum', new Attribute(key: 'value', type: ColumnType::Integer, size: 0, 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
@@ -2716,19 +2164,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->createAttribute('vectorUpsert', new Attribute(key: 'embedding', type: ColumnType::Vector, 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],
         ]));
@@ -2742,7 +2191,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 f6574ab0d..6a0467fef 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 61904861c..5b95b1fcd 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 697c42c7e..a90826cbb 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 cb9633c01..6536ecc02 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 ea4a042ea..d98b919e0 100644
--- a/tests/e2e/Adapter/SharedTables/SQLiteTest.php
+++ b/tests/e2e/Adapter/SharedTables/SQLiteTest.php
@@ -13,52 +13,50 @@
 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));
 
         $database = new Database(new SQLite($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().'_'.uniqid());
 
         if ($database->exists()) {
             $database->delete();
@@ -67,14 +65,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;
@@ -82,9 +82,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/unit/Adapter/ReadWritePoolTest.php b/tests/unit/Adapter/ReadWritePoolTest.php
new file mode 100644
index 000000000..b6380e19f
--- /dev/null
+++ b/tests/unit/Adapter/ReadWritePoolTest.php
@@ -0,0 +1,310 @@
+<?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\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 Adapter&MockObject */
+    private Adapter $writeAdapter;
+
+    /** @var Adapter&MockObject */
+    private Adapter $readAdapter;
+
+    protected function setUp(): void
+    {
+        $this->writeAdapter = $this->createMock(Adapter::class);
+        $this->readAdapter = $this->createMock(Adapter::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',
+            'getSizeOfCollection',
+            'getSizeOfCollectionOnDisk',
+            'ping',
+            'getConnectionId',
+            'getDocumentSizeLimit',
+            'getAttributeWidth',
+            'getCountOfAttributes',
+            'getCountOfIndexes',
+            'getLimitForString',
+            'getLimitForInt',
+            'getLimitForAttributes',
+            'getLimitForIndexes',
+            'getMaxIndexLength',
+            'getMaxVarcharLength',
+            'getMaxUIDLength',
+            'getIdAttributeType',
+            'supports',
+        ];
+
+        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 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']);
+    }
+
+    /**
+     * @return mixed
+     */
+    private function getDefaultReturnForMethod(string $method): mixed
+    {
+        return match ($method) {
+            'find', 'list' => [],
+            'getDocument' => new Document(),
+            'count', 'sum', 'getSizeOfCollection', 'getSizeOfCollectionOnDisk',
+            'getDocumentSizeLimit', 'getAttributeWidth', 'getCountOfAttributes',
+            'getCountOfIndexes', 'getLimitForString', 'getLimitForInt',
+            'getLimitForAttributes', 'getLimitForIndexes', 'getMaxIndexLength',
+            'getMaxVarcharLength', 'getMaxUIDLength' => 0,
+            'exists', 'ping', 'supports' => true,
+            'getConnectionId', 'getIdAttributeType' => 'string',
+            'getSchemaAttributes' => [],
+            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',
+            'getLimitForAttributes', 'getLimitForIndexes',
+            'getMaxIndexLength', 'getMaxVarcharLength',
+            'getMaxUIDLength' => [],
+            'getIdAttributeType' => [],
+            'supports' => [\Utopia\Database\Capability::Index],
+            'getSchemaAttributes' => ['collection'],
+            default => [],
+        };
+    }
+}
diff --git a/tests/unit/AttributeModelTest.php b/tests/unit/AttributeModelTest.php
new file mode 100644
index 000000000..4299c8a94
--- /dev/null
+++ b/tests/unit/AttributeModelTest.php
@@ -0,0 +1,366 @@
+<?php
+
+namespace Tests\Unit;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Attribute;
+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 = new Attribute(
+            key: 'score',
+            type: ColumnType::Double,
+            size: 0,
+            required: true,
+            default: 0.0,
+            signed: true,
+            array: false,
+            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 = new Attribute(
+            key: 'email',
+            type: ColumnType::String,
+            size: 256,
+            required: true,
+            default: null,
+            signed: true,
+            array: false,
+            format: 'email',
+            formatOptions: ['allowPlus' => true],
+            filters: ['lowercase'],
+        );
+
+        $doc = $attr->toDocument();
+
+        $this->assertInstanceOf(Document::class, $doc);
+        $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 = new Attribute(key: 'name', type: ColumnType::String, status: 'processing');
+
+        $doc = $attr->toDocument();
+        $this->assertSame('processing', $doc->getAttribute('status'));
+    }
+
+    public function testToDocumentExcludesStatusWhenNull(): void
+    {
+        $attr = new Attribute(key: 'name', type: ColumnType::String);
+
+        $doc = $attr->toDocument();
+        $this->assertNull($doc->getAttribute('status'));
+    }
+
+    public function testToDocumentIncludesOptionsWhenSet(): void
+    {
+        $options = [
+            'relatedCollection' => 'users',
+            'relationType' => 'oneToMany',
+            'twoWay' => true,
+            'twoWayKey' => 'posts',
+        ];
+        $attr = new Attribute(key: 'author', type: ColumnType::Relationship, options: $options);
+
+        $doc = $attr->toDocument();
+        $this->assertSame($options, $doc->getAttribute('options'));
+    }
+
+    public function testToDocumentExcludesOptionsWhenNull(): void
+    {
+        $attr = new Attribute(key: 'name', type: ColumnType::String);
+
+        $doc = $attr->toDocument();
+        $this->assertNull($doc->getAttribute('options'));
+    }
+
+    public function testFromDocumentRoundtrip(): void
+    {
+        $original = new Attribute(
+            key: 'tags',
+            type: ColumnType::String,
+            size: 64,
+            required: false,
+            default: null,
+            signed: true,
+            array: true,
+            format: null,
+            formatOptions: [],
+            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 = new Attribute(
+            key: 'url',
+            type: ColumnType::String,
+            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 = new Attribute(
+            key: 'content',
+            type: ColumnType::String,
+            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 = new Attribute(
+            key: 'comments',
+            type: ColumnType::Relationship,
+            options: $options,
+        );
+
+        $doc = $attr->toDocument();
+        $restored = Attribute::fromDocument($doc);
+
+        $this->assertSame($options, $restored->options);
+    }
+
+    public function testWithDefaultValueTypes(): void
+    {
+        $stringAttr = new Attribute(key: 's', type: ColumnType::String, size: 32, default: 'hello');
+        $this->assertSame('hello', $stringAttr->default);
+
+        $intAttr = new Attribute(key: 'i', type: ColumnType::Integer, default: 42);
+        $this->assertSame(42, $intAttr->default);
+
+        $boolAttr = new Attribute(key: 'b', type: ColumnType::Boolean, default: true);
+        $this->assertTrue($boolAttr->default);
+
+        $doubleAttr = new Attribute(key: 'd', type: ColumnType::Double, default: 3.14);
+        $this->assertSame(3.14, $doubleAttr->default);
+
+        $nullAttr = new Attribute(key: 'n', type: ColumnType::String, size: 32, default: null);
+        $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);
+    }
+}
diff --git a/tests/unit/Attributes/AttributeValidationTest.php b/tests/unit/Attributes/AttributeValidationTest.php
new file mode 100644
index 000000000..94a4a7a36
--- /dev/null
+++ b/tests/unit/Attributes/AttributeValidationTest.php
@@ -0,0 +1,416 @@
+<?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;
+use Utopia\Query\Schema\ColumnType;
+
+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('castingBefore')->willReturnArgument(1);
+        $this->adapter->method('castingAfter')->willReturnArgument(1);
+        $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,
+        ]);
+    }
+
+    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', new Attribute(
+            key: 'name',
+            type: ColumnType::String,
+            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', new Attribute(
+            key: 'title',
+            type: ColumnType::String,
+            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', new Attribute(
+            key: 'bigstr',
+            type: ColumnType::String,
+            size: $tooBig,
+        ));
+    }
+
+    public function testCreateAttributeSucceedsWithValidString(): void
+    {
+        $this->setupCollection('testCol');
+
+        $result = $this->database->createAttribute('testCol', new Attribute(
+            key: 'name',
+            type: ColumnType::String,
+            size: 128,
+        ));
+        $this->assertTrue($result);
+    }
+
+    public function testCreateAttributeSucceedsWithInteger(): void
+    {
+        $this->setupCollection('testCol');
+
+        $result = $this->database->createAttribute('testCol', new Attribute(
+            key: 'age',
+            type: ColumnType::Integer,
+            size: 0,
+        ));
+        $this->assertTrue($result);
+    }
+
+    public function testCreateAttributeSucceedsWithBoolean(): void
+    {
+        $this->setupCollection('testCol');
+
+        $result = $this->database->createAttribute('testCol', new Attribute(
+            key: 'active',
+            type: ColumnType::Boolean,
+            size: 0,
+        ));
+        $this->assertTrue($result);
+    }
+
+    public function testCreateAttributeSucceedsWithDouble(): void
+    {
+        $this->setupCollection('testCol');
+
+        $result = $this->database->createAttribute('testCol', new Attribute(
+            key: 'score',
+            type: ColumnType::Double,
+            size: 0,
+        ));
+        $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('castingBefore')->willReturnArgument(1);
+        $adapter->method('castingAfter')->willReturnArgument(1);
+        $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::COLLECTION);
+                }
+
+                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', new Attribute(
+            key: 'extra',
+            type: ColumnType::String,
+            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('castingBefore')->willReturnArgument(1);
+        $adapter->method('castingAfter')->willReturnArgument(1);
+        $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::COLLECTION);
+                }
+
+                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', new Attribute(
+            key: 'wide',
+            type: ColumnType::String,
+            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', [
+            new Attribute(key: 'name', type: ColumnType::String, 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 000000000..b968a5edd
--- /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 000000000..a4e3b3403
--- /dev/null
+++ b/tests/unit/Authorization/PermissionCheckTest.php
@@ -0,0 +1,898 @@
+<?php
+
+namespace Tests\Unit\Authorization;
+
+use DateTime;
+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 $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('castingBefore')->willReturnCallback(
+            fn (Document $collection, Document $document) => $document
+        );
+        $this->adapter->method('castingAfter')->willReturnCallback(
+            fn (Document $collection, Document $document) => $document
+        );
+        $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();
+    }
+
+    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/Cache/QueryCacheTest.php b/tests/unit/Cache/QueryCacheTest.php
new file mode 100644
index 000000000..bb1828beb
--- /dev/null
+++ b/tests/unit/Cache/QueryCacheTest.php
@@ -0,0 +1,289 @@
+<?php
+
+namespace Tests\Unit\Cache;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Cache\Cache;
+use Utopia\Database\Cache\CacheInvalidator;
+use Utopia\Database\Cache\CacheRegion;
+use Utopia\Database\Cache\QueryCache;
+use Utopia\Database\Document;
+use Utopia\Database\Event;
+use Utopia\Database\Query;
+
+class QueryCacheTest extends TestCase
+{
+    private QueryCache $queryCache;
+
+    private Cache $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 CacheRegion(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->assertInstanceOf(CacheRegion::class, $region);
+        $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);
+        $this->assertStringContainsString('myns', $key);
+        $this->assertStringContainsString('42', $key);
+    }
+
+    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([
+            ['$id' => 'doc1', 'name' => 'Alice'],
+            ['$id' => 'doc2', 'name' => 'Bob'],
+        ]);
+
+        $result = $this->queryCache->get('some-key');
+
+        $this->assertNotNull($result);
+        $this->assertCount(2, $result);
+        $this->assertInstanceOf(Document::class, $result[0]);
+        $this->assertEquals('doc1', $result[0]->getId());
+    }
+
+    public function testGetHandlesDocumentObjectsInCache(): void
+    {
+        $doc = new Document(['$id' => 'doc1', 'name' => 'Alice']);
+        $this->cache->method('load')->willReturn([$doc]);
+
+        $result = $this->queryCache->get('some-key');
+
+        $this->assertNotNull($result);
+        $this->assertCount(1, $result);
+        $this->assertSame($doc, $result[0]);
+    }
+
+    public function testGetReturnsNullForNonArrayData(): void
+    {
+        $this->cache->method('load')->willReturn('not-an-array');
+        $result = $this->queryCache->get('some-key');
+        $this->assertNull($result);
+    }
+
+    public function testSetSerializesDocuments(): void
+    {
+        $cache = $this->createMock(Cache::class);
+        $queryCache = new QueryCache($cache);
+
+        $docs = [
+            new Document(['$id' => 'doc1', 'name' => 'Alice']),
+        ];
+
+        $cache->expects($this->once())
+            ->method('save')
+            ->with(
+                'cache-key',
+                $this->callback(function (array $data) {
+                    return \is_array($data[0]) && $data[0]['$id'] === 'doc1';
+                })
+            );
+
+        $queryCache->set('cache-key', $docs);
+    }
+
+    public function testInvalidateCollectionCallsPurge(): void
+    {
+        $cache = $this->createMock(Cache::class);
+        $queryCache = new QueryCache($cache);
+
+        $cache->expects($this->once())
+            ->method('purge')
+            ->with($this->stringContains('users'));
+
+        $queryCache->invalidateCollection('users');
+    }
+
+    public function testIsEnabledReturnsTrueByDefault(): void
+    {
+        $this->assertTrue($this->queryCache->isEnabled('any'));
+    }
+
+    public function testIsEnabledReturnsFalseWhenRegionDisabled(): void
+    {
+        $this->queryCache->setRegion('users', new CacheRegion(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');
+
+        $queryCache->flush();
+    }
+
+    public function testCacheRegionDefaults(): void
+    {
+        $region = new CacheRegion();
+        $this->assertEquals(3600, $region->ttl);
+        $this->assertTrue($region->enabled);
+    }
+
+    public function testCacheRegionCustomValues(): void
+    {
+        $region = new CacheRegion(ttl: 120, enabled: false);
+        $this->assertEquals(120, $region->ttl);
+        $this->assertFalse($region->enabled);
+    }
+
+    public function testCacheInvalidatorInvalidatesOnDocumentCreate(): void
+    {
+        $cache = $this->createMock(Cache::class);
+        $queryCache = new QueryCache($cache);
+        $invalidator = new CacheInvalidator($queryCache);
+
+        $doc = new Document(['$id' => 'doc1', '$collection' => 'users']);
+
+        $cache->expects($this->once())->method('purge');
+        $invalidator->handle(Event::DocumentCreate, $doc);
+    }
+
+    public function testCacheInvalidatorInvalidatesOnDocumentUpdate(): void
+    {
+        $cache = $this->createMock(Cache::class);
+        $queryCache = new QueryCache($cache);
+        $invalidator = new CacheInvalidator($queryCache);
+
+        $doc = new Document(['$id' => 'doc1', '$collection' => 'posts']);
+
+        $cache->expects($this->once())->method('purge');
+        $invalidator->handle(Event::DocumentUpdate, $doc);
+    }
+
+    public function testCacheInvalidatorInvalidatesOnDocumentDelete(): void
+    {
+        $cache = $this->createMock(Cache::class);
+        $queryCache = new QueryCache($cache);
+        $invalidator = new CacheInvalidator($queryCache);
+
+        $doc = new Document(['$id' => 'doc1', '$collection' => 'users']);
+
+        $cache->expects($this->once())->method('purge');
+        $invalidator->handle(Event::DocumentDelete, $doc);
+    }
+
+    public function testCacheInvalidatorIgnoresNonWriteEvents(): void
+    {
+        $cache = $this->createMock(Cache::class);
+        $queryCache = new QueryCache($cache);
+        $invalidator = new CacheInvalidator($queryCache);
+
+        $doc = new Document(['$id' => 'doc1', '$collection' => 'users']);
+
+        $cache->expects($this->never())->method('purge');
+        $invalidator->handle(Event::DocumentFind, $doc);
+    }
+
+    public function testCacheInvalidatorExtractsCollectionFromDocument(): void
+    {
+        $cache = $this->createMock(Cache::class);
+        $queryCache = new QueryCache($cache);
+        $invalidator = new CacheInvalidator($queryCache);
+
+        $cache->expects($this->once())
+            ->method('purge')
+            ->with($this->stringContains('orders'));
+
+        $doc = new Document(['$id' => 'doc1', '$collection' => 'orders']);
+        $invalidator->handle(Event::DocumentCreate, $doc);
+    }
+
+    public function testCacheInvalidatorHandlesStringData(): void
+    {
+        $cache = $this->createMock(Cache::class);
+        $queryCache = new QueryCache($cache);
+        $invalidator = new CacheInvalidator($queryCache);
+
+        $cache->expects($this->once())
+            ->method('purge')
+            ->with($this->stringContains('products'));
+
+        $invalidator->handle(Event::DocumentCreate, 'products');
+    }
+
+    public function testCacheInvalidatorIgnoresEmptyCollection(): void
+    {
+        $cache = $this->createMock(Cache::class);
+        $queryCache = new QueryCache($cache);
+        $invalidator = new CacheInvalidator($queryCache);
+
+        $doc = new Document(['$id' => 'doc1']);
+
+        $cache->expects($this->never())->method('purge');
+        $invalidator->handle(Event::DocumentCreate, $doc);
+    }
+}
diff --git a/tests/unit/CacheKeyTest.php b/tests/unit/CacheKeyTest.php
index 7e5e41d44..9e4a1c59c 100644
--- a/tests/unit/CacheKeyTest.php
+++ b/tests/unit/CacheKeyTest.php
@@ -6,6 +6,7 @@
 use Utopia\Cache\Adapter\None;
 use Utopia\Cache\Cache;
 use Utopia\Database\Adapter;
+use Utopia\Database\Capability;
 use Utopia\Database\Database;
 
 class CacheKeyTest extends TestCase
@@ -16,7 +17,12 @@ class CacheKeyTest extends TestCase
     private function createDatabase(array $instanceFilters = []): 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');
 
diff --git a/tests/unit/ChangeTest.php b/tests/unit/ChangeTest.php
new file mode 100644
index 000000000..a236f435f
--- /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/CollectionModelTest.php b/tests/unit/CollectionModelTest.php
new file mode 100644
index 000000000..65132dff0
--- /dev/null
+++ b/tests/unit/CollectionModelTest.php
@@ -0,0 +1,247 @@
+<?php
+
+namespace Tests\Unit;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Attribute;
+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\ColumnType;
+use Utopia\Query\Schema\IndexType;
+
+class CollectionModelTest extends TestCase
+{
+    public function testConstructorDefaults(): void
+    {
+        $collection = new Collection();
+
+        $this->assertSame('', $collection->id);
+        $this->assertSame('', $collection->name);
+        $this->assertSame([], $collection->attributes);
+        $this->assertSame([], $collection->indexes);
+        $this->assertSame([], $collection->permissions);
+        $this->assertTrue($collection->documentSecurity);
+    }
+
+    public function testConstructorWithValues(): void
+    {
+        $attr = new Attribute(key: 'title', type: ColumnType::String, size: 128);
+        $idx = new Index(key: 'idx_title', type: IndexType::Key, 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->assertSame('Users', $collection->name);
+        $this->assertCount(1, $collection->attributes);
+        $this->assertCount(1, $collection->indexes);
+        $this->assertCount(1, $collection->permissions);
+        $this->assertFalse($collection->documentSecurity);
+    }
+
+    public function testToDocumentProducesCorrectStructure(): void
+    {
+        $attr = new Attribute(key: 'email', type: ColumnType::String, size: 256, required: true);
+        $idx = new Index(key: 'idx_email', type: IndexType::Unique, 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->toDocument();
+
+        $this->assertInstanceOf(Document::class, $doc);
+        $this->assertSame('accounts', $doc->getId());
+        $this->assertSame('Accounts', $doc->getAttribute('name'));
+        $this->assertTrue($doc->getAttribute('documentSecurity'));
+        $this->assertCount(1, $doc->getAttribute('attributes'));
+        $this->assertCount(1, $doc->getAttribute('indexes'));
+        $this->assertCount(2, $doc->getPermissions());
+    }
+
+    public function testToDocumentUsesIdWhenNameEmpty(): void
+    {
+        $collection = new Collection(id: 'myCol', name: '');
+        $doc = $collection->toDocument();
+
+        $this->assertSame('myCol', $doc->getAttribute('name'));
+    }
+
+    public function testToDocumentPreservesNameWhenSet(): void
+    {
+        $collection = new Collection(id: 'myCol', name: 'My Collection');
+        $doc = $collection->toDocument();
+
+        $this->assertSame('My Collection', $doc->getAttribute('name'));
+    }
+
+    public function testFromDocumentRoundtrip(): void
+    {
+        $attr = new Attribute(key: 'status', type: ColumnType::String, size: 32, required: false, default: 'active');
+        $idx = new Index(key: 'idx_status', type: IndexType::Key, attributes: ['status']);
+
+        $original = new Collection(
+            id: 'projects',
+            name: 'Projects',
+            attributes: [$attr],
+            indexes: [$idx],
+            permissions: [Permission::read(Role::any())],
+            documentSecurity: false,
+        );
+
+        $doc = $original->toDocument();
+        $restored = Collection::fromDocument($doc);
+
+        $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);
+    }
+
+    public function testFromDocumentWithEmptyDocument(): void
+    {
+        $doc = new Document();
+        $collection = Collection::fromDocument($doc);
+
+        $this->assertSame('', $collection->id);
+        $this->assertSame('', $collection->name);
+        $this->assertSame([], $collection->attributes);
+        $this->assertSame([], $collection->indexes);
+        $this->assertSame([], $collection->permissions);
+        $this->assertTrue($collection->documentSecurity);
+    }
+
+    public function testWithMultipleAttributes(): void
+    {
+        $attrs = [
+            new Attribute(key: 'name', type: ColumnType::String, size: 128, required: true),
+            new Attribute(key: 'email', type: ColumnType::String, size: 256, required: true),
+            new Attribute(key: 'age', type: ColumnType::Integer, size: 0, required: false, default: 0),
+            new Attribute(key: 'active', type: ColumnType::Boolean),
+        ];
+
+        $collection = new Collection(id: 'users', attributes: $attrs);
+
+        $doc = $collection->toDocument();
+        $restoredAttrs = $doc->getAttribute('attributes');
+        $this->assertCount(4, $restoredAttrs);
+
+        $restored = Collection::fromDocument($doc);
+        $this->assertCount(4, $restored->attributes);
+        $this->assertSame('name', $restored->attributes[0]->key);
+        $this->assertSame('active', $restored->attributes[3]->key);
+    }
+
+    public function testWithMultipleIndexes(): void
+    {
+        $indexes = [
+            new Index(key: 'idx_name', type: IndexType::Key, attributes: ['name']),
+            new Index(key: 'idx_email', type: IndexType::Unique, attributes: ['email']),
+            new Index(key: 'idx_compound', type: IndexType::Key, attributes: ['name', 'email']),
+        ];
+
+        $collection = new Collection(id: 'users', indexes: $indexes);
+
+        $doc = $collection->toDocument();
+        $this->assertCount(3, $doc->getAttribute('indexes'));
+
+        $restored = Collection::fromDocument($doc);
+        $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);
+        $doc = $collection->toDocument();
+
+        $this->assertCount(4, $doc->getPermissions());
+        $this->assertContains(Permission::read(Role::any()), $doc->getPermissions());
+    }
+
+    public function testDocumentSecurityTrue(): void
+    {
+        $collection = new Collection(id: 'secure', documentSecurity: true);
+        $doc = $collection->toDocument();
+
+        $this->assertTrue($doc->getAttribute('documentSecurity'));
+    }
+
+    public function testDocumentSecurityFalse(): void
+    {
+        $collection = new Collection(id: 'insecure', documentSecurity: false);
+        $doc = $collection->toDocument();
+
+        $this->assertFalse($doc->getAttribute('documentSecurity'));
+    }
+
+    public function testFromDocumentPreservesPermissions(): void
+    {
+        $permissions = [
+            Permission::read(Role::any()),
+            Permission::create(Role::any()),
+        ];
+
+        $doc = new Document([
+            '$id' => 'test',
+            '$permissions' => $permissions,
+            'name' => 'test',
+            'attributes' => [],
+            'indexes' => [],
+            'documentSecurity' => true,
+        ]);
+
+        $collection = Collection::fromDocument($doc);
+        $this->assertCount(2, $collection->permissions);
+    }
+
+    public function testAttributeDocumentsAreProperDocuments(): void
+    {
+        $attr = new Attribute(key: 'title', type: ColumnType::String, size: 64);
+        $collection = new Collection(id: 'articles', attributes: [$attr]);
+
+        $doc = $collection->toDocument();
+        $attrDocs = $doc->getAttribute('attributes');
+
+        $this->assertInstanceOf(Document::class, $attrDocs[0]);
+        $this->assertSame('title', $attrDocs[0]->getAttribute('key'));
+        $this->assertSame('string', $attrDocs[0]->getAttribute('type'));
+    }
+
+    public function testIndexDocumentsAreProperDocuments(): void
+    {
+        $idx = new Index(key: 'idx_test', type: IndexType::Fulltext, attributes: ['body']);
+        $collection = new Collection(id: 'articles', indexes: [$idx]);
+
+        $doc = $collection->toDocument();
+        $idxDocs = $doc->getAttribute('indexes');
+
+        $this->assertInstanceOf(Document::class, $idxDocs[0]);
+        $this->assertSame('idx_test', $idxDocs[0]->getAttribute('key'));
+        $this->assertSame('fulltext', $idxDocs[0]->getAttribute('type'));
+    }
+}
diff --git a/tests/unit/Collections/CollectionValidationTest.php b/tests/unit/Collections/CollectionValidationTest.php
new file mode 100644
index 000000000..4e92a1b15
--- /dev/null
+++ b/tests/unit/Collections/CollectionValidationTest.php
@@ -0,0 +1,446 @@
+<?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\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 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('castingBefore')->willReturnArgument(1);
+        $this->adapter->method('castingAfter')->willReturnArgument(1);
+        $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('existing');
+    }
+
+    public function testCreateCollectionValidatesPermissionsFormat(): void
+    {
+        $this->setupEmptyMetadata();
+        $this->database->enableValidation();
+
+        $this->expectException(DatabaseException::class);
+        $this->database->createCollection('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('castingBefore')->willReturnArgument(1);
+        $adapter->method('castingAfter')->willReturnArgument(1);
+        $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('newCol', [$attr]);
+    }
+
+    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('castingBefore')->willReturnArgument(1);
+        $adapter->method('castingAfter')->willReturnArgument(1);
+        $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('newCol', [$attr], [$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/CustomDocumentTypeTest.php b/tests/unit/CustomDocumentTypeTest.php
new file mode 100644
index 000000000..c080fd0f3
--- /dev/null
+++ b/tests/unit/CustomDocumentTypeTest.php
@@ -0,0 +1,328 @@
+<?php
+
+namespace Tests\Unit;
+
+use DateTime;
+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 $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('castingBefore')->willReturnCallback(
+            fn (Document $collection, Document $document) => $document
+        );
+        $this->adapter->method('castingAfter')->willReturnCallback(
+            fn (Document $collection, Document $document) => $document
+        );
+        $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
+    {
+        $result = $this->database->setDocumentType('users', TestUserDocument::class);
+        $this->assertInstanceOf(Database::class, $result);
+
+        $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);
+        $result = $this->database->clearDocumentType('users');
+        $this->assertInstanceOf(Database::class, $result);
+    }
+
+    public function testClearAllDocumentTypesReturnsSelf(): void
+    {
+        $result = $this->database->clearAllDocumentTypes();
+        $this->assertInstanceOf(Database::class, $result);
+    }
+
+    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->assertInstanceOf(Document::class, $result);
+        $this->assertNotInstanceOf(TestUserDocument::class, $result);
+        $this->assertNotInstanceOf(TestPostDocument::class, $result);
+    }
+}
diff --git a/tests/unit/DocumentAdvancedTest.php b/tests/unit/DocumentAdvancedTest.php
new file mode 100644
index 000000000..bd8d19c67
--- /dev/null
+++ b/tests/unit/DocumentAdvancedTest.php
@@ -0,0 +1,446 @@
+<?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();
+        $this->assertIsArray($copy['children']);
+        $this->assertCount(2, $copy['children']);
+        $this->assertSame('a', $copy['children'][0]['$id']);
+        $this->assertSame('b', $copy['children'][1]['$id']);
+    }
+
+    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',
+        ]);
+
+        $result = $doc->removeAttribute('name');
+
+        $this->assertInstanceOf(Document::class, $result);
+        $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]);
+
+        $result = $doc->removeAttribute('a')->removeAttribute('b');
+
+        $this->assertInstanceOf(Document::class, $result);
+        $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'],
+            ],
+        ]);
+
+        /** @var array<Document> $children */
+        $children = $doc->getAttribute('children');
+        $this->assertCount(2, $children);
+        $this->assertInstanceOf(Document::class, $children[0]);
+        $this->assertInstanceOf(Document::class, $children[1]);
+    }
+
+    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 9a41ab534..619a96d0d 100644
--- a/tests/unit/DocumentTest.php
+++ b/tests/unit/DocumentTest.php
@@ -3,35 +3,24 @@
 namespace Tests\Unit;
 
 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\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();
 
@@ -52,23 +41,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 +75,58 @@ 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_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 +140,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 +172,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 +206,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 +223,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 +247,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 +279,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 +296,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 +327,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 +359,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 +416,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 000000000..f1071a445
--- /dev/null
+++ b/tests/unit/Documents/AggregationErrorTest.php
@@ -0,0 +1,161 @@
+<?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
+{
+    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('castingBefore')->willReturnArgument(1);
+        $adapter->method('castingAfter')->willReturnArgument(1);
+        $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->assertIsArray($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 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 000000000..1ab3f1c64
--- /dev/null
+++ b/tests/unit/Documents/ConflictDetectionTest.php
@@ -0,0 +1,210 @@
+<?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('castingBefore')->willReturnArgument(1);
+        $adapter->method('castingAfter')->willReturnArgument(1);
+        $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;
+    }
+
+    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::COLLECTION);
+                }
+                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 000000000..f614bf0e8
--- /dev/null
+++ b/tests/unit/Documents/CreateDocumentLogicTest.php
@@ -0,0 +1,323 @@
+<?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('castingBefore')->willReturnArgument(1);
+        $this->adapter->method('castingAfter')->willReturnArgument(1);
+        $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());
+    }
+
+    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::COLLECTION);
+                }
+
+                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->assertIsArray($result->getPermissions());
+    }
+}
diff --git a/tests/unit/Documents/FindLogicTest.php b/tests/unit/Documents/FindLogicTest.php
new file mode 100644
index 000000000..69d5e71f4
--- /dev/null
+++ b/tests/unit/Documents/FindLogicTest.php
@@ -0,0 +1,839 @@
+<?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;
+
+#[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,
+            ]);
+        });
+        $this->adapter->method('castingBefore')->willReturnArgument(1);
+        $this->adapter->method('castingAfter')->willReturnArgument(1);
+
+        $cache = new Cache(new None());
+        $this->database = new Database($this->adapter, $cache);
+        $this->database->getAuthorization()->addRole(Role::any()->toString());
+    }
+
+    private function collectionDoc(string $id, array $attributes = [], array $indexes = [], 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,
+            '$collection' => Database::METADATA,
+            '$permissions' => $permissions,
+            'name' => $id,
+            'attributes' => $attributes,
+            'indexes' => $indexes,
+            'documentSecurity' => true,
+        ]);
+    }
+
+    private function setupCollectionLookup(string $id, array $attributes = [], array $indexes = [], array $permissions = []): void
+    {
+        $collection = $this->collectionDoc($id, $attributes, $indexes, $permissions);
+        $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::COLLECTION);
+                }
+
+                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 ($orderAttributes) {
+                    return in_array('$sequence', $orderAttributes);
+                }),
+                $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 ($orderAttributes) {
+                    return in_array('$id', $orderAttributes)
+                        && ! in_array('$sequence', $orderAttributes);
+                }),
+                $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 ($orderAttributes) {
+                    $sequenceCount = array_count_values($orderAttributes)['$sequence'] ?? 0;
+
+                    return $sequenceCount === 1;
+                }),
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->anything()
+            )
+            ->willReturn([]);
+
+        $this->database->find('testCol', [Query::orderAsc('$sequence')]);
+    }
+
+    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 ($queries) {
+                    foreach ($queries as $q) {
+                        if ($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) {
+            $adapter->expects($this->once())
+                ->method('find')
+                ->with(
+                    $this->anything(),
+                    $this->callback(function ($queries) {
+                        foreach ($queries as $q) {
+                            if ($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 ($queries) {
+                    foreach ($queries as $q) {
+                        if ($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 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) {
+            $aggResult = new Document(['cnt' => 10]);
+            $adapter->expects($this->once())
+                ->method('find')
+                ->willReturn([$aggResult]);
+        });
+
+        $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 ($orderAttributes) {
+                    return $orderAttributes[0] === 'name'
+                        && $orderAttributes[1] === 'age'
+                        && in_array('$sequence', $orderAttributes);
+                }),
+                $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'])]);
+    }
+
+    private function buildDbWithCapabilities(array $capabilities, ?callable $adapterSetup = 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('castingBefore')->willReturnArgument(1);
+        $adapter->method('castingAfter')->willReturnArgument(1);
+        $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' => 'status', 'key' => 'status', 'type' => 'string', 'size' => 64, '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();
+            }
+        );
+
+        if ($adapterSetup) {
+            $adapterSetup($adapter);
+        } else {
+            $adapter->method('find')->willReturn([]);
+        }
+
+        $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 000000000..8d50eae6c
--- /dev/null
+++ b/tests/unit/Documents/IncreaseDecreaseTest.php
@@ -0,0 +1,310 @@
+<?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\Helpers\Permission;
+use Utopia\Database\Helpers\Role;
+use Utopia\Query\Schema\ColumnType;
+
+class IncreaseDecreaseTest 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('castingBefore')->willReturnArgument(1);
+        $this->adapter->method('castingAfter')->willReturnArgument(1);
+        $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());
+    }
+
+    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::COLLECTION);
+                }
+                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' => [],
+        ]);
+    }
+
+    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 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 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 000000000..ad6229067
--- /dev/null
+++ b/tests/unit/Documents/SkipPermissionsTest.php
@@ -0,0 +1,173 @@
+<?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('castingBefore')->willReturnArgument(1);
+        $adapter->method('castingAfter')->willReturnArgument(1);
+        $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::COLLECTION);
+                }
+                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::COLLECTION);
+                }
+
+                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 000000000..111743922
--- /dev/null
+++ b/tests/unit/Documents/UpdateDocumentLogicTest.php
@@ -0,0 +1,399 @@
+<?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('castingBefore')->willReturnArgument(1);
+        $adapter->method('castingAfter')->willReturnArgument(1);
+        $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;
+    }
+
+    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::COLLECTION);
+                }
+
+                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/Event/DomainEventTest.php b/tests/unit/Event/DomainEventTest.php
new file mode 100644
index 000000000..67176fdfa
--- /dev/null
+++ b/tests/unit/Event/DomainEventTest.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\CollectionCreated;
+use Utopia\Database\Event\CollectionDeleted;
+use Utopia\Database\Event\DocumentCreated;
+use Utopia\Database\Event\DocumentDeleted;
+use Utopia\Database\Event\DocumentUpdated;
+use Utopia\Database\Event\DomainEvent;
+
+class DomainEventTest extends TestCase
+{
+    public function testDomainEventConstructorWithCollectionAndEvent(): void
+    {
+        $event = new DomainEvent('users', Event::DocumentCreate);
+        $this->assertEquals('users', $event->collection);
+        $this->assertEquals(Event::DocumentCreate, $event->event);
+    }
+
+    public function testDomainEventOccurredAtAutoSetToNow(): void
+    {
+        $before = new \DateTimeImmutable();
+        $event = new DomainEvent('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 DomainEvent('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 DomainEvent('users', Event::DocumentCreate);
+
+        $this->assertInstanceOf(\DateTimeImmutable::class, $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->assertInstanceOf(\DateTimeImmutable::class, $event->occurredAt);
+    }
+
+    public function testDocumentDeletedOccurredAtIsAutoPopulated(): void
+    {
+        $event = new DocumentDeleted('users', 'doc1');
+        $this->assertInstanceOf(\DateTimeImmutable::class, $event->occurredAt);
+    }
+
+    public function testCollectionDeletedOccurredAtIsAutoPopulated(): void
+    {
+        $event = new CollectionDeleted('users');
+        $this->assertInstanceOf(\DateTimeImmutable::class, $event->occurredAt);
+    }
+}
diff --git a/tests/unit/Event/EventDispatcherHookTest.php b/tests/unit/Event/EventDispatcherHookTest.php
new file mode 100644
index 000000000..1a3dee31d
--- /dev/null
+++ b/tests/unit/Event/EventDispatcherHookTest.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\DocumentCreated;
+use Utopia\Database\Event\DocumentDeleted;
+use Utopia\Database\Event\DocumentUpdated;
+use Utopia\Database\Event\EventDispatcherHook;
+
+class EventDispatcherHookTest extends TestCase
+{
+    private EventDispatcherHook $hook;
+
+    protected function setUp(): void
+    {
+        $this->hook = new EventDispatcherHook();
+    }
+
+    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/Format.php b/tests/unit/Format.php
index f4f4a4a0f..ded6c0bfe 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/IDTest.php b/tests/unit/IDTest.php
index 895309756..68b30f5d3 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 000000000..8c73b156c
--- /dev/null
+++ b/tests/unit/IndexModelTest.php
@@ -0,0 +1,193 @@
+<?php
+
+namespace Tests\Unit;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Document;
+use Utopia\Database\Index;
+use Utopia\Query\Schema\IndexType;
+
+class IndexModelTest extends TestCase
+{
+    public function testConstructorDefaults(): void
+    {
+        $index = new Index(key: 'idx_test', type: IndexType::Key);
+
+        $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 = new Index(
+            key: 'idx_compound',
+            type: IndexType::Unique,
+            attributes: ['name', 'email'],
+            lengths: [128, 256],
+            orders: ['ASC', '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(['ASC', 'DESC'], $index->orders);
+        $this->assertSame(3600, $index->ttl);
+    }
+
+    public function testToDocumentProducesCorrectStructure(): void
+    {
+        $index = new Index(
+            key: 'idx_email',
+            type: IndexType::Unique,
+            attributes: ['email'],
+            lengths: [256],
+            orders: ['ASC'],
+            ttl: 1,
+        );
+
+        $doc = $index->toDocument();
+
+        $this->assertInstanceOf(Document::class, $doc);
+        $this->assertSame('idx_email', $doc->getId());
+        $this->assertSame('idx_email', $doc->getAttribute('key'));
+        $this->assertSame('unique', $doc->getAttribute('type'));
+        $this->assertSame(['email'], $doc->getAttribute('attributes'));
+        $this->assertSame([256], $doc->getAttribute('lengths'));
+        $this->assertSame(['ASC'], $doc->getAttribute('orders'));
+        $this->assertSame(1, $doc->getAttribute('ttl'));
+    }
+
+    public function testFromDocumentRoundtrip(): void
+    {
+        $original = new Index(
+            key: 'idx_status_name',
+            type: IndexType::Key,
+            attributes: ['status', 'name'],
+            lengths: [32, 128],
+            orders: ['ASC', '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 = new Index(
+            key: 'idx_ttl',
+            type: IndexType::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 = new Index(
+            key: 'idx_mixed',
+            type: IndexType::Key,
+            attributes: ['a', 'b'],
+            lengths: [128, null],
+            orders: ['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(['ASC', null], $restored->orders);
+    }
+
+    public function testMultipleAttributeIndex(): void
+    {
+        $index = new Index(
+            key: 'idx_multi',
+            type: IndexType::Key,
+            attributes: ['firstName', 'lastName', 'email'],
+            lengths: [64, 64, 256],
+            orders: ['ASC', 'ASC', 'DESC'],
+        );
+
+        $doc = $index->toDocument();
+        $restored = Index::fromDocument($doc);
+
+        $this->assertCount(3, $restored->attributes);
+        $this->assertCount(3, $restored->lengths);
+        $this->assertCount(3, $restored->orders);
+    }
+}
diff --git a/tests/unit/Indexes/IndexValidationTest.php b/tests/unit/Indexes/IndexValidationTest.php
new file mode 100644
index 000000000..64cba262d
--- /dev/null
+++ b/tests/unit/Indexes/IndexValidationTest.php
@@ -0,0 +1,309 @@
+<?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;
+use Utopia\Query\Schema\IndexType;
+
+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('castingBefore')->willReturnArgument(1);
+        $this->adapter->method('castingAfter')->willReturnArgument(1);
+        $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,
+        ]);
+    }
+
+    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', new Index(
+            key: 'idx1',
+            type: IndexType::Key,
+            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('castingBefore')->willReturnArgument(1);
+        $adapter->method('castingAfter')->willReturnArgument(1);
+        $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::COLLECTION);
+                }
+
+                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', new Index(
+            key: 'idx_name',
+            type: IndexType::Key,
+            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', new Index(
+            key: 'idx_name',
+            type: IndexType::Key,
+            attributes: ['name'],
+        ));
+    }
+
+    public function testCreateIndexMissingAttributesThrows(): void
+    {
+        $this->setupCollection('testCol');
+        $this->expectException(DatabaseException::class);
+        $this->expectExceptionMessage('Missing attributes');
+        $this->database->createIndex('testCol', new Index(
+            key: 'idx_empty',
+            type: IndexType::Key,
+            attributes: [],
+        ));
+    }
+
+    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', new Index(
+            key: 'idx_name',
+            type: IndexType::Key,
+            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 000000000..907a14ba4
--- /dev/null
+++ b/tests/unit/Loading/LazyProxyTest.php
@@ -0,0 +1,188 @@
+<?php
+
+namespace Tests\Unit\Loading;
+
+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 $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 000000000..e5e757739
--- /dev/null
+++ b/tests/unit/Loading/NPlusOneDetectorTest.php
@@ -0,0 +1,62 @@
+<?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 = false;
+        $detector = new NPlusOneDetector(3, function () use (&$detected) {
+            $detected = true;
+        });
+
+        $doc = new Document(['$id' => '1', '$collection' => 'users']);
+
+        $detector->handle(Event::DocumentFind, $doc);
+        $detector->handle(Event::DocumentFind, $doc);
+        $this->assertFalse($detected);
+
+        $detector->handle(Event::DocumentFind, $doc);
+        $this->assertTrue($detected);
+    }
+
+    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/Migration/MigrationRunnerTest.php b/tests/unit/Migration/MigrationRunnerTest.php
new file mode 100644
index 000000000..97a9038e1
--- /dev/null
+++ b/tests/unit/Migration/MigrationRunnerTest.php
@@ -0,0 +1,357 @@
+<?php
+
+namespace Tests\Unit\Migration;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Attribute;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Index;
+use Utopia\Database\Migration\Migration;
+use Utopia\Database\Migration\MigrationGenerator;
+use Utopia\Database\Migration\MigrationRunner;
+use Utopia\Database\Migration\MigrationTracker;
+use Utopia\Database\Schema\DiffResult;
+use Utopia\Database\Schema\SchemaChange;
+use Utopia\Database\Schema\SchemaChangeType;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\IndexType;
+
+class MigrationRunnerTest extends TestCase
+{
+    private Database $db;
+
+    protected function setUp(): void
+    {
+        $this->db = self::createStub(Database::class);
+    }
+
+    private function createMigration(string $version, ?callable $up = null, ?callable $down = null): Migration
+    {
+        return new class ($version, $up, $down) extends Migration {
+            private string $ver;
+
+            /** @var callable|null */
+            private $upFn;
+
+            /** @var callable|null */
+            private $downFn;
+
+            public function __construct(string $ver, ?callable $upFn = null, ?callable $downFn = null)
+            {
+                $this->ver = $ver;
+                $this->upFn = $upFn;
+                $this->downFn = $downFn;
+            }
+
+            public function version(): string
+            {
+                return $this->ver;
+            }
+
+            public function up(Database $db): void
+            {
+                if ($this->upFn) {
+                    ($this->upFn)($db);
+                }
+            }
+
+            public function down(Database $db): void
+            {
+                if ($this->downFn) {
+                    ($this->downFn)($db);
+                }
+            }
+        };
+    }
+
+    private function createTrackerMock(array $appliedVersions = [], int $lastBatch = 0, array $batchDocs = []): MigrationTracker
+    {
+        $tracker = self::createStub(MigrationTracker::class);
+        $tracker->method('setup');
+        $tracker->method('getAppliedVersions')->willReturn($appliedVersions);
+        $tracker->method('getLastBatch')->willReturn($lastBatch);
+        $tracker->method('getByBatch')->willReturnCallback(function (int $batch) use ($batchDocs) {
+            return $batchDocs[$batch] ?? [];
+        });
+        $tracker->method('markApplied');
+        $tracker->method('markRolledBack');
+
+        return $tracker;
+    }
+
+    public function testMigrateRunsPendingMigrationsInVersionOrder(): void
+    {
+        $order = [];
+
+        $m1 = $this->createMigration('002', function () use (&$order) {
+            $order[] = '002';
+        });
+        $m2 = $this->createMigration('001', function () use (&$order) {
+            $order[] = '001';
+        });
+
+        $tracker = $this->createTrackerMock();
+        $this->db->method('withTransaction')->willReturnCallback(fn (callable $cb) => $cb());
+
+        $runner = new MigrationRunner($this->db, $tracker);
+        $runner->migrate([$m1, $m2]);
+
+        $this->assertEquals(['001', '002'], $order);
+    }
+
+    public function testMigrateSkipsAlreadyAppliedMigrations(): void
+    {
+        $executed = [];
+
+        $m1 = $this->createMigration('001', function () use (&$executed) {
+            $executed[] = '001';
+        });
+        $m2 = $this->createMigration('002', function () use (&$executed) {
+            $executed[] = '002';
+        });
+
+        $tracker = $this->createTrackerMock(appliedVersions: ['001']);
+        $this->db->method('withTransaction')->willReturnCallback(fn (callable $cb) => $cb());
+
+        $runner = new MigrationRunner($this->db, $tracker);
+        $runner->migrate([$m1, $m2]);
+
+        $this->assertEquals(['002'], $executed);
+    }
+
+    public function testMigrateReturnsCountOfExecutedMigrations(): void
+    {
+        $m1 = $this->createMigration('001');
+        $m2 = $this->createMigration('002');
+
+        $tracker = $this->createTrackerMock();
+        $this->db->method('withTransaction')->willReturnCallback(fn (callable $cb) => $cb());
+
+        $runner = new MigrationRunner($this->db, $tracker);
+        $count = $runner->migrate([$m1, $m2]);
+
+        $this->assertEquals(2, $count);
+    }
+
+    public function testMigrateWithNoPendingReturnsZero(): void
+    {
+        $m1 = $this->createMigration('001');
+
+        $tracker = $this->createTrackerMock(appliedVersions: ['001']);
+
+        $runner = new MigrationRunner($this->db, $tracker);
+        $count = $runner->migrate([$m1]);
+
+        $this->assertEquals(0, $count);
+    }
+
+    public function testRollbackCallsDownInReverseOrder(): void
+    {
+        $order = [];
+
+        $m1 = $this->createMigration('001', null, function () use (&$order) {
+            $order[] = '001';
+        });
+        $m2 = $this->createMigration('002', null, function () use (&$order) {
+            $order[] = '002';
+        });
+
+        $batchDocs = [
+            1 => [
+                new Document(['version' => '002']),
+                new Document(['version' => '001']),
+            ],
+        ];
+
+        $tracker = $this->createTrackerMock(lastBatch: 1, batchDocs: $batchDocs);
+        $this->db->method('withTransaction')->willReturnCallback(fn (callable $cb) => $cb());
+
+        $runner = new MigrationRunner($this->db, $tracker);
+        $runner->rollback([$m1, $m2], 1);
+
+        $this->assertEquals(['002', '001'], $order);
+    }
+
+    public function testRollbackBySteps(): void
+    {
+        $order = [];
+
+        $m1 = $this->createMigration('001', null, function () use (&$order) {
+            $order[] = '001';
+        });
+        $m2 = $this->createMigration('002', null, function () use (&$order) {
+            $order[] = '002';
+        });
+        $m3 = $this->createMigration('003', null, function () use (&$order) {
+            $order[] = '003';
+        });
+
+        $batchDocs = [
+            1 => [new Document(['version' => '001'])],
+            2 => [new Document(['version' => '002']), new Document(['version' => '003'])],
+        ];
+
+        $tracker = $this->createTrackerMock(lastBatch: 2, batchDocs: $batchDocs);
+        $this->db->method('withTransaction')->willReturnCallback(fn (callable $cb) => $cb());
+
+        $runner = new MigrationRunner($this->db, $tracker);
+        $count = $runner->rollback([$m1, $m2, $m3], 1);
+
+        $this->assertEquals(2, $count);
+        $this->assertEquals(['002', '003'], $order);
+    }
+
+    public function testRollbackReturnsCount(): void
+    {
+        $m1 = $this->createMigration('001', null, function () {
+        });
+
+        $batchDocs = [
+            1 => [new Document(['version' => '001'])],
+        ];
+
+        $tracker = $this->createTrackerMock(lastBatch: 1, batchDocs: $batchDocs);
+        $this->db->method('withTransaction')->willReturnCallback(fn (callable $cb) => $cb());
+
+        $runner = new MigrationRunner($this->db, $tracker);
+        $count = $runner->rollback([$m1], 1);
+
+        $this->assertEquals(1, $count);
+    }
+
+    public function testStatusReturnsAllMigrationsWithAppliedFlag(): void
+    {
+        $m1 = $this->createMigration('001');
+        $m2 = $this->createMigration('002');
+
+        $tracker = $this->createTrackerMock(appliedVersions: ['001']);
+
+        $runner = new MigrationRunner($this->db, $tracker);
+        $status = $runner->status([$m1, $m2]);
+
+        $this->assertCount(2, $status);
+        $this->assertTrue($status[0]['applied']);
+        $this->assertFalse($status[1]['applied']);
+    }
+
+    public function testStatusReturnsSortedByVersion(): void
+    {
+        $m1 = $this->createMigration('003');
+        $m2 = $this->createMigration('001');
+
+        $tracker = $this->createTrackerMock();
+
+        $runner = new MigrationRunner($this->db, $tracker);
+        $status = $runner->status([$m1, $m2]);
+
+        $this->assertEquals('001', $status[0]['version']);
+        $this->assertEquals('003', $status[1]['version']);
+    }
+
+    public function testGetTrackerReturnsMigrationTracker(): void
+    {
+        $tracker = $this->createTrackerMock();
+        $runner = new MigrationRunner($this->db, $tracker);
+        $this->assertSame($tracker, $runner->getTracker());
+    }
+
+    public function testMigrationGeneratorGenerateEmptyProducesValidPHP(): void
+    {
+        $generator = new MigrationGenerator();
+        $output = $generator->generateEmpty('V001_CreateUsers');
+
+        $this->assertStringContainsString('class V001_CreateUsers extends Migration', $output);
+        $this->assertStringContainsString("return '001'", $output);
+        $this->assertStringContainsString('public function up(Database $db): void', $output);
+        $this->assertStringContainsString('public function down(Database $db): void', $output);
+    }
+
+    public function testMigrationGeneratorGenerateWithDiffResultIncludesUpDownMethods(): void
+    {
+        $diff = new DiffResult([
+            new SchemaChange(
+                type: SchemaChangeType::AddAttribute,
+                attribute: new Attribute(key: 'email', type: ColumnType::String, size: 255),
+            ),
+        ]);
+
+        $generator = new MigrationGenerator();
+        $output = $generator->generate($diff, 'V002_AddEmail');
+
+        $this->assertStringContainsString('class V002_AddEmail extends Migration', $output);
+        $this->assertStringContainsString("return '002'", $output);
+        $this->assertStringContainsString('email', $output);
+    }
+
+    public function testMigrationGeneratorExtractVersionFromV001Prefix(): void
+    {
+        $generator = new MigrationGenerator();
+        $output = $generator->generateEmpty('V042_SomeChange');
+        $this->assertStringContainsString("return '042'", $output);
+    }
+
+    public function testMigrationGeneratorFallsBackToClassName(): void
+    {
+        $generator = new MigrationGenerator();
+        $output = $generator->generateEmpty('CreateUsersTable');
+        $this->assertStringContainsString("return 'CreateUsersTable'", $output);
+    }
+
+    public function testMigrationAbstractClassNameReturnsClassName(): void
+    {
+        $migration = $this->createMigration('001');
+        $this->assertIsString($migration->name());
+        $this->assertNotEmpty($migration->name());
+    }
+
+    public function testMigrateWithEmptyArrayReturnsZero(): void
+    {
+        $tracker = $this->createTrackerMock();
+        $runner = new MigrationRunner($this->db, $tracker);
+        $count = $runner->migrate([]);
+        $this->assertEquals(0, $count);
+    }
+
+    public function testRollbackWithNoMigrationsInBatch(): void
+    {
+        $tracker = $this->createTrackerMock(lastBatch: 1, batchDocs: [1 => []]);
+        $this->db->method('withTransaction')->willReturnCallback(fn (callable $cb) => $cb());
+
+        $runner = new MigrationRunner($this->db, $tracker);
+        $count = $runner->rollback([], 1);
+        $this->assertEquals(0, $count);
+    }
+
+    public function testMigrationGeneratorGenerateWithDropAttribute(): void
+    {
+        $diff = new DiffResult([
+            new SchemaChange(
+                type: SchemaChangeType::DropAttribute,
+                attribute: new Attribute(key: 'legacy', type: ColumnType::String, size: 100),
+            ),
+        ]);
+
+        $generator = new MigrationGenerator();
+        $output = $generator->generate($diff, 'V003_DropLegacy');
+
+        $this->assertStringContainsString('legacy', $output);
+        $this->assertStringContainsString('deleteAttribute', $output);
+    }
+
+    public function testMigrationGeneratorGenerateWithAddIndex(): void
+    {
+        $diff = new DiffResult([
+            new SchemaChange(
+                type: SchemaChangeType::AddIndex,
+                index: new Index(key: 'idx_email', type: IndexType::Index, attributes: ['email']),
+            ),
+        ]);
+
+        $generator = new MigrationGenerator();
+        $output = $generator->generate($diff, 'V004_AddIndex');
+
+        $this->assertStringContainsString('idx_email', $output);
+        $this->assertStringContainsString('createIndex', $output);
+    }
+}
diff --git a/tests/unit/ORM/EmbeddableTest.php b/tests/unit/ORM/EmbeddableTest.php
new file mode 100644
index 000000000..1556e5b57
--- /dev/null
+++ b/tests/unit/ORM/EmbeddableTest.php
@@ -0,0 +1,149 @@
+<?php
+
+namespace Tests\Unit\ORM;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\ORM\EmbeddableMapping;
+use Utopia\Database\ORM\Mapping\Column;
+use Utopia\Database\ORM\Mapping\Embedded;
+use Utopia\Database\ORM\Mapping\Entity;
+use Utopia\Database\ORM\Mapping\Id;
+use Utopia\Database\ORM\MetadataFactory;
+use Utopia\Query\Schema\ColumnType;
+
+#[Entity(collection: 'embeddable_entities')]
+class EmbeddableEntity
+{
+    #[Id]
+    public string $id = '';
+
+    #[Column(type: ColumnType::String, size: 255)]
+    public string $name = '';
+
+    #[Embedded(type: 'address')]
+    public mixed $address = null;
+}
+
+#[Entity(collection: 'custom_prefix_entities')]
+class CustomPrefixEmbeddableEntity
+{
+    #[Id]
+    public string $id = '';
+
+    #[Embedded(type: 'address', prefix: 'home_')]
+    public mixed $homeAddress = null;
+}
+
+#[Entity(collection: 'multi_embeddable_entities')]
+class MultiEmbeddableEntity
+{
+    #[Id]
+    public string $id = '';
+
+    #[Embedded(type: 'address')]
+    public mixed $billing = null;
+
+    #[Embedded(type: 'address', prefix: 'ship_')]
+    public mixed $shipping = null;
+}
+
+#[Entity(collection: 'no_embeddable_entities')]
+class NoEmbeddableEntity
+{
+    #[Id]
+    public string $id = '';
+
+    #[Column(type: ColumnType::String, size: 255)]
+    public string $title = '';
+}
+
+class EmbeddableTest extends TestCase
+{
+    protected MetadataFactory $factory;
+
+    protected function setUp(): void
+    {
+        MetadataFactory::clearCache();
+        $this->factory = new MetadataFactory();
+    }
+
+    public function testMetadataFactoryParsesEmbeddedAttribute(): void
+    {
+        $metadata = $this->factory->getMetadata(EmbeddableEntity::class);
+
+        $this->assertArrayHasKey('address', $metadata->embeddables);
+    }
+
+    public function testEmbeddableMappingHasCorrectPropertyName(): void
+    {
+        $metadata = $this->factory->getMetadata(EmbeddableEntity::class);
+        $mapping = $metadata->embeddables['address'];
+
+        $this->assertEquals('address', $mapping->propertyName);
+    }
+
+    public function testEmbeddableMappingHasCorrectTypeName(): void
+    {
+        $metadata = $this->factory->getMetadata(EmbeddableEntity::class);
+        $mapping = $metadata->embeddables['address'];
+
+        $this->assertEquals('address', $mapping->typeName);
+    }
+
+    public function testDefaultPrefixIsPropertyNameWithUnderscore(): void
+    {
+        $metadata = $this->factory->getMetadata(EmbeddableEntity::class);
+        $mapping = $metadata->embeddables['address'];
+
+        $this->assertEquals('address_', $mapping->prefix);
+    }
+
+    public function testCustomPrefixOverridesDefault(): void
+    {
+        $metadata = $this->factory->getMetadata(CustomPrefixEmbeddableEntity::class);
+        $mapping = $metadata->embeddables['homeAddress'];
+
+        $this->assertEquals('home_', $mapping->prefix);
+    }
+
+    public function testEntityWithoutEmbeddablesHasEmptyArray(): void
+    {
+        $metadata = $this->factory->getMetadata(NoEmbeddableEntity::class);
+
+        $this->assertEmpty($metadata->embeddables);
+    }
+
+    public function testEmbeddableMappingIsInstanceOfEmbeddableMapping(): void
+    {
+        $metadata = $this->factory->getMetadata(EmbeddableEntity::class);
+        $mapping = $metadata->embeddables['address'];
+
+        $this->assertInstanceOf(EmbeddableMapping::class, $mapping);
+    }
+
+    public function testMultipleEmbeddablesAreParsed(): void
+    {
+        $metadata = $this->factory->getMetadata(MultiEmbeddableEntity::class);
+
+        $this->assertCount(2, $metadata->embeddables);
+        $this->assertArrayHasKey('billing', $metadata->embeddables);
+        $this->assertArrayHasKey('shipping', $metadata->embeddables);
+    }
+
+    public function testMultipleEmbeddablesHaveDistinctPrefixes(): void
+    {
+        $metadata = $this->factory->getMetadata(MultiEmbeddableEntity::class);
+
+        $this->assertEquals('billing_', $metadata->embeddables['billing']->prefix);
+        $this->assertEquals('ship_', $metadata->embeddables['shipping']->prefix);
+    }
+
+    public function testEmbeddableMappingConstructorSetsReadonlyProperties(): void
+    {
+        $mapping = new EmbeddableMapping('myProp', 'myType', 'my_');
+
+        $this->assertEquals('myProp', $mapping->propertyName);
+        $this->assertEquals('myType', $mapping->typeName);
+        $this->assertEquals('my_', $mapping->prefix);
+    }
+}
diff --git a/tests/unit/ORM/EntityManagerTest.php b/tests/unit/ORM/EntityManagerTest.php
new file mode 100644
index 000000000..6a3b87335
--- /dev/null
+++ b/tests/unit/ORM/EntityManagerTest.php
@@ -0,0 +1,646 @@
+<?php
+
+namespace Tests\Unit\ORM;
+
+use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\ORM\EntityManager;
+use Utopia\Database\ORM\EntityMapper;
+use Utopia\Database\ORM\EntityState;
+use Utopia\Database\ORM\IdentityMap;
+use Utopia\Database\ORM\MetadataFactory;
+use Utopia\Database\ORM\UnitOfWork;
+use Utopia\Database\Query;
+
+#[AllowMockObjectsWithoutExpectations]
+class EntityManagerTest extends TestCase
+{
+    private EntityManager $em;
+
+    private Database $db;
+
+    protected function setUp(): void
+    {
+        MetadataFactory::clearCache();
+        $this->db = $this->createMock(Database::class);
+        $this->em = new EntityManager($this->db);
+    }
+
+    public function testPersistDelegatesToUnitOfWork(): void
+    {
+        $entity = new TestEntity();
+        $entity->id = 'persist-1';
+        $entity->name = 'Test';
+        $entity->email = 'test@example.com';
+
+        $this->em->persist($entity);
+
+        $this->assertEquals(EntityState::New, $this->em->getUnitOfWork()->getState($entity));
+    }
+
+    public function testRemoveDelegatesToUnitOfWork(): void
+    {
+        $entity = new TestEntity();
+        $entity->id = 'remove-1';
+        $entity->name = 'Test';
+        $entity->email = 'test@example.com';
+
+        $metadata = $this->em->getMetadataFactory()->getMetadata(TestEntity::class);
+        $this->em->getIdentityMap()->put('users', 'remove-1', $entity);
+        $this->em->getUnitOfWork()->registerManaged($entity, $metadata);
+
+        $this->em->remove($entity);
+
+        $this->assertEquals(EntityState::Removed, $this->em->getUnitOfWork()->getState($entity));
+    }
+
+    public function testFindChecksIdentityMapFirst(): void
+    {
+        $entity = new TestEntity();
+        $entity->id = 'cached-1';
+        $entity->name = 'Cached';
+        $entity->email = 'cached@example.com';
+
+        $this->em->getIdentityMap()->put('users', 'cached-1', $entity);
+
+        $this->db->expects($this->never())
+            ->method('getDocument');
+
+        $result = $this->em->find(TestEntity::class, 'cached-1');
+
+        $this->assertSame($entity, $result);
+    }
+
+    public function testFindFallsBackToDatabase(): void
+    {
+        $doc = new Document([
+            '$id' => 'db-1',
+            '$version' => 1,
+            'name' => 'FromDB',
+            'email' => 'db@example.com',
+            'age' => 30,
+            'active' => true,
+        ]);
+
+        $this->db->expects($this->once())
+            ->method('getDocument')
+            ->with('users', 'db-1')
+            ->willReturn($doc);
+
+        /** @var TestEntity $result */
+        $result = $this->em->find(TestEntity::class, 'db-1');
+
+        $this->assertInstanceOf(TestEntity::class, $result);
+        $this->assertEquals('db-1', $result->id);
+        $this->assertEquals('FromDB', $result->name);
+    }
+
+    public function testFindReturnsNullForEmptyDocument(): void
+    {
+        $this->db->expects($this->once())
+            ->method('getDocument')
+            ->willReturn(new Document());
+
+        $result = $this->em->find(TestEntity::class, 'nonexistent');
+
+        $this->assertNull($result);
+    }
+
+    public function testFindRegistersEntityAsManaged(): void
+    {
+        $doc = new Document([
+            '$id' => 'managed-find-1',
+            'name' => 'Managed',
+            'email' => 'managed@example.com',
+            'age' => 25,
+            'active' => true,
+        ]);
+
+        $this->db->method('getDocument')->willReturn($doc);
+
+        $result = $this->em->find(TestEntity::class, 'managed-find-1');
+
+        $this->assertNotNull($result);
+        $this->assertEquals(EntityState::Managed, $this->em->getUnitOfWork()->getState($result));
+    }
+
+    public function testFindPutsEntityInIdentityMap(): void
+    {
+        $doc = new Document([
+            '$id' => 'identity-1',
+            'name' => 'Identity',
+            'email' => 'identity@example.com',
+            'age' => 20,
+            'active' => true,
+        ]);
+
+        $this->db->method('getDocument')->willReturn($doc);
+
+        $this->em->find(TestEntity::class, 'identity-1');
+
+        $this->assertTrue($this->em->getIdentityMap()->has('users', 'identity-1'));
+    }
+
+    public function testFindReturnsSameInstanceOnSecondCall(): void
+    {
+        $doc = new Document([
+            '$id' => 'repeat-1',
+            'name' => 'Repeat',
+            'email' => 'repeat@example.com',
+            'age' => 20,
+            'active' => true,
+        ]);
+
+        $this->db->expects($this->once())
+            ->method('getDocument')
+            ->willReturn($doc);
+
+        $first = $this->em->find(TestEntity::class, 'repeat-1');
+        $second = $this->em->find(TestEntity::class, 'repeat-1');
+
+        $this->assertSame($first, $second);
+    }
+
+    public function testFindManyHydratesAllDocuments(): void
+    {
+        $docs = [
+            new Document([
+                '$id' => 'many-1',
+                'name' => 'Alice',
+                'email' => 'alice@example.com',
+                'age' => 25,
+                'active' => true,
+            ]),
+            new Document([
+                '$id' => 'many-2',
+                'name' => 'Bob',
+                'email' => 'bob@example.com',
+                'age' => 30,
+                'active' => false,
+            ]),
+        ];
+
+        $this->db->expects($this->once())
+            ->method('find')
+            ->with('users', [])
+            ->willReturn($docs);
+
+        $results = $this->em->findMany(TestEntity::class);
+
+        $this->assertCount(2, $results);
+        $this->assertInstanceOf(TestEntity::class, $results[0]);
+        $this->assertInstanceOf(TestEntity::class, $results[1]);
+        $this->assertEquals('Alice', $results[0]->name);
+        $this->assertEquals('Bob', $results[1]->name);
+    }
+
+    public function testFindManyWithEmptyResults(): void
+    {
+        $this->db->method('find')->willReturn([]);
+
+        $results = $this->em->findMany(TestEntity::class);
+
+        $this->assertEmpty($results);
+    }
+
+    public function testFindManyRegistersAllAsManaged(): void
+    {
+        $docs = [
+            new Document([
+                '$id' => 'managed-many-1',
+                'name' => 'A',
+                'email' => 'a@example.com',
+                'age' => 20,
+                'active' => true,
+            ]),
+            new Document([
+                '$id' => 'managed-many-2',
+                'name' => 'B',
+                'email' => 'b@example.com',
+                'age' => 25,
+                'active' => true,
+            ]),
+        ];
+
+        $this->db->method('find')->willReturn($docs);
+
+        $results = $this->em->findMany(TestEntity::class);
+
+        foreach ($results as $entity) {
+            $this->assertEquals(EntityState::Managed, $this->em->getUnitOfWork()->getState($entity));
+        }
+    }
+
+    public function testFindManyWithQueries(): void
+    {
+        $queries = [Query::equal('active', [true])];
+
+        $this->db->expects($this->once())
+            ->method('find')
+            ->with('users', $queries)
+            ->willReturn([]);
+
+        $this->em->findMany(TestEntity::class, $queries);
+    }
+
+    public function testFindOneAddsLimitAndReturnsFirst(): void
+    {
+        $doc = new Document([
+            '$id' => 'one-1',
+            'name' => 'Only',
+            'email' => 'only@example.com',
+            'age' => 30,
+            'active' => true,
+        ]);
+
+        $this->db->expects($this->once())
+            ->method('find')
+            ->with(
+                'users',
+                $this->callback(function (array $queries) {
+                    $lastQuery = end($queries);
+
+                    return $lastQuery instanceof Query
+                        && $lastQuery->getMethod()->value === 'limit';
+                })
+            )
+            ->willReturn([$doc]);
+
+        /** @var TestEntity $result */
+        $result = $this->em->findOne(TestEntity::class);
+
+        $this->assertInstanceOf(TestEntity::class, $result);
+        $this->assertEquals('Only', $result->name);
+    }
+
+    public function testFindOneReturnsNullWhenNoResults(): void
+    {
+        $this->db->method('find')->willReturn([]);
+
+        $result = $this->em->findOne(TestEntity::class);
+
+        $this->assertNull($result);
+    }
+
+    public function testFindOneWithCustomQueries(): void
+    {
+        $this->db->expects($this->once())
+            ->method('find')
+            ->with(
+                'users',
+                $this->callback(function (array $queries) {
+                    return count($queries) === 2;
+                })
+            )
+            ->willReturn([]);
+
+        $this->em->findOne(TestEntity::class, [Query::equal('name', ['Test'])]);
+    }
+
+    public function testFindOneRegistersAsManaged(): void
+    {
+        $doc = new Document([
+            '$id' => 'managed-one-1',
+            'name' => 'Managed',
+            'email' => 'managed@example.com',
+            'age' => 25,
+            'active' => true,
+        ]);
+
+        $this->db->method('find')->willReturn([$doc]);
+
+        $result = $this->em->findOne(TestEntity::class);
+
+        $this->assertNotNull($result);
+        $this->assertEquals(EntityState::Managed, $this->em->getUnitOfWork()->getState($result));
+    }
+
+    public function testCreateCollectionFromEntityCallsCreateCollection(): void
+    {
+        $this->db->expects($this->once())
+            ->method('createCollection')
+            ->with(
+                $this->equalTo('users'),
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->equalTo(true),
+            )
+            ->willReturn(new Document(['$id' => 'users']));
+
+        $this->db->expects($this->once())
+            ->method('createRelationship')
+            ->with($this->isInstanceOf(\Utopia\Database\Relationship::class));
+
+        $this->em->createCollectionFromEntity(TestEntity::class);
+    }
+
+    public function testCreateCollectionFromEntityReturnsDocument(): void
+    {
+        $returnDoc = new Document(['$id' => 'users']);
+
+        $this->db->method('createCollection')->willReturn($returnDoc);
+        $this->db->method('createRelationship')->willReturn(true);
+
+        $result = $this->em->createCollectionFromEntity(TestEntity::class);
+
+        $this->assertInstanceOf(Document::class, $result);
+        $this->assertEquals('users', $result->getAttribute('$id'));
+    }
+
+    public function testCreateCollectionFromEntityWithNoRelationships(): void
+    {
+        $this->db->expects($this->once())
+            ->method('createCollection')
+            ->willReturn(new Document(['$id' => 'posts']));
+
+        $this->db->expects($this->once())
+            ->method('createRelationship');
+
+        $this->em->createCollectionFromEntity(TestPost::class);
+    }
+
+    public function testDetachDelegatesToUnitOfWork(): void
+    {
+        $entity = new TestEntity();
+        $entity->id = 'detach-1';
+        $entity->name = 'Test';
+        $entity->email = 'test@example.com';
+
+        $this->em->persist($entity);
+        $this->assertEquals(EntityState::New, $this->em->getUnitOfWork()->getState($entity));
+
+        $this->em->detach($entity);
+
+        $this->assertNull($this->em->getUnitOfWork()->getState($entity));
+    }
+
+    public function testClearResetsUnitOfWork(): void
+    {
+        $entity = new TestEntity();
+        $entity->id = 'clear-1';
+        $entity->name = 'Test';
+        $entity->email = 'test@example.com';
+
+        $this->em->persist($entity);
+        $this->em->clear();
+
+        $this->assertNull($this->em->getUnitOfWork()->getState($entity));
+    }
+
+    public function testClearResetsIdentityMap(): void
+    {
+        $entity = new TestEntity();
+        $entity->id = 'clear-map-1';
+        $entity->name = 'Test';
+        $entity->email = 'test@example.com';
+
+        $this->em->getIdentityMap()->put('users', 'clear-map-1', $entity);
+        $this->em->clear();
+
+        $this->assertEmpty(\iterator_to_array($this->em->getIdentityMap()->all()));
+    }
+
+    public function testGetUnitOfWorkReturnsUnitOfWork(): void
+    {
+        $this->assertInstanceOf(UnitOfWork::class, $this->em->getUnitOfWork());
+    }
+
+    public function testGetIdentityMapReturnsIdentityMap(): void
+    {
+        $this->assertInstanceOf(IdentityMap::class, $this->em->getIdentityMap());
+    }
+
+    public function testGetMetadataFactoryReturnsMetadataFactory(): void
+    {
+        $this->assertInstanceOf(MetadataFactory::class, $this->em->getMetadataFactory());
+    }
+
+    public function testGetEntityMapperReturnsEntityMapper(): void
+    {
+        $this->assertInstanceOf(EntityMapper::class, $this->em->getEntityMapper());
+    }
+
+    public function testFlushDelegatesToUnitOfWork(): void
+    {
+        $this->db->expects($this->never())
+            ->method('withTransaction');
+
+        $this->em->flush();
+    }
+
+    public function testFlushWithPendingInsert(): void
+    {
+        $entity = new TestEntity();
+        $entity->id = 'flush-1';
+        $entity->name = 'Flush';
+        $entity->email = 'flush@example.com';
+        $entity->age = 25;
+        $entity->active = true;
+
+        $this->em->persist($entity);
+
+        $createdDoc = new Document([
+            '$id' => 'flush-1',
+            '$version' => 1,
+            '$createdAt' => '2024-01-01 00:00:00',
+            '$updatedAt' => '2024-01-01 00:00:00',
+            'name' => 'Flush',
+            'email' => 'flush@example.com',
+            'age' => 25,
+            'active' => true,
+        ]);
+
+        $this->db->expects($this->once())
+            ->method('withTransaction')
+            ->willReturnCallback(function (callable $callback) {
+                return $callback();
+            });
+
+        $this->db->expects($this->once())
+            ->method('createDocument')
+            ->with('users', $this->isInstanceOf(Document::class))
+            ->willReturn($createdDoc);
+
+        $this->em->flush();
+
+        $this->assertEquals(EntityState::Managed, $this->em->getUnitOfWork()->getState($entity));
+    }
+
+    public function testFlushWithPendingDelete(): void
+    {
+        $entity = new TestEntity();
+        $entity->id = 'flush-del-1';
+        $entity->name = 'Delete';
+        $entity->email = 'delete@example.com';
+        $entity->age = 20;
+        $entity->active = true;
+
+        $metadata = $this->em->getMetadataFactory()->getMetadata(TestEntity::class);
+        $this->em->getIdentityMap()->put('users', 'flush-del-1', $entity);
+        $this->em->getUnitOfWork()->registerManaged($entity, $metadata);
+        $this->em->remove($entity);
+
+        $this->db->expects($this->once())
+            ->method('withTransaction')
+            ->willReturnCallback(function (callable $callback) {
+                return $callback();
+            });
+
+        $this->db->expects($this->once())
+            ->method('deleteDocument')
+            ->with('users', 'flush-del-1');
+
+        $this->em->flush();
+    }
+
+    public function testFlushWithPendingUpdate(): void
+    {
+        $entity = new TestEntity();
+        $entity->id = 'flush-upd-1';
+        $entity->name = 'Before';
+        $entity->email = 'update@example.com';
+        $entity->age = 20;
+        $entity->active = true;
+
+        $metadata = $this->em->getMetadataFactory()->getMetadata(TestEntity::class);
+        $this->em->getIdentityMap()->put('users', 'flush-upd-1', $entity);
+        $this->em->getUnitOfWork()->registerManaged($entity, $metadata);
+
+        $entity->name = 'After';
+
+        $updatedDoc = new Document([
+            '$id' => 'flush-upd-1',
+            '$version' => 2,
+            '$createdAt' => '2024-01-01 00:00:00',
+            '$updatedAt' => '2024-01-02 00:00:00',
+            'name' => 'After',
+            'email' => 'update@example.com',
+            'age' => 20,
+            'active' => true,
+        ]);
+
+        $this->db->expects($this->once())
+            ->method('withTransaction')
+            ->willReturnCallback(function (callable $callback) {
+                return $callback();
+            });
+
+        $this->db->expects($this->once())
+            ->method('updateDocument')
+            ->with('users', 'flush-upd-1', $this->isInstanceOf(Document::class))
+            ->willReturn($updatedDoc);
+
+        $this->em->flush();
+    }
+
+    public function testPersistMultipleEntities(): void
+    {
+        $e1 = new TestEntity();
+        $e1->id = 'multi-1';
+        $e1->name = 'A';
+        $e1->email = 'a@example.com';
+
+        $e2 = new TestEntity();
+        $e2->id = 'multi-2';
+        $e2->name = 'B';
+        $e2->email = 'b@example.com';
+
+        $this->em->persist($e1);
+        $this->em->persist($e2);
+
+        $this->assertEquals(EntityState::New, $this->em->getUnitOfWork()->getState($e1));
+        $this->assertEquals(EntityState::New, $this->em->getUnitOfWork()->getState($e2));
+    }
+
+    public function testRemoveUntrackedEntityDoesNothing(): void
+    {
+        $entity = new TestEntity();
+        $entity->id = 'untracked-1';
+        $entity->name = 'Untracked';
+        $entity->email = 'untracked@example.com';
+
+        $this->em->remove($entity);
+
+        $this->assertNull($this->em->getUnitOfWork()->getState($entity));
+    }
+
+    public function testPersistThenRemoveNewEntity(): void
+    {
+        $entity = new TestEntity();
+        $entity->id = 'pr-1';
+        $entity->name = 'PersistRemove';
+        $entity->email = 'pr@example.com';
+
+        $this->em->persist($entity);
+        $this->em->remove($entity);
+
+        $this->assertNull($this->em->getUnitOfWork()->getState($entity));
+    }
+
+    public function testPersistCascadesToRelationships(): void
+    {
+        $post = new TestPost();
+        $post->id = 'cascade-post-1';
+        $post->title = 'Cascade Post';
+        $post->content = 'Content';
+
+        $user = new TestEntity();
+        $user->id = 'cascade-user-1';
+        $user->name = 'User';
+        $user->email = 'user@example.com';
+        $user->posts = [$post];
+
+        $this->em->persist($user);
+
+        $this->assertEquals(EntityState::New, $this->em->getUnitOfWork()->getState($user));
+        $this->assertEquals(EntityState::New, $this->em->getUnitOfWork()->getState($post));
+    }
+
+    public function testDetachRemovesFromIdentityMap(): void
+    {
+        $entity = new TestEntity();
+        $entity->id = 'detach-map-1';
+        $entity->name = 'DetachMap';
+        $entity->email = 'detachmap@example.com';
+
+        $metadata = $this->em->getMetadataFactory()->getMetadata(TestEntity::class);
+        $this->em->getIdentityMap()->put('users', 'detach-map-1', $entity);
+        $this->em->getUnitOfWork()->registerManaged($entity, $metadata);
+
+        $this->em->detach($entity);
+
+        $this->assertFalse($this->em->getIdentityMap()->has('users', 'detach-map-1'));
+    }
+
+    public function testFindManyPutsEntitiesInIdentityMap(): void
+    {
+        $docs = [
+            new Document([
+                '$id' => 'findmany-map-1',
+                'name' => 'A',
+                'email' => 'a@example.com',
+                'age' => 20,
+                'active' => true,
+            ]),
+        ];
+
+        $this->db->method('find')->willReturn($docs);
+
+        $this->em->findMany(TestEntity::class);
+
+        $this->assertTrue($this->em->getIdentityMap()->has('users', 'findmany-map-1'));
+    }
+
+    public function testConstructorCreatesAllComponents(): void
+    {
+        $em = new EntityManager($this->db);
+
+        $this->assertInstanceOf(UnitOfWork::class, $em->getUnitOfWork());
+        $this->assertInstanceOf(IdentityMap::class, $em->getIdentityMap());
+        $this->assertInstanceOf(MetadataFactory::class, $em->getMetadataFactory());
+        $this->assertInstanceOf(EntityMapper::class, $em->getEntityMapper());
+    }
+}
diff --git a/tests/unit/ORM/EntityMapperAdvancedTest.php b/tests/unit/ORM/EntityMapperAdvancedTest.php
new file mode 100644
index 000000000..f58c43fd4
--- /dev/null
+++ b/tests/unit/ORM/EntityMapperAdvancedTest.php
@@ -0,0 +1,470 @@
+<?php
+
+namespace Tests\Unit\ORM;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Document;
+use Utopia\Database\ORM\EntityMapper;
+use Utopia\Database\ORM\IdentityMap;
+use Utopia\Database\ORM\MetadataFactory;
+use Utopia\Database\RelationType;
+use Utopia\Query\Schema\ColumnType;
+
+class EntityMapperAdvancedTest extends TestCase
+{
+    private EntityMapper $mapper;
+
+    private MetadataFactory $metadataFactory;
+
+    protected function setUp(): void
+    {
+        MetadataFactory::clearCache();
+        $this->metadataFactory = new MetadataFactory();
+        $this->mapper = new EntityMapper($this->metadataFactory);
+    }
+
+    public function testToDocumentWithNullSingleRelationship(): void
+    {
+        $post = new TestPost();
+        $post->id = 'post-null-rel';
+        $post->title = 'No Author';
+        $post->content = 'Content';
+        $post->author = null;
+
+        $metadata = $this->metadataFactory->getMetadata(TestPost::class);
+        $doc = $this->mapper->toDocument($post, $metadata);
+
+        $this->assertNull($doc->getAttribute('author'));
+    }
+
+    public function testToDocumentWithNullArrayRelationship(): void
+    {
+        $entity = new TestEntity();
+        $entity->id = 'user-null-posts';
+        $entity->name = 'No Posts';
+        $entity->email = 'noposts@example.com';
+        $entity->age = 20;
+        $entity->active = true;
+        $entity->posts = [];
+
+        $metadata = $this->metadataFactory->getMetadata(TestEntity::class);
+        $doc = $this->mapper->toDocument($entity, $metadata);
+
+        $this->assertEquals([], $doc->getAttribute('posts'));
+    }
+
+    public function testToDocumentWithNestedEntityObjectsInRelationships(): void
+    {
+        $post = new TestPost();
+        $post->id = 'nested-post-1';
+        $post->title = 'Nested';
+        $post->content = 'Content';
+
+        $entity = new TestEntity();
+        $entity->id = 'user-nested';
+        $entity->name = 'With Posts';
+        $entity->email = 'nested@example.com';
+        $entity->age = 30;
+        $entity->active = true;
+        $entity->posts = [$post];
+
+        $metadata = $this->metadataFactory->getMetadata(TestEntity::class);
+        $doc = $this->mapper->toDocument($entity, $metadata);
+
+        $posts = $doc->getAttribute('posts');
+        $this->assertCount(1, $posts);
+        $this->assertInstanceOf(Document::class, $posts[0]);
+        $this->assertEquals('nested-post-1', $posts[0]->getAttribute('$id'));
+        $this->assertEquals('Nested', $posts[0]->getAttribute('title'));
+    }
+
+    public function testToDocumentWithStringIdsInRelationships(): void
+    {
+        $entity = new TestEntity();
+        $entity->id = 'user-string-rels';
+        $entity->name = 'String Rels';
+        $entity->email = 'stringrels@example.com';
+        $entity->age = 25;
+        $entity->active = true;
+        $entity->posts = ['post-id-1', 'post-id-2'];
+
+        $metadata = $this->metadataFactory->getMetadata(TestEntity::class);
+        $doc = $this->mapper->toDocument($entity, $metadata);
+
+        $posts = $doc->getAttribute('posts');
+        $this->assertEquals(['post-id-1', 'post-id-2'], $posts);
+    }
+
+    public function testToDocumentWithSingleObjectRelationship(): void
+    {
+        $author = new TestEntity();
+        $author->id = 'author-obj-1';
+        $author->name = 'Author';
+        $author->email = 'author@example.com';
+        $author->age = 40;
+        $author->active = true;
+
+        $post = new TestPost();
+        $post->id = 'post-obj-rel';
+        $post->title = 'Post';
+        $post->content = 'Content';
+        $post->author = $author;
+
+        $metadata = $this->metadataFactory->getMetadata(TestPost::class);
+        $doc = $this->mapper->toDocument($post, $metadata);
+
+        $authorDoc = $doc->getAttribute('author');
+        $this->assertInstanceOf(Document::class, $authorDoc);
+        $this->assertEquals('author-obj-1', $authorDoc->getAttribute('$id'));
+    }
+
+    public function testToEntityWithNestedDocumentRelationships(): void
+    {
+        $postDoc = new Document([
+            '$id' => 'nested-doc-post',
+            'title' => 'Nested Post',
+            'content' => 'Content',
+        ]);
+
+        $userDoc = new Document([
+            '$id' => 'nested-doc-user',
+            'name' => 'User',
+            'email' => 'user@example.com',
+            'age' => 25,
+            'active' => true,
+            'posts' => [$postDoc],
+        ]);
+
+        $metadata = $this->metadataFactory->getMetadata(TestEntity::class);
+        $identityMap = new IdentityMap();
+
+        /** @var TestEntity $entity */
+        $entity = $this->mapper->toEntity($userDoc, $metadata, $identityMap);
+
+        $this->assertCount(1, $entity->posts);
+        $this->assertInstanceOf(TestPost::class, $entity->posts[0]);
+        $this->assertEquals('nested-doc-post', $entity->posts[0]->id);
+        $this->assertEquals('Nested Post', $entity->posts[0]->title);
+    }
+
+    public function testToEntityWithEmptyRelationshipArrays(): void
+    {
+        $doc = new Document([
+            '$id' => 'empty-rels',
+            'name' => 'NoRels',
+            'email' => 'norels@example.com',
+            'age' => 20,
+            'active' => true,
+            'posts' => null,
+        ]);
+
+        $metadata = $this->metadataFactory->getMetadata(TestEntity::class);
+        $identityMap = new IdentityMap();
+
+        /** @var TestEntity $entity */
+        $entity = $this->mapper->toEntity($doc, $metadata, $identityMap);
+
+        $this->assertEquals([], $entity->posts);
+    }
+
+    public function testToEntityHandlesMixedArray(): void
+    {
+        $postDoc = new Document([
+            '$id' => 'mixed-post-1',
+            'title' => 'Mixed',
+            'content' => 'Content',
+        ]);
+
+        $doc = new Document([
+            '$id' => 'mixed-user',
+            'name' => 'Mixed',
+            'email' => 'mixed@example.com',
+            'age' => 25,
+            'active' => true,
+            'posts' => [$postDoc, 'string-id-1'],
+        ]);
+
+        $metadata = $this->metadataFactory->getMetadata(TestEntity::class);
+        $identityMap = new IdentityMap();
+
+        /** @var TestEntity $entity */
+        $entity = $this->mapper->toEntity($doc, $metadata, $identityMap);
+
+        $this->assertCount(2, $entity->posts);
+        $this->assertInstanceOf(TestPost::class, $entity->posts[0]);
+        $this->assertEquals('string-id-1', $entity->posts[1]);
+    }
+
+    public function testToEntityWithUninitializedPropertiesDoesNotCrash(): void
+    {
+        $doc = new Document([
+            '$id' => 'uninit-1',
+            'name' => 'Uninit',
+            'email' => 'uninit@example.com',
+            'age' => 20,
+            'active' => true,
+        ]);
+
+        $metadata = $this->metadataFactory->getMetadata(TestEntity::class);
+        $identityMap = new IdentityMap();
+
+        $entity = $this->mapper->toEntity($doc, $metadata, $identityMap);
+
+        $this->assertInstanceOf(TestEntity::class, $entity);
+    }
+
+    public function testTakeSnapshotStoresRelationshipIdsNotFullObjects(): void
+    {
+        $post = new TestPost();
+        $post->id = 'snap-post-1';
+        $post->title = 'Snap Post';
+        $post->content = 'Content';
+
+        $entity = new TestEntity();
+        $entity->id = 'snap-user-1';
+        $entity->name = 'Snap User';
+        $entity->email = 'snap@example.com';
+        $entity->age = 30;
+        $entity->active = true;
+        $entity->posts = [$post];
+
+        $metadata = $this->metadataFactory->getMetadata(TestEntity::class);
+        $snapshot = $this->mapper->takeSnapshot($entity, $metadata);
+
+        $this->assertEquals(['snap-post-1'], $snapshot['posts']);
+    }
+
+    public function testTakeSnapshotWithEmptyRelationships(): void
+    {
+        $entity = new TestEntity();
+        $entity->id = 'snap-empty-1';
+        $entity->name = 'Snap Empty';
+        $entity->email = 'snapempty@example.com';
+        $entity->age = 20;
+        $entity->active = true;
+        $entity->posts = [];
+
+        $metadata = $this->metadataFactory->getMetadata(TestEntity::class);
+        $snapshot = $this->mapper->takeSnapshot($entity, $metadata);
+
+        $this->assertEquals([], $snapshot['posts']);
+    }
+
+    public function testTakeSnapshotWithSingleObjectRelationship(): void
+    {
+        $author = new TestEntity();
+        $author->id = 'snap-author-1';
+        $author->name = 'Author';
+        $author->email = 'author@example.com';
+        $author->age = 40;
+        $author->active = true;
+
+        $post = new TestPost();
+        $post->id = 'snap-post-obj';
+        $post->title = 'Title';
+        $post->content = 'Content';
+        $post->author = $author;
+
+        $metadata = $this->metadataFactory->getMetadata(TestPost::class);
+        $snapshot = $this->mapper->takeSnapshot($post, $metadata);
+
+        $this->assertEquals('snap-author-1', $snapshot['author']);
+    }
+
+    public function testTakeSnapshotWithStringRelationship(): void
+    {
+        $post = new TestPost();
+        $post->id = 'snap-str-1';
+        $post->title = 'String Rel';
+        $post->content = 'Content';
+        $post->author = 'author-id-string';
+
+        $metadata = $this->metadataFactory->getMetadata(TestPost::class);
+        $snapshot = $this->mapper->takeSnapshot($post, $metadata);
+
+        $this->assertEquals('author-id-string', $snapshot['author']);
+    }
+
+    public function testToCollectionDefinitionsGeneratesCorrectRelationshipTypes(): void
+    {
+        $metadata = $this->metadataFactory->getMetadata(TestAllRelationsEntity::class);
+        $defs = $this->mapper->toCollectionDefinitions($metadata);
+
+        $relationships = $defs['relationships'];
+
+        $this->assertCount(4, $relationships);
+
+        $types = array_map(fn ($r) => $r->type, $relationships);
+        $this->assertContains(RelationType::OneToOne, $types);
+        $this->assertContains(RelationType::ManyToOne, $types);
+        $this->assertContains(RelationType::OneToMany, $types);
+        $this->assertContains(RelationType::ManyToMany, $types);
+    }
+
+    public function testToCollectionDefinitionsGeneratesCorrectAttributes(): void
+    {
+        $metadata = $this->metadataFactory->getMetadata(TestEntity::class);
+        $defs = $this->mapper->toCollectionDefinitions($metadata);
+
+        $collection = $defs['collection'];
+        $attrs = $collection->attributes;
+
+        $this->assertCount(4, $attrs);
+
+        $nameAttr = $attrs[0];
+        $this->assertEquals('name', $nameAttr->key);
+        $this->assertEquals(ColumnType::String, $nameAttr->type);
+        $this->assertEquals(255, $nameAttr->size);
+        $this->assertTrue($nameAttr->required);
+
+        $emailAttr = $attrs[1];
+        $this->assertEquals('email', $emailAttr->key);
+        $this->assertEquals(ColumnType::String, $emailAttr->type);
+
+        $ageAttr = $attrs[2];
+        $this->assertEquals('age', $ageAttr->key);
+        $this->assertEquals(ColumnType::Integer, $ageAttr->type);
+
+        $activeAttr = $attrs[3];
+        $this->assertEquals('active', $activeAttr->key);
+        $this->assertEquals(ColumnType::Boolean, $activeAttr->type);
+    }
+
+    public function testToCollectionDefinitionsWithCustomKeyColumn(): void
+    {
+        $metadata = $this->metadataFactory->getMetadata(TestCustomKeyEntity::class);
+        $defs = $this->mapper->toCollectionDefinitions($metadata);
+
+        $attrs = $defs['collection']->attributes;
+        $this->assertCount(1, $attrs);
+        $this->assertEquals('display_name', $attrs[0]->key);
+    }
+
+    public function testToCollectionDefinitionsRelationshipKeys(): void
+    {
+        $metadata = $this->metadataFactory->getMetadata(TestEntity::class);
+        $defs = $this->mapper->toCollectionDefinitions($metadata);
+
+        $relationships = $defs['relationships'];
+        $this->assertCount(1, $relationships);
+        $this->assertEquals('users', $relationships[0]->collection);
+        $this->assertEquals('posts', $relationships[0]->relatedCollection);
+        $this->assertEquals('posts', $relationships[0]->key);
+        $this->assertEquals('author', $relationships[0]->twoWayKey);
+        $this->assertTrue($relationships[0]->twoWay);
+    }
+
+    public function testRoundTripEntityDocumentEntity(): void
+    {
+        $entity = new TestEntity();
+        $entity->id = 'round-trip-1';
+        $entity->name = 'RoundTrip';
+        $entity->email = 'roundtrip@example.com';
+        $entity->age = 42;
+        $entity->active = false;
+        $entity->version = 3;
+        $entity->permissions = ['read("any")'];
+
+        $metadata = $this->metadataFactory->getMetadata(TestEntity::class);
+        $doc = $this->mapper->toDocument($entity, $metadata);
+
+        $identityMap = new IdentityMap();
+        /** @var TestEntity $restored */
+        $restored = $this->mapper->toEntity($doc, $metadata, $identityMap);
+
+        $this->assertEquals($entity->id, $restored->id);
+        $this->assertEquals($entity->name, $restored->name);
+        $this->assertEquals($entity->email, $restored->email);
+        $this->assertEquals($entity->age, $restored->age);
+        $this->assertEquals($entity->active, $restored->active);
+        $this->assertEquals($entity->version, $restored->version);
+        $this->assertEquals($entity->permissions, $restored->permissions);
+    }
+
+    public function testToEntityWithSingleDocumentRelationship(): void
+    {
+        $authorDoc = new Document([
+            '$id' => 'author-doc-1',
+            'name' => 'Author',
+            'email' => 'author@example.com',
+            'age' => 35,
+            'active' => true,
+        ]);
+
+        $postDoc = new Document([
+            '$id' => 'post-with-author',
+            'title' => 'Post',
+            'content' => 'Content',
+            'author' => $authorDoc,
+        ]);
+
+        $metadata = $this->metadataFactory->getMetadata(TestPost::class);
+        $identityMap = new IdentityMap();
+
+        /** @var TestPost $post */
+        $post = $this->mapper->toEntity($postDoc, $metadata, $identityMap);
+
+        $this->assertInstanceOf(TestEntity::class, $post->author);
+        $this->assertEquals('author-doc-1', $post->author->id);
+    }
+
+    public function testToEntityWithStringRelationshipValue(): void
+    {
+        $postDoc = new Document([
+            '$id' => 'post-string-author',
+            'title' => 'Post',
+            'content' => 'Content',
+            'author' => 'author-string-id',
+        ]);
+
+        $metadata = $this->metadataFactory->getMetadata(TestPost::class);
+        $identityMap = new IdentityMap();
+
+        /** @var TestPost $post */
+        $post = $this->mapper->toEntity($postDoc, $metadata, $identityMap);
+
+        $this->assertEquals('author-string-id', $post->author);
+    }
+
+    public function testToEntityWithNullRelationshipSetsDefault(): void
+    {
+        $postDoc = new Document([
+            '$id' => 'post-null-author',
+            'title' => 'Post',
+            'content' => 'Content',
+            'author' => null,
+        ]);
+
+        $metadata = $this->metadataFactory->getMetadata(TestPost::class);
+        $identityMap = new IdentityMap();
+
+        /** @var TestPost $post */
+        $post = $this->mapper->toEntity($postDoc, $metadata, $identityMap);
+
+        $this->assertNull($post->author);
+    }
+
+    public function testToDocumentIncludesTenantProperty(): void
+    {
+        $entity = new TestTenantEntity();
+        $entity->id = 'tenant-1';
+        $entity->tenantId = 'org-123';
+        $entity->name = 'Tenant Item';
+
+        $metadata = $this->metadataFactory->getMetadata(TestTenantEntity::class);
+        $doc = $this->mapper->toDocument($entity, $metadata);
+
+        $this->assertEquals('org-123', $doc->getAttribute('$tenant'));
+    }
+
+    public function testGetIdReturnsNullWhenNoIdProperty(): void
+    {
+        $entity = new TestEntity();
+        $entity->id = 'test-id';
+
+        $metadata = $this->metadataFactory->getMetadata(TestEntity::class);
+        $result = $this->mapper->getId($entity, $metadata);
+
+        $this->assertEquals('test-id', $result);
+    }
+}
diff --git a/tests/unit/ORM/EntityMapperTest.php b/tests/unit/ORM/EntityMapperTest.php
new file mode 100644
index 000000000..6dce7f109
--- /dev/null
+++ b/tests/unit/ORM/EntityMapperTest.php
@@ -0,0 +1,199 @@
+<?php
+
+namespace Tests\Unit\ORM;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Document;
+use Utopia\Database\ORM\EntityMapper;
+use Utopia\Database\ORM\IdentityMap;
+use Utopia\Database\ORM\MetadataFactory;
+use Utopia\Query\Schema\ColumnType;
+
+class EntityMapperTest extends TestCase
+{
+    private EntityMapper $mapper;
+
+    private MetadataFactory $metadataFactory;
+
+    protected function setUp(): void
+    {
+        MetadataFactory::clearCache();
+        $this->metadataFactory = new MetadataFactory();
+        $this->mapper = new EntityMapper($this->metadataFactory);
+    }
+
+    public function testToDocument(): void
+    {
+        $entity = new TestEntity();
+        $entity->id = 'user-123';
+        $entity->name = 'John';
+        $entity->email = 'john@example.com';
+        $entity->age = 30;
+        $entity->active = true;
+        $entity->version = 1;
+        $entity->permissions = ['read("any")'];
+
+        $metadata = $this->metadataFactory->getMetadata(TestEntity::class);
+        $doc = $this->mapper->toDocument($entity, $metadata);
+
+        $this->assertEquals('user-123', $doc->getAttribute('$id'));
+        $this->assertEquals('John', $doc->getAttribute('name'));
+        $this->assertEquals('john@example.com', $doc->getAttribute('email'));
+        $this->assertEquals(30, $doc->getAttribute('age'));
+        $this->assertTrue($doc->getAttribute('active'));
+        $this->assertEquals(1, $doc->getAttribute('$version'));
+        $this->assertEquals(['read("any")'], $doc->getAttribute('$permissions'));
+    }
+
+    public function testToEntity(): void
+    {
+        $doc = new Document([
+            '$id' => 'user-456',
+            '$version' => 2,
+            '$createdAt' => '2024-01-01 00:00:00',
+            '$updatedAt' => '2024-01-02 00:00:00',
+            '$permissions' => ['read("any")'],
+            'name' => 'Jane',
+            'email' => 'jane@example.com',
+            'age' => 25,
+            'active' => false,
+        ]);
+
+        $metadata = $this->metadataFactory->getMetadata(TestEntity::class);
+        $identityMap = new IdentityMap();
+
+        /** @var TestEntity $entity */
+        $entity = $this->mapper->toEntity($doc, $metadata, $identityMap);
+
+        $this->assertInstanceOf(TestEntity::class, $entity);
+        $this->assertEquals('user-456', $entity->id);
+        $this->assertEquals(2, $entity->version);
+        $this->assertEquals('2024-01-01 00:00:00', $entity->createdAt);
+        $this->assertEquals('2024-01-02 00:00:00', $entity->updatedAt);
+        $this->assertEquals(['read("any")'], $entity->permissions);
+        $this->assertEquals('Jane', $entity->name);
+        $this->assertEquals('jane@example.com', $entity->email);
+        $this->assertEquals(25, $entity->age);
+        $this->assertFalse($entity->active);
+    }
+
+    public function testToEntityUsesIdentityMap(): void
+    {
+        $doc = new Document([
+            '$id' => 'user-789',
+            'name' => 'Alice',
+            'email' => 'alice@example.com',
+            'age' => 28,
+            'active' => true,
+        ]);
+
+        $metadata = $this->metadataFactory->getMetadata(TestEntity::class);
+        $identityMap = new IdentityMap();
+
+        $entity1 = $this->mapper->toEntity($doc, $metadata, $identityMap);
+        $entity2 = $this->mapper->toEntity($doc, $metadata, $identityMap);
+
+        $this->assertSame($entity1, $entity2);
+    }
+
+    public function testTakeSnapshot(): void
+    {
+        $entity = new TestEntity();
+        $entity->id = 'snap-1';
+        $entity->name = 'Bob';
+        $entity->email = 'bob@example.com';
+        $entity->age = 35;
+        $entity->active = true;
+
+        $metadata = $this->metadataFactory->getMetadata(TestEntity::class);
+        $snapshot = $this->mapper->takeSnapshot($entity, $metadata);
+
+        $this->assertEquals('snap-1', $snapshot['$id']);
+        $this->assertEquals('Bob', $snapshot['name']);
+        $this->assertEquals('bob@example.com', $snapshot['email']);
+        $this->assertEquals(35, $snapshot['age']);
+        $this->assertTrue($snapshot['active']);
+    }
+
+    public function testSnapshotChangesDetected(): void
+    {
+        $entity = new TestEntity();
+        $entity->id = 'snap-2';
+        $entity->name = 'Before';
+        $entity->email = 'before@example.com';
+        $entity->age = 20;
+        $entity->active = true;
+
+        $metadata = $this->metadataFactory->getMetadata(TestEntity::class);
+        $snapshot1 = $this->mapper->takeSnapshot($entity, $metadata);
+
+        $entity->name = 'After';
+        $snapshot2 = $this->mapper->takeSnapshot($entity, $metadata);
+
+        $this->assertNotEquals($snapshot1, $snapshot2);
+        $this->assertEquals('Before', $snapshot1['name']);
+        $this->assertEquals('After', $snapshot2['name']);
+    }
+
+    public function testGetId(): void
+    {
+        $entity = new TestEntity();
+        $entity->id = 'id-test';
+
+        $metadata = $this->metadataFactory->getMetadata(TestEntity::class);
+        $this->assertEquals('id-test', $this->mapper->getId($entity, $metadata));
+    }
+
+    public function testToCollectionDefinitions(): void
+    {
+        $metadata = $this->metadataFactory->getMetadata(TestEntity::class);
+        $defs = $this->mapper->toCollectionDefinitions($metadata);
+
+        $collection = $defs['collection'];
+        $relationships = $defs['relationships'];
+
+        $this->assertEquals('users', $collection->id);
+        $this->assertTrue($collection->documentSecurity);
+        $this->assertCount(4, $collection->attributes);
+        $this->assertCount(2, $collection->indexes);
+
+        $attrKeys = array_map(fn ($a) => $a->key, $collection->attributes);
+        $this->assertContains('name', $attrKeys);
+        $this->assertContains('email', $attrKeys);
+        $this->assertContains('age', $attrKeys);
+        $this->assertContains('active', $attrKeys);
+
+        $nameAttr = $collection->attributes[0];
+        $this->assertEquals(ColumnType::String, $nameAttr->type);
+        $this->assertEquals(255, $nameAttr->size);
+        $this->assertTrue($nameAttr->required);
+
+        $this->assertCount(1, $relationships);
+        $this->assertEquals('users', $relationships[0]->collection);
+        $this->assertEquals('posts', $relationships[0]->relatedCollection);
+    }
+
+    public function testApplyDocumentToEntity(): void
+    {
+        $entity = new TestEntity();
+        $entity->id = '';
+        $entity->version = null;
+        $entity->createdAt = null;
+        $entity->updatedAt = null;
+
+        $doc = new Document([
+            '$id' => 'generated-id',
+            '$version' => 1,
+            '$createdAt' => '2024-06-01 12:00:00',
+            '$updatedAt' => '2024-06-01 12:00:00',
+        ]);
+
+        $metadata = $this->metadataFactory->getMetadata(TestEntity::class);
+        $this->mapper->applyDocumentToEntity($doc, $entity, $metadata);
+
+        $this->assertEquals('generated-id', $entity->id);
+        $this->assertEquals(1, $entity->version);
+        $this->assertEquals('2024-06-01 12:00:00', $entity->createdAt);
+        $this->assertEquals('2024-06-01 12:00:00', $entity->updatedAt);
+    }
+}
diff --git a/tests/unit/ORM/EntitySchemasSyncTest.php b/tests/unit/ORM/EntitySchemasSyncTest.php
new file mode 100644
index 000000000..0e268d8fb
--- /dev/null
+++ b/tests/unit/ORM/EntitySchemasSyncTest.php
@@ -0,0 +1,324 @@
+<?php
+
+namespace Tests\Unit\ORM;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Adapter;
+use Utopia\Database\Attribute;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\ORM\EntityManager;
+use Utopia\Database\ORM\MetadataFactory;
+use Utopia\Query\Schema\ColumnType;
+
+class EntitySchemasSyncTest extends TestCase
+{
+    protected Database $db;
+
+    protected Adapter $adapter;
+
+    protected EntityManager $em;
+
+    protected function setUp(): void
+    {
+        MetadataFactory::clearCache();
+        $this->db = $this->createMock(Database::class);
+        $this->adapter = self::createStub(Adapter::class);
+        $this->adapter->method('getDatabase')->willReturn('test_db');
+        $this->db->method('getAdapter')->willReturn($this->adapter);
+        $this->em = new EntityManager($this->db);
+    }
+
+    public function testSyncCreatesCollectionWhenItDoesNotExist(): void
+    {
+        $this->db->expects($this->once())
+            ->method('exists')
+            ->with('test_db', 'users')
+            ->willReturn(false);
+
+        $this->db->expects($this->once())
+            ->method('createCollection')
+            ->with(
+                $this->equalTo('users'),
+                $this->anything(),
+                $this->anything(),
+                $this->anything(),
+                $this->equalTo(true),
+            )
+            ->willReturn(new Document(['$id' => 'users']));
+
+        $this->db->expects($this->once())
+            ->method('createRelationship');
+
+        $this->em->syncCollectionFromEntity(TestEntity::class);
+    }
+
+    public function testSyncDiffsAndAppliesChangesWhenCollectionExists(): void
+    {
+        $this->db->expects($this->once())
+            ->method('exists')
+            ->with('test_db', 'users')
+            ->willReturn(true);
+
+        $existingAttrDoc = new Document([
+            'key' => 'name',
+            'type' => ColumnType::String->value,
+            'size' => 255,
+            'required' => true,
+            'default' => null,
+            'signed' => true,
+            'array' => false,
+            'format' => null,
+            'formatOptions' => [],
+            'filters' => [],
+        ]);
+
+        $collectionDoc = new Document([
+            '$id' => 'users',
+            'name' => 'users',
+            'attributes' => [$existingAttrDoc],
+            'indexes' => [],
+            '$permissions' => [],
+            'documentSecurity' => true,
+        ]);
+
+        $this->db->expects($this->once())
+            ->method('getCollection')
+            ->with('users')
+            ->willReturn($collectionDoc);
+
+        $this->db->expects($this->never())
+            ->method('createCollection');
+
+        $this->db->expects($this->atLeastOnce())
+            ->method('createAttribute');
+
+        $this->em->syncCollectionFromEntity(TestEntity::class);
+    }
+
+    public function testSyncIsNoOpWhenNoChangesNeeded(): void
+    {
+        $this->db->expects($this->once())
+            ->method('exists')
+            ->with('test_db', 'users')
+            ->willReturn(true);
+
+        $metadata = $this->em->getMetadataFactory()->getMetadata(TestEntity::class);
+        $defs = $this->em->getEntityMapper()->toCollectionDefinitions($metadata);
+
+        /** @var \Utopia\Database\Collection $desired */
+        $desired = $defs['collection'];
+
+        $attrDocs = array_map(fn (Attribute $a) => $a->toDocument(), $desired->attributes);
+        $indexDocs = array_map(fn (\Utopia\Database\Index $i) => $i->toDocument(), $desired->indexes);
+
+        $collectionDoc = new Document([
+            '$id' => 'users',
+            'name' => 'users',
+            'attributes' => $attrDocs,
+            'indexes' => $indexDocs,
+            '$permissions' => [],
+            'documentSecurity' => true,
+        ]);
+
+        $this->db->expects($this->once())
+            ->method('getCollection')
+            ->with('users')
+            ->willReturn($collectionDoc);
+
+        $this->db->expects($this->never())
+            ->method('createCollection');
+
+        $this->db->expects($this->never())
+            ->method('createAttribute');
+
+        $this->db->expects($this->never())
+            ->method('deleteAttribute');
+
+        $this->db->expects($this->never())
+            ->method('createIndex');
+
+        $this->db->expects($this->never())
+            ->method('deleteIndex');
+
+        $this->em->syncCollectionFromEntity(TestEntity::class);
+    }
+
+    public function testSyncDetectsNewAttributes(): void
+    {
+        $this->db->expects($this->once())
+            ->method('exists')
+            ->with('test_db', 'users')
+            ->willReturn(true);
+
+        $collectionDoc = new Document([
+            '$id' => 'users',
+            'name' => 'users',
+            'attributes' => [],
+            'indexes' => [],
+            '$permissions' => [],
+            'documentSecurity' => true,
+        ]);
+
+        $this->db->expects($this->once())
+            ->method('getCollection')
+            ->with('users')
+            ->willReturn($collectionDoc);
+
+        $this->db->expects($this->atLeastOnce())
+            ->method('createAttribute');
+
+        $this->em->syncCollectionFromEntity(TestEntity::class);
+    }
+
+    public function testSyncDetectsDroppedAttributes(): void
+    {
+        $this->db->expects($this->once())
+            ->method('exists')
+            ->with('test_db', 'users')
+            ->willReturn(true);
+
+        $metadata = $this->em->getMetadataFactory()->getMetadata(TestEntity::class);
+        $defs = $this->em->getEntityMapper()->toCollectionDefinitions($metadata);
+
+        /** @var \Utopia\Database\Collection $desired */
+        $desired = $defs['collection'];
+
+        $attrDocs = array_map(fn (Attribute $a) => $a->toDocument(), $desired->attributes);
+        $indexDocs = array_map(fn (\Utopia\Database\Index $i) => $i->toDocument(), $desired->indexes);
+
+        $extraAttr = new Attribute(key: 'obsolete_field', type: ColumnType::String, size: 100);
+        $attrDocs[] = $extraAttr->toDocument();
+
+        $collectionDoc = new Document([
+            '$id' => 'users',
+            'name' => 'users',
+            'attributes' => $attrDocs,
+            'indexes' => $indexDocs,
+            '$permissions' => [],
+            'documentSecurity' => true,
+        ]);
+
+        $this->db->expects($this->once())
+            ->method('getCollection')
+            ->with('users')
+            ->willReturn($collectionDoc);
+
+        $this->db->expects($this->once())
+            ->method('deleteAttribute')
+            ->with('users', 'obsolete_field');
+
+        $this->em->syncCollectionFromEntity(TestEntity::class);
+    }
+
+    public function testSyncDetectsNewIndexes(): void
+    {
+        $this->db->expects($this->once())
+            ->method('exists')
+            ->with('test_db', 'users')
+            ->willReturn(true);
+
+        $metadata = $this->em->getMetadataFactory()->getMetadata(TestEntity::class);
+        $defs = $this->em->getEntityMapper()->toCollectionDefinitions($metadata);
+
+        /** @var \Utopia\Database\Collection $desired */
+        $desired = $defs['collection'];
+
+        $attrDocs = array_map(fn (Attribute $a) => $a->toDocument(), $desired->attributes);
+
+        $collectionDoc = new Document([
+            '$id' => 'users',
+            'name' => 'users',
+            'attributes' => $attrDocs,
+            'indexes' => [],
+            '$permissions' => [],
+            'documentSecurity' => true,
+        ]);
+
+        $this->db->expects($this->once())
+            ->method('getCollection')
+            ->with('users')
+            ->willReturn($collectionDoc);
+
+        $this->db->expects($this->atLeastOnce())
+            ->method('createIndex');
+
+        $this->em->syncCollectionFromEntity(TestEntity::class);
+    }
+
+    public function testSyncDetectsDroppedIndexes(): void
+    {
+        $this->db->expects($this->once())
+            ->method('exists')
+            ->with('test_db', 'users')
+            ->willReturn(true);
+
+        $metadata = $this->em->getMetadataFactory()->getMetadata(TestEntity::class);
+        $defs = $this->em->getEntityMapper()->toCollectionDefinitions($metadata);
+
+        /** @var \Utopia\Database\Collection $desired */
+        $desired = $defs['collection'];
+
+        $attrDocs = array_map(fn (Attribute $a) => $a->toDocument(), $desired->attributes);
+        $indexDocs = array_map(fn (\Utopia\Database\Index $i) => $i->toDocument(), $desired->indexes);
+
+        $extraIndex = new \Utopia\Database\Index(key: 'idx_old', type: \Utopia\Query\Schema\IndexType::Index, attributes: ['name']);
+        $indexDocs[] = $extraIndex->toDocument();
+
+        $collectionDoc = new Document([
+            '$id' => 'users',
+            'name' => 'users',
+            'attributes' => $attrDocs,
+            'indexes' => $indexDocs,
+            '$permissions' => [],
+            'documentSecurity' => true,
+        ]);
+
+        $this->db->expects($this->once())
+            ->method('getCollection')
+            ->with('users')
+            ->willReturn($collectionDoc);
+
+        $this->db->expects($this->once())
+            ->method('deleteIndex')
+            ->with('users', 'idx_old');
+
+        $this->em->syncCollectionFromEntity(TestEntity::class);
+    }
+
+    public function testSyncDoesNotCallCreateCollectionWhenAlreadyExists(): void
+    {
+        $this->db->expects($this->once())
+            ->method('exists')
+            ->with('test_db', 'users')
+            ->willReturn(true);
+
+        $metadata = $this->em->getMetadataFactory()->getMetadata(TestEntity::class);
+        $defs = $this->em->getEntityMapper()->toCollectionDefinitions($metadata);
+
+        /** @var \Utopia\Database\Collection $desired */
+        $desired = $defs['collection'];
+
+        $attrDocs = array_map(fn (Attribute $a) => $a->toDocument(), $desired->attributes);
+        $indexDocs = array_map(fn (\Utopia\Database\Index $i) => $i->toDocument(), $desired->indexes);
+
+        $collectionDoc = new Document([
+            '$id' => 'users',
+            'name' => 'users',
+            'attributes' => $attrDocs,
+            'indexes' => $indexDocs,
+            '$permissions' => [],
+            'documentSecurity' => true,
+        ]);
+
+        $this->db->expects($this->once())
+            ->method('getCollection')
+            ->with('users')
+            ->willReturn($collectionDoc);
+
+        $this->db->expects($this->never())
+            ->method('createCollection');
+
+        $this->em->syncCollectionFromEntity(TestEntity::class);
+    }
+}
diff --git a/tests/unit/ORM/IdentityMapTest.php b/tests/unit/ORM/IdentityMapTest.php
new file mode 100644
index 000000000..8d03407cb
--- /dev/null
+++ b/tests/unit/ORM/IdentityMapTest.php
@@ -0,0 +1,95 @@
+<?php
+
+namespace Tests\Unit\ORM;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\ORM\IdentityMap;
+
+class IdentityMapTest extends TestCase
+{
+    private IdentityMap $map;
+
+    protected function setUp(): void
+    {
+        $this->map = new IdentityMap();
+    }
+
+    public function testPutAndGet(): void
+    {
+        $entity = new \stdClass();
+        $entity->name = 'test';
+
+        $this->map->put('users', 'abc123', $entity);
+
+        $this->assertSame($entity, $this->map->get('users', 'abc123'));
+    }
+
+    public function testGetReturnsNullForMissing(): void
+    {
+        $this->assertNull($this->map->get('users', 'nonexistent'));
+        $this->assertNull($this->map->get('nonexistent', 'abc'));
+    }
+
+    public function testHas(): void
+    {
+        $entity = new \stdClass();
+        $this->map->put('users', 'abc', $entity);
+
+        $this->assertTrue($this->map->has('users', 'abc'));
+        $this->assertFalse($this->map->has('users', 'xyz'));
+        $this->assertFalse($this->map->has('other', 'abc'));
+    }
+
+    public function testRemove(): void
+    {
+        $entity = new \stdClass();
+        $this->map->put('users', 'abc', $entity);
+        $this->map->remove('users', 'abc');
+
+        $this->assertFalse($this->map->has('users', 'abc'));
+        $this->assertNull($this->map->get('users', 'abc'));
+    }
+
+    public function testClear(): void
+    {
+        $this->map->put('users', 'a', new \stdClass());
+        $this->map->put('users', 'b', new \stdClass());
+        $this->map->put('posts', 'c', new \stdClass());
+
+        $this->map->clear();
+
+        $this->assertEmpty(\iterator_to_array($this->map->all()));
+        $this->assertFalse($this->map->has('users', 'a'));
+    }
+
+    public function testAll(): void
+    {
+        $e1 = new \stdClass();
+        $e2 = new \stdClass();
+        $e3 = new \stdClass();
+
+        $this->map->put('users', 'a', $e1);
+        $this->map->put('users', 'b', $e2);
+        $this->map->put('posts', 'c', $e3);
+
+        $all = \iterator_to_array($this->map->all(), false);
+        $this->assertCount(3, $all);
+        $this->assertContains($e1, $all);
+        $this->assertContains($e2, $all);
+        $this->assertContains($e3, $all);
+    }
+
+    public function testOverwrite(): void
+    {
+        $e1 = new \stdClass();
+        $e1->v = 1;
+        $e2 = new \stdClass();
+        $e2->v = 2;
+
+        $this->map->put('users', 'a', $e1);
+        $this->map->put('users', 'a', $e2);
+
+        $this->assertSame($e2, $this->map->get('users', 'a'));
+        $this->assertCount(1, \iterator_to_array($this->map->all(), false));
+    }
+}
diff --git a/tests/unit/ORM/LifecycleCallbackTest.php b/tests/unit/ORM/LifecycleCallbackTest.php
new file mode 100644
index 000000000..eda9c002e
--- /dev/null
+++ b/tests/unit/ORM/LifecycleCallbackTest.php
@@ -0,0 +1,243 @@
+<?php
+
+namespace Tests\Unit\ORM;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\ORM\Mapping\Column;
+use Utopia\Database\ORM\Mapping\Entity;
+use Utopia\Database\ORM\Mapping\Id;
+use Utopia\Database\ORM\Mapping\PostPersist;
+use Utopia\Database\ORM\Mapping\PostRemove;
+use Utopia\Database\ORM\Mapping\PostUpdate;
+use Utopia\Database\ORM\Mapping\PrePersist;
+use Utopia\Database\ORM\Mapping\PreRemove;
+use Utopia\Database\ORM\Mapping\PreUpdate;
+use Utopia\Database\ORM\MetadataFactory;
+use Utopia\Query\Schema\ColumnType;
+
+#[Entity(collection: 'lifecycle_entities')]
+class LifecycleEntity
+{
+    #[Id]
+    public string $id = '';
+
+    #[Column(type: ColumnType::String, size: 255)]
+    public string $name = '';
+
+    public array $callLog = [];
+
+    #[PrePersist]
+    public function onPrePersist(): void
+    {
+        $this->callLog[] = 'prePersist';
+    }
+
+    #[PostPersist]
+    public function onPostPersist(): void
+    {
+        $this->callLog[] = 'postPersist';
+    }
+
+    #[PreUpdate]
+    public function onPreUpdate(): void
+    {
+        $this->callLog[] = 'preUpdate';
+    }
+
+    #[PostUpdate]
+    public function onPostUpdate(): void
+    {
+        $this->callLog[] = 'postUpdate';
+    }
+
+    #[PreRemove]
+    public function onPreRemove(): void
+    {
+        $this->callLog[] = 'preRemove';
+    }
+
+    #[PostRemove]
+    public function onPostRemove(): void
+    {
+        $this->callLog[] = 'postRemove';
+    }
+}
+
+#[Entity(collection: 'multi_callback_entities')]
+class MultiCallbackEntity
+{
+    #[Id]
+    public string $id = '';
+
+    #[Column(type: ColumnType::String, size: 255)]
+    public string $name = '';
+
+    public array $callLog = [];
+
+    #[PrePersist]
+    public function firstPrePersist(): void
+    {
+        $this->callLog[] = 'firstPrePersist';
+    }
+
+    #[PrePersist]
+    public function secondPrePersist(): void
+    {
+        $this->callLog[] = 'secondPrePersist';
+    }
+}
+
+#[Entity(collection: 'no_callback_entities')]
+class NoCallbackEntity
+{
+    #[Id]
+    public string $id = '';
+
+    #[Column(type: ColumnType::String, size: 255)]
+    public string $name = '';
+}
+
+class LifecycleCallbackTest extends TestCase
+{
+    protected MetadataFactory $factory;
+
+    protected function setUp(): void
+    {
+        MetadataFactory::clearCache();
+        $this->factory = new MetadataFactory();
+    }
+
+    public function testMetadataFactoryParsesPrePersistCallback(): void
+    {
+        $metadata = $this->factory->getMetadata(LifecycleEntity::class);
+
+        $this->assertContains('onPrePersist', $metadata->prePersistCallbacks);
+    }
+
+    public function testMetadataFactoryParsesPostPersistCallback(): void
+    {
+        $metadata = $this->factory->getMetadata(LifecycleEntity::class);
+
+        $this->assertContains('onPostPersist', $metadata->postPersistCallbacks);
+    }
+
+    public function testMetadataFactoryParsesPreUpdateCallback(): void
+    {
+        $metadata = $this->factory->getMetadata(LifecycleEntity::class);
+
+        $this->assertContains('onPreUpdate', $metadata->preUpdateCallbacks);
+    }
+
+    public function testMetadataFactoryParsesPostUpdateCallback(): void
+    {
+        $metadata = $this->factory->getMetadata(LifecycleEntity::class);
+
+        $this->assertContains('onPostUpdate', $metadata->postUpdateCallbacks);
+    }
+
+    public function testMetadataFactoryParsesPreRemoveCallback(): void
+    {
+        $metadata = $this->factory->getMetadata(LifecycleEntity::class);
+
+        $this->assertContains('onPreRemove', $metadata->preRemoveCallbacks);
+    }
+
+    public function testMetadataFactoryParsesPostRemoveCallback(): void
+    {
+        $metadata = $this->factory->getMetadata(LifecycleEntity::class);
+
+        $this->assertContains('onPostRemove', $metadata->postRemoveCallbacks);
+    }
+
+    public function testMetadataFactoryParsesMultipleCallbacksOfSameType(): void
+    {
+        $metadata = $this->factory->getMetadata(MultiCallbackEntity::class);
+
+        $this->assertCount(2, $metadata->prePersistCallbacks);
+        $this->assertContains('firstPrePersist', $metadata->prePersistCallbacks);
+        $this->assertContains('secondPrePersist', $metadata->prePersistCallbacks);
+    }
+
+    public function testEntityWithoutCallbacksHasEmptyArrays(): void
+    {
+        $metadata = $this->factory->getMetadata(NoCallbackEntity::class);
+
+        $this->assertEmpty($metadata->prePersistCallbacks);
+        $this->assertEmpty($metadata->postPersistCallbacks);
+        $this->assertEmpty($metadata->preUpdateCallbacks);
+        $this->assertEmpty($metadata->postUpdateCallbacks);
+        $this->assertEmpty($metadata->preRemoveCallbacks);
+        $this->assertEmpty($metadata->postRemoveCallbacks);
+    }
+
+    public function testCallbackValuesAreStrings(): void
+    {
+        $metadata = $this->factory->getMetadata(LifecycleEntity::class);
+
+        foreach ($metadata->prePersistCallbacks as $cb) {
+            $this->assertIsString($cb);
+        }
+
+        foreach ($metadata->postPersistCallbacks as $cb) {
+            $this->assertIsString($cb);
+        }
+
+        foreach ($metadata->preUpdateCallbacks as $cb) {
+            $this->assertIsString($cb);
+        }
+
+        foreach ($metadata->postUpdateCallbacks as $cb) {
+            $this->assertIsString($cb);
+        }
+
+        foreach ($metadata->preRemoveCallbacks as $cb) {
+            $this->assertIsString($cb);
+        }
+
+        foreach ($metadata->postRemoveCallbacks as $cb) {
+            $this->assertIsString($cb);
+        }
+    }
+
+    public function testPrePersistCallbackCountIsExactlyOne(): void
+    {
+        $metadata = $this->factory->getMetadata(LifecycleEntity::class);
+
+        $this->assertCount(1, $metadata->prePersistCallbacks);
+    }
+
+    public function testPostPersistCallbackCountIsExactlyOne(): void
+    {
+        $metadata = $this->factory->getMetadata(LifecycleEntity::class);
+
+        $this->assertCount(1, $metadata->postPersistCallbacks);
+    }
+
+    public function testPreUpdateCallbackCountIsExactlyOne(): void
+    {
+        $metadata = $this->factory->getMetadata(LifecycleEntity::class);
+
+        $this->assertCount(1, $metadata->preUpdateCallbacks);
+    }
+
+    public function testPostUpdateCallbackCountIsExactlyOne(): void
+    {
+        $metadata = $this->factory->getMetadata(LifecycleEntity::class);
+
+        $this->assertCount(1, $metadata->postUpdateCallbacks);
+    }
+
+    public function testPreRemoveCallbackCountIsExactlyOne(): void
+    {
+        $metadata = $this->factory->getMetadata(LifecycleEntity::class);
+
+        $this->assertCount(1, $metadata->preRemoveCallbacks);
+    }
+
+    public function testPostRemoveCallbackCountIsExactlyOne(): void
+    {
+        $metadata = $this->factory->getMetadata(LifecycleEntity::class);
+
+        $this->assertCount(1, $metadata->postRemoveCallbacks);
+    }
+}
diff --git a/tests/unit/ORM/MappingAttributeTest.php b/tests/unit/ORM/MappingAttributeTest.php
new file mode 100644
index 000000000..3cb80e4d9
--- /dev/null
+++ b/tests/unit/ORM/MappingAttributeTest.php
@@ -0,0 +1,446 @@
+<?php
+
+namespace Tests\Unit\ORM;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\ORM\Mapping\BelongsTo;
+use Utopia\Database\ORM\Mapping\BelongsToMany;
+use Utopia\Database\ORM\Mapping\Column;
+use Utopia\Database\ORM\Mapping\CreatedAt;
+use Utopia\Database\ORM\Mapping\Entity;
+use Utopia\Database\ORM\Mapping\HasMany;
+use Utopia\Database\ORM\Mapping\HasOne;
+use Utopia\Database\ORM\Mapping\Id;
+use Utopia\Database\ORM\Mapping\Permissions;
+use Utopia\Database\ORM\Mapping\TableIndex;
+use Utopia\Database\ORM\Mapping\Tenant;
+use Utopia\Database\ORM\Mapping\UpdatedAt;
+use Utopia\Database\ORM\Mapping\Version;
+use Utopia\Database\ORM\MetadataFactory;
+use Utopia\Database\RelationType;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\ForeignKeyAction;
+use Utopia\Query\Schema\IndexType;
+
+class MappingAttributeTest extends TestCase
+{
+    private MetadataFactory $factory;
+
+    protected function setUp(): void
+    {
+        MetadataFactory::clearCache();
+        $this->factory = new MetadataFactory();
+    }
+
+    public function testEntityAttributeWithAllParameters(): void
+    {
+        $entity = new Entity(
+            collection: 'custom_collection',
+            documentSecurity: false,
+            permissions: ['read("any")', 'write("users")'],
+        );
+
+        $this->assertEquals('custom_collection', $entity->collection);
+        $this->assertFalse($entity->documentSecurity);
+        $this->assertEquals(['read("any")', 'write("users")'], $entity->permissions);
+    }
+
+    public function testEntityAttributeWithDefaults(): void
+    {
+        $entity = new Entity(collection: 'test');
+
+        $this->assertEquals('test', $entity->collection);
+        $this->assertTrue($entity->documentSecurity);
+        $this->assertEquals([], $entity->permissions);
+    }
+
+    public function testColumnAttributeWithAllParameters(): void
+    {
+        $column = new Column(
+            type: ColumnType::String,
+            size: 500,
+            required: true,
+            default: 'hello',
+            signed: false,
+            array: true,
+            format: 'email',
+            formatOptions: ['domain' => 'example.com'],
+            filters: ['trim', 'lowercase'],
+            key: 'custom_key',
+        );
+
+        $this->assertEquals(ColumnType::String, $column->type);
+        $this->assertEquals(500, $column->size);
+        $this->assertTrue($column->required);
+        $this->assertEquals('hello', $column->default);
+        $this->assertFalse($column->signed);
+        $this->assertTrue($column->array);
+        $this->assertEquals('email', $column->format);
+        $this->assertEquals(['domain' => 'example.com'], $column->formatOptions);
+        $this->assertEquals(['trim', 'lowercase'], $column->filters);
+        $this->assertEquals('custom_key', $column->key);
+    }
+
+    public function testColumnAttributeWithDefaults(): void
+    {
+        $column = new Column();
+
+        $this->assertEquals(ColumnType::String, $column->type);
+        $this->assertEquals(0, $column->size);
+        $this->assertFalse($column->required);
+        $this->assertNull($column->default);
+        $this->assertTrue($column->signed);
+        $this->assertFalse($column->array);
+        $this->assertNull($column->format);
+        $this->assertEquals([], $column->formatOptions);
+        $this->assertEquals([], $column->filters);
+        $this->assertNull($column->key);
+    }
+
+    public function testColumnWithCustomKeyOverride(): void
+    {
+        $column = new Column(type: ColumnType::Integer, key: 'db_age');
+
+        $this->assertEquals('db_age', $column->key);
+        $this->assertEquals(ColumnType::Integer, $column->type);
+    }
+
+    public function testIdAttributeIsMarker(): void
+    {
+        $ref = new \ReflectionClass(Id::class);
+        $attrs = $ref->getAttributes(\Attribute::class);
+
+        $this->assertNotEmpty($attrs);
+        $attr = $attrs[0]->newInstance();
+        $this->assertEquals(\Attribute::TARGET_PROPERTY, $attr->flags);
+    }
+
+    public function testVersionAttributeIsMarker(): void
+    {
+        $ref = new \ReflectionClass(Version::class);
+        $attrs = $ref->getAttributes(\Attribute::class);
+
+        $this->assertNotEmpty($attrs);
+    }
+
+    public function testCreatedAtAttributeIsMarker(): void
+    {
+        $ref = new \ReflectionClass(CreatedAt::class);
+        $attrs = $ref->getAttributes(\Attribute::class);
+
+        $this->assertNotEmpty($attrs);
+    }
+
+    public function testUpdatedAtAttributeIsMarker(): void
+    {
+        $ref = new \ReflectionClass(UpdatedAt::class);
+        $attrs = $ref->getAttributes(\Attribute::class);
+
+        $this->assertNotEmpty($attrs);
+    }
+
+    public function testTenantAttributeIsMarker(): void
+    {
+        $ref = new \ReflectionClass(Tenant::class);
+        $attrs = $ref->getAttributes(\Attribute::class);
+
+        $this->assertNotEmpty($attrs);
+    }
+
+    public function testPermissionsAttributeIsMarker(): void
+    {
+        $ref = new \ReflectionClass(Permissions::class);
+        $attrs = $ref->getAttributes(\Attribute::class);
+
+        $this->assertNotEmpty($attrs);
+    }
+
+    public function testHasOneWithAllParameters(): void
+    {
+        $hasOne = new HasOne(
+            target: TestEntity::class,
+            key: 'profile',
+            twoWayKey: 'user',
+            twoWay: false,
+            onDelete: ForeignKeyAction::Cascade,
+        );
+
+        $this->assertEquals(TestEntity::class, $hasOne->target);
+        $this->assertEquals('profile', $hasOne->key);
+        $this->assertEquals('user', $hasOne->twoWayKey);
+        $this->assertFalse($hasOne->twoWay);
+        $this->assertEquals(ForeignKeyAction::Cascade, $hasOne->onDelete);
+    }
+
+    public function testHasOneWithDefaults(): void
+    {
+        $hasOne = new HasOne(target: TestEntity::class);
+
+        $this->assertEquals(TestEntity::class, $hasOne->target);
+        $this->assertEquals('', $hasOne->key);
+        $this->assertEquals('', $hasOne->twoWayKey);
+        $this->assertTrue($hasOne->twoWay);
+        $this->assertEquals(ForeignKeyAction::Restrict, $hasOne->onDelete);
+    }
+
+    public function testBelongsToWithAllParameters(): void
+    {
+        $belongsTo = new BelongsTo(
+            target: TestEntity::class,
+            key: 'author',
+            twoWayKey: 'posts',
+            twoWay: false,
+            onDelete: ForeignKeyAction::Cascade,
+        );
+
+        $this->assertEquals(TestEntity::class, $belongsTo->target);
+        $this->assertEquals('author', $belongsTo->key);
+        $this->assertEquals('posts', $belongsTo->twoWayKey);
+        $this->assertFalse($belongsTo->twoWay);
+        $this->assertEquals(ForeignKeyAction::Cascade, $belongsTo->onDelete);
+    }
+
+    public function testBelongsToWithDefaults(): void
+    {
+        $belongsTo = new BelongsTo(target: TestEntity::class);
+
+        $this->assertEquals(ForeignKeyAction::Restrict, $belongsTo->onDelete);
+        $this->assertTrue($belongsTo->twoWay);
+    }
+
+    public function testHasManyDefaultOnDeleteIsSetNull(): void
+    {
+        $hasMany = new HasMany(target: TestPost::class);
+
+        $this->assertEquals(ForeignKeyAction::SetNull, $hasMany->onDelete);
+    }
+
+    public function testHasManyWithAllParameters(): void
+    {
+        $hasMany = new HasMany(
+            target: TestPost::class,
+            key: 'posts',
+            twoWayKey: 'author',
+            twoWay: false,
+            onDelete: ForeignKeyAction::Cascade,
+        );
+
+        $this->assertEquals(TestPost::class, $hasMany->target);
+        $this->assertEquals('posts', $hasMany->key);
+        $this->assertEquals('author', $hasMany->twoWayKey);
+        $this->assertFalse($hasMany->twoWay);
+        $this->assertEquals(ForeignKeyAction::Cascade, $hasMany->onDelete);
+    }
+
+    public function testBelongsToManyDefaultOnDeleteIsCascade(): void
+    {
+        $belongsToMany = new BelongsToMany(target: TestEntity::class);
+
+        $this->assertEquals(ForeignKeyAction::Cascade, $belongsToMany->onDelete);
+    }
+
+    public function testBelongsToManyWithAllParameters(): void
+    {
+        $belongsToMany = new BelongsToMany(
+            target: TestEntity::class,
+            key: 'tags',
+            twoWayKey: 'posts',
+            twoWay: false,
+            onDelete: ForeignKeyAction::SetNull,
+        );
+
+        $this->assertEquals(TestEntity::class, $belongsToMany->target);
+        $this->assertEquals('tags', $belongsToMany->key);
+        $this->assertEquals('posts', $belongsToMany->twoWayKey);
+        $this->assertFalse($belongsToMany->twoWay);
+        $this->assertEquals(ForeignKeyAction::SetNull, $belongsToMany->onDelete);
+    }
+
+    public function testTableIndexWithAllParameters(): void
+    {
+        $index = new TableIndex(
+            key: 'idx_test',
+            type: IndexType::Fulltext,
+            attributes: ['title', 'content'],
+            lengths: [100, 200],
+            orders: ['asc', 'desc'],
+        );
+
+        $this->assertEquals('idx_test', $index->key);
+        $this->assertEquals(IndexType::Fulltext, $index->type);
+        $this->assertEquals(['title', 'content'], $index->attributes);
+        $this->assertEquals([100, 200], $index->lengths);
+        $this->assertEquals(['asc', 'desc'], $index->orders);
+    }
+
+    public function testTableIndexWithDefaults(): void
+    {
+        $index = new TableIndex(key: 'idx_basic');
+
+        $this->assertEquals('idx_basic', $index->key);
+        $this->assertEquals(IndexType::Index, $index->type);
+        $this->assertEquals([], $index->attributes);
+        $this->assertEquals([], $index->lengths);
+        $this->assertEquals([], $index->orders);
+    }
+
+    public function testTableIndexIsRepeatable(): void
+    {
+        $ref = new \ReflectionClass(TableIndex::class);
+        $attrs = $ref->getAttributes(\Attribute::class);
+
+        $this->assertNotEmpty($attrs);
+        $attr = $attrs[0]->newInstance();
+        $this->assertTrue(($attr->flags & \Attribute::IS_REPEATABLE) !== 0);
+    }
+
+    public function testTestEntityHasTwoIndexes(): void
+    {
+        $metadata = $this->factory->getMetadata(TestEntity::class);
+
+        $this->assertCount(2, $metadata->indexes);
+    }
+
+    public function testEntityWithNoRelationships(): void
+    {
+        $metadata = $this->factory->getMetadata(TestNoRelationsEntity::class);
+
+        $this->assertEmpty($metadata->relationships);
+        $this->assertEquals('no_relations', $metadata->collection);
+    }
+
+    public function testEntityWithCustomKeyOnColumn(): void
+    {
+        $metadata = $this->factory->getMetadata(TestCustomKeyEntity::class);
+
+        $this->assertArrayHasKey('displayName', $metadata->columns);
+        $this->assertEquals('display_name', $metadata->columns['displayName']->documentKey);
+        $this->assertEquals('displayName', $metadata->columns['displayName']->propertyName);
+    }
+
+    public function testEntityWithTenantAttribute(): void
+    {
+        $metadata = $this->factory->getMetadata(TestTenantEntity::class);
+
+        $this->assertEquals('tenantId', $metadata->tenantProperty);
+        $this->assertEquals('tenant_items', $metadata->collection);
+    }
+
+    public function testEntityWithAllRelationshipTypes(): void
+    {
+        $metadata = $this->factory->getMetadata(TestAllRelationsEntity::class);
+
+        $this->assertCount(4, $metadata->relationships);
+        $this->assertArrayHasKey('profile', $metadata->relationships);
+        $this->assertArrayHasKey('team', $metadata->relationships);
+        $this->assertArrayHasKey('posts', $metadata->relationships);
+        $this->assertArrayHasKey('tags', $metadata->relationships);
+
+        $this->assertEquals(RelationType::OneToOne, $metadata->relationships['profile']->type);
+        $this->assertEquals(RelationType::ManyToOne, $metadata->relationships['team']->type);
+        $this->assertEquals(RelationType::OneToMany, $metadata->relationships['posts']->type);
+        $this->assertEquals(RelationType::ManyToMany, $metadata->relationships['tags']->type);
+    }
+
+    public function testEntityWithNoIndexes(): void
+    {
+        $metadata = $this->factory->getMetadata(TestNoRelationsEntity::class);
+
+        $this->assertEmpty($metadata->indexes);
+    }
+
+    public function testEntityAttributeTargetsClass(): void
+    {
+        $ref = new \ReflectionClass(Entity::class);
+        $attrs = $ref->getAttributes(\Attribute::class);
+
+        $this->assertNotEmpty($attrs);
+        $attr = $attrs[0]->newInstance();
+        $this->assertEquals(\Attribute::TARGET_CLASS, $attr->flags);
+    }
+
+    public function testColumnAttributeTargetsProperty(): void
+    {
+        $ref = new \ReflectionClass(Column::class);
+        $attrs = $ref->getAttributes(\Attribute::class);
+
+        $this->assertNotEmpty($attrs);
+        $attr = $attrs[0]->newInstance();
+        $this->assertEquals(\Attribute::TARGET_PROPERTY, $attr->flags);
+    }
+
+    public function testTableIndexTargetsClassAndIsRepeatable(): void
+    {
+        $ref = new \ReflectionClass(TableIndex::class);
+        $attrs = $ref->getAttributes(\Attribute::class);
+        $attr = $attrs[0]->newInstance();
+
+        $this->assertTrue(($attr->flags & \Attribute::TARGET_CLASS) !== 0);
+        $this->assertTrue(($attr->flags & \Attribute::IS_REPEATABLE) !== 0);
+    }
+
+    public function testColumnWithEveryColumnType(): void
+    {
+        $types = [
+            ColumnType::String,
+            ColumnType::Integer,
+            ColumnType::Boolean,
+            ColumnType::Float,
+            ColumnType::Datetime,
+            ColumnType::Json,
+        ];
+
+        foreach ($types as $type) {
+            $column = new Column(type: $type);
+            $this->assertEquals($type, $column->type);
+        }
+    }
+
+    public function testHasOneAttributeTargetsProperty(): void
+    {
+        $ref = new \ReflectionClass(HasOne::class);
+        $attrs = $ref->getAttributes(\Attribute::class);
+
+        $this->assertNotEmpty($attrs);
+        $attr = $attrs[0]->newInstance();
+        $this->assertEquals(\Attribute::TARGET_PROPERTY, $attr->flags);
+    }
+
+    public function testHasManyAttributeTargetsProperty(): void
+    {
+        $ref = new \ReflectionClass(HasMany::class);
+        $attrs = $ref->getAttributes(\Attribute::class);
+
+        $this->assertNotEmpty($attrs);
+    }
+
+    public function testBelongsToAttributeTargetsProperty(): void
+    {
+        $ref = new \ReflectionClass(BelongsTo::class);
+        $attrs = $ref->getAttributes(\Attribute::class);
+
+        $this->assertNotEmpty($attrs);
+    }
+
+    public function testBelongsToManyAttributeTargetsProperty(): void
+    {
+        $ref = new \ReflectionClass(BelongsToMany::class);
+        $attrs = $ref->getAttributes(\Attribute::class);
+
+        $this->assertNotEmpty($attrs);
+    }
+
+    public function testEntityWithPermissionsInAttribute(): void
+    {
+        $metadata = $this->factory->getMetadata(TestPermissionEntity::class);
+
+        $this->assertEquals(['read("any")', 'write("users")'], $metadata->permissions);
+    }
+
+    public function testEntityWithDocumentSecurityFalse(): void
+    {
+        $metadata = $this->factory->getMetadata(TestPermissionEntity::class);
+
+        $this->assertFalse($metadata->documentSecurity);
+    }
+}
diff --git a/tests/unit/ORM/MetadataFactoryTest.php b/tests/unit/ORM/MetadataFactoryTest.php
new file mode 100644
index 000000000..b5293b52a
--- /dev/null
+++ b/tests/unit/ORM/MetadataFactoryTest.php
@@ -0,0 +1,141 @@
+<?php
+
+namespace Tests\Unit\ORM;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\ORM\MetadataFactory;
+use Utopia\Database\RelationType;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\IndexType;
+
+class MetadataFactoryTest extends TestCase
+{
+    private MetadataFactory $factory;
+
+    protected function setUp(): void
+    {
+        MetadataFactory::clearCache();
+        $this->factory = new MetadataFactory();
+    }
+
+    public function testParseEntityAttribute(): void
+    {
+        $metadata = $this->factory->getMetadata(TestEntity::class);
+
+        $this->assertEquals('users', $metadata->collection);
+        $this->assertTrue($metadata->documentSecurity);
+        $this->assertEquals(TestEntity::class, $metadata->className);
+    }
+
+    public function testParseIdProperty(): void
+    {
+        $metadata = $this->factory->getMetadata(TestEntity::class);
+
+        $this->assertEquals('id', $metadata->idProperty);
+    }
+
+    public function testParseVersionProperty(): void
+    {
+        $metadata = $this->factory->getMetadata(TestEntity::class);
+
+        $this->assertEquals('version', $metadata->versionProperty);
+    }
+
+    public function testParseTimestampProperties(): void
+    {
+        $metadata = $this->factory->getMetadata(TestEntity::class);
+
+        $this->assertEquals('createdAt', $metadata->createdAtProperty);
+        $this->assertEquals('updatedAt', $metadata->updatedAtProperty);
+    }
+
+    public function testParsePermissionsProperty(): void
+    {
+        $metadata = $this->factory->getMetadata(TestEntity::class);
+
+        $this->assertEquals('permissions', $metadata->permissionsProperty);
+    }
+
+    public function testParseColumns(): void
+    {
+        $metadata = $this->factory->getMetadata(TestEntity::class);
+
+        $this->assertCount(4, $metadata->columns);
+        $this->assertArrayHasKey('name', $metadata->columns);
+        $this->assertArrayHasKey('email', $metadata->columns);
+        $this->assertArrayHasKey('age', $metadata->columns);
+        $this->assertArrayHasKey('active', $metadata->columns);
+
+        $nameMapping = $metadata->columns['name'];
+        $this->assertEquals('name', $nameMapping->propertyName);
+        $this->assertEquals('name', $nameMapping->documentKey);
+        $this->assertEquals(ColumnType::String, $nameMapping->column->type);
+        $this->assertEquals(255, $nameMapping->column->size);
+        $this->assertTrue($nameMapping->column->required);
+
+        $ageMapping = $metadata->columns['age'];
+        $this->assertEquals(ColumnType::Integer, $ageMapping->column->type);
+        $this->assertFalse($ageMapping->column->required);
+    }
+
+    public function testParseRelationships(): void
+    {
+        $metadata = $this->factory->getMetadata(TestEntity::class);
+
+        $this->assertCount(1, $metadata->relationships);
+        $this->assertArrayHasKey('posts', $metadata->relationships);
+
+        $rel = $metadata->relationships['posts'];
+        $this->assertEquals('posts', $rel->propertyName);
+        $this->assertEquals('posts', $rel->documentKey);
+        $this->assertEquals(RelationType::OneToMany, $rel->type);
+        $this->assertEquals(TestPost::class, $rel->targetClass);
+        $this->assertEquals('author', $rel->twoWayKey);
+        $this->assertTrue($rel->twoWay);
+    }
+
+    public function testParseIndexes(): void
+    {
+        $metadata = $this->factory->getMetadata(TestEntity::class);
+
+        $this->assertCount(2, $metadata->indexes);
+        $this->assertEquals('idx_email', $metadata->indexes[0]->key);
+        $this->assertEquals(IndexType::Unique, $metadata->indexes[0]->type);
+        $this->assertEquals(['email'], $metadata->indexes[0]->attributes);
+
+        $this->assertEquals('idx_name', $metadata->indexes[1]->key);
+        $this->assertEquals(IndexType::Index, $metadata->indexes[1]->type);
+    }
+
+    public function testCaching(): void
+    {
+        $metadata1 = $this->factory->getMetadata(TestEntity::class);
+        $metadata2 = $this->factory->getMetadata(TestEntity::class);
+
+        $this->assertSame($metadata1, $metadata2);
+    }
+
+    public function testGetCollection(): void
+    {
+        $this->assertEquals('users', $this->factory->getCollection(TestEntity::class));
+        $this->assertEquals('posts', $this->factory->getCollection(TestPost::class));
+    }
+
+    public function testNonEntityThrows(): void
+    {
+        $this->expectException(\RuntimeException::class);
+        $this->factory->getMetadata(\stdClass::class);
+    }
+
+    public function testBelongsToRelationship(): void
+    {
+        $metadata = $this->factory->getMetadata(TestPost::class);
+
+        $this->assertCount(1, $metadata->relationships);
+        $this->assertArrayHasKey('author', $metadata->relationships);
+
+        $rel = $metadata->relationships['author'];
+        $this->assertEquals(RelationType::ManyToOne, $rel->type);
+        $this->assertEquals(TestEntity::class, $rel->targetClass);
+    }
+}
diff --git a/tests/unit/ORM/SoftDeleteTest.php b/tests/unit/ORM/SoftDeleteTest.php
new file mode 100644
index 000000000..48e16ee0b
--- /dev/null
+++ b/tests/unit/ORM/SoftDeleteTest.php
@@ -0,0 +1,203 @@
+<?php
+
+namespace Tests\Unit\ORM;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\ORM\EntityMapper;
+use Utopia\Database\ORM\EntityState;
+use Utopia\Database\ORM\IdentityMap;
+use Utopia\Database\ORM\Mapping\Column;
+use Utopia\Database\ORM\Mapping\Entity;
+use Utopia\Database\ORM\Mapping\Id;
+use Utopia\Database\ORM\Mapping\SoftDelete;
+use Utopia\Database\ORM\MetadataFactory;
+use Utopia\Database\ORM\UnitOfWork;
+use Utopia\Query\Schema\ColumnType;
+
+#[Entity(collection: 'soft_items')]
+#[SoftDelete]
+class SoftDeleteEntity
+{
+    #[Id]
+    public string $id = '';
+
+    #[Column(type: ColumnType::String, size: 255)]
+    public string $name = '';
+
+    public ?string $deletedAt = null;
+}
+
+#[Entity(collection: 'custom_soft_items')]
+#[SoftDelete(column: 'removedAt')]
+class CustomSoftDeleteEntity
+{
+    #[Id]
+    public string $id = '';
+
+    #[Column(type: ColumnType::String, size: 255)]
+    public string $name = '';
+
+    public ?string $removedAt = null;
+}
+
+#[Entity(collection: 'hard_items')]
+class HardDeleteEntity
+{
+    #[Id]
+    public string $id = '';
+
+    #[Column(type: ColumnType::String, size: 255)]
+    public string $name = '';
+}
+
+class SoftDeleteTest extends TestCase
+{
+    protected MetadataFactory $metadataFactory;
+
+    protected IdentityMap $identityMap;
+
+    protected UnitOfWork $uow;
+
+    protected function setUp(): void
+    {
+        MetadataFactory::clearCache();
+        $this->metadataFactory = new MetadataFactory();
+        $this->identityMap = new IdentityMap();
+        $mapper = new EntityMapper($this->metadataFactory);
+        $this->uow = new UnitOfWork($this->identityMap, $this->metadataFactory, $mapper);
+    }
+
+    public function testMetadataFactoryParsesSoftDeleteAttribute(): void
+    {
+        $metadata = $this->metadataFactory->getMetadata(SoftDeleteEntity::class);
+
+        $this->assertEquals('deletedAt', $metadata->softDeleteColumn);
+    }
+
+    public function testMetadataFactoryParsesSoftDeleteWithCustomColumn(): void
+    {
+        $metadata = $this->metadataFactory->getMetadata(CustomSoftDeleteEntity::class);
+
+        $this->assertEquals('removedAt', $metadata->softDeleteColumn);
+    }
+
+    public function testEntityWithoutSoftDeleteHasNullColumn(): void
+    {
+        $metadata = $this->metadataFactory->getMetadata(HardDeleteEntity::class);
+
+        $this->assertNull($metadata->softDeleteColumn);
+    }
+
+    public function testRemoveSetsDeletedAtOnSoftDeletableEntity(): void
+    {
+        $entity = new SoftDeleteEntity();
+        $entity->id = 'soft-1';
+        $entity->name = 'Soft';
+
+        $metadata = $this->metadataFactory->getMetadata(SoftDeleteEntity::class);
+        $this->identityMap->put('soft_items', 'soft-1', $entity);
+        $this->uow->registerManaged($entity, $metadata);
+
+        $this->assertNull($entity->deletedAt);
+
+        $this->uow->remove($entity);
+
+        $this->assertNotNull($entity->deletedAt);
+        $this->assertEquals(EntityState::Managed, $this->uow->getState($entity));
+    }
+
+    public function testRemoveSchedulesDeletionOnNonSoftDeletableEntity(): void
+    {
+        $entity = new HardDeleteEntity();
+        $entity->id = 'hard-1';
+        $entity->name = 'Hard';
+
+        $metadata = $this->metadataFactory->getMetadata(HardDeleteEntity::class);
+        $this->identityMap->put('hard_items', 'hard-1', $entity);
+        $this->uow->registerManaged($entity, $metadata);
+
+        $this->uow->remove($entity);
+
+        $this->assertEquals(EntityState::Removed, $this->uow->getState($entity));
+    }
+
+    public function testForceRemoveAlwaysSchedulesRealDeletion(): void
+    {
+        $entity = new SoftDeleteEntity();
+        $entity->id = 'force-1';
+        $entity->name = 'Force';
+
+        $metadata = $this->metadataFactory->getMetadata(SoftDeleteEntity::class);
+        $this->identityMap->put('soft_items', 'force-1', $entity);
+        $this->uow->registerManaged($entity, $metadata);
+
+        $this->uow->forceRemove($entity);
+
+        $this->assertEquals(EntityState::Removed, $this->uow->getState($entity));
+    }
+
+    public function testForceRemoveOnNonSoftDeletableEntitySchedulesDeletion(): void
+    {
+        $entity = new HardDeleteEntity();
+        $entity->id = 'force-hard-1';
+        $entity->name = 'ForceHard';
+
+        $metadata = $this->metadataFactory->getMetadata(HardDeleteEntity::class);
+        $this->identityMap->put('hard_items', 'force-hard-1', $entity);
+        $this->uow->registerManaged($entity, $metadata);
+
+        $this->uow->forceRemove($entity);
+
+        $this->assertEquals(EntityState::Removed, $this->uow->getState($entity));
+    }
+
+    public function testRestoreClearsDeletedAt(): void
+    {
+        $entity = new SoftDeleteEntity();
+        $entity->id = 'restore-1';
+        $entity->name = 'Restore';
+        $entity->deletedAt = '2024-01-01 00:00:00';
+
+        $this->uow->restore($entity);
+
+        $this->assertNull($entity->deletedAt);
+    }
+
+    public function testRestoreIsNoOpWithoutSoftDelete(): void
+    {
+        $entity = new HardDeleteEntity();
+        $entity->id = 'restore-hard-1';
+        $entity->name = 'RestoreHard';
+
+        $this->uow->restore($entity);
+
+        $this->assertNull($this->uow->getState($entity));
+    }
+
+    public function testSoftDeleteDoesNotScheduleDeletion(): void
+    {
+        $entity = new SoftDeleteEntity();
+        $entity->id = 'no-schedule-1';
+        $entity->name = 'NoSchedule';
+
+        $metadata = $this->metadataFactory->getMetadata(SoftDeleteEntity::class);
+        $this->identityMap->put('soft_items', 'no-schedule-1', $entity);
+        $this->uow->registerManaged($entity, $metadata);
+
+        $this->uow->remove($entity);
+
+        $this->assertNotEquals(EntityState::Removed, $this->uow->getState($entity));
+    }
+
+    public function testRestoreWithCustomColumnClearsValue(): void
+    {
+        $entity = new CustomSoftDeleteEntity();
+        $entity->id = 'restore-custom-1';
+        $entity->name = 'RestoreCustom';
+        $entity->removedAt = '2024-06-15 12:00:00';
+
+        $this->uow->restore($entity);
+
+        $this->assertNull($entity->removedAt);
+    }
+}
diff --git a/tests/unit/ORM/TestAllRelationsEntity.php b/tests/unit/ORM/TestAllRelationsEntity.php
new file mode 100644
index 000000000..35f9269d6
--- /dev/null
+++ b/tests/unit/ORM/TestAllRelationsEntity.php
@@ -0,0 +1,29 @@
+<?php
+
+namespace Tests\Unit\ORM;
+
+use Utopia\Database\ORM\Mapping\BelongsTo;
+use Utopia\Database\ORM\Mapping\BelongsToMany;
+use Utopia\Database\ORM\Mapping\Entity;
+use Utopia\Database\ORM\Mapping\HasMany;
+use Utopia\Database\ORM\Mapping\HasOne;
+use Utopia\Database\ORM\Mapping\Id;
+
+#[Entity(collection: 'all_relations')]
+class TestAllRelationsEntity
+{
+    #[Id]
+    public string $id = '';
+
+    #[HasOne(target: TestNoRelationsEntity::class, key: 'profile', twoWayKey: 'owner')]
+    public mixed $profile = null;
+
+    #[BelongsTo(target: TestNoRelationsEntity::class, key: 'team', twoWayKey: 'members')]
+    public mixed $team = null;
+
+    #[HasMany(target: TestPost::class, key: 'posts', twoWayKey: 'author')]
+    public array $posts = [];
+
+    #[BelongsToMany(target: TestNoRelationsEntity::class, key: 'tags', twoWayKey: 'items')]
+    public array $tags = [];
+}
diff --git a/tests/unit/ORM/TestCustomKeyEntity.php b/tests/unit/ORM/TestCustomKeyEntity.php
new file mode 100644
index 000000000..cee5a8f43
--- /dev/null
+++ b/tests/unit/ORM/TestCustomKeyEntity.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace Tests\Unit\ORM;
+
+use Utopia\Database\ORM\Mapping\Column;
+use Utopia\Database\ORM\Mapping\Entity;
+use Utopia\Database\ORM\Mapping\Id;
+use Utopia\Query\Schema\ColumnType;
+
+#[Entity(collection: 'custom_keys')]
+class TestCustomKeyEntity
+{
+    #[Id]
+    public string $id = '';
+
+    #[Column(type: ColumnType::String, size: 100, key: 'display_name')]
+    public string $displayName = '';
+}
diff --git a/tests/unit/ORM/TestEntity.php b/tests/unit/ORM/TestEntity.php
new file mode 100644
index 000000000..0e386fe17
--- /dev/null
+++ b/tests/unit/ORM/TestEntity.php
@@ -0,0 +1,51 @@
+<?php
+
+namespace Tests\Unit\ORM;
+
+use Utopia\Database\ORM\Mapping\Column;
+use Utopia\Database\ORM\Mapping\CreatedAt;
+use Utopia\Database\ORM\Mapping\Entity;
+use Utopia\Database\ORM\Mapping\HasMany;
+use Utopia\Database\ORM\Mapping\Id;
+use Utopia\Database\ORM\Mapping\Permissions;
+use Utopia\Database\ORM\Mapping\TableIndex;
+use Utopia\Database\ORM\Mapping\UpdatedAt;
+use Utopia\Database\ORM\Mapping\Version;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\IndexType;
+
+#[Entity(collection: 'users', documentSecurity: true)]
+#[TableIndex(key: 'idx_email', type: IndexType::Unique, attributes: ['email'])]
+#[TableIndex(key: 'idx_name', type: IndexType::Index, attributes: ['name'])]
+class TestEntity
+{
+    #[Id]
+    public string $id = '';
+
+    #[Version]
+    public ?int $version = null;
+
+    #[CreatedAt]
+    public ?string $createdAt = null;
+
+    #[UpdatedAt]
+    public ?string $updatedAt = null;
+
+    #[Permissions]
+    public array $permissions = [];
+
+    #[Column(type: ColumnType::String, size: 255, required: true)]
+    public string $name = '';
+
+    #[Column(type: ColumnType::String, size: 255, required: true)]
+    public string $email = '';
+
+    #[Column(type: ColumnType::Integer, size: 0)]
+    public int $age = 0;
+
+    #[Column(type: ColumnType::Boolean)]
+    public bool $active = true;
+
+    #[HasMany(target: TestPost::class, key: 'posts', twoWayKey: 'author')]
+    public array $posts = [];
+}
diff --git a/tests/unit/ORM/TestNoRelationsEntity.php b/tests/unit/ORM/TestNoRelationsEntity.php
new file mode 100644
index 000000000..c60c14039
--- /dev/null
+++ b/tests/unit/ORM/TestNoRelationsEntity.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace Tests\Unit\ORM;
+
+use Utopia\Database\ORM\Mapping\Column;
+use Utopia\Database\ORM\Mapping\Entity;
+use Utopia\Database\ORM\Mapping\Id;
+use Utopia\Query\Schema\ColumnType;
+
+#[Entity(collection: 'no_relations')]
+class TestNoRelationsEntity
+{
+    #[Id]
+    public string $id = '';
+
+    #[Column(type: ColumnType::String, size: 100)]
+    public string $label = '';
+}
diff --git a/tests/unit/ORM/TestPermissionEntity.php b/tests/unit/ORM/TestPermissionEntity.php
new file mode 100644
index 000000000..078820e4a
--- /dev/null
+++ b/tests/unit/ORM/TestPermissionEntity.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace Tests\Unit\ORM;
+
+use Utopia\Database\ORM\Mapping\Column;
+use Utopia\Database\ORM\Mapping\Entity;
+use Utopia\Database\ORM\Mapping\Id;
+use Utopia\Query\Schema\ColumnType;
+
+#[Entity(collection: 'permission_items', documentSecurity: false, permissions: ['read("any")', 'write("users")'])]
+class TestPermissionEntity
+{
+    #[Id]
+    public string $id = '';
+
+    #[Column(type: ColumnType::String, size: 100)]
+    public string $name = '';
+}
diff --git a/tests/unit/ORM/TestPost.php b/tests/unit/ORM/TestPost.php
new file mode 100644
index 000000000..10621642d
--- /dev/null
+++ b/tests/unit/ORM/TestPost.php
@@ -0,0 +1,25 @@
+<?php
+
+namespace Tests\Unit\ORM;
+
+use Utopia\Database\ORM\Mapping\BelongsTo;
+use Utopia\Database\ORM\Mapping\Column;
+use Utopia\Database\ORM\Mapping\Entity;
+use Utopia\Database\ORM\Mapping\Id;
+use Utopia\Query\Schema\ColumnType;
+
+#[Entity(collection: 'posts')]
+class TestPost
+{
+    #[Id]
+    public string $id = '';
+
+    #[Column(type: ColumnType::String, size: 255, required: true)]
+    public string $title = '';
+
+    #[Column(type: ColumnType::String, size: 10000)]
+    public string $content = '';
+
+    #[BelongsTo(target: TestEntity::class, key: 'author', twoWayKey: 'posts')]
+    public mixed $author = null;
+}
diff --git a/tests/unit/ORM/TestTenantEntity.php b/tests/unit/ORM/TestTenantEntity.php
new file mode 100644
index 000000000..ed63a1a4f
--- /dev/null
+++ b/tests/unit/ORM/TestTenantEntity.php
@@ -0,0 +1,22 @@
+<?php
+
+namespace Tests\Unit\ORM;
+
+use Utopia\Database\ORM\Mapping\Column;
+use Utopia\Database\ORM\Mapping\Entity;
+use Utopia\Database\ORM\Mapping\Id;
+use Utopia\Database\ORM\Mapping\Tenant;
+use Utopia\Query\Schema\ColumnType;
+
+#[Entity(collection: 'tenant_items')]
+class TestTenantEntity
+{
+    #[Id]
+    public string $id = '';
+
+    #[Tenant]
+    public ?string $tenantId = null;
+
+    #[Column(type: ColumnType::String, size: 100)]
+    public string $name = '';
+}
diff --git a/tests/unit/ORM/UnitOfWorkAdvancedTest.php b/tests/unit/ORM/UnitOfWorkAdvancedTest.php
new file mode 100644
index 000000000..d43ae4267
--- /dev/null
+++ b/tests/unit/ORM/UnitOfWorkAdvancedTest.php
@@ -0,0 +1,511 @@
+<?php
+
+namespace Tests\Unit\ORM;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\ORM\EntityMapper;
+use Utopia\Database\ORM\EntityState;
+use Utopia\Database\ORM\IdentityMap;
+use Utopia\Database\ORM\MetadataFactory;
+use Utopia\Database\ORM\UnitOfWork;
+
+class UnitOfWorkAdvancedTest extends TestCase
+{
+    private UnitOfWork $uow;
+
+    private IdentityMap $identityMap;
+
+    private MetadataFactory $metadataFactory;
+
+    private EntityMapper $mapper;
+
+    protected function setUp(): void
+    {
+        MetadataFactory::clearCache();
+        $this->identityMap = new IdentityMap();
+        $this->metadataFactory = new MetadataFactory();
+        $this->mapper = new EntityMapper($this->metadataFactory);
+        $this->uow = new UnitOfWork($this->identityMap, $this->metadataFactory, $this->mapper);
+    }
+
+    public function testFlushWithNoChangesDoesNothing(): void
+    {
+        $db = $this->createMock(Database::class);
+
+        $db->expects($this->never())
+            ->method('withTransaction');
+
+        $this->uow->flush($db);
+    }
+
+    public function testFlushProcessesInsertsBeforeUpdatesBeforeDeletes(): void
+    {
+        $insertEntity = new TestEntity();
+        $insertEntity->id = 'insert-1';
+        $insertEntity->name = 'Insert';
+        $insertEntity->email = 'insert@example.com';
+        $insertEntity->age = 20;
+        $insertEntity->active = true;
+
+        $updateEntity = new TestEntity();
+        $updateEntity->id = 'update-1';
+        $updateEntity->name = 'Before';
+        $updateEntity->email = 'update@example.com';
+        $updateEntity->age = 25;
+        $updateEntity->active = true;
+
+        $deleteEntity = new TestEntity();
+        $deleteEntity->id = 'delete-1';
+        $deleteEntity->name = 'Delete';
+        $deleteEntity->email = 'delete@example.com';
+        $deleteEntity->age = 30;
+        $deleteEntity->active = true;
+
+        $metadata = $this->metadataFactory->getMetadata(TestEntity::class);
+
+        $this->identityMap->put('users', 'update-1', $updateEntity);
+        $this->uow->registerManaged($updateEntity, $metadata);
+        $updateEntity->name = 'After';
+
+        $this->identityMap->put('users', 'delete-1', $deleteEntity);
+        $this->uow->registerManaged($deleteEntity, $metadata);
+        $this->uow->remove($deleteEntity);
+
+        $this->uow->persist($insertEntity);
+
+        $callOrder = [];
+        $db = $this->createMock(Database::class);
+
+        $db->expects($this->once())
+            ->method('withTransaction')
+            ->willReturnCallback(function (callable $callback) {
+                return $callback();
+            });
+
+        $db->method('createDocument')
+            ->willReturnCallback(function (string $collection, Document $doc) use (&$callOrder) {
+                $callOrder[] = 'insert';
+
+                return $doc;
+            });
+
+        $db->method('updateDocument')
+            ->willReturnCallback(function (string $collection, string $id, Document $doc) use (&$callOrder) {
+                $callOrder[] = 'update';
+
+                return $doc;
+            });
+
+        $db->method('deleteDocument')
+            ->willReturnCallback(function (string $collection, string $id) use (&$callOrder) {
+                $callOrder[] = 'delete';
+
+                return true;
+            });
+
+        $this->uow->flush($db);
+
+        $this->assertEquals(['insert', 'update', 'delete'], $callOrder);
+    }
+
+    public function testRegisterManagedSetsStateAndTakesSnapshot(): void
+    {
+        $entity = new TestEntity();
+        $entity->id = 'reg-1';
+        $entity->name = 'Registered';
+        $entity->email = 'reg@example.com';
+        $entity->age = 30;
+        $entity->active = true;
+
+        $metadata = $this->metadataFactory->getMetadata(TestEntity::class);
+        $this->uow->registerManaged($entity, $metadata);
+
+        $this->assertEquals(EntityState::Managed, $this->uow->getState($entity));
+    }
+
+    public function testDirtyDetectionUnchangedEntityNotQueuedForUpdate(): void
+    {
+        $entity = new TestEntity();
+        $entity->id = 'dirty-no-1';
+        $entity->name = 'Clean';
+        $entity->email = 'clean@example.com';
+        $entity->age = 20;
+        $entity->active = true;
+
+        $metadata = $this->metadataFactory->getMetadata(TestEntity::class);
+        $this->identityMap->put('users', 'dirty-no-1', $entity);
+        $this->uow->registerManaged($entity, $metadata);
+
+        $db = $this->createMock(Database::class);
+
+        $db->expects($this->never())
+            ->method('withTransaction');
+
+        $db->expects($this->never())
+            ->method('updateDocument');
+
+        $this->uow->flush($db);
+    }
+
+    public function testDirtyDetectionChangedColumnQueuedForUpdate(): void
+    {
+        $entity = new TestEntity();
+        $entity->id = 'dirty-col-1';
+        $entity->name = 'Before';
+        $entity->email = 'dirty@example.com';
+        $entity->age = 20;
+        $entity->active = true;
+
+        $metadata = $this->metadataFactory->getMetadata(TestEntity::class);
+        $this->identityMap->put('users', 'dirty-col-1', $entity);
+        $this->uow->registerManaged($entity, $metadata);
+
+        $entity->name = 'After';
+
+        $db = $this->createMock(Database::class);
+
+        $db->expects($this->once())
+            ->method('withTransaction')
+            ->willReturnCallback(function (callable $callback) {
+                return $callback();
+            });
+
+        $updatedDoc = new Document([
+            '$id' => 'dirty-col-1',
+            '$version' => 2,
+            '$createdAt' => '2024-01-01 00:00:00',
+            '$updatedAt' => '2024-01-02 00:00:00',
+            'name' => 'After',
+        ]);
+
+        $db->expects($this->once())
+            ->method('updateDocument')
+            ->with('users', 'dirty-col-1', $this->isInstanceOf(Document::class))
+            ->willReturn($updatedDoc);
+
+        $this->uow->flush($db);
+    }
+
+    public function testDirtyDetectionChangedRelationshipQueuedForUpdate(): void
+    {
+        $entity = new TestEntity();
+        $entity->id = 'dirty-rel-1';
+        $entity->name = 'User';
+        $entity->email = 'user@example.com';
+        $entity->age = 25;
+        $entity->active = true;
+        $entity->posts = [];
+
+        $metadata = $this->metadataFactory->getMetadata(TestEntity::class);
+        $this->identityMap->put('users', 'dirty-rel-1', $entity);
+        $this->uow->registerManaged($entity, $metadata);
+
+        $post = new TestPost();
+        $post->id = 'new-post-1';
+        $post->title = 'New Post';
+        $post->content = 'Content';
+        $entity->posts = [$post];
+
+        $db = $this->createMock(Database::class);
+
+        $db->expects($this->once())
+            ->method('withTransaction')
+            ->willReturnCallback(function (callable $callback) {
+                return $callback();
+            });
+
+        $db->expects($this->once())
+            ->method('updateDocument')
+            ->willReturn(new Document(['$id' => 'dirty-rel-1']));
+
+        $this->uow->flush($db);
+    }
+
+    public function testDetachRemovesFromIdentityMap(): void
+    {
+        $entity = new TestEntity();
+        $entity->id = 'detach-map-1';
+        $entity->name = 'Detach';
+        $entity->email = 'detach@example.com';
+        $entity->age = 20;
+        $entity->active = true;
+
+        $metadata = $this->metadataFactory->getMetadata(TestEntity::class);
+        $this->identityMap->put('users', 'detach-map-1', $entity);
+        $this->uow->registerManaged($entity, $metadata);
+
+        $this->uow->detach($entity);
+
+        $this->assertFalse($this->identityMap->has('users', 'detach-map-1'));
+    }
+
+    public function testDetachRemovesFromScheduledInsertions(): void
+    {
+        $entity = new TestEntity();
+        $entity->id = 'detach-ins-1';
+        $entity->name = 'DetachIns';
+        $entity->email = 'detachins@example.com';
+        $entity->age = 20;
+        $entity->active = true;
+
+        $this->uow->persist($entity);
+        $this->assertEquals(EntityState::New, $this->uow->getState($entity));
+
+        $this->uow->detach($entity);
+
+        $this->assertNull($this->uow->getState($entity));
+
+        $db = $this->createMock(Database::class);
+        $db->expects($this->never())->method('withTransaction');
+        $db->expects($this->never())->method('createDocument');
+
+        $this->uow->flush($db);
+    }
+
+    public function testDetachRemovesFromScheduledDeletions(): void
+    {
+        $entity = new TestEntity();
+        $entity->id = 'detach-del-1';
+        $entity->name = 'DetachDel';
+        $entity->email = 'detachdel@example.com';
+        $entity->age = 20;
+        $entity->active = true;
+
+        $metadata = $this->metadataFactory->getMetadata(TestEntity::class);
+        $this->identityMap->put('users', 'detach-del-1', $entity);
+        $this->uow->registerManaged($entity, $metadata);
+        $this->uow->remove($entity);
+        $this->assertEquals(EntityState::Removed, $this->uow->getState($entity));
+
+        $this->uow->detach($entity);
+
+        $this->assertNull($this->uow->getState($entity));
+
+        $db = $this->createMock(Database::class);
+        $db->expects($this->never())->method('withTransaction');
+        $db->expects($this->never())->method('deleteDocument');
+
+        $this->uow->flush($db);
+    }
+
+    public function testClearResetsAllSplObjectStorage(): void
+    {
+        $e1 = new TestEntity();
+        $e1->id = 'clear-1';
+        $e1->name = 'A';
+        $e1->email = 'a@example.com';
+        $e1->age = 20;
+        $e1->active = true;
+
+        $e2 = new TestEntity();
+        $e2->id = 'clear-2';
+        $e2->name = 'B';
+        $e2->email = 'b@example.com';
+        $e2->age = 25;
+        $e2->active = true;
+
+        $metadata = $this->metadataFactory->getMetadata(TestEntity::class);
+        $this->identityMap->put('users', 'clear-2', $e2);
+        $this->uow->registerManaged($e2, $metadata);
+
+        $this->uow->persist($e1);
+        $this->uow->remove($e2);
+
+        $this->uow->clear();
+
+        $this->assertNull($this->uow->getState($e1));
+        $this->assertNull($this->uow->getState($e2));
+        $this->assertEmpty(\iterator_to_array($this->identityMap->all()));
+    }
+
+    public function testCascadePersistDeeplyNestedEntities(): void
+    {
+        $innerPost = new TestPost();
+        $innerPost->id = 'deep-post';
+        $innerPost->title = 'Deep Post';
+        $innerPost->content = 'Content';
+
+        $author = new TestEntity();
+        $author->id = 'deep-author';
+        $author->name = 'Deep Author';
+        $author->email = 'deep@example.com';
+        $author->age = 30;
+        $author->active = true;
+        $author->posts = [$innerPost];
+
+        $innerPost->author = $author;
+
+        $outerUser = new TestEntity();
+        $outerUser->id = 'outer-user';
+        $outerUser->name = 'Outer';
+        $outerUser->email = 'outer@example.com';
+        $outerUser->age = 40;
+        $outerUser->active = true;
+        $outerUser->posts = [$innerPost];
+
+        $this->uow->persist($outerUser);
+
+        $this->assertEquals(EntityState::New, $this->uow->getState($outerUser));
+        $this->assertEquals(EntityState::New, $this->uow->getState($innerPost));
+        $this->assertEquals(EntityState::New, $this->uow->getState($author));
+    }
+
+    public function testCascadePersistDoesNotRepersistTrackedEntities(): void
+    {
+        $post = new TestPost();
+        $post->id = 'tracked-post';
+        $post->title = 'Tracked';
+        $post->content = 'Content';
+
+        $user = new TestEntity();
+        $user->id = 'tracked-user';
+        $user->name = 'Tracked';
+        $user->email = 'tracked@example.com';
+        $user->age = 25;
+        $user->active = true;
+        $user->posts = [$post];
+
+        $this->uow->persist($post);
+        $this->assertEquals(EntityState::New, $this->uow->getState($post));
+
+        $this->uow->persist($user);
+        $this->assertEquals(EntityState::New, $this->uow->getState($user));
+        $this->assertEquals(EntityState::New, $this->uow->getState($post));
+    }
+
+    public function testRemoveUntrackedEntityDoesNothing(): void
+    {
+        $entity = new TestEntity();
+        $entity->id = 'untracked-1';
+        $entity->name = 'Untracked';
+        $entity->email = 'untracked@example.com';
+
+        $this->uow->remove($entity);
+
+        $this->assertNull($this->uow->getState($entity));
+    }
+
+    public function testFlushClearsScheduledInsertionsAfterExecution(): void
+    {
+        $entity = new TestEntity();
+        $entity->id = 'flush-clear-1';
+        $entity->name = 'FlushClear';
+        $entity->email = 'flushclear@example.com';
+        $entity->age = 20;
+        $entity->active = true;
+
+        $this->uow->persist($entity);
+
+        $db = self::createStub(Database::class);
+        $db->method('withTransaction')
+            ->willReturnCallback(function (callable $callback) {
+                return $callback();
+            });
+
+        $createdDoc = new Document([
+            '$id' => 'flush-clear-1',
+            '$version' => 1,
+            '$createdAt' => '2024-01-01 00:00:00',
+            '$updatedAt' => '2024-01-01 00:00:00',
+        ]);
+
+        $db->method('createDocument')->willReturn($createdDoc);
+
+        $this->uow->flush($db);
+
+        $db2 = $this->createMock(Database::class);
+        $db2->expects($this->never())->method('withTransaction');
+
+        $this->uow->flush($db2);
+    }
+
+    public function testFlushClearsScheduledDeletionsAfterExecution(): void
+    {
+        $entity = new TestEntity();
+        $entity->id = 'flush-del-clear';
+        $entity->name = 'FlushDelClear';
+        $entity->email = 'flushdelclear@example.com';
+        $entity->age = 20;
+        $entity->active = true;
+
+        $metadata = $this->metadataFactory->getMetadata(TestEntity::class);
+        $this->identityMap->put('users', 'flush-del-clear', $entity);
+        $this->uow->registerManaged($entity, $metadata);
+        $this->uow->remove($entity);
+
+        $db = self::createStub(Database::class);
+        $db->method('withTransaction')
+            ->willReturnCallback(function (callable $callback) {
+                return $callback();
+            });
+        $db->method('deleteDocument')->willReturn(true);
+
+        $this->uow->flush($db);
+
+        $db2 = $this->createMock(Database::class);
+        $db2->expects($this->never())->method('withTransaction');
+
+        $this->uow->flush($db2);
+    }
+
+    public function testFlushInsertTransitionsEntityToManaged(): void
+    {
+        $entity = new TestEntity();
+        $entity->id = 'transition-1';
+        $entity->name = 'Transition';
+        $entity->email = 'transition@example.com';
+        $entity->age = 20;
+        $entity->active = true;
+
+        $this->uow->persist($entity);
+        $this->assertEquals(EntityState::New, $this->uow->getState($entity));
+
+        $db = self::createStub(Database::class);
+        $db->method('withTransaction')
+            ->willReturnCallback(function (callable $callback) {
+                return $callback();
+            });
+
+        $createdDoc = new Document([
+            '$id' => 'transition-1',
+            '$version' => 1,
+            '$createdAt' => '2024-01-01 00:00:00',
+            '$updatedAt' => '2024-01-01 00:00:00',
+        ]);
+
+        $db->method('createDocument')->willReturn($createdDoc);
+
+        $this->uow->flush($db);
+
+        $this->assertEquals(EntityState::Managed, $this->uow->getState($entity));
+    }
+
+    public function testFlushDeleteRemovesEntityFromTracking(): void
+    {
+        $entity = new TestEntity();
+        $entity->id = 'del-track-1';
+        $entity->name = 'DelTrack';
+        $entity->email = 'deltrack@example.com';
+        $entity->age = 20;
+        $entity->active = true;
+
+        $metadata = $this->metadataFactory->getMetadata(TestEntity::class);
+        $this->identityMap->put('users', 'del-track-1', $entity);
+        $this->uow->registerManaged($entity, $metadata);
+        $this->uow->remove($entity);
+
+        $db = self::createStub(Database::class);
+        $db->method('withTransaction')
+            ->willReturnCallback(function (callable $callback) {
+                return $callback();
+            });
+        $db->method('deleteDocument')->willReturn(true);
+
+        $this->uow->flush($db);
+
+        $this->assertNull($this->uow->getState($entity));
+        $this->assertFalse($this->identityMap->has('users', 'del-track-1'));
+    }
+}
diff --git a/tests/unit/ORM/UnitOfWorkTest.php b/tests/unit/ORM/UnitOfWorkTest.php
new file mode 100644
index 000000000..07a493187
--- /dev/null
+++ b/tests/unit/ORM/UnitOfWorkTest.php
@@ -0,0 +1,159 @@
+<?php
+
+namespace Tests\Unit\ORM;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\ORM\EntityMapper;
+use Utopia\Database\ORM\EntityState;
+use Utopia\Database\ORM\IdentityMap;
+use Utopia\Database\ORM\MetadataFactory;
+use Utopia\Database\ORM\UnitOfWork;
+
+class UnitOfWorkTest extends TestCase
+{
+    private UnitOfWork $uow;
+
+    private IdentityMap $identityMap;
+
+    private MetadataFactory $metadataFactory;
+
+    protected function setUp(): void
+    {
+        MetadataFactory::clearCache();
+        $this->identityMap = new IdentityMap();
+        $this->metadataFactory = new MetadataFactory();
+        $mapper = new EntityMapper($this->metadataFactory);
+        $this->uow = new UnitOfWork($this->identityMap, $this->metadataFactory, $mapper);
+    }
+
+    public function testPersistNewEntity(): void
+    {
+        $entity = new TestEntity();
+        $entity->id = 'new-1';
+        $entity->name = 'Test';
+        $entity->email = 'test@example.com';
+
+        $this->uow->persist($entity);
+
+        $this->assertEquals(EntityState::New, $this->uow->getState($entity));
+    }
+
+    public function testPersistIdempotent(): void
+    {
+        $entity = new TestEntity();
+        $entity->id = 'new-2';
+        $entity->name = 'Test';
+        $entity->email = 'test@example.com';
+
+        $this->uow->persist($entity);
+        $this->uow->persist($entity);
+
+        $this->assertEquals(EntityState::New, $this->uow->getState($entity));
+    }
+
+    public function testRemoveNewEntityUnracks(): void
+    {
+        $entity = new TestEntity();
+        $entity->id = 'new-3';
+        $entity->name = 'Test';
+        $entity->email = 'test@example.com';
+
+        $this->uow->persist($entity);
+        $this->uow->remove($entity);
+
+        $this->assertNull($this->uow->getState($entity));
+    }
+
+    public function testRemoveManagedEntitySchedulesDeletion(): void
+    {
+        $entity = new TestEntity();
+        $entity->id = 'managed-1';
+        $entity->name = 'Test';
+        $entity->email = 'test@example.com';
+
+        $metadata = $this->metadataFactory->getMetadata(TestEntity::class);
+        $this->identityMap->put('users', 'managed-1', $entity);
+        $this->uow->registerManaged($entity, $metadata);
+
+        $this->assertEquals(EntityState::Managed, $this->uow->getState($entity));
+
+        $this->uow->remove($entity);
+
+        $this->assertEquals(EntityState::Removed, $this->uow->getState($entity));
+    }
+
+    public function testPersistRemovedEntityRestoresManaged(): void
+    {
+        $entity = new TestEntity();
+        $entity->id = 'managed-2';
+        $entity->name = 'Test';
+        $entity->email = 'test@example.com';
+
+        $metadata = $this->metadataFactory->getMetadata(TestEntity::class);
+        $this->identityMap->put('users', 'managed-2', $entity);
+        $this->uow->registerManaged($entity, $metadata);
+        $this->uow->remove($entity);
+        $this->uow->persist($entity);
+
+        $this->assertEquals(EntityState::Managed, $this->uow->getState($entity));
+    }
+
+    public function testDetach(): void
+    {
+        $entity = new TestEntity();
+        $entity->id = 'detach-1';
+        $entity->name = 'Test';
+        $entity->email = 'test@example.com';
+
+        $this->uow->persist($entity);
+        $this->uow->detach($entity);
+
+        $this->assertNull($this->uow->getState($entity));
+    }
+
+    public function testClear(): void
+    {
+        $e1 = new TestEntity();
+        $e1->id = 'clear-1';
+        $e1->name = 'A';
+        $e1->email = 'a@example.com';
+
+        $e2 = new TestEntity();
+        $e2->id = 'clear-2';
+        $e2->name = 'B';
+        $e2->email = 'b@example.com';
+
+        $this->uow->persist($e1);
+        $this->uow->persist($e2);
+        $this->uow->clear();
+
+        $this->assertNull($this->uow->getState($e1));
+        $this->assertNull($this->uow->getState($e2));
+        $this->assertEmpty(\iterator_to_array($this->identityMap->all()));
+    }
+
+    public function testGetStateReturnsNullForUntracked(): void
+    {
+        $entity = new TestEntity();
+        $this->assertNull($this->uow->getState($entity));
+    }
+
+    public function testCascadePersistRelatedEntities(): void
+    {
+        $post = new TestPost();
+        $post->id = 'post-1';
+        $post->title = 'My Post';
+        $post->content = 'Content';
+
+        $user = new TestEntity();
+        $user->id = 'cascade-1';
+        $user->name = 'User';
+        $user->email = 'user@example.com';
+        $user->posts = [$post];
+
+        $this->uow->persist($user);
+
+        $this->assertEquals(EntityState::New, $this->uow->getState($user));
+        $this->assertEquals(EntityState::New, $this->uow->getState($post));
+    }
+}
diff --git a/tests/unit/ObjectAttribute/ObjectAttributeValidationTest.php b/tests/unit/ObjectAttribute/ObjectAttributeValidationTest.php
new file mode 100644
index 000000000..29c6c0673
--- /dev/null
+++ b/tests/unit/ObjectAttribute/ObjectAttributeValidationTest.php
@@ -0,0 +1,260 @@
+<?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('castingBefore')->willReturnArgument(1);
+        $this->adapter->method('castingAfter')->willReturnArgument(1);
+        $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,
+        ]);
+    }
+
+    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,
+        ]);
+    }
+
+    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'));
+
+        $this->assertIsArray($doc->getAttribute('settings'));
+        $this->assertEquals('light', $doc->getAttribute('settings')['config']['theme']);
+
+        $this->assertEquals('provided', $doc->getAttribute('profile')['name']);
+
+        $this->assertIsArray($doc->getAttribute('profile2'));
+        $this->assertEquals('anon', $doc->getAttribute('profile2')['name']);
+
+        $this->assertNull($doc->getAttribute('misc'));
+    }
+}
diff --git a/tests/unit/Operator/OperatorValidationTest.php b/tests/unit/Operator/OperatorValidationTest.php
new file mode 100644
index 000000000..a317f3662
--- /dev/null
+++ b/tests/unit/Operator/OperatorValidationTest.php
@@ -0,0 +1,1522 @@
+<?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
+{
+    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' => [],
+        ]);
+    }
+
+    private function makeValidator(array $attributes, ?Document $currentDoc = null): OperatorValidator
+    {
+        return new OperatorValidator($this->makeCollection($attributes), $currentDoc);
+    }
+
+    private function makeOperator(OperatorType $method, string $attribute, array $values = []): Operator
+    {
+        return new Operator($method, $attribute, $values);
+    }
+
+    public function testIncrementOnInteger(): void
+    {
+        $validator = $this->makeValidator([
+            new Attribute(key: 'count', type: ColumnType::Integer, size: 0),
+        ]);
+
+        $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([
+            new Attribute(key: 'count', type: ColumnType::Integer, size: 0),
+        ], $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([
+            new Attribute(key: 'count', type: ColumnType::Integer, size: 0),
+        ]);
+
+        $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([
+            new Attribute(key: 'count', type: ColumnType::Integer, size: 0),
+        ], $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([
+            new Attribute(key: 'value', type: ColumnType::Integer, size: 0),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Multiply, 'value', [3]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testMultiplyOnFloat(): void
+    {
+        $validator = $this->makeValidator([
+            new Attribute(key: 'score', type: ColumnType::Double, size: 0),
+        ]);
+
+        $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([
+            new Attribute(key: 'value', type: ColumnType::Integer, size: 0),
+        ], $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([
+            new Attribute(key: 'value', type: ColumnType::Integer, size: 0),
+        ], $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([
+            new Attribute(key: 'value', type: ColumnType::Integer, size: 0),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Divide, 'value', [2]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testDivideOnFloat(): void
+    {
+        $validator = $this->makeValidator([
+            new Attribute(key: 'score', type: ColumnType::Double, size: 0),
+        ]);
+
+        $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([
+            new Attribute(key: 'value', type: ColumnType::Integer, size: 0),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Divide, 'value', [0]);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('division', $validator->getDescription());
+    }
+
+    public function testModuloOnInteger(): void
+    {
+        $validator = $this->makeValidator([
+            new Attribute(key: 'value', type: ColumnType::Integer, size: 0),
+        ]);
+
+        $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([
+            new Attribute(key: 'value', type: ColumnType::Integer, size: 0),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Modulo, 'value', [0]);
+        $this->assertFalse($validator->isValid($op));
+        $this->assertStringContainsString('modulo', $validator->getDescription());
+    }
+
+    public function testModuloNegative(): void
+    {
+        $validator = $this->makeValidator([
+            new Attribute(key: 'value', type: ColumnType::Integer, size: 0),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Modulo, 'value', [-3]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testPowerOnInteger(): void
+    {
+        $validator = $this->makeValidator([
+            new Attribute(key: 'value', type: ColumnType::Integer, size: 0),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Power, 'value', [3]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testPowerFractional(): void
+    {
+        $validator = $this->makeValidator([
+            new Attribute(key: 'value', type: ColumnType::Double, size: 0),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Power, 'value', [0.5]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testPowerNegativeExponent(): void
+    {
+        $validator = $this->makeValidator([
+            new Attribute(key: 'value', type: ColumnType::Double, size: 0),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Power, 'value', [-2]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testPowerOverflow(): void
+    {
+        $currentDoc = new Document(['value' => 100]);
+        $validator = $this->makeValidator([
+            new Attribute(key: 'value', type: ColumnType::Integer, size: 0),
+        ], $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([
+            new Attribute(key: 'title', type: ColumnType::String, size: 255),
+        ]);
+
+        $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([
+            new Attribute(key: 'title', type: ColumnType::String, 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([
+            new Attribute(key: 'title', type: ColumnType::String, 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([
+            new Attribute(key: 'title', type: ColumnType::String, size: 255),
+        ]);
+
+        $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([
+            new Attribute(key: 'title', type: ColumnType::String, size: 255),
+        ]);
+
+        $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([
+            new Attribute(key: 'text', type: ColumnType::String, size: 255),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::StringReplace, 'text', ['old', 'new']);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testStringReplaceMultipleOccurrences(): void
+    {
+        $validator = $this->makeValidator([
+            new Attribute(key: 'text', type: ColumnType::String, size: 255),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::StringReplace, 'text', ['test', 'demo']);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testStringReplaceValidation(): void
+    {
+        $validator = $this->makeValidator([
+            new Attribute(key: 'text', type: ColumnType::String, size: 255),
+        ]);
+
+        $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([
+            new Attribute(key: 'text', type: ColumnType::String, size: 255),
+        ]);
+
+        $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([
+            new Attribute(key: 'number', type: ColumnType::Integer, size: 0),
+        ]);
+
+        $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([
+            new Attribute(key: 'active', type: ColumnType::Boolean, size: 0),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Toggle, 'active', []);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testToggleFromDefault(): void
+    {
+        $validator = $this->makeValidator([
+            new Attribute(key: 'active', type: ColumnType::Boolean, size: 0, default: false),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Toggle, 'active', []);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testToggleOnNonBoolean(): void
+    {
+        $validator = $this->makeValidator([
+            new Attribute(key: 'count', type: ColumnType::Integer, size: 0),
+        ]);
+
+        $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([
+            new Attribute(key: 'name', type: ColumnType::String, size: 255),
+        ]);
+
+        $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([
+            new Attribute(key: 'date', type: ColumnType::Datetime, size: 0),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::DateAddDays, 'date', [5]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testDateSubDays(): void
+    {
+        $validator = $this->makeValidator([
+            new Attribute(key: 'date', type: ColumnType::Datetime, size: 0),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::DateSubDays, 'date', [3]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testDateSetNow(): void
+    {
+        $validator = $this->makeValidator([
+            new Attribute(key: 'timestamp', type: ColumnType::Datetime, size: 0),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::DateSetNow, 'timestamp', []);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testDateAtYearBoundaries(): void
+    {
+        $validator = $this->makeValidator([
+            new Attribute(key: 'date', type: ColumnType::Datetime, size: 0),
+        ]);
+
+        $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([
+            new Attribute(key: 'name', type: ColumnType::String, size: 255),
+        ]);
+
+        $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([
+            new Attribute(key: 'date', type: ColumnType::Datetime, size: 0),
+        ]);
+
+        $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([
+            new Attribute(key: 'date', type: ColumnType::Datetime, size: 0),
+        ]);
+
+        $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([
+            new Attribute(key: 'name', type: ColumnType::String, size: 255),
+        ]);
+
+        $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([
+            new Attribute(key: 'tags', type: ColumnType::String, size: 50, array: true),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::ArrayAppend, 'tags', ['new', 'items']);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testArrayAppendViolatesConstraints(): void
+    {
+        $validator = $this->makeValidator([
+            new Attribute(key: 'name', type: ColumnType::String, size: 255, array: false),
+        ]);
+
+        $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([
+            new Attribute(key: 'numbers', type: ColumnType::Integer, size: 0, 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([
+            new Attribute(key: 'tags', type: ColumnType::String, size: 50, array: true),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::ArrayPrepend, 'tags', ['first', 'second']);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testArrayPrependOnNonArray(): void
+    {
+        $validator = $this->makeValidator([
+            new Attribute(key: 'name', type: ColumnType::String, size: 255),
+        ]);
+
+        $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([
+            new Attribute(key: 'numbers', type: ColumnType::Integer, size: 0, 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([
+            new Attribute(key: 'numbers', type: ColumnType::Integer, size: 0, 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([
+            new Attribute(key: 'items', type: ColumnType::String, 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([
+            new Attribute(key: 'items', type: ColumnType::String, 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([
+            new Attribute(key: 'items', type: ColumnType::String, 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([
+            new Attribute(key: 'name', type: ColumnType::String, size: 255),
+        ]);
+
+        $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([
+            new Attribute(key: 'tags', type: ColumnType::String, size: 50, array: true),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::ArrayRemove, 'tags', ['unwanted']);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testArrayRemoveOnNonArray(): void
+    {
+        $validator = $this->makeValidator([
+            new Attribute(key: 'name', type: ColumnType::String, size: 255),
+        ]);
+
+        $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([
+            new Attribute(key: 'tags', type: ColumnType::String, 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([
+            new Attribute(key: 'numbers', type: ColumnType::Integer, size: 0, array: true),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::ArrayFilter, 'numbers', ['greaterThan', 5]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testArrayFilterNumeric(): void
+    {
+        $validator = $this->makeValidator([
+            new Attribute(key: 'numbers', type: ColumnType::Integer, size: 0, 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([
+            new Attribute(key: 'numbers', type: ColumnType::Integer, size: 0, 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([
+            new Attribute(key: 'name', type: ColumnType::String, size: 255),
+        ]);
+
+        $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([
+            new Attribute(key: 'numbers', type: ColumnType::Integer, size: 0, 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([
+            new Attribute(key: 'numbers', type: ColumnType::Integer, size: 0, 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([
+            new Attribute(key: 'numbers', type: ColumnType::Integer, size: 0, 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([
+            new Attribute(key: 'tags', type: ColumnType::String, 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([
+            new Attribute(key: 'tags', type: ColumnType::String, 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([
+            new Attribute(key: 'name', type: ColumnType::String, size: 255),
+        ]);
+
+        $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([
+            new Attribute(key: 'items', type: ColumnType::String, 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([
+            new Attribute(key: 'items', type: ColumnType::String, 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([
+            new Attribute(key: 'name', type: ColumnType::String, size: 255),
+        ]);
+
+        $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([
+            new Attribute(key: 'items', type: ColumnType::String, size: 50, array: true),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::ArrayUnique, 'items', []);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testArrayUniqueOnNonArray(): void
+    {
+        $validator = $this->makeValidator([
+            new Attribute(key: 'name', type: ColumnType::String, size: 255),
+        ]);
+
+        $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([
+            new Attribute(key: 'items', type: ColumnType::String, 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([
+            new Attribute(key: 'items', type: ColumnType::String, 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([
+            new Attribute(key: 'items', type: ColumnType::String, size: 50, array: true),
+        ], $currentDoc);
+
+        $opAppend = $this->makeOperator(OperatorType::ArrayAppend, 'items', ['first']);
+        $this->assertTrue($validator->isValid($opAppend));
+    }
+
+    public function testIncrementOnFloat(): void
+    {
+        $validator = $this->makeValidator([
+            new Attribute(key: 'score', type: ColumnType::Double, size: 0),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Increment, 'score', [1.5]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testIncrementWithPreciseFloats(): void
+    {
+        $validator = $this->makeValidator([
+            new Attribute(key: 'score', type: ColumnType::Double, size: 0),
+        ]);
+
+        $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([
+            new Attribute(key: 'score', type: ColumnType::Double, size: 0),
+        ]);
+
+        $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([
+            new Attribute(key: 'count', type: ColumnType::Integer, size: 0),
+            new Attribute(key: 'score', type: ColumnType::Double, size: 0),
+            new Attribute(key: 'name', type: ColumnType::String, size: 255),
+        ]);
+
+        $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([
+            new Attribute(key: 'count', type: ColumnType::Integer, size: 0),
+            new Attribute(key: 'tags', type: ColumnType::String, size: 50, array: true),
+            new Attribute(key: 'name', type: ColumnType::String, size: 255),
+            new Attribute(key: 'active', type: ColumnType::Boolean, size: 0),
+            new Attribute(key: 'date', type: ColumnType::Datetime, size: 0),
+        ], $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([
+            new Attribute(key: 'count', type: ColumnType::Integer, size: 0),
+        ]);
+
+        $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([
+            new Attribute(key: 'count', type: ColumnType::Integer, size: 0),
+            new Attribute(key: 'name', type: ColumnType::String, 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([
+            new Attribute(key: 'counter', type: ColumnType::Integer, size: 0),
+        ]);
+
+        $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([
+            new Attribute(key: 'counter', type: ColumnType::Integer, size: 0),
+        ]);
+
+        $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([
+            new Attribute(key: 'score', type: ColumnType::Double, size: 0),
+            new Attribute(key: 'tags', type: ColumnType::String, 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([
+            new Attribute(key: 'text', type: ColumnType::String, size: 255),
+        ]);
+
+        $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([
+            new Attribute(key: 'value', type: ColumnType::Integer, size: 0),
+        ], $currentDoc);
+
+        $opMaxInc = $this->makeOperator(OperatorType::Increment, 'value', [Database::MAX_INT]);
+        $this->assertTrue($validator->isValid($opMaxInc));
+
+        $currentDoc2 = new Document(['value' => 1]);
+        $validator2 = $this->makeValidator([
+            new Attribute(key: 'value', type: ColumnType::Integer, size: 0),
+        ], $currentDoc2);
+
+        $opOverflow = $this->makeOperator(OperatorType::Increment, 'value', [Database::MAX_INT]);
+        $this->assertFalse($validator2->isValid($opOverflow));
+    }
+
+    public function testUnicodeCharacters(): void
+    {
+        $validator = $this->makeValidator([
+            new Attribute(key: 'text', type: ColumnType::String, size: 255),
+        ]);
+
+        $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([
+            new Attribute(key: 'text', type: ColumnType::String, 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([
+            new Attribute(key: 'count', type: ColumnType::Integer, size: 0),
+            new Attribute(key: 'score', type: ColumnType::Double, size: 0),
+        ]);
+
+        $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([
+            new Attribute(key: 'count', type: ColumnType::Integer, size: 0),
+            new Attribute(key: 'score', type: ColumnType::Double, size: 0),
+            new Attribute(key: 'tags', type: ColumnType::String, size: 50, array: true),
+            new Attribute(key: 'title', type: ColumnType::String, size: 255),
+            new Attribute(key: 'active', type: ColumnType::Boolean, size: 0),
+            new Attribute(key: 'date', type: ColumnType::Datetime, size: 0),
+        ]);
+
+        $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([
+            new Attribute(key: 'text_field', type: ColumnType::String, 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([
+            new Attribute(key: 'tags', type: ColumnType::String, 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([
+            new Attribute(key: 'active', type: ColumnType::Boolean, size: 0),
+        ]);
+
+        $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([
+            new Attribute(key: 'count', type: ColumnType::Integer, size: 0),
+        ]);
+
+        $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([
+            new Attribute(key: 'count', type: ColumnType::Integer, size: 0),
+        ]);
+
+        $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([
+            new Attribute(key: 'count', type: ColumnType::Integer, size: 0),
+        ]);
+
+        $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([
+            new Attribute(key: 'tags', type: ColumnType::String, 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([
+            new Attribute(key: 'numbers', type: ColumnType::Integer, size: 0, 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([
+            new Attribute(key: 'count', type: ColumnType::Integer, size: 0),
+        ], $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([
+            new Attribute(key: 'score', type: ColumnType::Double, size: 0),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Modulo, 'score', [3.5]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testPowerWithMaxLimit(): void
+    {
+        $validator = $this->makeValidator([
+            new Attribute(key: 'value', type: ColumnType::Integer, size: 0),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Power, 'value', [2, 1000]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testDivideWithMinLimit(): void
+    {
+        $validator = $this->makeValidator([
+            new Attribute(key: 'value', type: ColumnType::Double, size: 0),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Divide, 'value', [2.0, 1.0]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testIncrementWithMaxCap(): void
+    {
+        $validator = $this->makeValidator([
+            new Attribute(key: 'counter', type: ColumnType::Integer, size: 0),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Increment, 'counter', [100, 50]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testDecrementWithMinCap(): void
+    {
+        $validator = $this->makeValidator([
+            new Attribute(key: 'counter', type: ColumnType::Integer, size: 0),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::Decrement, 'counter', [100, 0]);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testOperatorOnNonexistentAttribute(): void
+    {
+        $validator = $this->makeValidator([
+            new Attribute(key: 'count', type: ColumnType::Integer, size: 0),
+        ]);
+
+        $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([
+            new Attribute(key: 'name', type: ColumnType::String, size: 255),
+        ]);
+
+        $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([
+            new Attribute(key: 'name', type: ColumnType::String, size: 255),
+        ]);
+
+        $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([
+            new Attribute(key: 'count', type: ColumnType::Integer, size: 0),
+            new Attribute(key: 'name', type: ColumnType::String, size: 255),
+            new Attribute(key: 'active', type: ColumnType::Boolean, size: 0),
+        ]);
+
+        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([
+            new Attribute(key: 'count', type: ColumnType::Integer, size: 0),
+            new Attribute(key: 'tags', type: ColumnType::String, size: 50, array: true),
+            new Attribute(key: 'name', type: ColumnType::String, size: 255),
+        ]);
+
+        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([
+            new Attribute(key: 'tags', type: ColumnType::String, size: 50, array: true),
+        ]);
+
+        $op = $this->makeOperator(OperatorType::ArrayFilter, 'tags', ['equal', 'active']);
+        $this->assertTrue($validator->isValid($op));
+    }
+
+    public function testArrayFilterNotEqualCondition(): void
+    {
+        $validator = $this->makeValidator([
+            new Attribute(key: 'tags', type: ColumnType::String, 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([
+            new Attribute(key: 'value', type: ColumnType::Integer, size: 0),
+        ], $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([
+            new Attribute(key: 'value', type: ColumnType::Integer, size: 0),
+        ], $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([
+            new Attribute(key: 'value', type: ColumnType::Integer, size: 0),
+        ], $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([
+            new Attribute(key: 'value', type: ColumnType::Integer, size: 0),
+        ], $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([
+            new Attribute(key: 'score', type: ColumnType::Double, size: 0),
+        ], $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([
+            new Attribute(key: 'value', type: ColumnType::Integer, size: 0),
+        ], $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));
+    }
+}
diff --git a/tests/unit/OperatorTest.php b/tests/unit/OperatorTest.php
index 0c07a6d03..cd9d7e0a2 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,13 +230,13 @@ 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);
@@ -260,7 +260,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 +268,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 +281,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 +299,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);
@@ -318,11 +318,11 @@ public function testParseOperators(): void
         $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 +332,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 +372,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 +380,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 +409,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 +421,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 +433,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 +460,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);
@@ -474,30 +474,30 @@ public function testExtractOperatorsWithNewMethods(): void
         // 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 +507,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 +534,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 +555,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 +576,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 +596,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 +620,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 +628,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 +640,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 +653,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 +677,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 +727,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 +734,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 +770,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 +780,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 +795,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 +856,7 @@ public function testNewOperatorParsing(): void
         }
     }
 
-    public function testOperatorCloning(): void
+    public function test_operator_cloning(): void
     {
         // Test cloning all new operator types
         $operators = [
@@ -888,7 +884,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 +911,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 +923,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 +939,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 +956,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 +964,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 +977,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 +995,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 +1017,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 +1034,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 +1056,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 +1064,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 +1077,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 +1095,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 +1118,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 +1139,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 +1147,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 +1160,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 +1178,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 +1201,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 +1225,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 +1244,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 +1252,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 +1265,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 +1283,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 +1306,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 +1329,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 +1337,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 +1350,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 +1368,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 +1390,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 +1407,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 +1430,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 +1438,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 +1451,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 +1469,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 +1491,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(),
@@ -1528,24 +1524,52 @@ public function testExtractOperatorsWithNewOperators(): void
 
         // 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->assertInstanceOf(Operator::class, $operators['commonItems']);
-        $this->assertEquals(Operator::TYPE_ARRAY_INTERSECT, $operators['commonItems']->getMethod());
+        $this->assertEquals(OperatorType::ArrayIntersect, $operators['commonItems']->getMethod());
 
         $this->assertInstanceOf(Operator::class, $operators['filteredList']);
-        $this->assertEquals(Operator::TYPE_ARRAY_DIFF, $operators['filteredList']->getMethod());
+        $this->assertEquals(OperatorType::ArrayDiff, $operators['filteredList']->getMethod());
 
         $this->assertInstanceOf(Operator::class, $operators['activeUsers']);
-        $this->assertEquals(Operator::TYPE_ARRAY_FILTER, $operators['activeUsers']->getMethod());
+        $this->assertEquals(OperatorType::ArrayFilter, $operators['activeUsers']->getMethod());
 
         $this->assertInstanceOf(Operator::class, $operators['expiry']);
-        $this->assertEquals(Operator::TYPE_DATE_ADD_DAYS, $operators['expiry']->getMethod());
+        $this->assertEquals(OperatorType::DateAddDays, $operators['expiry']->getMethod());
 
         $this->assertInstanceOf(Operator::class, $operators['reminder']);
-        $this->assertEquals(Operator::TYPE_DATE_SUB_DAYS, $operators['reminder']->getMethod());
+        $this->assertEquals(OperatorType::DateSubDays, $operators['reminder']->getMethod());
 
         // Check updates
         $this->assertEquals(['name' => 'Regular value'], $updates);
     }
+
+    public function test_clone_deep_copies_nested_operator_values(): void
+    {
+        $nested = Operator::increment(1);
+        $parent = new Operator(OperatorType::ArrayAppend, 'items', [$nested, 'plain']);
+
+        $cloned = clone $parent;
+
+        $parentValues = $parent->getValues();
+        $clonedValues = $cloned->getValues();
+
+        $this->assertNotSame($parentValues[0], $clonedValues[0]);
+        $this->assertInstanceOf(Operator::class, $clonedValues[0]);
+        $this->assertEquals($nested->getMethod(), $clonedValues[0]->getMethod());
+        $this->assertEquals($nested->getValues(), $clonedValues[0]->getValues());
+
+        $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/PDOTest.php b/tests/unit/PDOTest.php
index 45e9a12a2..e3a575c03 100644
--- a/tests/unit/PDOTest.php
+++ b/tests/unit/PDOTest.php
@@ -8,7 +8,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);
@@ -23,25 +23,22 @@ public function testMethodCallIsForwardedToPDO(): void
             ->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)
@@ -52,17 +49,19 @@ 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');
@@ -77,10 +76,10 @@ 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);
@@ -96,17 +95,17 @@ 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);
@@ -119,10 +118,10 @@ public function testReconnectCreatesNewPDOInstance(): void
         $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);
@@ -135,19 +134,17 @@ public function testMethodCallForPrepare(): void
             ->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->assertSame($pdoStatementMock, $result);
+        $this->assertSame($pdoStatementStub, $result);
     }
 }
diff --git a/tests/unit/PermissionTest.php b/tests/unit/PermissionTest.php
index 6ca554f37..7c4ce45ba 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/Profiler/QueryProfilerAdvancedTest.php b/tests/unit/Profiler/QueryProfilerAdvancedTest.php
new file mode 100644
index 000000000..4955e22af
--- /dev/null
+++ b/tests/unit/Profiler/QueryProfilerAdvancedTest.php
@@ -0,0 +1,201 @@
+<?php
+
+namespace Tests\Unit\Profiler;
+
+use PHPUnit\Framework\TestCase;
+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->assertIsArray($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 = null;
+        $this->profiler->onSlowQuery(function ($entry) use (&$received) {
+            $received = $entry;
+        });
+
+        $this->profiler->log('fast', [], 5.0);
+        $this->assertNull($received);
+
+        $this->profiler->log('slow', [], 20.0);
+        $this->assertNotNull($received);
+        $this->assertEquals('slow', $received->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 = null;
+        $this->profiler->onSlowQuery(function ($entry) use (&$received) {
+            $received = $entry;
+        });
+
+        $this->profiler->log('SELECT slow', ['param'], 50.0, 'users', 'find');
+
+        $this->assertNotNull($received);
+        $this->assertEquals('SELECT slow', $received->query);
+        $this->assertEquals(50.0, $received->durationMs);
+        $this->assertEquals('users', $received->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 000000000..c36240507
--- /dev/null
+++ b/tests/unit/Profiler/QueryProfilerTest.php
@@ -0,0 +1,122 @@
+<?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 = false;
+        $this->profiler->onSlowQuery(function () use (&$called) {
+            $called = true;
+        });
+
+        $this->profiler->log('fast', [], 10.0);
+        $this->assertFalse($called);
+
+        $this->profiler->log('slow', [], 100.0);
+        $this->assertTrue($called);
+    }
+
+    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/QueryTest.php b/tests/unit/QueryTest.php
index e23193ecb..cbdca130b 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,12 +390,12 @@ 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());
     }
 
-    public function testIsMethod(): void
+    public function test_is_method(): void
     {
         $this->assertTrue(Query::isMethod('equal'));
         $this->assertTrue(Query::isMethod('notEqual'));
@@ -426,46 +426,47 @@ 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);
     }
 }
diff --git a/tests/unit/RelationshipModelTest.php b/tests/unit/RelationshipModelTest.php
new file mode 100644
index 000000000..e6378952c
--- /dev/null
+++ b/tests/unit/RelationshipModelTest.php
@@ -0,0 +1,261 @@
+<?php
+
+namespace Tests\Unit;
+
+use PHPUnit\Framework\TestCase;
+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 = new Relationship(
+            collection: 'posts',
+            relatedCollection: 'comments',
+            type: RelationType::OneToMany,
+            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 = new Relationship(
+            collection: 'a',
+            relatedCollection: 'b',
+            type: RelationType::OneToOne,
+        );
+
+        $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 = new Relationship(
+            collection: 'users',
+            relatedCollection: 'profiles',
+            type: RelationType::OneToOne,
+            twoWay: true,
+            key: 'profile',
+            twoWayKey: 'user',
+            onDelete: ForeignKeyAction::SetNull,
+            side: RelationSide::Parent,
+        );
+
+        $doc = $rel->toDocument();
+
+        $this->assertInstanceOf(Document::class, $doc);
+        $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 = new Relationship(
+            collection: 'posts',
+            relatedCollection: 'tags',
+            type: RelationType::ManyToMany,
+            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);
+    }
+}
diff --git a/tests/unit/Relationships/RelationshipValidationTest.php b/tests/unit/Relationships/RelationshipValidationTest.php
new file mode 100644
index 000000000..5cd0fd1a6
--- /dev/null
+++ b/tests/unit/Relationships/RelationshipValidationTest.php
@@ -0,0 +1,733 @@
+<?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,
+        ]);
+    }
+
+    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
+    {
+        $adapter = self::createStub(RelationshipsAdapter::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,
+                Capability::Operators,
+            ]);
+        });
+        $adapter->method('castingBefore')->willReturnArgument(1);
+        $adapter->method('castingAfter')->willReturnArgument(1);
+        $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(new Relationship(
+            collection: 'missing',
+            relatedCollection: 'missing',
+            type: RelationType::OneToMany,
+            twoWay: true
+        ));
+    }
+
+    public function testCreateRelationshipMissingRelatedCollection(): void
+    {
+        $db = $this->buildDatabase([$this->makeCollection('test')]);
+
+        $this->expectException(NotFoundException::class);
+        $this->expectExceptionMessage('Related collection not found');
+
+        $db->createRelationship(new Relationship(
+            collection: 'test',
+            relatedCollection: 'missing',
+            type: RelationType::OneToMany,
+            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(new Relationship(
+            collection: 'test1',
+            relatedCollection: 'test2',
+            type: RelationType::OneToMany,
+            twoWay: true
+        ));
+    }
+
+    public function testCreateInvalidRelationship(): void
+    {
+        $this->expectException(\TypeError::class);
+
+        new Relationship(collection: 'test3', relatedCollection: 'test4', type: 'invalid', twoWay: 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->assertNotNull($updated);
+    }
+
+    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->assertNotNull($updated);
+    }
+}
diff --git a/tests/unit/Repository/RepositoryTest.php b/tests/unit/Repository/RepositoryTest.php
new file mode 100644
index 000000000..ccd6e38ee
--- /dev/null
+++ b/tests/unit/Repository/RepositoryTest.php
@@ -0,0 +1,325 @@
+<?php
+
+namespace Tests\Unit\Repository;
+
+use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Query;
+use Utopia\Database\Repository\CompositeSpecification;
+use Utopia\Database\Repository\Repository;
+use Utopia\Database\Repository\Specification;
+
+class TestRepository extends Repository
+{
+    public function collection(): string
+    {
+        return 'users';
+    }
+}
+
+class ActiveSpecification implements Specification
+{
+    public function toQueries(): array
+    {
+        return [Query::equal('status', ['active'])];
+    }
+
+    public function and(Specification $other): Specification
+    {
+        return new CompositeSpecification([$this, $other], 'and');
+    }
+
+    public function or(Specification $other): Specification
+    {
+        return new CompositeSpecification([$this, $other], 'or');
+    }
+}
+
+class AdminSpecification implements Specification
+{
+    public function toQueries(): array
+    {
+        return [Query::equal('role', ['admin'])];
+    }
+
+    public function and(Specification $other): Specification
+    {
+        return new CompositeSpecification([$this, $other], 'and');
+    }
+
+    public function or(Specification $other): Specification
+    {
+        return new CompositeSpecification([$this, $other], 'or');
+    }
+}
+
+#[AllowMockObjectsWithoutExpectations]
+class RepositoryTest extends TestCase
+{
+    private Database $db;
+
+    private TestRepository $repo;
+
+    protected function setUp(): void
+    {
+        $this->db = $this->createMock(Database::class);
+        $this->repo = new TestRepository($this->db);
+    }
+
+    public function testFindByIdDelegatesToGetDocument(): void
+    {
+        $doc = new Document(['$id' => 'u1', 'name' => 'Alice']);
+
+        $this->db->expects($this->once())
+            ->method('getDocument')
+            ->with('users', 'u1')
+            ->willReturn($doc);
+
+        $result = $this->repo->findById('u1');
+        $this->assertSame($doc, $result);
+    }
+
+    public function testFindAllDelegatesToFind(): void
+    {
+        $docs = [new Document(['$id' => 'u1']), new Document(['$id' => 'u2'])];
+
+        $this->db->expects($this->once())
+            ->method('find')
+            ->with('users', [])
+            ->willReturn($docs);
+
+        $result = $this->repo->findAll();
+        $this->assertCount(2, $result);
+    }
+
+    public function testFindAllWithQueriesPassesThem(): void
+    {
+        $queries = [Query::equal('status', ['active'])];
+
+        $this->db->expects($this->once())
+            ->method('find')
+            ->with('users', $queries)
+            ->willReturn([]);
+
+        $this->repo->findAll($queries);
+    }
+
+    public function testFindOneByCreatesEqualQueryWithLimit1(): void
+    {
+        $doc = new Document(['$id' => 'u1', 'email' => 'alice@test.com']);
+
+        $this->db->expects($this->once())
+            ->method('find')
+            ->with(
+                'users',
+                $this->callback(function (array $queries) {
+                    $methods = array_map(fn (Query $q) => $q->getMethod()->value, $queries);
+
+                    return in_array('equal', $methods) && in_array('limit', $methods);
+                })
+            )
+            ->willReturn([$doc]);
+
+        $result = $this->repo->findOneBy('email', 'alice@test.com');
+        $this->assertEquals('u1', $result->getId());
+    }
+
+    public function testFindOneByReturnsEmptyDocumentWhenNoResults(): void
+    {
+        $this->db->method('find')->willReturn([]);
+
+        $result = $this->repo->findOneBy('email', 'nonexistent@test.com');
+        $this->assertTrue($result->isEmpty());
+    }
+
+    public function testCountDelegatesToCount(): void
+    {
+        $this->db->expects($this->once())
+            ->method('count')
+            ->with('users', [])
+            ->willReturn(42);
+
+        $this->assertEquals(42, $this->repo->count());
+    }
+
+    public function testCountWithQueries(): void
+    {
+        $queries = [Query::equal('status', ['active'])];
+
+        $this->db->expects($this->once())
+            ->method('count')
+            ->with('users', $queries)
+            ->willReturn(10);
+
+        $this->assertEquals(10, $this->repo->count($queries));
+    }
+
+    public function testCreateDelegatesToCreateDocument(): void
+    {
+        $doc = new Document(['name' => 'Alice']);
+        $created = new Document(['$id' => 'u1', 'name' => 'Alice']);
+
+        $this->db->expects($this->once())
+            ->method('createDocument')
+            ->with('users', $doc)
+            ->willReturn($created);
+
+        $result = $this->repo->create($doc);
+        $this->assertEquals('u1', $result->getId());
+    }
+
+    public function testUpdateDelegatesToUpdateDocument(): void
+    {
+        $doc = new Document(['$id' => 'u1', 'name' => 'Bob']);
+
+        $this->db->expects($this->once())
+            ->method('updateDocument')
+            ->with('users', 'u1', $doc)
+            ->willReturn($doc);
+
+        $result = $this->repo->update('u1', $doc);
+        $this->assertEquals('Bob', $result->getAttribute('name'));
+    }
+
+    public function testDeleteDelegatesToDeleteDocument(): void
+    {
+        $this->db->expects($this->once())
+            ->method('deleteDocument')
+            ->with('users', 'u1')
+            ->willReturn(true);
+
+        $this->assertTrue($this->repo->delete('u1'));
+    }
+
+    public function testMatchingAppliesSpecificationQueries(): void
+    {
+        $spec = new ActiveSpecification();
+
+        $this->db->expects($this->once())
+            ->method('find')
+            ->with(
+                'users',
+                $this->callback(function (array $queries) {
+                    return count($queries) === 1
+                        && $queries[0]->getMethod()->value === 'equal';
+                })
+            )
+            ->willReturn([]);
+
+        $this->repo->matching($spec);
+    }
+
+    public function testCompositeSpecificationAndMergesQueries(): void
+    {
+        $activeSpec = new ActiveSpecification();
+        $adminSpec = new AdminSpecification();
+
+        $composite = $activeSpec->and($adminSpec);
+        $queries = $composite->toQueries();
+
+        $this->assertCount(2, $queries);
+        $attributes = array_map(fn (Query $q) => $q->getAttribute(), $queries);
+        $this->assertContains('status', $attributes);
+        $this->assertContains('role', $attributes);
+    }
+
+    public function testCompositeSpecificationOrCreatesOrQueries(): void
+    {
+        $activeSpec = new ActiveSpecification();
+        $adminSpec = new AdminSpecification();
+
+        $composite = $activeSpec->or($adminSpec);
+        $queries = $composite->toQueries();
+
+        $this->assertNotEmpty($queries);
+        $methods = array_map(fn (Query $q) => $q->getMethod()->value, $queries);
+        $this->assertContains('or', $methods);
+    }
+
+    public function testSpecificationAndCreatesComposite(): void
+    {
+        $spec1 = new ActiveSpecification();
+        $spec2 = new AdminSpecification();
+
+        $composite = $spec1->and($spec2);
+        $this->assertInstanceOf(Specification::class, $composite);
+        $this->assertCount(2, $composite->toQueries());
+    }
+
+    public function testSpecificationOrCreatesComposite(): void
+    {
+        $spec1 = new ActiveSpecification();
+        $spec2 = new AdminSpecification();
+
+        $composite = $spec1->or($spec2);
+        $this->assertInstanceOf(Specification::class, $composite);
+    }
+
+    public function testCustomSpecificationImplementingInterface(): void
+    {
+        $spec = new ActiveSpecification();
+        $queries = $spec->toQueries();
+
+        $this->assertCount(1, $queries);
+        $this->assertEquals('status', $queries[0]->getAttribute());
+    }
+
+    public function testMatchingWithBaseQueriesMergesBoth(): void
+    {
+        $spec = new ActiveSpecification();
+        $baseQueries = [Query::orderAsc('name')];
+
+        $this->db->expects($this->once())
+            ->method('find')
+            ->with(
+                'users',
+                $this->callback(function (array $queries) {
+                    return count($queries) === 2;
+                })
+            )
+            ->willReturn([]);
+
+        $this->repo->matching($spec, $baseQueries);
+    }
+
+    public function testFindOneByHandlesArrayValue(): void
+    {
+        $this->db->expects($this->once())
+            ->method('find')
+            ->with(
+                'users',
+                $this->callback(function (array $queries) {
+                    return $queries[0]->getValues() === ['admin', 'editor'];
+                })
+            )
+            ->willReturn([]);
+
+        $this->repo->findOneBy('role', ['admin', 'editor']);
+    }
+
+    public function testCompositeSpecificationAndCanChainFurther(): void
+    {
+        $spec1 = new ActiveSpecification();
+        $spec2 = new AdminSpecification();
+        $spec3 = new ActiveSpecification();
+
+        $composite = $spec1->and($spec2)->and($spec3);
+        $queries = $composite->toQueries();
+
+        $this->assertGreaterThanOrEqual(3, count($queries));
+    }
+
+    public function testCompositeSpecificationOrCanChainFurther(): void
+    {
+        $spec1 = new ActiveSpecification();
+        $spec2 = new AdminSpecification();
+        $spec3 = new ActiveSpecification();
+
+        $composite = $spec1->or($spec2)->or($spec3);
+        $queries = $composite->toQueries();
+
+        $this->assertNotEmpty($queries);
+    }
+}
diff --git a/tests/unit/Repository/ScopeTest.php b/tests/unit/Repository/ScopeTest.php
new file mode 100644
index 000000000..21518fe61
--- /dev/null
+++ b/tests/unit/Repository/ScopeTest.php
@@ -0,0 +1,291 @@
+<?php
+
+namespace Tests\Unit\Repository;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Query;
+use Utopia\Database\Repository\CompositeSpecification;
+use Utopia\Database\Repository\Repository;
+use Utopia\Database\Repository\Scope;
+use Utopia\Database\Repository\Specification;
+
+class ScopedRepository extends Repository
+{
+    public function collection(): string
+    {
+        return 'products';
+    }
+}
+
+class ActiveScope implements Scope
+{
+    public function apply(): array
+    {
+        return [Query::equal('active', [true])];
+    }
+}
+
+class TenantScope implements Scope
+{
+    public function __construct(private string $tenantId)
+    {
+    }
+
+    public function apply(): array
+    {
+        return [Query::equal('tenantId', [$this->tenantId])];
+    }
+}
+
+class PriceSpec implements Specification
+{
+    public function __construct(private int $maxPrice)
+    {
+    }
+
+    public function toQueries(): array
+    {
+        return [Query::lessThanEqual('price', $this->maxPrice)];
+    }
+
+    public function and(Specification $other): Specification
+    {
+        return new CompositeSpecification([$this, $other], 'and');
+    }
+
+    public function or(Specification $other): Specification
+    {
+        return new CompositeSpecification([$this, $other], 'or');
+    }
+}
+
+class ScopeTest extends TestCase
+{
+    protected Database $db;
+
+    protected ScopedRepository $repo;
+
+    protected function setUp(): void
+    {
+        $this->db = $this->createMock(Database::class);
+        $this->repo = new ScopedRepository($this->db);
+    }
+
+    public function testAddScopeAddsScope(): void
+    {
+        $scope = new ActiveScope();
+        $this->repo->addScope($scope);
+
+        $this->db->expects($this->once())
+            ->method('find')
+            ->with(
+                'products',
+                $this->callback(function (array $queries) {
+                    return count($queries) === 1
+                        && $queries[0]->getAttribute() === 'active';
+                })
+            )
+            ->willReturn([]);
+
+        $this->repo->findAll();
+    }
+
+    public function testFindAllAppliesGlobalScopes(): void
+    {
+        $this->repo->addScope(new ActiveScope());
+
+        $this->db->expects($this->once())
+            ->method('find')
+            ->with(
+                'products',
+                $this->callback(function (array $queries) {
+                    $attrs = array_map(fn (Query $q) => $q->getAttribute(), $queries);
+
+                    return in_array('active', $attrs);
+                })
+            )
+            ->willReturn([new Document(['$id' => 'p1'])]);
+
+        $results = $this->repo->findAll();
+        $this->assertCount(1, $results);
+    }
+
+    public function testFindOneByAppliesGlobalScopes(): void
+    {
+        $this->repo->addScope(new ActiveScope());
+
+        $this->db->expects($this->once())
+            ->method('find')
+            ->with(
+                'products',
+                $this->callback(function (array $queries) {
+                    $attrs = array_map(fn (Query $q) => $q->getAttribute(), $queries);
+
+                    return in_array('active', $attrs) && in_array('name', $attrs);
+                })
+            )
+            ->willReturn([new Document(['$id' => 'p1', 'name' => 'Widget'])]);
+
+        $result = $this->repo->findOneBy('name', 'Widget');
+        $this->assertEquals('p1', $result->getId());
+    }
+
+    public function testCountAppliesGlobalScopes(): void
+    {
+        $this->repo->addScope(new ActiveScope());
+
+        $this->db->expects($this->once())
+            ->method('count')
+            ->with(
+                'products',
+                $this->callback(function (array $queries) {
+                    $attrs = array_map(fn (Query $q) => $q->getAttribute(), $queries);
+
+                    return in_array('active', $attrs);
+                })
+            )
+            ->willReturn(5);
+
+        $this->assertEquals(5, $this->repo->count());
+    }
+
+    public function testWithoutScopesBypassesGlobalScopes(): void
+    {
+        $this->repo->addScope(new ActiveScope());
+
+        $this->db->expects($this->once())
+            ->method('find')
+            ->with('products', [])
+            ->willReturn([new Document(['$id' => 'p1']), new Document(['$id' => 'p2'])]);
+
+        $results = $this->repo->withoutScopes();
+        $this->assertCount(2, $results);
+    }
+
+    public function testClearScopesRemovesAllScopes(): void
+    {
+        $this->repo->addScope(new ActiveScope());
+        $this->repo->addScope(new TenantScope('t1'));
+
+        $this->repo->clearScopes();
+
+        $this->db->expects($this->once())
+            ->method('find')
+            ->with('products', [])
+            ->willReturn([]);
+
+        $this->repo->findAll();
+    }
+
+    public function testMultipleScopesMergeQueries(): void
+    {
+        $this->repo->addScope(new ActiveScope());
+        $this->repo->addScope(new TenantScope('t1'));
+
+        $this->db->expects($this->once())
+            ->method('find')
+            ->with(
+                'products',
+                $this->callback(function (array $queries) {
+                    $attrs = array_map(fn (Query $q) => $q->getAttribute(), $queries);
+
+                    return in_array('active', $attrs) && in_array('tenantId', $attrs);
+                })
+            )
+            ->willReturn([]);
+
+        $this->repo->findAll();
+    }
+
+    public function testMatchingCombinesScopesWithSpecification(): void
+    {
+        $this->repo->addScope(new ActiveScope());
+
+        $spec = new PriceSpec(100);
+
+        $this->db->expects($this->once())
+            ->method('find')
+            ->with(
+                'products',
+                $this->callback(function (array $queries) {
+                    $attrs = array_map(fn (Query $q) => $q->getAttribute(), $queries);
+
+                    return in_array('active', $attrs) && in_array('price', $attrs);
+                })
+            )
+            ->willReturn([]);
+
+        $this->repo->matching($spec);
+    }
+
+    public function testScopesAppliedWithExplicitQueries(): void
+    {
+        $this->repo->addScope(new ActiveScope());
+
+        $this->db->expects($this->once())
+            ->method('find')
+            ->with(
+                'products',
+                $this->callback(function (array $queries) {
+                    return count($queries) === 2;
+                })
+            )
+            ->willReturn([]);
+
+        $this->repo->findAll([Query::orderAsc('name')]);
+    }
+
+    public function testWithoutScopesPassesCustomQueries(): void
+    {
+        $this->repo->addScope(new ActiveScope());
+
+        $customQueries = [Query::equal('category', ['electronics'])];
+
+        $this->db->expects($this->once())
+            ->method('find')
+            ->with('products', $customQueries)
+            ->willReturn([]);
+
+        $this->repo->withoutScopes($customQueries);
+    }
+
+    public function testCountWithScopesAndExplicitQueries(): void
+    {
+        $this->repo->addScope(new TenantScope('t2'));
+
+        $this->db->expects($this->once())
+            ->method('count')
+            ->with(
+                'products',
+                $this->callback(function (array $queries) {
+                    return count($queries) === 2;
+                })
+            )
+            ->willReturn(3);
+
+        $this->assertEquals(3, $this->repo->count([Query::equal('status', ['published'])]));
+    }
+
+    public function testClearScopesThenAddNewScope(): void
+    {
+        $this->repo->addScope(new ActiveScope());
+        $this->repo->clearScopes();
+        $this->repo->addScope(new TenantScope('t3'));
+
+        $this->db->expects($this->once())
+            ->method('find')
+            ->with(
+                'products',
+                $this->callback(function (array $queries) {
+                    $attrs = array_map(fn (Query $q) => $q->getAttribute(), $queries);
+
+                    return in_array('tenantId', $attrs) && ! in_array('active', $attrs);
+                })
+            )
+            ->willReturn([]);
+
+        $this->repo->findAll();
+    }
+}
diff --git a/tests/unit/RoleTest.php b/tests/unit/RoleTest.php
index 2c1cbee27..7e32914cc 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/Schema/SchemaDiffTest.php b/tests/unit/Schema/SchemaDiffTest.php
new file mode 100644
index 000000000..640815f32
--- /dev/null
+++ b/tests/unit/Schema/SchemaDiffTest.php
@@ -0,0 +1,185 @@
+<?php
+
+namespace Tests\Unit\Schema;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Attribute;
+use Utopia\Database\Collection;
+use Utopia\Database\Index;
+use Utopia\Database\Schema\SchemaChangeType;
+use Utopia\Database\Schema\SchemaDiff;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\IndexType;
+
+class SchemaDiffTest extends TestCase
+{
+    private SchemaDiff $differ;
+
+    protected function setUp(): void
+    {
+        $this->differ = new SchemaDiff();
+    }
+
+    public function testNoChanges(): void
+    {
+        $collection = new Collection(
+            id: 'test',
+            attributes: [
+                new Attribute(key: 'name', type: ColumnType::String, size: 255),
+            ],
+        );
+
+        $result = $this->differ->diff($collection, $collection);
+
+        $this->assertFalse($result->hasChanges());
+        $this->assertEmpty($result->changes);
+    }
+
+    public function testDetectAddedAttribute(): void
+    {
+        $source = new Collection(
+            id: 'test',
+            attributes: [
+                new Attribute(key: 'name', type: ColumnType::String, size: 255),
+            ],
+        );
+
+        $target = new Collection(
+            id: 'test',
+            attributes: [
+                new Attribute(key: 'name', type: ColumnType::String, size: 255),
+                new Attribute(key: 'email', type: ColumnType::String, size: 255),
+            ],
+        );
+
+        $result = $this->differ->diff($source, $target);
+
+        $this->assertTrue($result->hasChanges());
+        $additions = $result->getAdditions();
+        $this->assertCount(1, $additions);
+        $change = \array_values($additions)[0];
+        $this->assertEquals(SchemaChangeType::AddAttribute, $change->type);
+        $this->assertEquals('email', $change->attribute->key);
+    }
+
+    public function testDetectRemovedAttribute(): void
+    {
+        $source = new Collection(
+            id: 'test',
+            attributes: [
+                new Attribute(key: 'name', type: ColumnType::String, size: 255),
+                new Attribute(key: 'email', type: ColumnType::String, size: 255),
+            ],
+        );
+
+        $target = new Collection(
+            id: 'test',
+            attributes: [
+                new Attribute(key: 'name', type: ColumnType::String, size: 255),
+            ],
+        );
+
+        $result = $this->differ->diff($source, $target);
+
+        $removals = $result->getRemovals();
+        $this->assertCount(1, $removals);
+        $change = \array_values($removals)[0];
+        $this->assertEquals(SchemaChangeType::DropAttribute, $change->type);
+        $this->assertEquals('email', $change->attribute->key);
+    }
+
+    public function testDetectModifiedAttribute(): void
+    {
+        $source = new Collection(
+            id: 'test',
+            attributes: [
+                new Attribute(key: 'name', type: ColumnType::String, size: 100),
+            ],
+        );
+
+        $target = new Collection(
+            id: 'test',
+            attributes: [
+                new Attribute(key: 'name', type: ColumnType::String, size: 255),
+            ],
+        );
+
+        $result = $this->differ->diff($source, $target);
+
+        $modifications = $result->getModifications();
+        $this->assertCount(1, $modifications);
+        $change = \array_values($modifications)[0];
+        $this->assertEquals(SchemaChangeType::ModifyAttribute, $change->type);
+        $this->assertEquals(255, $change->attribute->size);
+        $this->assertEquals(100, $change->previousAttribute->size);
+    }
+
+    public function testDetectAddedIndex(): void
+    {
+        $source = new Collection(id: 'test');
+        $target = new Collection(
+            id: 'test',
+            indexes: [
+                new Index(key: 'idx_name', type: IndexType::Index, attributes: ['name']),
+            ],
+        );
+
+        $result = $this->differ->diff($source, $target);
+
+        $additions = $result->getAdditions();
+        $this->assertCount(1, $additions);
+        $change = \array_values($additions)[0];
+        $this->assertEquals(SchemaChangeType::AddIndex, $change->type);
+        $this->assertEquals('idx_name', $change->index->key);
+    }
+
+    public function testDetectRemovedIndex(): void
+    {
+        $source = new Collection(
+            id: 'test',
+            indexes: [
+                new Index(key: 'idx_name', type: IndexType::Index, attributes: ['name']),
+            ],
+        );
+        $target = new Collection(id: 'test');
+
+        $result = $this->differ->diff($source, $target);
+
+        $removals = $result->getRemovals();
+        $this->assertCount(1, $removals);
+        $change = \array_values($removals)[0];
+        $this->assertEquals(SchemaChangeType::DropIndex, $change->type);
+    }
+
+    public function testComplexDiff(): void
+    {
+        $source = new Collection(
+            id: 'test',
+            attributes: [
+                new Attribute(key: 'name', type: ColumnType::String, size: 100),
+                new Attribute(key: 'old_field', type: ColumnType::String, size: 50),
+            ],
+            indexes: [
+                new Index(key: 'idx_old', type: IndexType::Index, attributes: ['old_field']),
+            ],
+        );
+
+        $target = new Collection(
+            id: 'test',
+            attributes: [
+                new Attribute(key: 'name', type: ColumnType::String, size: 255),
+                new Attribute(key: 'new_field', type: ColumnType::Integer, size: 0),
+            ],
+            indexes: [
+                new Index(key: 'idx_new', type: IndexType::Index, attributes: ['new_field']),
+            ],
+        );
+
+        $result = $this->differ->diff($source, $target);
+
+        $this->assertTrue($result->hasChanges());
+        $this->assertNotEmpty($result->getAdditions());
+        $this->assertNotEmpty($result->getRemovals());
+        $this->assertNotEmpty($result->getModifications());
+    }
+}
diff --git a/tests/unit/Schemaless/SchemalessValidationTest.php b/tests/unit/Schemaless/SchemalessValidationTest.php
new file mode 100644
index 000000000..b033ff53e
--- /dev/null
+++ b/tests/unit/Schemaless/SchemalessValidationTest.php
@@ -0,0 +1,249 @@
+<?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\OrderDirection;
+use Utopia\Query\Schema\IndexType;
+
+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('castingBefore')->willReturnArgument(1);
+        $this->adapter->method('castingAfter')->willReturnArgument(1);
+        $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('updateDocument')->willReturnArgument(2);
+        $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,
+        ]);
+    }
+
+    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,
+        ]);
+    }
+
+    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();
+            }
+        );
+    }
+
+    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',
+            new Index(key: 'duplicate', type: IndexType::Key, attributes: ['name'], lengths: [0], orders: [OrderDirection::Asc->value])
+        ));
+
+        try {
+            $this->database->createIndex(
+                'sl_idx_dup',
+                new Index(key: 'duplicate', type: IndexType::Key, attributes: ['name'], lengths: [0], orders: [OrderDirection::Asc->value])
+            );
+            $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',
+            new Index(key: 'idx_ttl_expires', type: IndexType::Ttl, attributes: ['expiresAt'], lengths: [], orders: [OrderDirection::Asc->value], ttl: 3600)
+        ));
+
+        try {
+            $this->database->createIndex(
+                'sl_ttl_dup',
+                new Index(key: 'idx_ttl_expires_duplicate', type: IndexType::Ttl, attributes: ['expiresAt'], lengths: [], orders: [OrderDirection::Asc->value], 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/Seeder/FactoryTest.php b/tests/unit/Seeder/FactoryTest.php
new file mode 100644
index 000000000..925568df9
--- /dev/null
+++ b/tests/unit/Seeder/FactoryTest.php
@@ -0,0 +1,75 @@
+<?php
+
+namespace Tests\Unit\Seeder;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Document;
+use Utopia\Database\Seeder\Factory;
+
+class FactoryTest extends TestCase
+{
+    public function testDefineAndMake(): void
+    {
+        $factory = new Factory();
+        $factory->define('users', function ($faker) {
+            return [
+                'name' => $faker->name(),
+                'email' => $faker->email(),
+                'age' => $faker->numberBetween(18, 65),
+            ];
+        });
+
+        $doc = $factory->make('users');
+
+        $this->assertInstanceOf(Document::class, $doc);
+        $this->assertNotEmpty($doc->getAttribute('name'));
+        $this->assertNotEmpty($doc->getAttribute('email'));
+        $this->assertGreaterThanOrEqual(18, $doc->getAttribute('age'));
+    }
+
+    public function testMakeWithOverrides(): void
+    {
+        $factory = new Factory();
+        $factory->define('users', function ($faker) {
+            return [
+                'name' => $faker->name(),
+                'email' => $faker->email(),
+            ];
+        });
+
+        $doc = $factory->make('users', ['name' => 'Override Name']);
+
+        $this->assertEquals('Override Name', $doc->getAttribute('name'));
+    }
+
+    public function testMakeMany(): void
+    {
+        $factory = new Factory();
+        $factory->define('users', function ($faker) {
+            return [
+                'name' => $faker->name(),
+            ];
+        });
+
+        $docs = $factory->makeMany('users', 5);
+
+        $this->assertCount(5, $docs);
+        foreach ($docs as $doc) {
+            $this->assertInstanceOf(Document::class, $doc);
+        }
+    }
+
+    public function testUndefinedCollectionThrows(): void
+    {
+        $factory = new Factory();
+
+        $this->expectException(\RuntimeException::class);
+        $factory->make('nonexistent');
+    }
+
+    public function testGetFaker(): void
+    {
+        $factory = new Factory();
+        $this->assertNotNull($factory->getFaker());
+    }
+}
diff --git a/tests/unit/Seeder/FixtureTest.php b/tests/unit/Seeder/FixtureTest.php
new file mode 100644
index 000000000..7e1b3cfdc
--- /dev/null
+++ b/tests/unit/Seeder/FixtureTest.php
@@ -0,0 +1,156 @@
+<?php
+
+namespace Tests\Unit\Seeder;
+
+use PHPUnit\Framework\Attributes\AllowMockObjectsWithoutExpectations;
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Seeder\Fixture;
+
+#[AllowMockObjectsWithoutExpectations]
+class FixtureTest extends TestCase
+{
+    private Database $db;
+
+    private Fixture $fixture;
+
+    protected function setUp(): void
+    {
+        $this->db = $this->createMock(Database::class);
+        $this->fixture = new Fixture();
+    }
+
+    public function testLoadSingleDocumentUsesCreateDocument(): void
+    {
+        $this->db->expects($this->once())
+            ->method('createDocument')
+            ->with('users', $this->isInstanceOf(Document::class))
+            ->willReturn(new Document(['$id' => 'u1', 'name' => 'Alice']));
+
+        $this->fixture->load($this->db, 'users', [
+            ['name' => 'Alice'],
+        ]);
+
+        $this->assertCount(1, $this->fixture->getCreated());
+        $this->assertEquals('u1', $this->fixture->getCreated()[0]['id']);
+    }
+
+    public function testLoadMultipleDocumentsUsesCreateDocuments(): void
+    {
+        $this->db->expects($this->once())
+            ->method('createDocuments')
+            ->willReturnCallback(function (string $collection, array $docs, int $batch, ?callable $onNext) {
+                foreach ($docs as $i => $doc) {
+                    $created = new Document(['$id' => 'u' . ($i + 1)]);
+                    if ($onNext) {
+                        $onNext($created);
+                    }
+                }
+
+                return \count($docs);
+            });
+
+        $this->fixture->load($this->db, 'users', [
+            ['name' => 'Alice'],
+            ['name' => 'Bob'],
+        ]);
+
+        $created = $this->fixture->getCreated();
+        $this->assertCount(2, $created);
+        $this->assertEquals('u1', $created[0]['id']);
+        $this->assertEquals('u2', $created[1]['id']);
+    }
+
+    public function testGetCreatedReturnsAllTrackedEntries(): void
+    {
+        $this->db->method('createDocument')
+            ->willReturnOnConsecutiveCalls(
+                new Document(['$id' => 'doc1']),
+                new Document(['$id' => 'doc2']),
+            );
+
+        $this->fixture->load($this->db, 'users', [['name' => 'A']]);
+        $this->fixture->load($this->db, 'posts', [['title' => 'B']]);
+
+        $created = $this->fixture->getCreated();
+        $this->assertCount(2, $created);
+        $this->assertEquals('users', $created[0]['collection']);
+        $this->assertEquals('posts', $created[1]['collection']);
+    }
+
+    public function testCleanupDeletesDocumentsIndividually(): void
+    {
+        $this->db->method('createDocument')
+            ->willReturn(new Document(['$id' => 'u1']));
+
+        $this->db->expects($this->once())
+            ->method('deleteDocument')
+            ->with('users', 'u1')
+            ->willReturn(true);
+
+        $this->fixture->load($this->db, 'users', [['name' => 'A']]);
+        $this->fixture->cleanup($this->db);
+
+        $this->assertEmpty($this->fixture->getCreated());
+    }
+
+    public function testCleanupHandlesDeleteErrors(): void
+    {
+        $this->db->method('createDocument')
+            ->willReturn(new Document(['$id' => 'u1']));
+        $this->db->method('deleteDocument')
+            ->willThrowException(new \RuntimeException('Delete failed'));
+
+        $this->fixture->load($this->db, 'users', [['name' => 'A']]);
+        $this->fixture->cleanup($this->db);
+
+        $this->assertEmpty($this->fixture->getCreated());
+    }
+
+    public function testLoadWithEmptyArray(): void
+    {
+        $this->db->expects($this->never())->method('createDocument');
+        $this->db->expects($this->never())->method('createDocuments');
+
+        $this->fixture->load($this->db, 'users', []);
+        $this->assertEmpty($this->fixture->getCreated());
+    }
+
+    public function testCleanupWithNoCreatedDocuments(): void
+    {
+        $this->db->expects($this->never())->method('deleteDocument');
+        $this->fixture->cleanup($this->db);
+        $this->assertEmpty($this->fixture->getCreated());
+    }
+
+    public function testMultipleCleanupCallsAreIdempotent(): void
+    {
+        $this->db->method('createDocument')
+            ->willReturn(new Document(['$id' => 'u1']));
+        $this->db->expects($this->once())->method('deleteDocument')
+            ->with('users', 'u1')
+            ->willReturn(true);
+
+        $this->fixture->load($this->db, 'users', [['name' => 'A']]);
+        $this->fixture->cleanup($this->db);
+        $this->fixture->cleanup($this->db);
+    }
+
+    public function testLoadWithMultipleCollections(): void
+    {
+        $this->db->method('createDocument')
+            ->willReturnOnConsecutiveCalls(
+                new Document(['$id' => 'u1']),
+                new Document(['$id' => 'p1']),
+            );
+
+        $this->fixture->load($this->db, 'users', [['name' => 'Alice']]);
+        $this->fixture->load($this->db, 'posts', [['title' => 'Hello']]);
+
+        $created = $this->fixture->getCreated();
+        $this->assertCount(2, $created);
+        $this->assertEquals('users', $created[0]['collection']);
+        $this->assertEquals('posts', $created[1]['collection']);
+    }
+}
diff --git a/tests/unit/Seeder/SeederRunnerTest.php b/tests/unit/Seeder/SeederRunnerTest.php
new file mode 100644
index 000000000..74e6985dd
--- /dev/null
+++ b/tests/unit/Seeder/SeederRunnerTest.php
@@ -0,0 +1,118 @@
+<?php
+
+namespace Tests\Unit\Seeder;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Database;
+use Utopia\Database\Seeder\Seeder;
+use Utopia\Database\Seeder\SeederRunner;
+
+class SeederRunnerTest extends TestCase
+{
+    public function testRunsInDependencyOrder(): void
+    {
+        $order = [];
+
+        $seederA = new class ($order) extends Seeder {
+            private array $order;
+
+            public function __construct(array &$order)
+            {
+                $this->order = &$order;
+            }
+
+            public function run(Database $db): void
+            {
+                $this->order[] = 'A';
+            }
+        };
+
+        $seederB = new class ($order, $seederA::class) extends Seeder {
+            private array $order;
+
+            private string $depClass;
+
+            public function __construct(array &$order, string $depClass)
+            {
+                $this->order = &$order;
+                $this->depClass = $depClass;
+            }
+
+            public function dependencies(): array
+            {
+                return [$this->depClass];
+            }
+
+            public function run(Database $db): void
+            {
+                $this->order[] = 'B';
+            }
+        };
+
+        $runner = new SeederRunner();
+        $runner->register($seederA);
+        $runner->register($seederB);
+
+        $db = self::createStub(Database::class);
+        $runner->run($db);
+
+        $this->assertEquals(['A', 'B'], $order);
+    }
+
+    public function testDoesNotRunSameSeederTwice(): void
+    {
+        $count = 0;
+
+        $seeder = new class ($count) extends Seeder {
+            private int $count;
+
+            public function __construct(int &$count)
+            {
+                $this->count = &$count;
+            }
+
+            public function run(Database $db): void
+            {
+                $this->count++;
+            }
+        };
+
+        $runner = new SeederRunner();
+        $runner->register($seeder);
+
+        $db = self::createStub(Database::class);
+        $runner->run($db);
+
+        $this->assertEquals(1, $count);
+        $this->assertArrayHasKey($seeder::class, $runner->getExecuted());
+    }
+
+    public function testResetAllowsRerun(): void
+    {
+        $count = 0;
+
+        $seeder = new class ($count) extends Seeder {
+            private int $count;
+
+            public function __construct(int &$count)
+            {
+                $this->count = &$count;
+            }
+
+            public function run(Database $db): void
+            {
+                $this->count++;
+            }
+        };
+
+        $runner = new SeederRunner();
+        $runner->register($seeder);
+
+        $db = self::createStub(Database::class);
+        $runner->run($db);
+        $runner->reset();
+        $runner->run($db);
+
+        $this->assertEquals(2, $count);
+    }
+}
diff --git a/tests/unit/Spatial/SpatialValidationTest.php b/tests/unit/Spatial/SpatialValidationTest.php
new file mode 100644
index 000000000..6e75ac20b
--- /dev/null
+++ b/tests/unit/Spatial/SpatialValidationTest.php
@@ -0,0 +1,353 @@
+<?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;
+use Utopia\Query\Schema\IndexType;
+
+/** @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('castingBefore')->willReturnArgument(1);
+        $this->adapter->method('castingAfter')->willReturnArgument(1);
+        $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,
+        ]);
+    }
+
+    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,
+        ]);
+    }
+
+    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', new Index(
+                key: 'idx_multi',
+                type: IndexType::Spatial,
+                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', new Index(
+                key: 'idx_name_spatial',
+                type: IndexType::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', new Index(
+                key: 'idx_loc_key',
+                type: IndexType::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/Type/TypeRegistryTest.php b/tests/unit/Type/TypeRegistryTest.php
new file mode 100644
index 000000000..e5c16b168
--- /dev/null
+++ b/tests/unit/Type/TypeRegistryTest.php
@@ -0,0 +1,84 @@
+<?php
+
+namespace Tests\Unit\Type;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Type\CustomType;
+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 CustomType {
+            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
+            {
+                return (int) ($value * 100);
+            }
+
+            public function decode(mixed $value): mixed
+            {
+                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 CustomType {
+            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/Validator/AttributeTest.php b/tests/unit/Validator/AttributeTest.php
index 2f7303cd1..c7e9dc254 100644
--- a/tests/unit/Validator/AttributeTest.php
+++ b/tests/unit/Validator/AttributeTest.php
@@ -3,31 +3,33 @@
 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 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 +39,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 +53,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 +65,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 +77,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 +89,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 +103,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 +115,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 +129,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 +141,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 +155,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 +167,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 +181,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 +193,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 +207,7 @@ public function testIntegerSizeTooLarge(): void
         $validator->isValid($attribute);
     }
 
-    public function testUnknownType(): void
+    public function test_unknown_type(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -231,7 +233,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 +245,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 +259,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 +271,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 +283,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 +295,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 +309,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 +321,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 +331,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 +348,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 +362,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 +375,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 +389,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 +402,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 +416,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 +429,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 +443,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 +456,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 +470,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 +483,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 +497,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 +510,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 +524,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 +537,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 +551,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 +564,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 +578,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 +591,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 +605,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 +621,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 +635,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 +651,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 +665,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 +678,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 +692,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 +705,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 +719,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 +732,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 +746,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 +758,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 +772,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 +784,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 +796,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 +808,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 +820,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 +832,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 +844,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 +856,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 +868,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 +880,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 +892,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 +904,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 +916,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 +928,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 +938,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 +954,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 +964,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 +980,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 +994,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 +1006,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 +1018,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 +1030,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,7 +1042,7 @@ public function testValidIntegerWithDefaultValue(): void
         $this->assertTrue($validator->isValid($attribute));
     }
 
-    public function testValidFloatWithDefaultValue(): void
+    public function test_valid_float_with_default_value(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -1052,7 +1054,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,
@@ -1064,7 +1066,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: [],
@@ -1076,7 +1078,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,
@@ -1088,7 +1090,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: [],
@@ -1101,7 +1103,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,
@@ -1113,7 +1115,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: [],
@@ -1125,7 +1127,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,
@@ -1139,21 +1141,21 @@ public function testUnsignedIntegerSizeTooLarge(): void
         $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,
@@ -1163,7 +1165,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,
@@ -1177,7 +1179,7 @@ public function testDuplicateAttributeIdCaseInsensitive(): void
         $validator->isValid($attribute);
     }
 
-    public function testDuplicateInSchema(): void
+    public function test_duplicate_in_schema(): void
     {
         $validator = new Attribute(
             attributes: [],
@@ -1185,9 +1187,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,
@@ -1198,7 +1200,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,
@@ -1212,7 +1214,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: [],
@@ -1220,9 +1222,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,
@@ -1235,7 +1237,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,
@@ -1247,7 +1249,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: [],
@@ -1260,7 +1262,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,
@@ -1272,7 +1274,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: [],
@@ -1285,7 +1287,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,
@@ -1297,7 +1299,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: [],
@@ -1310,7 +1312,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,
@@ -1322,7 +1324,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: [],
@@ -1335,7 +1337,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,
@@ -1347,7 +1349,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: [],
@@ -1360,7 +1362,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],
@@ -1372,7 +1374,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: [],
@@ -1385,7 +1387,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,
@@ -1397,7 +1399,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: [],
@@ -1409,7 +1411,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,
@@ -1421,7 +1423,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: [],
@@ -1433,7 +1435,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'],
@@ -1445,7 +1447,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: [],
@@ -1457,7 +1459,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'],
@@ -1471,7 +1473,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: [],
@@ -1483,7 +1485,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,
@@ -1497,7 +1499,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: [],
@@ -1509,7 +1511,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',
@@ -1521,7 +1523,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: [],
@@ -1533,7 +1535,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,
@@ -1547,7 +1549,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: [],
@@ -1559,7 +1561,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,
@@ -1573,7 +1575,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: [],
@@ -1585,7 +1587,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,
@@ -1599,7 +1601,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: [],
@@ -1611,7 +1613,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,
@@ -1625,7 +1627,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: [],
@@ -1637,7 +1639,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',
@@ -1649,7 +1651,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: [],
@@ -1661,7 +1663,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',
@@ -1673,7 +1675,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: [],
@@ -1685,7 +1687,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,
@@ -1697,7 +1699,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: [],
@@ -1709,7 +1711,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,
@@ -1721,7 +1723,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: [],
@@ -1733,7 +1735,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'],
@@ -1746,4 +1748,329 @@ public function testArrayDefaultOnNonArrayAttribute(): void
         $this->expectExceptionMessage('Cannot set an array default value for a non-array attribute');
         $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 e8685549e..b51763c07 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 106080c29..3a400b441 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 558d0b455..1d6fa3885 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
+    protected 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' => [],
-                ])
-            ]
+        $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,9 +69,9 @@ 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));
     }
diff --git a/tests/unit/Validator/DocumentsQueriesTest.php b/tests/unit/Validator/DocumentsQueriesTest.php
index 6530ad299..f2fd9c7cc 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,11 @@ 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());
 
-
     }
 }
diff --git a/tests/unit/Validator/IndexTest.php b/tests/unit/Validator/IndexTest.php
index 322973e54..ba3808e19 100644
--- a/tests/unit/Validator/IndexTest.php
+++ b/tests/unit/Validator/IndexTest.php
@@ -4,55 +4,53 @@
 
 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\OrderDirection;
+use Utopia\Query\Schema\ColumnType;
+use Utopia\Query\Schema\IndexType;
 
 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 = [
+            new Attribute(
+                key: 'title',
+                type: ColumnType::String,
+                size: 255,
+                required: false,
+                signed: true,
+                array: false,
+                format: '',
+                filters: [],
+            ),
+        ];
+
+        $indexes = [
+            new Index(
+                key: 'index1',
+                type: IndexType::Key,
+                attributes: ['not_exist'],
+                lengths: [],
+                orders: [],
+            ),
+        ];
+
+        $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 +58,43 @@ 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 = [
+            new Attribute(
+                key: 'title',
+                type: ColumnType::String,
+                size: 255,
+                required: false,
+                signed: true,
+                array: false,
+                format: '',
+                filters: [],
+            ),
+            new Attribute(
+                key: 'date',
+                type: ColumnType::Datetime,
+                size: 0,
+                required: false,
+                signed: false,
+                array: false,
+                format: '',
+                filters: ['datetime'],
+            ),
+        ];
+
+        $indexes = [
+            new Index(
+                key: 'index1',
+                type: IndexType::Fulltext,
+                attributes: ['title', 'date'],
+                lengths: [],
+                orders: [],
+            ),
+        ];
+
+        $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 +102,33 @@ 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 = [
+            new Attribute(
+                key: 'title',
+                type: ColumnType::String,
+                size: 769,
+                required: false,
+                signed: true,
+                array: false,
+                format: '',
+                filters: [],
+            ),
+        ];
+
+        $indexes = [
+            new Index(
+                key: 'index1',
+                type: IndexType::Key,
+                attributes: ['title'],
+                lengths: [],
+                orders: [],
+            ),
+        ];
+
+        $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 +136,84 @@ 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 = [
+            new Attribute(
+                key: 'title',
+                type: ColumnType::String,
+                size: 256,
+                required: false,
+                signed: true,
+                array: false,
+                format: '',
+                filters: [],
+            ),
+            new Attribute(
+                key: 'description',
+                type: ColumnType::String,
+                size: 1024,
+                required: false,
+                signed: true,
+                array: false,
+                format: '',
+                filters: [],
+            ),
+        ];
+
+        $indexes = [
+            new Index(
+                key: 'index1',
+                type: IndexType::Fulltext,
+                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 = new Index(
+            key: 'index2',
+            type: IndexType::Key,
+            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 = [
+            new Attribute(
+                key: 'title',
+                type: ColumnType::String,
+                size: 769,
+                required: false,
+                signed: true,
+                array: false,
+                format: '',
+                filters: [],
+            ),
+        ];
+
+        $indexes = [
+            new Index(
+                key: 'index1',
+                type: IndexType::Key,
+                attributes: [],
+                lengths: [],
+                orders: [],
+            ),
+        ];
+
+        $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 +221,82 @@ 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 = [
+            new Attribute(
+                key: 'data',
+                type: ColumnType::Object,
+                size: 0,
+                required: true,
+                signed: false,
+                array: false,
+                format: '',
+                filters: [],
+            ),
+            new Attribute(
+                key: 'name',
+                type: ColumnType::String,
+                size: 255,
+                required: false,
+                signed: true,
+                array: false,
+                format: '',
+                filters: [],
+            ),
+        ];
+
+        /** @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 = new Index(
+            key: 'idx_gin_valid',
+            type: IndexType::Object,
+            attributes: ['data'],
+            lengths: [],
+            orders: [],
+        );
         $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 = new Index(
+            key: 'idx_gin_invalid_type',
+            type: IndexType::Object,
+            attributes: ['name'],
+            lengths: [],
+            orders: [],
+        );
         $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 = new Index(
+            key: 'idx_gin_multi',
+            type: IndexType::Object,
+            attributes: ['data', 'name'],
+            lengths: [],
+            orders: [],
+        );
         $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 = new Index(
+            key: 'idx_gin_order',
+            type: IndexType::Object,
+            attributes: ['data'],
+            lengths: [],
+            orders: ['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 +304,141 @@ 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 = [
+            new Attribute(
+                key: 'data',
+                type: ColumnType::Object,
+                size: 0,
+                required: true,
+                signed: false,
+                array: false,
+                format: '',
+                filters: [],
+            ),
+            new Attribute(
+                key: 'metadata',
+                type: ColumnType::Object,
+                size: 0,
+                required: false,
+                signed: false,
+                array: false,
+                format: '',
+                filters: [],
+            ),
+            new Attribute(
+                key: 'name',
+                type: ColumnType::String,
+                size: 255,
+                required: false,
+                signed: true,
+                array: false,
+                format: '',
+                filters: [],
+            ),
+        ];
+
+        /** @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 = new Index(
+            key: 'idx_nested_object',
+            type: IndexType::Object,
+            attributes: ['data.key.nestedKey'],
+            lengths: [],
+            orders: [],
+        );
 
         $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 = new Index(
+            key: 'idx_nested_unique',
+            type: IndexType::Unique,
+            attributes: ['data.key.nestedKey'],
+            lengths: [],
+            orders: [],
+        );
         $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 = new Index(
+            key: 'idx_nested_key',
+            type: IndexType::Key,
+            attributes: ['metadata.user.id'],
+            lengths: [],
+            orders: [],
+        );
         $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 = new Index(
+            key: 'idx_invalid_nested',
+            type: IndexType::Object,
+            attributes: ['name.key'],
+            lengths: [],
+            orders: [],
+        );
         $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 = new Index(
+            key: 'idx_invalid_base',
+            type: IndexType::Object,
+            attributes: ['nonexistent.key'],
+            lengths: [],
+            orders: [],
+        );
         $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 = new Index(
+            key: 'idx_multi_nested',
+            type: IndexType::Key,
+            attributes: ['data.key1', 'data.key2'],
+            lengths: [],
+            orders: [],
+        );
         $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 = [
+            new Attribute(
+                key: 'title',
+                type: ColumnType::String,
+                size: 255,
+                required: false,
+                signed: true,
+                array: false,
+                format: '',
+                filters: [],
+            ),
+        ];
+
+        $indexes = [
+            new Index(
+                key: 'index1',
+                type: IndexType::Fulltext,
+                attributes: ['title', 'title'],
+                lengths: [],
+                orders: [],
+            ),
+        ];
+
+        $validator = new IndexValidator($attributes, $indexes, 768);
+        $index = $indexes[0];
         $this->assertFalse($validator->isValid($index));
         $this->assertEquals('Duplicate attributes provided', $validator->getDescription());
     }
@@ -479,233 +446,216 @@ 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 = [
+            new Attribute(
+                key: 'title',
+                type: ColumnType::String,
+                size: 255,
+                required: false,
+                signed: true,
+                array: false,
+                format: '',
+                filters: [],
+            ),
+        ];
+
+        $indexes = [
+            new Index(
+                key: 'index1',
+                type: IndexType::Fulltext,
+                attributes: ['title', 'title'],
+                lengths: [],
+                orders: ['asc', '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 = [
+            new Attribute(
+                key: 'title',
+                type: ColumnType::String,
+                size: 255,
+                required: false,
+                signed: true,
+                array: false,
+                format: '',
+                filters: [],
+            ),
+        ];
+
+        $indexes = [
+            new Index(
+                key: 'primary',
+                type: IndexType::Fulltext,
+                attributes: ['title'],
+                lengths: [],
+                orders: [],
+            ),
+        ];
+
+        $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 = [
+            new Attribute(
+                key: 'title',
+                type: ColumnType::String,
+                size: 769,
+                required: false,
+                signed: true,
+                array: false,
+                format: '',
+                filters: [],
+            ),
+        ];
+
+        $indexes = [
+            new Index(
+                key: 'index1',
+                type: IndexType::Key,
+                attributes: ['new'],
+                lengths: [],
+                orders: [],
+            ),
+        ];
+
+        $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 = [
+            new Attribute(
+                key: 'name',
+                type: ColumnType::String,
+                size: 255,
+                required: false,
+                signed: true,
+                array: false,
+                format: '',
+                filters: [],
+            ),
+            new Attribute(
+                key: 'description',
+                type: ColumnType::String,
+                size: 512,
+                required: false,
+                signed: true,
+                array: false,
+                format: '',
+                filters: [],
+            ),
+            new Attribute(
+                key: 'age',
+                type: ColumnType::Integer,
+                size: 0,
+                required: false,
+                signed: true,
+                array: false,
+                format: '',
+                filters: [],
+            ),
+        ];
+
+        /** @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 = new Index(
+            key: 'idx_trigram_valid',
+            type: IndexType::Trigram,
+            attributes: ['name'],
+            lengths: [],
+            orders: [],
+        );
         $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 = new Index(
+            key: 'idx_trigram_multi_valid',
+            type: IndexType::Trigram,
+            attributes: ['name', 'description'],
+            lengths: [],
+            orders: [],
+        );
         $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 = new Index(
+            key: 'idx_trigram_invalid_type',
+            type: IndexType::Trigram,
+            attributes: ['age'],
+            lengths: [],
+            orders: [],
+        );
         $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 = new Index(
+            key: 'idx_trigram_mixed',
+            type: IndexType::Trigram,
+            attributes: ['name', 'age'],
+            lengths: [],
+            orders: [],
+        );
         $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 = new Index(
+            key: 'idx_trigram_order',
+            type: IndexType::Trigram,
+            attributes: ['name'],
+            lengths: [],
+            orders: ['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 = new Index(
+            key: 'idx_trigram_length',
+            type: IndexType::Trigram,
+            attributes: ['name'],
+            lengths: [128],
+            orders: [],
+        );
         $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 +663,38 @@ 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 = [
+            new Attribute(
+                key: 'expiresAt',
+                type: ColumnType::Datetime,
+                size: 0,
+                required: false,
+                signed: false,
+                array: false,
+                format: '',
+                filters: ['datetime'],
+            ),
+            new Attribute(
+                key: 'name',
+                type: ColumnType::String,
+                size: 255,
+                required: false,
+                signed: true,
+                array: false,
+                format: '',
+                filters: [],
+            ),
+        ];
+
+        /** @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 +714,80 @@ 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 = new Index(
+            key: 'idx_ttl_valid',
+            type: IndexType::Ttl,
+            attributes: ['expiresAt'],
+            lengths: [],
+            orders: [OrderDirection::Asc->value],
+            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 = new Index(
+            key: 'idx_ttl_zero',
+            type: IndexType::Ttl,
+            attributes: ['expiresAt'],
+            lengths: [],
+            orders: [OrderDirection::Asc->value],
+            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 = new Index(
+            key: 'idx_ttl_negative',
+            type: IndexType::Ttl,
+            attributes: ['expiresAt'],
+            lengths: [],
+            orders: [OrderDirection::Asc->value],
+            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 = new Index(
+            key: 'idx_ttl_invalid_type',
+            type: IndexType::Ttl,
+            attributes: ['name'],
+            lengths: [],
+            orders: [OrderDirection::Asc->value],
+            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 = new Index(
+            key: 'idx_ttl_multi',
+            type: IndexType::Ttl,
+            attributes: ['expiresAt', 'name'],
+            lengths: [],
+            orders: [OrderDirection::Asc->value, OrderDirection::Asc->value],
+            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 = new Index(
+            key: 'idx_ttl_min',
+            type: IndexType::Ttl,
+            attributes: ['expiresAt'],
+            lengths: [],
+            orders: [OrderDirection::Asc->value],
+            ttl: 1,
+        );
         $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 +806,19 @@ 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 = new Index(
+            key: 'idx_ttl_duplicate',
+            type: IndexType::Ttl,
+            attributes: ['expiresAt'],
+            lengths: [],
+            orders: [OrderDirection::Asc->value],
+            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 409fcf365..a812a9ec9 100644
--- a/tests/unit/Validator/IndexedQueriesTest.php
+++ b/tests/unit/Validator/IndexedQueriesTest.php
@@ -3,7 +3,6 @@
 namespace Tests\Unit\Validator;
 
 use PHPUnit\Framework\TestCase;
-use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Exception;
 use Utopia\Database\Query;
@@ -13,32 +12,34 @@
 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 +48,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 +81,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 +122,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 +144,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 +168,27 @@ public function testMissingIndex(): void
         $this->assertEquals('Searching by attribute "name" requires a fulltext index.', $validator->getDescription());
     }
 
-    public function testTwoAttributesFulltext(): void
+    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 +197,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 +216,99 @@ 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_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 3c19346d8..fbc8d1ddf 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 a6dd50bef..2bc93420d 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 3cf50b026..0c3021b45 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,11 @@ 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_empty_cases(): void
     {
         $validator = new ObjectValidator();
 
diff --git a/tests/unit/Validator/OperatorTest.php b/tests/unit/Validator/OperatorTest.php
index e89d39104..10c156316 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 d57464463..96a5fd47b 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 40e8d7671..503cd8d67 100644
--- a/tests/unit/Validator/QueriesTest.php
+++ b/tests/unit/Validator/QueriesTest.php
@@ -4,43 +4,48 @@
 
 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\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 +54,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 +74,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 +121,98 @@ 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_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 7f1806549..2421cf40c 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 a0ec65eeb..0be5f2e76 100644
--- a/tests/unit/Validator/Query/FilterTest.php
+++ b/tests/unit/Validator/Query/FilterTest.php
@@ -3,54 +3,55 @@
 namespace Tests\Unit\Validator\Query;
 
 use PHPUnit\Framework\TestCase;
-use Utopia\Database\Database;
 use Utopia\Database\Document;
 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
      */
-    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,
             ]),
         ];
 
         $this->validator = new Filter(
             $attributes,
-            Database::VAR_INTEGER
+            ColumnType::Integer->value
         );
     }
 
-    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')));
@@ -58,12 +59,12 @@ public function testSuccess(): void
         $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('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'])));
     }
 
-    public function testFailure(): void
+    public function test_failure(): void
     {
         $this->assertFalse($this->validator->isValid(Query::select(['attr'])));
         $this->assertEquals('Invalid query', $this->validator->getDescription());
@@ -81,14 +82,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(new Query(Method::CursorAfter, values: ['asdf'])));
+        $this->assertFalse($this->validator->isValid(new Query(Method::CursorBefore, 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::equal('integer_array', [100, -1])));
         $this->assertFalse($this->validator->isValid(Query::contains('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());
@@ -97,7 +98,7 @@ 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->assertEquals('Contains queries require at least one value.', $this->validator->getDescription());
@@ -106,7 +107,7 @@ public function testEmptyValues(): void
         $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 = [];
@@ -118,7 +119,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'])));
@@ -130,7 +131,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')));
@@ -140,11 +141,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')));
@@ -154,11 +155,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')));
@@ -168,11 +169,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)));
@@ -182,10 +183,10 @@ 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());
     }
 }
diff --git a/tests/unit/Validator/Query/LimitTest.php b/tests/unit/Validator/Query/LimitTest.php
index f0c598d3d..be287ac71 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 948408346..ef380d049 100644
--- a/tests/unit/Validator/Query/OffsetTest.php
+++ b/tests/unit/Validator/Query/OffsetTest.php
@@ -8,7 +8,7 @@
 
 class OffsetTest extends TestCase
 {
-    public function testValueSuccess(): void
+    public function test_value_success(): void
     {
         $validator = new Offset(5000);
 
@@ -17,7 +17,7 @@ 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);
 
diff --git a/tests/unit/Validator/Query/OrderTest.php b/tests/unit/Validator/Query/OrderTest.php
index b84d896d1..c953f05d6 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,48 @@ 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')));
+    }
 }
diff --git a/tests/unit/Validator/Query/SelectTest.php b/tests/unit/Validator/Query/SelectTest.php
index 2dafdb94c..a482bc1e5 100644
--- a/tests/unit/Validator/Query/SelectTest.php
+++ b/tests/unit/Validator/Query/SelectTest.php
@@ -3,47 +3,46 @@
 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\Select;
+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());
diff --git a/tests/unit/Validator/QueryTest.php b/tests/unit/Validator/QueryTest.php
index 8433f47f2..c993b811d 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,11 +243,11 @@ 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);
@@ -257,14 +258,14 @@ public function testQueryGetByType(): void
 
         $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 +275,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 +298,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 +306,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 +335,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 +352,7 @@ public function testOrQuery(): void
                 Query::or(
                     [
                         Query::equal('price', [0]),
-                        Query::equal('not_found', [''])
+                        Query::equal('not_found', ['']),
                     ]
                 )]
         ));
@@ -364,7 +365,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 a0ac63ed7..90cc4e06d 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 e8df4d3d1..dc954e052 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 f3b49864d..8f6113cbf 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,17 +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 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([
@@ -385,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());
@@ -400,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());
@@ -415,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([
@@ -428,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());
@@ -437,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([
@@ -454,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([
@@ -475,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([
@@ -496,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());
@@ -511,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([
@@ -535,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([
@@ -549,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([
@@ -563,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([
@@ -577,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([
@@ -600,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());
@@ -615,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([
@@ -638,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());
@@ -653,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([
@@ -676,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([
@@ -699,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([
@@ -722,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([
@@ -745,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';
@@ -789,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([
@@ -821,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
@@ -839,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
@@ -861,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
@@ -883,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([
@@ -907,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([
@@ -921,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());
@@ -937,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([
@@ -961,7 +968,7 @@ public function testTextValidation(): void
             'feedback' => 'team@appwrite.io',
             'text_field' => \str_repeat('a', 65535),
             '$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([
@@ -975,7 +982,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 and no longer than 65535 chars', $validator->getDescription());
@@ -991,17 +998,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 and no longer than 65535 chars', $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([
@@ -1015,7 +1022,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([
@@ -1029,17 +1036,17 @@ 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 and no longer than 16777215 chars', $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([
@@ -1053,7 +1060,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([
@@ -1067,13 +1074,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 and no longer than 4294967295 chars', $validator->getDescription());
     }
 
-    public function testStringTypeArrayValidation(): void
+    public function test_string_type_array_validation(): void
     {
         $collection = [
             '$id' => Database::METADATA,
@@ -1082,7 +1089,7 @@ public function testStringTypeArrayValidation(): void
             'attributes' => [
                 [
                     '$id' => 'varchar_array',
-                    'type' => Database::VAR_VARCHAR,
+                    'type' => ColumnType::Varchar->value,
                     'format' => '',
                     'size' => 128,
                     'required' => false,
@@ -1092,7 +1099,7 @@ public function testStringTypeArrayValidation(): void
                 ],
                 [
                     '$id' => 'text_array',
-                    'type' => Database::VAR_TEXT,
+                    'type' => ColumnType::Text->value,
                     'format' => '',
                     'size' => 65535,
                     'required' => false,
@@ -1106,21 +1113,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());
@@ -1129,10 +1136,9 @@ 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());
     }
-
 }
diff --git a/tests/unit/Validator/VectorTest.php b/tests/unit/Validator/VectorTest.php
index be98d7ecf..c57ff9953 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 000000000..bddd6ca92
--- /dev/null
+++ b/tests/unit/Vector/VectorValidationTest.php
@@ -0,0 +1,475 @@
+<?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;
+use Utopia\Query\Schema\IndexType;
+
+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('castingBefore')->willReturnArgument(1);
+        $this->adapter->method('castingAfter')->willReturnArgument(1);
+        $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,
+        ]);
+    }
+
+    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,
+        ]);
+    }
+
+    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();
+            }
+        );
+    }
+
+    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', new Attribute(
+            key: 'bad_embedding',
+            type: ColumnType::Vector,
+            size: 0,
+            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', new Attribute(
+            key: 'huge_embedding',
+            type: ColumnType::Vector,
+            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->assertNotNull($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->assertNotNull($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->assertNotNull($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', new Index(
+                key: 'bad_idx',
+                type: IndexType::HnswCosine,
+                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->assertTrue(true);
+        }
+    }
+}