diff --git a/composer.lock b/composer.lock
index 2a5302cd2..c61aaa684 100644
--- a/composer.lock
+++ b/composer.lock
@@ -68,16 +68,16 @@
         },
         {
             "name": "composer/semver",
-            "version": "3.4.3",
+            "version": "3.4.4",
             "source": {
                 "type": "git",
                 "url": "https://github.com/composer/semver.git",
-                "reference": "4313d26ada5e0c4edfbd1dc481a92ff7bff91f12"
+                "reference": "198166618906cb2de69b95d7d47e5fa8aa1b2b95"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/composer/semver/zipball/4313d26ada5e0c4edfbd1dc481a92ff7bff91f12",
-                "reference": "4313d26ada5e0c4edfbd1dc481a92ff7bff91f12",
+                "url": "https://api.github.com/repos/composer/semver/zipball/198166618906cb2de69b95d7d47e5fa8aa1b2b95",
+                "reference": "198166618906cb2de69b95d7d47e5fa8aa1b2b95",
                 "shasum": ""
             },
             "require": {
@@ -129,7 +129,7 @@
             "support": {
                 "irc": "ircs://irc.libera.chat:6697/composer",
                 "issues": "https://github.com/composer/semver/issues",
-                "source": "https://github.com/composer/semver/tree/3.4.3"
+                "source": "https://github.com/composer/semver/tree/3.4.4"
             },
             "funding": [
                 {
@@ -139,33 +139,32 @@
                 {
                     "url": "https://github.com/composer",
                     "type": "github"
-                },
-                {
-                    "url": "https://tidelift.com/funding/github/packagist/composer/composer",
-                    "type": "tidelift"
                 }
             ],
-            "time": "2024-09-19T14:15:21+00:00"
+            "time": "2025-08-20T19:15:30+00:00"
         },
         {
             "name": "google/protobuf",
-            "version": "v4.31.1",
+            "version": "v4.32.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/protocolbuffers/protobuf-php.git",
-                "reference": "2b028ce8876254e2acbeceea7d9b573faad41864"
+                "reference": "9a9a92ecbe9c671dc1863f6d4a91ea3ea12c8646"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/protocolbuffers/protobuf-php/zipball/2b028ce8876254e2acbeceea7d9b573faad41864",
-                "reference": "2b028ce8876254e2acbeceea7d9b573faad41864",
+                "url": "https://api.github.com/repos/protocolbuffers/protobuf-php/zipball/9a9a92ecbe9c671dc1863f6d4a91ea3ea12c8646",
+                "reference": "9a9a92ecbe9c671dc1863f6d4a91ea3ea12c8646",
                 "shasum": ""
             },
             "require": {
-                "php": ">=7.0.0"
+                "php": ">=8.1.0"
+            },
+            "provide": {
+                "ext-protobuf": "*"
             },
             "require-dev": {
-                "phpunit/phpunit": ">=5.0.0"
+                "phpunit/phpunit": ">=5.0.0 <8.5.27"
             },
             "suggest": {
                 "ext-bcmath": "Need to support JSON deserialization"
@@ -187,9 +186,9 @@
                 "proto"
             ],
             "support": {
-                "source": "https://github.com/protocolbuffers/protobuf-php/tree/v4.31.1"
+                "source": "https://github.com/protocolbuffers/protobuf-php/tree/v4.32.0"
             },
-            "time": "2025-05-28T18:52:35+00:00"
+            "time": "2025-08-14T20:00:33+00:00"
         },
         {
             "name": "nyholm/psr7",
@@ -407,16 +406,16 @@
         },
         {
             "name": "open-telemetry/context",
-            "version": "1.2.1",
+            "version": "1.3.1",
             "source": {
                 "type": "git",
                 "url": "https://github.com/opentelemetry-php/context.git",
-                "reference": "1eb2b837ee9362db064a6b65d5ecce15a9f9f020"
+                "reference": "438f71812242db3f196fb4c717c6f92cbc819be6"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/opentelemetry-php/context/zipball/1eb2b837ee9362db064a6b65d5ecce15a9f9f020",
-                "reference": "1eb2b837ee9362db064a6b65d5ecce15a9f9f020",
+                "url": "https://api.github.com/repos/opentelemetry-php/context/zipball/438f71812242db3f196fb4c717c6f92cbc819be6",
+                "reference": "438f71812242db3f196fb4c717c6f92cbc819be6",
                 "shasum": ""
             },
             "require": {
@@ -462,7 +461,7 @@
                 "issues": "https://github.com/open-telemetry/opentelemetry-php/issues",
                 "source": "https://github.com/open-telemetry/opentelemetry-php"
             },
-            "time": "2025-05-07T23:36:50+00:00"
+            "time": "2025-08-13T01:12:00+00:00"
         },
         {
             "name": "open-telemetry/exporter-otlp",
@@ -593,16 +592,16 @@
         },
         {
             "name": "open-telemetry/sdk",
-            "version": "1.6.0",
+            "version": "1.7.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/opentelemetry-php/sdk.git",
-                "reference": "1c0371794e4c0700afd4a9d4d8511cb5e3f78e6a"
+                "reference": "86287cf30fd6549444d7b8f7d8758d92e24086ac"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/opentelemetry-php/sdk/zipball/1c0371794e4c0700afd4a9d4d8511cb5e3f78e6a",
-                "reference": "1c0371794e4c0700afd4a9d4d8511cb5e3f78e6a",
+                "url": "https://api.github.com/repos/opentelemetry-php/sdk/zipball/86287cf30fd6549444d7b8f7d8758d92e24086ac",
+                "reference": "86287cf30fd6549444d7b8f7d8758d92e24086ac",
                 "shasum": ""
             },
             "require": {
@@ -621,7 +620,7 @@
                 "ramsey/uuid": "^3.0 || ^4.0",
                 "symfony/polyfill-mbstring": "^1.23",
                 "symfony/polyfill-php82": "^1.26",
-                "tbachert/spi": "^1.0.1"
+                "tbachert/spi": "^1.0.5"
             },
             "suggest": {
                 "ext-gmp": "To support unlimited number of synchronous metric readers",
@@ -635,6 +634,9 @@
                         "OpenTelemetry\\API\\Instrumentation\\Configuration\\General\\ConfigEnv\\EnvComponentLoaderHttpConfig",
                         "OpenTelemetry\\API\\Instrumentation\\Configuration\\General\\ConfigEnv\\EnvComponentLoaderPeerConfig"
                     ],
+                    "OpenTelemetry\\SDK\\Common\\Configuration\\Resolver\\ResolverInterface": [
+                        "OpenTelemetry\\SDK\\Common\\Configuration\\Resolver\\SdkConfigurationResolver"
+                    ],
                     "OpenTelemetry\\API\\Instrumentation\\AutoInstrumentation\\HookManagerInterface": [
                         "OpenTelemetry\\API\\Instrumentation\\AutoInstrumentation\\ExtensionHookManager"
                     ]
@@ -683,20 +685,20 @@
                 "issues": "https://github.com/open-telemetry/opentelemetry-php/issues",
                 "source": "https://github.com/open-telemetry/opentelemetry-php"
             },
-            "time": "2025-06-19T23:36:51+00:00"
+            "time": "2025-08-06T03:07:06+00:00"
         },
         {
             "name": "open-telemetry/sem-conv",
-            "version": "1.32.1",
+            "version": "1.36.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/opentelemetry-php/sem-conv.git",
-                "reference": "94daa85ea61a8e2b7e1b0af6be0e875bedda7c22"
+                "reference": "60dd18fd21d45e6f4234ecab89c14021b6e3de9a"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/opentelemetry-php/sem-conv/zipball/94daa85ea61a8e2b7e1b0af6be0e875bedda7c22",
-                "reference": "94daa85ea61a8e2b7e1b0af6be0e875bedda7c22",
+                "url": "https://api.github.com/repos/opentelemetry-php/sem-conv/zipball/60dd18fd21d45e6f4234ecab89c14021b6e3de9a",
+                "reference": "60dd18fd21d45e6f4234ecab89c14021b6e3de9a",
                 "shasum": ""
             },
             "require": {
@@ -740,7 +742,7 @@
                 "issues": "https://github.com/open-telemetry/opentelemetry-php/issues",
                 "source": "https://github.com/open-telemetry/opentelemetry-php"
             },
-            "time": "2025-06-24T02:32:27+00:00"
+            "time": "2025-08-04T03:22:08+00:00"
         },
         {
             "name": "php-http/discovery",
@@ -1307,16 +1309,16 @@
         },
         {
             "name": "symfony/http-client",
-            "version": "v7.3.1",
+            "version": "v7.3.3",
             "source": {
                 "type": "git",
                 "url": "https://github.com/symfony/http-client.git",
-                "reference": "4403d87a2c16f33345dca93407a8714ee8c05a64"
+                "reference": "333b9bd7639cbdaecd25a3a48a9d2dcfaa86e019"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/symfony/http-client/zipball/4403d87a2c16f33345dca93407a8714ee8c05a64",
-                "reference": "4403d87a2c16f33345dca93407a8714ee8c05a64",
+                "url": "https://api.github.com/repos/symfony/http-client/zipball/333b9bd7639cbdaecd25a3a48a9d2dcfaa86e019",
+                "reference": "333b9bd7639cbdaecd25a3a48a9d2dcfaa86e019",
                 "shasum": ""
             },
             "require": {
@@ -1324,6 +1326,7 @@
                 "psr/log": "^1|^2|^3",
                 "symfony/deprecation-contracts": "^2.5|^3",
                 "symfony/http-client-contracts": "~3.4.4|^3.5.2",
+                "symfony/polyfill-php83": "^1.29",
                 "symfony/service-contracts": "^2.5|^3"
             },
             "conflict": {
@@ -1382,7 +1385,7 @@
                 "http"
             ],
             "support": {
-                "source": "https://github.com/symfony/http-client/tree/v7.3.1"
+                "source": "https://github.com/symfony/http-client/tree/v7.3.3"
             },
             "funding": [
                 {
@@ -1393,12 +1396,16 @@
                     "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-06-28T07:58:39+00:00"
+            "time": "2025-08-27T07:45:05+00:00"
         },
         {
             "name": "symfony/http-client-contracts",
@@ -1480,7 +1487,7 @@
         },
         {
             "name": "symfony/polyfill-mbstring",
-            "version": "v1.32.0",
+            "version": "v1.33.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/symfony/polyfill-mbstring.git",
@@ -1541,7 +1548,7 @@
                 "shim"
             ],
             "support": {
-                "source": "https://github.com/symfony/polyfill-mbstring/tree/v1.32.0"
+                "source": "https://github.com/symfony/polyfill-mbstring/tree/v1.33.0"
             },
             "funding": [
                 {
@@ -1552,6 +1559,10 @@
                     "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"
@@ -1561,7 +1572,7 @@
         },
         {
             "name": "symfony/polyfill-php82",
-            "version": "v1.32.0",
+            "version": "v1.33.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/symfony/polyfill-php82.git",
@@ -1617,7 +1628,7 @@
                 "shim"
             ],
             "support": {
-                "source": "https://github.com/symfony/polyfill-php82/tree/v1.32.0"
+                "source": "https://github.com/symfony/polyfill-php82/tree/v1.33.0"
             },
             "funding": [
                 {
@@ -1628,6 +1639,10 @@
                     "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"
@@ -1635,6 +1650,86 @@
             ],
             "time": "2024-09-09T11:45:10+00:00"
         },
+        {
+            "name": "symfony/polyfill-php83",
+            "version": "v1.33.0",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/symfony/polyfill-php83.git",
+                "reference": "17f6f9a6b1735c0f163024d959f700cfbc5155e5"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/symfony/polyfill-php83/zipball/17f6f9a6b1735c0f163024d959f700cfbc5155e5",
+                "reference": "17f6f9a6b1735c0f163024d959f700cfbc5155e5",
+                "shasum": ""
+            },
+            "require": {
+                "php": ">=7.2"
+            },
+            "type": "library",
+            "extra": {
+                "thanks": {
+                    "url": "https://github.com/symfony/polyfill",
+                    "name": "symfony/polyfill"
+                }
+            },
+            "autoload": {
+                "files": [
+                    "bootstrap.php"
+                ],
+                "psr-4": {
+                    "Symfony\\Polyfill\\Php83\\": ""
+                },
+                "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 backporting some PHP 8.3+ features to lower PHP versions",
+            "homepage": "https://symfony.com",
+            "keywords": [
+                "compatibility",
+                "polyfill",
+                "portable",
+                "shim"
+            ],
+            "support": {
+                "source": "https://github.com/symfony/polyfill-php83/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-07-08T02:45:35+00:00"
+        },
         {
             "name": "symfony/service-contracts",
             "version": "v3.6.0",
@@ -1720,16 +1815,16 @@
         },
         {
             "name": "tbachert/spi",
-            "version": "v1.0.4",
+            "version": "v1.0.5",
             "source": {
                 "type": "git",
                 "url": "https://github.com/Nevay/spi.git",
-                "reference": "86e355edfdd57f9cb720bd2ac3af7dde521ca0e7"
+                "reference": "e7078767866d0a9e0f91d3f9d42a832df5e39002"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/Nevay/spi/zipball/86e355edfdd57f9cb720bd2ac3af7dde521ca0e7",
-                "reference": "86e355edfdd57f9cb720bd2ac3af7dde521ca0e7",
+                "url": "https://api.github.com/repos/Nevay/spi/zipball/e7078767866d0a9e0f91d3f9d42a832df5e39002",
+                "reference": "e7078767866d0a9e0f91d3f9d42a832df5e39002",
                 "shasum": ""
             },
             "require": {
@@ -1766,9 +1861,9 @@
             ],
             "support": {
                 "issues": "https://github.com/Nevay/spi/issues",
-                "source": "https://github.com/Nevay/spi/tree/v1.0.4"
+                "source": "https://github.com/Nevay/spi/tree/v1.0.5"
             },
-            "time": "2025-06-28T20:18:22+00:00"
+            "time": "2025-06-29T15:42:06+00:00"
         },
         {
             "name": "utopia-php/cache",
@@ -1870,16 +1965,16 @@
         },
         {
             "name": "utopia-php/framework",
-            "version": "0.33.20",
+            "version": "0.33.22",
             "source": {
                 "type": "git",
                 "url": "https://github.com/utopia-php/http.git",
-                "reference": "e1c7ab4e0b5b0a9a70256b1e00912e101e76a131"
+                "reference": "c01a815cb976c9255e045fc3bcc3f5fcf477e0bc"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/utopia-php/http/zipball/e1c7ab4e0b5b0a9a70256b1e00912e101e76a131",
-                "reference": "e1c7ab4e0b5b0a9a70256b1e00912e101e76a131",
+                "url": "https://api.github.com/repos/utopia-php/http/zipball/c01a815cb976c9255e045fc3bcc3f5fcf477e0bc",
+                "reference": "c01a815cb976c9255e045fc3bcc3f5fcf477e0bc",
                 "shasum": ""
             },
             "require": {
@@ -1911,9 +2006,9 @@
             ],
             "support": {
                 "issues": "https://github.com/utopia-php/http/issues",
-                "source": "https://github.com/utopia-php/http/tree/0.33.20"
+                "source": "https://github.com/utopia-php/http/tree/0.33.22"
             },
-            "time": "2025-05-18T23:51:21+00:00"
+            "time": "2025-08-26T10:29:50+00:00"
         },
         {
             "name": "utopia-php/pools",
@@ -2154,16 +2249,16 @@
         },
         {
             "name": "laravel/pint",
-            "version": "v1.22.1",
+            "version": "v1.24.0",
             "source": {
                 "type": "git",
                 "url": "https://github.com/laravel/pint.git",
-                "reference": "941d1927c5ca420c22710e98420287169c7bcaf7"
+                "reference": "0345f3b05f136801af8c339f9d16ef29e6b4df8a"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/laravel/pint/zipball/941d1927c5ca420c22710e98420287169c7bcaf7",
-                "reference": "941d1927c5ca420c22710e98420287169c7bcaf7",
+                "url": "https://api.github.com/repos/laravel/pint/zipball/0345f3b05f136801af8c339f9d16ef29e6b4df8a",
+                "reference": "0345f3b05f136801af8c339f9d16ef29e6b4df8a",
                 "shasum": ""
             },
             "require": {
@@ -2174,10 +2269,10 @@
                 "php": "^8.2.0"
             },
             "require-dev": {
-                "friendsofphp/php-cs-fixer": "^3.75.0",
-                "illuminate/view": "^11.44.7",
-                "larastan/larastan": "^3.4.0",
-                "laravel-zero/framework": "^11.36.1",
+                "friendsofphp/php-cs-fixer": "^3.82.2",
+                "illuminate/view": "^11.45.1",
+                "larastan/larastan": "^3.5.0",
+                "laravel-zero/framework": "^11.45.0",
                 "mockery/mockery": "^1.6.12",
                 "nunomaduro/termwind": "^2.3.1",
                 "pestphp/pest": "^2.36.0"
@@ -2187,6 +2282,9 @@
             ],
             "type": "project",
             "autoload": {
+                "files": [
+                    "overrides/Runner/Parallel/ProcessFactory.php"
+                ],
                 "psr-4": {
                     "App\\": "app/",
                     "Database\\Seeders\\": "database/seeders/",
@@ -2216,20 +2314,20 @@
                 "issues": "https://github.com/laravel/pint/issues",
                 "source": "https://github.com/laravel/pint"
             },
-            "time": "2025-05-08T08:38:12+00:00"
+            "time": "2025-07-10T18:09:32+00:00"
         },
         {
             "name": "myclabs/deep-copy",
-            "version": "1.13.1",
+            "version": "1.13.4",
             "source": {
                 "type": "git",
                 "url": "https://github.com/myclabs/DeepCopy.git",
-                "reference": "1720ddd719e16cf0db4eb1c6eca108031636d46c"
+                "reference": "07d290f0c47959fd5eed98c95ee5602db07e0b6a"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/myclabs/DeepCopy/zipball/1720ddd719e16cf0db4eb1c6eca108031636d46c",
-                "reference": "1720ddd719e16cf0db4eb1c6eca108031636d46c",
+                "url": "https://api.github.com/repos/myclabs/DeepCopy/zipball/07d290f0c47959fd5eed98c95ee5602db07e0b6a",
+                "reference": "07d290f0c47959fd5eed98c95ee5602db07e0b6a",
                 "shasum": ""
             },
             "require": {
@@ -2268,7 +2366,7 @@
             ],
             "support": {
                 "issues": "https://github.com/myclabs/DeepCopy/issues",
-                "source": "https://github.com/myclabs/DeepCopy/tree/1.13.1"
+                "source": "https://github.com/myclabs/DeepCopy/tree/1.13.4"
             },
             "funding": [
                 {
@@ -2276,7 +2374,7 @@
                     "type": "tidelift"
                 }
             ],
-            "time": "2025-04-29T12:36:36+00:00"
+            "time": "2025-08-01T08:46:24+00:00"
         },
         {
             "name": "nikic/php-parser",
@@ -2488,16 +2586,16 @@
         },
         {
             "name": "phpstan/phpstan",
-            "version": "1.12.27",
+            "version": "1.12.28",
             "source": {
                 "type": "git",
                 "url": "https://github.com/phpstan/phpstan.git",
-                "reference": "3a6e423c076ab39dfedc307e2ac627ef579db162"
+                "reference": "fcf8b71aeab4e1a1131d1783cef97b23a51b87a9"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/phpstan/phpstan/zipball/3a6e423c076ab39dfedc307e2ac627ef579db162",
-                "reference": "3a6e423c076ab39dfedc307e2ac627ef579db162",
+                "url": "https://api.github.com/repos/phpstan/phpstan/zipball/fcf8b71aeab4e1a1131d1783cef97b23a51b87a9",
+                "reference": "fcf8b71aeab4e1a1131d1783cef97b23a51b87a9",
                 "shasum": ""
             },
             "require": {
@@ -2542,7 +2640,7 @@
                     "type": "github"
                 }
             ],
-            "time": "2025-05-21T20:51:45+00:00"
+            "time": "2025-07-17T17:15:39+00:00"
         },
         {
             "name": "phpunit/php-code-coverage",
@@ -2865,16 +2963,16 @@
         },
         {
             "name": "phpunit/phpunit",
-            "version": "9.6.23",
+            "version": "9.6.25",
             "source": {
                 "type": "git",
                 "url": "https://github.com/sebastianbergmann/phpunit.git",
-                "reference": "43d2cb18d0675c38bd44982a5d1d88f6d53d8d95"
+                "reference": "049c011e01be805202d8eebedef49f769a8ec7b7"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/sebastianbergmann/phpunit/zipball/43d2cb18d0675c38bd44982a5d1d88f6d53d8d95",
-                "reference": "43d2cb18d0675c38bd44982a5d1d88f6d53d8d95",
+                "url": "https://api.github.com/repos/sebastianbergmann/phpunit/zipball/049c011e01be805202d8eebedef49f769a8ec7b7",
+                "reference": "049c011e01be805202d8eebedef49f769a8ec7b7",
                 "shasum": ""
             },
             "require": {
@@ -2885,7 +2983,7 @@
                 "ext-mbstring": "*",
                 "ext-xml": "*",
                 "ext-xmlwriter": "*",
-                "myclabs/deep-copy": "^1.13.1",
+                "myclabs/deep-copy": "^1.13.4",
                 "phar-io/manifest": "^2.0.4",
                 "phar-io/version": "^3.2.1",
                 "php": ">=7.3",
@@ -2896,11 +2994,11 @@
                 "phpunit/php-timer": "^5.0.3",
                 "sebastian/cli-parser": "^1.0.2",
                 "sebastian/code-unit": "^1.0.8",
-                "sebastian/comparator": "^4.0.8",
+                "sebastian/comparator": "^4.0.9",
                 "sebastian/diff": "^4.0.6",
                 "sebastian/environment": "^5.1.5",
                 "sebastian/exporter": "^4.0.6",
-                "sebastian/global-state": "^5.0.7",
+                "sebastian/global-state": "^5.0.8",
                 "sebastian/object-enumerator": "^4.0.4",
                 "sebastian/resource-operations": "^3.0.4",
                 "sebastian/type": "^3.2.1",
@@ -2948,7 +3046,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.23"
+                "source": "https://github.com/sebastianbergmann/phpunit/tree/9.6.25"
             },
             "funding": [
                 {
@@ -2972,7 +3070,7 @@
                     "type": "tidelift"
                 }
             ],
-            "time": "2025-05-02T06:40:34+00:00"
+            "time": "2025-08-20T14:38:31+00:00"
         },
         {
             "name": "rregeer/phpunit-coverage-check",
@@ -3189,16 +3287,16 @@
         },
         {
             "name": "sebastian/comparator",
-            "version": "4.0.8",
+            "version": "4.0.9",
             "source": {
                 "type": "git",
                 "url": "https://github.com/sebastianbergmann/comparator.git",
-                "reference": "fa0f136dd2334583309d32b62544682ee972b51a"
+                "reference": "67a2df3a62639eab2cc5906065e9805d4fd5dfc5"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/sebastianbergmann/comparator/zipball/fa0f136dd2334583309d32b62544682ee972b51a",
-                "reference": "fa0f136dd2334583309d32b62544682ee972b51a",
+                "url": "https://api.github.com/repos/sebastianbergmann/comparator/zipball/67a2df3a62639eab2cc5906065e9805d4fd5dfc5",
+                "reference": "67a2df3a62639eab2cc5906065e9805d4fd5dfc5",
                 "shasum": ""
             },
             "require": {
@@ -3251,15 +3349,27 @@
             ],
             "support": {
                 "issues": "https://github.com/sebastianbergmann/comparator/issues",
-                "source": "https://github.com/sebastianbergmann/comparator/tree/4.0.8"
+                "source": "https://github.com/sebastianbergmann/comparator/tree/4.0.9"
             },
             "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/comparator",
+                    "type": "tidelift"
                 }
             ],
-            "time": "2022-09-14T12:41:17+00:00"
+            "time": "2025-08-10T06:51:50+00:00"
         },
         {
             "name": "sebastian/complexity",
@@ -3526,16 +3636,16 @@
         },
         {
             "name": "sebastian/global-state",
-            "version": "5.0.7",
+            "version": "5.0.8",
             "source": {
                 "type": "git",
                 "url": "https://github.com/sebastianbergmann/global-state.git",
-                "reference": "bca7df1f32ee6fe93b4d4a9abbf69e13a4ada2c9"
+                "reference": "b6781316bdcd28260904e7cc18ec983d0d2ef4f6"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/sebastianbergmann/global-state/zipball/bca7df1f32ee6fe93b4d4a9abbf69e13a4ada2c9",
-                "reference": "bca7df1f32ee6fe93b4d4a9abbf69e13a4ada2c9",
+                "url": "https://api.github.com/repos/sebastianbergmann/global-state/zipball/b6781316bdcd28260904e7cc18ec983d0d2ef4f6",
+                "reference": "b6781316bdcd28260904e7cc18ec983d0d2ef4f6",
                 "shasum": ""
             },
             "require": {
@@ -3578,15 +3688,27 @@
             ],
             "support": {
                 "issues": "https://github.com/sebastianbergmann/global-state/issues",
-                "source": "https://github.com/sebastianbergmann/global-state/tree/5.0.7"
+                "source": "https://github.com/sebastianbergmann/global-state/tree/5.0.8"
             },
             "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/global-state",
+                    "type": "tidelift"
                 }
             ],
-            "time": "2024-03-02T06:35:11+00:00"
+            "time": "2025-08-10T07:10:35+00:00"
         },
         {
             "name": "sebastian/lines-of-code",
@@ -3759,16 +3881,16 @@
         },
         {
             "name": "sebastian/recursion-context",
-            "version": "4.0.5",
+            "version": "4.0.6",
             "source": {
                 "type": "git",
                 "url": "https://github.com/sebastianbergmann/recursion-context.git",
-                "reference": "e75bd0f07204fec2a0af9b0f3cfe97d05f92efc1"
+                "reference": "539c6691e0623af6dc6f9c20384c120f963465a0"
             },
             "dist": {
                 "type": "zip",
-                "url": "https://api.github.com/repos/sebastianbergmann/recursion-context/zipball/e75bd0f07204fec2a0af9b0f3cfe97d05f92efc1",
-                "reference": "e75bd0f07204fec2a0af9b0f3cfe97d05f92efc1",
+                "url": "https://api.github.com/repos/sebastianbergmann/recursion-context/zipball/539c6691e0623af6dc6f9c20384c120f963465a0",
+                "reference": "539c6691e0623af6dc6f9c20384c120f963465a0",
                 "shasum": ""
             },
             "require": {
@@ -3810,15 +3932,27 @@
             "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.5"
+                "source": "https://github.com/sebastianbergmann/recursion-context/tree/4.0.6"
             },
             "funding": [
                 {
                     "url": "https://github.com/sebastianbergmann",
                     "type": "github"
+                },
+                {
+                    "url": "https://liberapay.com/sebastianbergmann",
+                    "type": "liberapay"
+                },
+                {
+                    "url": "https://thanks.dev/u/gh/sebastianbergmann",
+                    "type": "thanks_dev"
+                },
+                {
+                    "url": "https://tidelift.com/funding/github/packagist/sebastian/recursion-context",
+                    "type": "tidelift"
                 }
             ],
-            "time": "2023-02-03T06:07:39+00:00"
+            "time": "2025-08-10T06:57:39+00:00"
         },
         {
             "name": "sebastian/resource-operations",
diff --git a/phpunit.xml b/phpunit.xml
index 2a0531cfd..476123727 100755
--- a/phpunit.xml
+++ b/phpunit.xml
@@ -1,4 +1,4 @@
-<phpunit 
+<phpunit
     backupGlobals="false"
     backupStaticAttributes="false"
     bootstrap="vendor/autoload.php"
@@ -7,7 +7,7 @@
     convertNoticesToExceptions="true"
     convertWarningsToExceptions="true"
     processIsolation="false"
-    stopOnFailure="false"
+    stopOnFailure="true"
 >
     <testsuites>
         <testsuite name="unit">
diff --git a/src/Database/Adapter.php b/src/Database/Adapter.php
index 1f2e8e306..f2df525bf 100644
--- a/src/Database/Adapter.php
+++ b/src/Database/Adapter.php
@@ -788,18 +788,33 @@ abstract public function deleteDocuments(string $collection, array $sequences, a
      *
      * Find data sets using chosen queries
      *
-     * @param Document $collection
+     * @param QueryContext $context
      * @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> $selects
+     * @param array<Query> $filters
+     * @param array<Query> $joins
+     * @param array<Query> $orderQueries
+     *
      * @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;
+    abstract public function find(
+        QueryContext $context,
+        array $queries = [],
+        ?int $limit = 25,
+        ?int $offset = null,
+        array $cursor = [],
+        string $cursorDirection = Database::CURSOR_AFTER,
+        string $forPermission = Database::PERMISSION_READ,
+        array $selects = [],
+        array $filters = [],
+        array $joins = [],
+        array $orderQueries = []
+    ): array;
 
     /**
      * Sum an attribute
@@ -1134,36 +1149,10 @@ abstract public function getAttributeWidth(Document $collection): int;
     abstract public function getKeywords(): array;
 
     /**
-     * Get an attribute projection given a list of selected attributes
-     *
-     * @param array<string> $selections
-     * @param string $prefix
-     * @return mixed
-     */
-    abstract protected function getAttributeProjection(array $selections, string $prefix): mixed;
-
-    /**
-     * Get all selected attributes from queries
-     *
-     * @param Query[] $queries
-     * @return string[]
+     * @param array<Query> $selects
+     * @return 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;
-            }
-        }
-
-        return $selections;
-    }
+    abstract protected function getAttributeProjection(array $selects): string;
 
     /**
      * Filter Keys
diff --git a/src/Database/Adapter/MariaDB.php b/src/Database/Adapter/MariaDB.php
index 0e1cb09b4..486e7f6c2 100644
--- a/src/Database/Adapter/MariaDB.php
+++ b/src/Database/Adapter/MariaDB.php
@@ -13,6 +13,8 @@
 use Utopia\Database\Exception\Truncate as TruncateException;
 use Utopia\Database\Helpers\ID;
 use Utopia\Database\Query;
+use Utopia\Database\QueryContext;
+use Utopia\Database\Validator\Authorization;
 
 class MariaDB extends SQL
 {
@@ -56,7 +58,7 @@ public function delete(string $name): bool
         $sql = "DROP DATABASE `{$name}`;";
 
         $sql = $this->trigger(Database::EVENT_DATABASE_DELETE, $sql);
-
+        var_dump($sql);
         return $this->getPDO()
             ->prepare($sql)
             ->execute();
@@ -1454,11 +1456,14 @@ protected function handleSpatialQueries(Query $query, array &$binds, string $att
     protected function getSQLCondition(Query $query, array &$binds, array $attributes = []): string
     {
         $query->setAttribute($this->getInternalKeyForAttribute($query->getAttribute()));
+        $query->setAttributeRight($this->getInternalKeyForAttribute($query->getAttributeRight()));
 
         $attribute = $query->getAttribute();
         $attribute = $this->filter($attribute);
         $attribute = $this->quote($attribute);
-        $alias = $this->quote(Query::DEFAULT_ALIAS);
+        $alias = $query->getAlias();
+        $alias = $this->filter($alias);
+        $alias = $this->quote($alias);
         $placeholder = ID::unique();
 
         $attributeType = $this->getAttributeType($query->getAttribute(), $attributes);
@@ -1502,6 +1507,12 @@ protected function getSQLCondition(Query $query, array &$binds, array $attribute
 
                 return "{$alias}.{$attribute} NOT BETWEEN :{$placeholder}_0 AND :{$placeholder}_1";
 
+            case Query::TYPE_RELATION_EQUAL:
+                $attributeRight = $this->quote($this->filter($query->getAttributeRight()));
+                $aliasRight = $this->quote($query->getRightAlias());
+
+                return "{$alias}.{$attribute}={$aliasRight}.{$attributeRight}";
+
             case Query::TYPE_IS_NULL:
             case Query::TYPE_IS_NOT_NULL:
 
diff --git a/src/Database/Adapter/Pool.php b/src/Database/Adapter/Pool.php
index fc099178b..e11b7daa5 100644
--- a/src/Database/Adapter/Pool.php
+++ b/src/Database/Adapter/Pool.php
@@ -6,6 +6,7 @@
 use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Exception as DatabaseException;
+use Utopia\Database\QueryContext;
 use Utopia\Pools\Pool as UtopiaPool;
 
 class Pool extends Adapter
@@ -260,7 +261,19 @@ public function deleteDocuments(string $collection, array $sequences, array $per
         return $this->delegate(__FUNCTION__, \func_get_args());
     }
 
-    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(
+        QueryContext $context,
+        array $queries = [],
+        ?int $limit = 25,
+        ?int $offset = null,
+        array $cursor = [],
+        string $cursorDirection = Database::CURSOR_AFTER,
+        string $forPermission = Database::PERMISSION_READ,
+        array $selects = [],
+        array $filters = [],
+        array $joins = [],
+        array $orderQueries = []
+    ): array
     {
         return $this->delegate(__FUNCTION__, \func_get_args());
     }
@@ -470,13 +483,7 @@ public function getKeywords(): array
         return $this->delegate(__FUNCTION__, \func_get_args());
     }
 
-    /**
-     * @param array<string,mixed> $selections
-     * @param string $prefix
-     * @param array<string,mixed> $spatialAttributes
-     * @return mixed
-     */
-    protected function getAttributeProjection(array $selections, string $prefix, array $spatialAttributes = []): mixed
+    protected function getAttributeProjection(array $selects): string
     {
         return $this->delegate(__FUNCTION__, \func_get_args());
     }
diff --git a/src/Database/Adapter/Postgres.php b/src/Database/Adapter/Postgres.php
index ab44bead1..2cd151542 100644
--- a/src/Database/Adapter/Postgres.php
+++ b/src/Database/Adapter/Postgres.php
@@ -15,6 +15,8 @@
 use Utopia\Database\Exception\Truncate as TruncateException;
 use Utopia\Database\Helpers\ID;
 use Utopia\Database\Query;
+use Utopia\Database\QueryContext;
+use Utopia\Database\Validator\Authorization;
 
 class Postgres extends SQL
 {
@@ -1556,10 +1558,13 @@ protected function handleSpatialQueries(Query $query, array &$binds, string $att
     protected function getSQLCondition(Query $query, array &$binds, array $attributes = []): string
     {
         $query->setAttribute($this->getInternalKeyForAttribute($query->getAttribute()));
+        $query->setAttributeRight($this->getInternalKeyForAttribute($query->getAttributeRight()));
 
         $attribute = $this->filter($query->getAttribute());
         $attribute = $this->quote($attribute);
-        $alias = $this->quote(Query::DEFAULT_ALIAS);
+        $alias = $query->getAlias();
+        $alias = $this->filter($alias);
+        $alias = $this->quote($alias);
         $placeholder = ID::unique();
 
         $attributeType = $this->getAttributeType($query->getAttribute(), $attributes);
@@ -1599,6 +1604,12 @@ protected function getSQLCondition(Query $query, array &$binds, array $attribute
                 $binds[":{$placeholder}_1"] = $query->getValues()[1];
                 return "{$alias}.{$attribute} NOT BETWEEN :{$placeholder}_0 AND :{$placeholder}_1";
 
+            case Query::TYPE_RELATION_EQUAL:
+                $attributeRight = $this->quote($this->filter($query->getAttributeRight()));
+                $aliasRight = $this->quote($query->getRightAlias());
+
+                return "{$alias}.{$attribute}={$aliasRight}.{$attributeRight}";
+
             case Query::TYPE_IS_NULL:
             case Query::TYPE_IS_NOT_NULL:
                 return "{$alias}.{$attribute} {$this->getSQLOperator($query->getMethod())}";
@@ -1629,6 +1640,7 @@ protected function getSQLCondition(Query $query, array &$binds, array $attribute
                         Query::TYPE_NOT_ENDS_WITH => '%' . $this->escapeWildcards($value),
                         Query::TYPE_CONTAINS => ($query->onArray()) ? \json_encode($value) : '%' . $this->escapeWildcards($value) . '%',
                         Query::TYPE_NOT_CONTAINS => ($query->onArray()) ? \json_encode($value) : '%' . $this->escapeWildcards($value) . '%',
+                        //Query::TYPE_SEARCH => $this->getFulltextValue($value),
                         default => $value
                     };
 
diff --git a/src/Database/Adapter/SQL.php b/src/Database/Adapter/SQL.php
index cc241c445..7a5985ed7 100644
--- a/src/Database/Adapter/SQL.php
+++ b/src/Database/Adapter/SQL.php
@@ -14,6 +14,7 @@
 use Utopia\Database\Exception\Timeout as TimeoutException;
 use Utopia\Database\Exception\Transaction as TransactionException;
 use Utopia\Database\Query;
+use Utopia\Database\QueryContext;
 use Utopia\Database\Validator\Authorization;
 
 abstract class SQL extends Adapter
@@ -191,6 +192,7 @@ public function exists(string $database, ?string $collection = null): bool
             $stmt->execute();
             $document = $stmt->fetchAll();
             $stmt->closeCursor();
+            var_dump($document);
         } catch (PDOException $e) {
             $e = $this->processException($e);
 
@@ -354,23 +356,22 @@ public function getDocument(Document $collection, string $id, array $queries = [
         $collection = $collection->getId();
 
         $name = $this->filter($collection);
-        $selections = $this->getAttributeSelections($queries);
 
         $forUpdate = $forUpdate ? 'FOR UPDATE' : '';
 
         $alias = Query::DEFAULT_ALIAS;
 
         $sql = "
-		    SELECT {$this->getAttributeProjection($selections, $alias, $spatialAttributes)}
+		    SELECT {$this->getAttributeProjection($queries, $spatialAttributes)}
             FROM {$this->getSQLTable($name)} AS {$this->quote($alias)}
-            WHERE {$this->quote($alias)}.{$this->quote('_uid')} = :_uid 
+            WHERE {$this->quote($alias)}._uid = :_uid 
             {$this->getTenantQuery($collection, $alias)}
 		";
 
         if ($this->getSupportForUpdateLock()) {
             $sql .= " {$forUpdate}";
         }
-
+var_dump($sql);
         $stmt = $this->getPDO()->prepare($sql);
 
         $stmt->bindValue(':_uid', $id);
@@ -1762,12 +1763,10 @@ abstract protected function getSQLCondition(Query $query, array &$binds, array $
      */
     public function getSQLConditions(array $queries, array &$binds, string $separator = 'AND', array $attributes = []): string
     {
+        $queries = Query::getFilterQueries($queries);
+
         $conditions = [];
         foreach ($queries as $query) {
-            if ($query->getMethod() === Query::TYPE_SELECT) {
-                continue;
-            }
-
             if ($query->isNested()) {
                 $conditions[] = $this->getSQLConditions($query->getValues(), $binds, $query->getMethod(), $attributes);
             } else {
@@ -1834,68 +1833,57 @@ public function getTenantQuery(
     /**
      * Get the SQL projection given the selected attributes
      *
-     * @param array<string> $selections
-     * @param string $prefix
-     * @param array<string> $spatialAttributes
-     * @return mixed
+     * @param array<Query> $selects
+     * @return string
      * @throws Exception
      */
-    protected function getAttributeProjection(array $selections, string $prefix, array $spatialAttributes = []): mixed
+    protected function getAttributeProjection(array $selects, array $spatialAttributes = []): string
     {
-        if (empty($selections) || \in_array('*', $selections)) {
-            if (empty($spatialAttributes)) {
-                return "{$this->quote($prefix)}.*";
-            }
+        //todo: fix this $spatialAttributes
 
-            $projections = [];
-            $projections[] = "{$this->quote($prefix)}.*";
+        if (empty($selects)) {
+            return Query::DEFAULT_ALIAS.'.*';
+        }
 
-            $internalColumns = ['_id', '_uid', '_createdAt', '_updatedAt', '_permissions'];
-            if ($this->sharedTables) {
-                $internalColumns[] = '_tenant';
-            }
-            foreach ($internalColumns as $col) {
-                $projections[] = "{$this->quote($prefix)}.{$this->quote($col)}";
+        $string = '';
+        foreach ($selects as $select) {
+            if ($select->getAttribute() === '$collection') {
+                continue;
             }
 
-            foreach ($spatialAttributes as $spatialAttr) {
-                $filteredAttr = $this->filter($spatialAttr);
-                $quotedAttr = $this->quote($filteredAttr);
-                $projections[] = "ST_AsText({$this->quote($prefix)}.{$quotedAttr}) AS {$quotedAttr}";
+            $alias = $select->getAlias();
+            $alias = $this->filter($alias);
+            $attribute = $select->getAttribute();
+
+            $attribute = match ($attribute) {
+                '$id' => '_uid',
+                '$sequence' => '_id',
+                '$tenant' => '_tenant',
+                '$createdAt' => '_createdAt',
+                '$updatedAt' => '_updatedAt',
+                '$permissions' => '_permissions',
+                default => $attribute
+            };
+
+            if ($attribute !== '*') {
+                $attribute = $this->filter($attribute);
+                $attribute = $this->quote($attribute);
             }
 
+            $as = $select->getAs();
 
-            return implode(', ', $projections);
-        }
-
-        // Handle specific selections with spatial conversion where needed
-        $internalKeys = [
-            '$id',
-            '$sequence',
-            '$permissions',
-            '$createdAt',
-            '$updatedAt',
-        ];
-
-        $selections = \array_diff($selections, [...$internalKeys, '$collection']);
-
-        foreach ($internalKeys as $internalKey) {
-            $selections[] = $this->getInternalKeyForAttribute($internalKey);
-        }
-
-        $projections = [];
-        foreach ($selections as $selection) {
-            $filteredSelection = $this->filter($selection);
-            $quotedSelection = $this->quote($filteredSelection);
+            if (!empty($as)){
+                $as = ' as '.$this->quote($this->filter($as));
+            }
 
-            if (in_array($selection, $spatialAttributes)) {
-                $projections[] = "ST_AsText({$this->quote($prefix)}.{$quotedSelection}) AS {$quotedSelection}";
-            } else {
-                $projections[] = "{$this->quote($prefix)}.{$quotedSelection}";
+            if (!empty($string)) {
+                $string .= ', ';
             }
+
+            $string .= "{$this->quote($alias)}.{$attribute}{$as}";
         }
 
-        return \implode(',', $projections);
+        return $string;
     }
 
     protected function getInternalKeyForAttribute(string $attribute): string
@@ -2317,51 +2305,66 @@ protected function getAttributeType(string $attributeName, array $attributes): ?
         return null;
     }
 
+
     /**
      * Find Documents
      *
-     * @param Document $collection
+     * @param QueryContext $context
      * @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> $selects
+     * @param array<Query> $filters
+     * @param array<Query> $joins
+     * @param array<Query> $orderQueries
      * @return array<Document>
      * @throws DatabaseException
      * @throws TimeoutException
      * @throws Exception
      */
-    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
-    {
-        $spatialAttributes = $this->getSpatialAttributes($collection);
-        $attributes = $collection->getAttribute('attributes', []);
+    public function find(
+        QueryContext $context,
+        array $queries = [],
+        ?int $limit = 25,
+        ?int $offset = null,
+        array $cursor = [],
+        string $cursorDirection = Database::CURSOR_AFTER,
+        string $forPermission = Database::PERMISSION_READ,
+        array $selects = [],
+        array $filters = [],
+        array $joins = [],
+        array $orderQueries = []
+    ): array {
+        unset($queries); // remove this since we pass explicit queries
+
+        $alias = Query::DEFAULT_ALIAS;
+        $binds = [];
+
+        $name = $context->getCollections()[0]->getId();
+        $name = $this->filter($name);
 
-        $collection = $collection->getId();
-        $name = $this->filter($collection);
         $roles = Authorization::getRoles();
         $where = [];
         $orders = [];
-        $alias = Query::DEFAULT_ALIAS;
-        $binds = [];
 
-        $queries = array_map(fn ($query) => clone $query, $queries);
+        $filters = array_map(fn ($query) => clone $query, $filters);
 
         $cursorWhere = [];
 
-        foreach ($orderAttributes as $i => $originalAttribute) {
+        foreach ($orderQueries as $i => $order) {
+            $orderAlias = $order->getAlias();
+            $attribute  = $order->getAttribute();
+            $originalAttribute = $attribute;
             $attribute = $this->getInternalKeyForAttribute($originalAttribute);
             $attribute = $this->filter($attribute);
 
-            $orderType = $this->filter($orderTypes[$i] ?? Database::ORDER_ASC);
-            $direction = $orderType;
+            $direction = $order->getOrderDirection();
 
             if ($cursorDirection === Database::CURSOR_BEFORE) {
-                $direction = ($direction === Database::ORDER_ASC)
-                    ? Database::ORDER_DESC
-                    : Database::ORDER_ASC;
+                $direction = ($direction === Database::ORDER_ASC) ? Database::ORDER_DESC : Database::ORDER_ASC;
             }
 
             $orders[] = "{$this->quote($attribute)} {$direction}";
@@ -2369,7 +2372,7 @@ public function find(Document $collection, array $queries = [], ?int $limit = 25
             // 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') {
+                if (count($orderQueries) === 1 && $i === 0 && $originalAttribute === '$sequence') {
                     $operator = ($direction === Database::ORDER_DESC)
                         ? Query::TYPE_LESSER
                         : Query::TYPE_GREATER;
@@ -2377,7 +2380,7 @@ public function find(Document $collection, array $queries = [], ?int $limit = 25
                     $bindName = ":cursor_pk";
                     $binds[$bindName] = $cursor[$originalAttribute];
 
-                    $cursorWhere[] = "{$this->quote($alias)}.{$this->quote($attribute)} {$this->getSQLOperator($operator)} {$bindName}";
+                    $cursorWhere[] = "{$this->quote($orderAlias)}.{$this->quote($attribute)} {$this->getSQLOperator($operator)} {$bindName}";
                     break;
                 }
 
@@ -2385,13 +2388,14 @@ public function find(Document $collection, array $queries = [], ?int $limit = 25
 
                 // Add equality conditions for previous attributes
                 for ($j = 0; $j < $i; $j++) {
-                    $prevOriginal = $orderAttributes[$j];
+                    $prevQuery = $orderQueries[$j];
+                    $prevOriginal = $prevQuery->getAttribute();
                     $prevAttr = $this->filter($this->getInternalKeyForAttribute($prevOriginal));
 
                     $bindName = ":cursor_{$j}";
                     $binds[$bindName] = $cursor[$prevOriginal];
 
-                    $conditions[] = "{$this->quote($alias)}.{$this->quote($prevAttr)} = {$bindName}";
+                    $conditions[] = "{$this->quote($orderAlias)}.{$this->quote($prevAttr)} = {$bindName}";
                 }
 
                 // Add comparison for current attribute
@@ -2402,7 +2406,7 @@ public function find(Document $collection, array $queries = [], ?int $limit = 25
                 $bindName = ":cursor_{$i}";
                 $binds[$bindName] = $cursor[$originalAttribute];
 
-                $conditions[] = "{$this->quote($alias)}.{$this->quote($attribute)} {$this->getSQLOperator($operator)} {$bindName}";
+                $conditions[] = "{$this->quote($orderAlias)}.{$this->quote($attribute)} {$this->getSQLOperator($operator)} {$bindName}";
 
                 $cursorWhere[] = '(' . implode(' AND ', $conditions) . ')';
             }
@@ -2412,18 +2416,37 @@ public function find(Document $collection, array $queries = [], ?int $limit = 25
             $where[] = '(' . implode(' OR ', $cursorWhere) . ')';
         }
 
-        $conditions = $this->getSQLConditions($queries, $binds, attributes:$attributes);
+        $sqlJoin = '';
+        foreach ($joins as $join) {
+            $permissions = '';
+            $collection = $join->getCollection();
+            $collection = $this->filter($collection);
+
+            $skipAuth = $context->skipAuth($collection, $forPermission);
+            if (! $skipAuth) {
+                $permissions = 'AND '.$this->getSQLPermissionsCondition($collection, $roles, $join->getAlias(), $forPermission);
+            }
+
+            $sqlJoin .= "INNER JOIN {$this->getSQLTable($collection)} AS {$this->quote($join->getAlias())}
+            ON {$this->getSQLConditions($join->getValues(), $binds)}
+            {$permissions}
+            {$this->getTenantQuery($collection, $join->getAlias())}
+            ";
+        }
+
+        $conditions = $this->getSQLConditions($filters, $binds);
         if (!empty($conditions)) {
             $where[] = $conditions;
         }
 
-        if (Authorization::$status) {
+        $skipAuth = $context->skipAuth($name, $forPermission);
+        if (! $skipAuth) {
             $where[] = $this->getSQLPermissionsCondition($name, $roles, $alias, $forPermission);
         }
 
         if ($this->sharedTables) {
             $binds[':_tenant'] = $this->tenant;
-            $where[] = "{$this->getTenantQuery($collection, $alias, condition: '')}";
+            $where[] = "{$this->getTenantQuery($name, $alias, condition: '')}";
         }
 
         $sqlWhere = !empty($where) ? 'WHERE ' . implode(' AND ', $where) : '';
@@ -2440,17 +2463,15 @@ public function find(Document $collection, array $queries = [], ?int $limit = 25
             $sqlLimit .= ' OFFSET :offset';
         }
 
-        $selections = $this->getAttributeSelections($queries);
-
-
         $sql = "
-            SELECT {$this->getAttributeProjection($selections, $alias, $spatialAttributes)}
+            SELECT {$this->getAttributeProjection($selects)}
             FROM {$this->getSQLTable($name)} AS {$this->quote($alias)}
+            {$sqlJoin}
             {$sqlWhere}
             {$sqlOrder}
             {$sqlLimit};
         ";
-
+var_dump($sql);
         $sql = $this->trigger(Database::EVENT_DOCUMENT_FIND, $sql);
 
         try {
@@ -2465,13 +2486,13 @@ public function find(Document $collection, array $queries = [], ?int $limit = 25
             }
 
             $this->execute($stmt);
+            $results = $stmt->fetchAll();
+            $stmt->closeCursor();
+
         } 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'];
diff --git a/src/Database/Database.php b/src/Database/Database.php
index aa87daa0f..4a1d2b984 100644
--- a/src/Database/Database.php
+++ b/src/Database/Database.php
@@ -29,8 +29,7 @@
 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\Queries\V2 as DocumentsValidator;
 use Utopia\Database\Validator\Spatial;
 use Utopia\Database\Validator\Structure;
 
@@ -1531,6 +1530,7 @@ public function deleteCollection(string $id): bool
             throw new NotFoundException('Collection not found');
         }
 
+
         $relationships = \array_filter(
             $collection->getAttribute('attributes'),
             fn ($attribute) => $attribute->getAttribute('type') === Database::VAR_RELATIONSHIP
@@ -3352,12 +3352,16 @@ public function getDocument(string $collection, string $id, array $queries = [],
             throw new NotFoundException('Collection not found');
         }
 
-        $attributes = $collection->getAttribute('attributes', []);
+        $context = new QueryContext();
+        $context->add($collection);
 
         $this->checkQueriesType($queries);
 
         if ($this->validate) {
-            $validator = new DocumentValidator($attributes);
+            $validator = new DocumentsValidator(
+                $context,
+                $this->adapter->getIdAttributeType()
+            );
             if (!$validator->isValid($queries)) {
                 throw new QueryException($validator->getDescription());
             }
@@ -3368,9 +3372,13 @@ public function getDocument(string $collection, string $id, array $queries = [],
             fn (Document $attribute) => $attribute->getAttribute('type') === self::VAR_RELATIONSHIP
         );
 
-        $selects = Query::groupByType($queries)['selections'];
-        $selections = $this->validateSelections($collection, $selects);
-        $nestedSelections = $this->processRelationshipQueries($relationships, $queries);
+        $selects = Query::getSelectQueries($queries);
+
+        //$selects = $this->validateSelections($collection, $selects);
+
+        [$selects, $nestedSelections] = $this->processRelationshipQueries($relationships, $selects);
+
+        [$selects, $permissionsAdded] = Query::addSelect($selects, Query::select('$permissions',  system: true));
 
         $validator = new Authorization(self::PERMISSION_READ);
         $documentSecurity = $collection->getAttribute('documentSecurity', false);
@@ -3378,7 +3386,7 @@ public function getDocument(string $collection, string $id, array $queries = [],
         [$collectionKey, $documentKey, $hashKey] = $this->getCacheKeys(
             $collection->getId(),
             $id,
-            $selections
+            $selects
         );
 
         try {
@@ -3408,13 +3416,14 @@ public function getDocument(string $collection, string $id, array $queries = [],
         $document = $this->adapter->getDocument(
             $collection,
             $id,
-            $queries,
+            $selects,
             $forUpdate
         );
 
         if ($document->isEmpty()) {
             return $document;
         }
+
         $document->setAttribute('$collection', $collection->getId());
 
         if ($collection->getId() !== self::METADATA) {
@@ -3426,8 +3435,8 @@ public function getDocument(string $collection, string $id, array $queries = [],
             }
         }
 
-        $document = $this->casting($collection, $document);
-        $document = $this->decode($collection, $document, $selections);
+        $document = $this->casting($context, $document, $selects);
+        $document = $this->decode($context, $document, $selects);
         $this->map = [];
 
         if ($this->resolveRelationships && !empty($relationships) && (empty($selects) || !empty($nestedSelections))) {
@@ -3449,6 +3458,10 @@ public function getDocument(string $collection, string $id, array $queries = [],
             }
         }
 
+        if($permissionsAdded){ // Or remove all queries added by system
+            $document->removeAttribute('$permissions');
+        }
+
         $this->trigger(self::EVENT_DOCUMENT_READ, $document);
 
         return $document;
@@ -3463,6 +3476,10 @@ public function getDocument(string $collection, string $id, array $queries = [],
      */
     private function populateDocumentRelationships(Document $collection, Document $document, array $selects = []): Document
     {
+        if (empty($document->getId())){
+            throw new DatabaseException('$id is a required for populate Document Relationships');
+        }
+
         $attributes = $collection->getAttribute('attributes', []);
 
         $relationships = [];
@@ -3809,8 +3826,11 @@ public function createDocument(string $collection, Document $document): Document
             $document = $this->silent(fn () => $this->populateDocumentRelationships($collection, $document));
         }
 
-        $document = $this->casting($collection, $document);
-        $document = $this->decode($collection, $document);
+        $context = new QueryContext();
+        $context->add($collection);
+
+        $document = $this->casting($context, $document);
+        $document = $this->decode($context, $document);
 
         $this->trigger(self::EVENT_DOCUMENT_CREATE, $document);
 
@@ -3853,6 +3873,9 @@ public function createDocuments(
             }
         }
 
+        $context = new QueryContext();
+        $context->add($collection);
+
         $time = DateTime::now();
         $modified = 0;
 
@@ -3909,8 +3932,8 @@ public function createDocuments(
                     $document = $this->silent(fn () => $this->populateDocumentRelationships($collection, $document));
                 }
 
-                $document = $this->casting($collection, $document);
-                $document = $this->decode($collection, $document);
+                $document = $this->casting($context, $document);
+                $document = $this->decode($context, $document);
                 $onNext && $onNext($document);
                 $modified++;
             }
@@ -4451,7 +4474,10 @@ public function updateDocument(string $collection, string $id, Document $documen
             $document = $this->silent(fn () => $this->populateDocumentRelationships($collection, $document));
         }
 
-        $document = $this->decode($collection, $document);
+        $context = new QueryContext();
+        $context->add($collection);
+
+        $document = $this->decode($context, $document);
 
         $this->trigger(self::EVENT_DOCUMENT_UPDATE, $document);
 
@@ -4505,19 +4531,18 @@ public function updateDocuments(
             throw new AuthorizationException($authorization->getDescription());
         }
 
-        $attributes = $collection->getAttribute('attributes', []);
-        $indexes = $collection->getAttribute('indexes', []);
+        $context = new QueryContext();
+        $context->add($collection);
 
         $this->checkQueriesType($queries);
 
         if ($this->validate) {
             $validator = new DocumentsValidator(
-                $attributes,
-                $indexes,
+                $context,
                 $this->adapter->getIdAttributeType(),
-                $this->maxQueryValues,
-                $this->adapter->getMinDateTime(),
-                $this->adapter->getMaxDateTime(),
+                maxValuesCount: $this->maxQueryValues,
+                minAllowedDate: $this->adapter->getMinDateTime(),
+                maxAllowedDate: $this->adapter->getMaxDateTime()
             );
 
             if (!$validator->isValid($queries)) {
@@ -4591,6 +4616,15 @@ public function updateDocuments(
                 break;
             }
 
+            /**
+             * Check and tests for required attributes
+             */
+            foreach (['$permissions', '$sequence'] as $required) {
+                if (!$batch[0]->offsetExists($required)) {
+                    throw new QueryException("Missing required attribute {$required} in select query");
+                }
+            }
+
             $currentPermissions  = $updates->getPermissions();
             sort($currentPermissions);
 
@@ -4645,7 +4679,7 @@ public function updateDocuments(
                 $doc->removeAttribute('$skipPermissionsUpdate');
 
                 $this->purgeCachedDocument($collection->getId(), $doc->getId());
-                $doc = $this->decode($collection, $doc);
+                $doc = $this->decode($context, $doc);
                 try {
                     $onNext && $onNext($doc);
                 } catch (Throwable $th) {
@@ -4733,7 +4767,7 @@ private function updateDocumentRelationships(Document $collection, Document $old
                             }
 
                             if (\is_string($value)) {
-                                $related = $this->skipRelationships(fn () => $this->getDocument($relatedCollection->getId(), $value, [Query::select(['$id'])]));
+                                $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
@@ -4762,7 +4796,7 @@ private function updateDocumentRelationships(Document $collection, Document $old
                         switch (\gettype($value)) {
                             case 'string':
                                 $related = $this->skipRelationships(
-                                    fn () => $this->getDocument($relatedCollection->getId(), $value, [Query::select(['$id'])])
+                                    fn () => $this->getDocument($relatedCollection->getId(), $value, [Query::select('$id')])
                                 );
 
                                 if ($related->isEmpty()) {
@@ -4774,7 +4808,7 @@ private function updateDocumentRelationships(Document $collection, Document $old
                                 if (
                                     $oldValue?->getId() !== $value
                                     && !($this->skipRelationships(fn () => $this->findOne($relatedCollection->getId(), [
-                                        Query::select(['$id']),
+                                        Query::select('$id'),
                                         Query::equal($twoWayKey, [$value]),
                                     ]))->isEmpty())
                                 ) {
@@ -4795,7 +4829,7 @@ private function updateDocumentRelationships(Document $collection, Document $old
                                     if (
                                         $oldValue?->getId() !== $value->getId()
                                         && !($this->skipRelationships(fn () => $this->findOne($relatedCollection->getId(), [
-                                            Query::select(['$id']),
+                                            Query::select('$id'),
                                             Query::equal($twoWayKey, [$value->getId()]),
                                         ]))->isEmpty())
                                     ) {
@@ -4876,7 +4910,7 @@ private function updateDocumentRelationships(Document $collection, Document $old
                             foreach ($value as $relation) {
                                 if (\is_string($relation)) {
                                     $related = $this->skipRelationships(
-                                        fn () => $this->getDocument($relatedCollection->getId(), $relation, [Query::select(['$id'])])
+                                        fn () => $this->getDocument($relatedCollection->getId(), $relation, [Query::select('$id')])
                                     );
 
                                     if ($related->isEmpty()) {
@@ -4890,7 +4924,7 @@ private function updateDocumentRelationships(Document $collection, Document $old
                                     ));
                                 } elseif ($relation instanceof Document) {
                                     $related = $this->skipRelationships(
-                                        fn () => $this->getDocument($relatedCollection->getId(), $relation->getId(), [Query::select(['$id'])])
+                                        fn () => $this->getDocument($relatedCollection->getId(), $relation->getId(), [Query::select('$id')])
                                     );
 
                                     if ($related->isEmpty()) {
@@ -4919,7 +4953,7 @@ private function updateDocumentRelationships(Document $collection, Document $old
 
                         if (\is_string($value)) {
                             $related = $this->skipRelationships(
-                                fn () => $this->getDocument($relatedCollection->getId(), $value, [Query::select(['$id'])])
+                                fn () => $this->getDocument($relatedCollection->getId(), $value, [Query::select('$id')])
                             );
 
                             if ($related->isEmpty()) {
@@ -4930,7 +4964,7 @@ private function updateDocumentRelationships(Document $collection, Document $old
                             $this->purgeCachedDocument($relatedCollection->getId(), $value);
                         } elseif ($value instanceof Document) {
                             $related = $this->skipRelationships(
-                                fn () => $this->getDocument($relatedCollection->getId(), $value->getId(), [Query::select(['$id'])])
+                                fn () => $this->getDocument($relatedCollection->getId(), $value->getId(), [Query::select('$id')])
                             );
 
                             if ($related->isEmpty()) {
@@ -5000,11 +5034,11 @@ private function updateDocumentRelationships(Document $collection, Document $old
 
                         foreach ($value as $relation) {
                             if (\is_string($relation)) {
-                                if (\in_array($relation, $oldIds) || $this->getDocument($relatedCollection->getId(), $relation, [Query::select(['$id'])])->isEmpty()) {
+                                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'])]);
+                                $related = $this->getDocument($relatedCollection->getId(), $relation->getId(), [Query::select('$id')]);
 
                                 if ($related->isEmpty()) {
                                     if (!isset($value['$permissions'])) {
@@ -5121,6 +5155,10 @@ public function createOrUpdateDocumentsWithIncrease(
         $created = 0;
         $updated = 0;
         $seenIds = [];
+
+        $context = new QueryContext();
+        $context->add($collection);
+
         foreach ($documents as $key => $document) {
             if ($this->getSharedTables() && $this->getTenantPerDocument()) {
                 $old = Authorization::skip(fn () => $this->withTenant($document->getTenant(), fn () => $this->silent(fn () => $this->getDocument(
@@ -5289,7 +5327,7 @@ public function createOrUpdateDocumentsWithIncrease(
                     $doc = $this->silent(fn () => $this->populateDocumentRelationships($collection, $doc));
                 }
 
-                $doc = $this->decode($collection, $doc);
+                $doc = $this->decode($context, $doc);
 
                 if ($this->getSharedTables() && $this->getTenantPerDocument()) {
                     $this->withTenant($doc->getTenant(), function () use ($collection, $doc) {
@@ -5708,7 +5746,7 @@ private function deleteRestrict(
         ) {
             Authorization::skip(function () use ($document, $relatedCollection, $twoWayKey) {
                 $related = $this->findOne($relatedCollection->getId(), [
-                    Query::select(['$id']),
+                    Query::select('$id'),
                     Query::equal($twoWayKey, [$document->getId()])
                 ]);
 
@@ -5731,7 +5769,7 @@ private function deleteRestrict(
             && $side === Database::RELATION_SIDE_CHILD
         ) {
             $related = Authorization::skip(fn () => $this->findOne($relatedCollection->getId(), [
-                Query::select(['$id']),
+                Query::select('$id'),
                 Query::equal($twoWayKey, [$document->getId()])
             ]));
 
@@ -5769,14 +5807,14 @@ private function deleteSetNull(Document $collection, Document $relatedCollection
                 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::select('$id'),
                             Query::equal($twoWayKey, [$document->getId()])
                         ]);
                     } else {
                         if (empty($value)) {
                             return;
                         }
-                        $related = $this->getDocument($relatedCollection->getId(), $value->getId(), [Query::select(['$id'])]);
+                        $related = $this->getDocument($relatedCollection->getId(), $value->getId(), [Query::select('$id')]);
                     }
 
                     if ($related->isEmpty()) {
@@ -5817,7 +5855,7 @@ private function deleteSetNull(Document $collection, Document $relatedCollection
 
                 if (!$twoWay) {
                     $value = $this->find($relatedCollection->getId(), [
-                        Query::select(['$id']),
+                        Query::select('$id'),
                         Query::equal($twoWayKey, [$document->getId()]),
                         Query::limit(PHP_INT_MAX)
                     ]);
@@ -5840,7 +5878,7 @@ private function deleteSetNull(Document $collection, Document $relatedCollection
                 $junction = $this->getJunctionCollection($collection, $relatedCollection, $side);
 
                 $junctions = $this->find($junction, [
-                    Query::select(['$id']),
+                    Query::select('$id'),
                     Query::equal($twoWayKey, [$document->getId()]),
                     Query::limit(PHP_INT_MAX)
                 ]);
@@ -5910,7 +5948,7 @@ private function deleteCascade(Document $collection, Document $relatedCollection
                 }
 
                 $value = $this->find($relatedCollection->getId(), [
-                    Query::select(['$id']),
+                    Query::select('$id'),
                     Query::equal($twoWayKey, [$document->getId()]),
                     Query::limit(PHP_INT_MAX),
                 ]);
@@ -5931,7 +5969,8 @@ private function deleteCascade(Document $collection, Document $relatedCollection
                 $junction = $this->getJunctionCollection($collection, $relatedCollection, $side);
 
                 $junctions = $this->skipRelationships(fn () => $this->find($junction, [
-                    Query::select(['$id', $key]),
+                    Query::select('$id'),
+                    Query::select($key),
                     Query::equal($twoWayKey, [$document->getId()]),
                     Query::limit(PHP_INT_MAX)
                 ]));
@@ -5997,19 +6036,18 @@ public function deleteDocuments(
             throw new AuthorizationException($authorization->getDescription());
         }
 
-        $attributes = $collection->getAttribute('attributes', []);
-        $indexes = $collection->getAttribute('indexes', []);
+        $context = new QueryContext();
+        $context->add($collection);
 
         $this->checkQueriesType($queries);
 
         if ($this->validate) {
             $validator = new DocumentsValidator(
-                $attributes,
-                $indexes,
+                $context,
                 $this->adapter->getIdAttributeType(),
-                $this->maxQueryValues,
-                $this->adapter->getMinDateTime(),
-                $this->adapter->getMaxDateTime()
+                maxValuesCount: $this->maxQueryValues,
+                minAllowedDate: $this->adapter->getMinDateTime(),
+                maxAllowedDate: $this->adapter->getMaxDateTime()
             );
 
             if (!$validator->isValid($queries)) {
@@ -6057,6 +6095,15 @@ public function deleteDocuments(
                 break;
             }
 
+            /**
+             * Check and tests for required attributes
+             */
+            foreach (['$permissions', '$sequence'] as $required) {
+                if (!$batch[0]->offsetExists($required)) {
+                    throw new QueryException("Missing required attribute {$required} in select query");
+                }
+            }
+
             $sequences = [];
             $permissionIds = [];
 
@@ -6193,38 +6240,54 @@ public function find(string $collection, array $queries = [], string $forPermiss
             throw new NotFoundException('Collection not found');
         }
 
-        $attributes = $collection->getAttribute('attributes', []);
-        $indexes = $collection->getAttribute('indexes', []);
+        $context = new QueryContext();
+        $context->add($collection);
+
+        $joins = Query::getJoinQueries($queries);
+
+        foreach ($joins as $join) {
+            $context->add(
+                $this->silent(fn () => $this->getCollection($join->getCollection())),
+                $join->getAlias()
+            );
+        }
+
+        $authorization = new Authorization($forPermission);
+
+        foreach ($context->getCollections() as $_collection) {
+            $documentSecurity = $_collection->getAttribute('documentSecurity', false);
+            $skipAuth = $authorization->isValid($_collection->getPermissionsByType($forPermission));
+
+            if (!$skipAuth && !$documentSecurity && $_collection->getId() !== self::METADATA) {
+                throw new AuthorizationException($authorization->getDescription());
+            }
+
+            $context->addSkipAuth($this->adapter->filter($_collection->getId()), $forPermission, $skipAuth);
+        }
 
         $this->checkQueriesType($queries);
 
         if ($this->validate) {
             $validator = new DocumentsValidator(
-                $attributes,
-                $indexes,
+                $context,
                 $this->adapter->getIdAttributeType(),
-                $this->maxQueryValues,
-                $this->adapter->getMinDateTime(),
-                $this->adapter->getMaxDateTime(),
+                maxValuesCount: $this->maxQueryValues,
+                minAllowedDate: $this->adapter->getMinDateTime(),
+                maxAllowedDate: $this->adapter->getMaxDateTime()
             );
+
             if (!$validator->isValid($queries)) {
                 throw new QueryException($validator->getDescription());
             }
         }
 
-        $authorization = new Authorization($forPermission);
-        $documentSecurity = $collection->getAttribute('documentSecurity', false);
-        $skipAuth = $authorization->isValid($collection->getPermissionsByType($forPermission));
-
-        if (!$skipAuth && !$documentSecurity && $collection->getId() !== self::METADATA) {
-            throw new AuthorizationException($authorization->getDescription());
-        }
-
         $relationships = \array_filter(
             $collection->getAttribute('attributes', []),
             fn (Document $attribute) => $attribute->getAttribute('type') === self::VAR_RELATIONSHIP
         );
 
+        $queries = self::convertQueries($context, $queries);
+
         $grouped = Query::groupByType($queries);
         $filters = $grouped['filters'];
         $selects = $grouped['selections'];
@@ -6235,23 +6298,29 @@ public function find(string $collection, array $queries = [], string $forPermiss
         $cursor = $grouped['cursor'];
         $cursorDirection = $grouped['cursorDirection'] ?? Database::CURSOR_AFTER;
 
+        $filters = Query::getFilterQueries($queries);
+        $selects = Query::getSelectQueries($queries);
+        $limit = Query::getLimitQuery($queries, 25);
+        $offset = Query::getOffsetQuery($queries, 0);
+        $orders = Query::getOrderQueries($queries);
+
         $uniqueOrderBy = false;
-        foreach ($orderAttributes as $order) {
-            if ($order === '$id' || $order === '$sequence') {
+        foreach ($orders as $order) {
+            if ($order->getAttribute() === '$id' || $order->getAttribute() === '$sequence') {
                 $uniqueOrderBy = true;
             }
         }
 
         if ($uniqueOrderBy === false) {
-            $orderAttributes[] = '$sequence';
+            $orders[] = Query::orderAsc(); // In joins we should not add a default order, we should validate when using a cursor we should have a unique order
         }
 
         if (!empty($cursor)) {
-            foreach ($orderAttributes as $order) {
-                if ($cursor->getAttribute($order) === null) {
+            foreach ($orders as $order) {
+                if ($cursor->getAttribute($order->getAttribute()) === null) {
                     throw new OrderException(
-                        message: "Order attribute '{$order}' is empty",
-                        attribute: $order
+                        message: "Order attribute '{$order->getAttribute()}' is empty",
+                        attribute: $order->getAttribute()
                     );
                 }
             }
@@ -6263,36 +6332,31 @@ public function find(string $collection, array $queries = [], string $forPermiss
 
         $cursor = empty($cursor) ? [] : $this->encode($collection, $cursor)->getArrayCopy();
 
-        /**  @var array<Query> $queries */
-        $queries = \array_merge(
-            $selects,
-            $this->convertQueries($collection, $filters)
-        );
+        //$selects = $this->validateSelections($collection, $selects);
 
-        $selections = $this->validateSelections($collection, $selects);
-        $nestedSelections = $this->processRelationshipQueries($relationships, $queries);
+        [$selects, $nestedSelections] = $this->processRelationshipQueries($relationships, $selects);
 
-        $getResults = fn () => $this->adapter->find(
-            $collection,
+        $results = $this->adapter->find(
+            $context,
             $queries,
             $limit ?? 25,
             $offset ?? 0,
-            $orderAttributes,
-            $orderTypes,
             $cursor,
             $cursorDirection,
-            $forPermission
+            $forPermission,
+            selects: $selects,
+            filters: $filters,
+            joins: $joins,
+            orderQueries: $orders
         );
 
-        $results = $skipAuth ? Authorization::skip($getResults) : $getResults();
-
         foreach ($results as $index => $node) {
             if ($this->resolveRelationships && !empty($relationships) && (empty($selects) || !empty($nestedSelections))) {
                 $node = $this->silent(fn () => $this->populateDocumentRelationships($collection, $node, $nestedSelections));
             }
 
-            $node = $this->casting($collection, $node);
-            $node = $this->decode($collection, $node, $selections);
+            $node = $this->casting($context, $node, $selects);
+            $node = $this->decode($context, $node, $selects);
 
             if (!$node->isEmpty()) {
                 $node->setAttribute('$collection', $collection->getId());
@@ -6404,19 +6468,28 @@ public function findOne(string $collection, array $queries = []): Document
     public function count(string $collection, array $queries = [], ?int $max = null): int
     {
         $collection = $this->silent(fn () => $this->getCollection($collection));
-        $attributes = $collection->getAttribute('attributes', []);
-        $indexes = $collection->getAttribute('indexes', []);
+
+        $this->checkQueriesType($queries);
+
+        if ($collection->isEmpty()) {
+            throw new NotFoundException('Collection not found');
+        }
+
+        $context = new QueryContext();
+        $context->add($collection);
+
+        $queries = Query::getFilterQueries($queries);
+        $queries = self::convertQueries($context, $queries);
 
         $this->checkQueriesType($queries);
 
         if ($this->validate) {
             $validator = new DocumentsValidator(
-                $attributes,
-                $indexes,
+                $context,
                 $this->adapter->getIdAttributeType(),
-                $this->maxQueryValues,
-                $this->adapter->getMinDateTime(),
-                $this->adapter->getMaxDateTime(),
+                maxValuesCount: $this->maxQueryValues,
+                minAllowedDate: $this->adapter->getMinDateTime(),
+                maxAllowedDate: $this->adapter->getMaxDateTime()
             );
             if (!$validator->isValid($queries)) {
                 throw new QueryException($validator->getDescription());
@@ -6428,9 +6501,6 @@ public function count(string $collection, array $queries = [], ?int $max = null)
             $skipAuth = true;
         }
 
-        $queries = Query::groupByType($queries)['filters'];
-        $queries = $this->convertQueries($collection, $queries);
-
         $getCount = fn () => $this->adapter->count($collection, $queries, $max);
         $count = $skipAuth ?? false ? Authorization::skip($getCount) : $getCount();
 
@@ -6455,28 +6525,39 @@ public function count(string $collection, array $queries = [], ?int $max = null)
     public function sum(string $collection, string $attribute, array $queries = [], ?int $max = null): float|int
     {
         $collection = $this->silent(fn () => $this->getCollection($collection));
-        $attributes = $collection->getAttribute('attributes', []);
-        $indexes = $collection->getAttribute('indexes', []);
+
+        if ($collection->isEmpty()) {
+            throw new NotFoundException('Collection not found');
+        }
+
+        $context = new QueryContext();
+        $context->add($collection);
+
+        $authorization = new Authorization(self::PERMISSION_READ);
+        if ($authorization->isValid($collection->getRead())) {
+            $skipAuth = true;
+        }
+
+        $queries = Query::getFilterQueries($queries);
+        $queries = self::convertQueries($context, $queries);
 
         $this->checkQueriesType($queries);
 
         if ($this->validate) {
             $validator = new DocumentsValidator(
-                $attributes,
-                $indexes,
+                $context,
                 $this->adapter->getIdAttributeType(),
-                $this->maxQueryValues,
-                $this->adapter->getMinDateTime(),
-                $this->adapter->getMaxDateTime(),
+                maxValuesCount: $this->maxQueryValues,
+                minAllowedDate: $this->adapter->getMinDateTime(),
+                maxAllowedDate: $this->adapter->getMaxDateTime()
             );
             if (!$validator->isValid($queries)) {
                 throw new QueryException($validator->getDescription());
             }
         }
 
-        $queries = $this->convertQueries($collection, $queries);
-
-        $sum = $this->adapter->sum($collection, $attribute, $queries, $max);
+        $getCount = fn () => $this->adapter->sum($collection, $attribute, $queries, $max);
+        $sum = $skipAuth ?? false ? Authorization::skip($getCount) : $getCount();
 
         $this->trigger(self::EVENT_DOCUMENT_SUM, $sum);
 
@@ -6578,11 +6659,11 @@ public function encode(Document $collection, Document $document): Document
      *
      * @param Document $collection
      * @param Document $document
-     * @param array<string> $selections
+     * @param array<Query> $selects
      * @return Document
      * @throws DatabaseException
      */
-    public function decode(Document $collection, Document $document, array $selections = []): Document
+    public function decodeOriginal(Document $collection, Document $document, array $selects = []): Document
     {
         $attributes = \array_filter(
             $collection->getAttribute('attributes', []),
@@ -6658,38 +6739,178 @@ public function decode(Document $collection, Document $document, array $selectio
     }
 
     /**
-     * Casting
+     * Decode Document
      *
-     * @param Document $collection
+     * @param QueryContext $context
      * @param Document $document
+     * @param array<Query> $selects
+     * @return Document
+     * @throws DatabaseException
+     */
+    public function decode(QueryContext $context, Document $document, array $selects = []): Document
+    {
+        $internals = [];
+        $schema = [];
+
+        foreach (Database::INTERNAL_ATTRIBUTES as $attribute) {
+            $internals[$attribute['$id']] = $attribute;
+        }
+
+        foreach ($context->getCollections() as $collection) {
+            foreach ($collection->getAttribute('attributes', []) as $attribute) {
+                $key = $attribute->getAttribute('key', $attribute->getAttribute('$id'));
+                $key = $this->adapter->filter($key);
+                $schema[$collection->getId()][$key] = $attribute->getArrayCopy();
+            }
+        }
+
+        $new = new Document();
+
+        foreach ($document as $key => $value) {
+            $alias = Query::DEFAULT_ALIAS;
+            $attributeKey = '';
+
+            foreach ($selects as $select) {
+                if ($select->getAs() === $key){
+                    $attributeKey = $key;
+                    $key = $select->getAttribute();
+                    $alias = $select->getAlias();
+
+                    break;
+                }
+
+                if ($select->getAttribute() == $key || $this->adapter->filter($select->getAttribute()) == $key) {
+                    $alias = $select->getAlias();
+
+                    break;
+                }
+            }
+
+            $collection = $context->getCollectionByAlias($alias);
+            if ($collection->isEmpty()) {
+                throw new \Exception('Invalid query: Unknown Alias context');
+            }
+
+            $attribute = $internals[$key] ?? null;
+
+            if (is_null($attribute)) {
+                $attribute = $schema[$collection->getId()][$this->adapter->filter($key)] ?? null;
+            }
+
+            if (is_null($attribute)) {
+                continue;
+            }
+
+            if (empty($attributeKey)){
+                $attributeKey = $attribute['$id'];
+            }
+
+            $type = $attribute['type'] ?? '';
+            $array = $attribute['array'] ?? false;
+            $filters = $attribute['filters'] ?? [];
+
+            $value = ($array) ? $value : [$value];
+            $value = (is_null($value)) ? [] : $value;
+
+            foreach ($value as $index => $node) {
+                if (is_string($node) && in_array($type, Database::SPATIAL_TYPES)) {
+                    $node = $this->decodeSpatialData($node);
+                }
+
+                foreach (array_reverse($filters) as $filter) {
+                    $node = $this->decodeAttribute($filter, $node, $document, $key);
+                }
+
+                $value[$index] = $node;
+            }
+
+            $value = ($array) ? $value : $value[0];
+
+            $new->setAttribute($attributeKey, $value);
+        }
+
+        return $new;
+    }
+
+    /**
+     * Casting
      *
+     * @param QueryContext $context
+     * @param Document $document
+     * @param array<Query> $selects
      * @return Document
+     * @throws Exception
      */
-    public function casting(Document $collection, Document $document): Document
+    public function casting(QueryContext $context, Document $document, array $selects = []): Document
     {
         if ($this->adapter->getSupportForCasting()) {
             return $document;
         }
 
-        $attributes = $collection->getAttribute('attributes', []);
+        $internals = [];
+        $schema = [];
 
-        foreach ($this->getInternalAttributes() as $attribute) {
-            $attributes[] = $attribute;
+        foreach (Database::INTERNAL_ATTRIBUTES as $attribute) {
+            $internals[$attribute['$id']] = $attribute;
         }
 
-        foreach ($attributes as $attribute) {
-            $key = $attribute['$id'] ?? '';
-            $type = $attribute['type'] ?? '';
-            $array = $attribute['array'] ?? false;
-            $value = $document->getAttribute($key, null);
-            if (is_null($value)) {
+        foreach ($context->getCollections() as $collection) {
+            foreach ($collection->getAttribute('attributes', []) as $attribute) {
+                $key = $attribute->getAttribute('key', $attribute->getAttribute('$id'));
+                $key = $this->adapter->filter($key);
+                $schema[$collection->getId()][$key] = $attribute->getArrayCopy();
+            }
+        }
+
+        $new = new Document();
+
+        foreach ($document as $key => $value) {
+            $alias = Query::DEFAULT_ALIAS;
+            $attributeKey = '';
+
+            foreach ($selects as $select) {
+                if ($select->getAs() === $key){
+                    $attributeKey = $key;
+                    $key = $select->getAttribute();
+                    $alias = $select->getAlias();
+
+                    break;
+                }
+
+                if ($select->getAttribute() == $key || $this->adapter->filter($select->getAttribute()) == $key) {
+                    $alias = $select->getAlias();
+
+                    break;
+                }
+            }
+
+            $collection = $context->getCollectionByAlias($alias);
+            if ($collection->isEmpty()) {
+                throw new \Exception('Invalid query: Unknown Alias context');
+            }
+
+            $attribute = $internals[$key] ?? null;
+
+            if (is_null($attribute)) {
+                $attribute = $schema[$collection->getId()][$this->adapter->filter($key)] ?? null;
+            }
+
+            if (is_null($attribute)) {
                 continue;
             }
 
-            if ($key === '$permissions') {
+            if (empty($attributeKey)){
+                $attributeKey = $attribute['$id'];
+            }
+
+            if (is_null($value)) {
+                $new->setAttribute($attributeKey, null);
                 continue;
             }
 
+            $type = $attribute['type'] ?? '';
+            $array = $attribute['array'] ?? false;
+
             if ($array) {
                 $value = !is_string($value)
                     ? $value
@@ -6709,23 +6930,25 @@ public function casting(Document $collection, Document $document): Document
                     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;
                 }
 
                 $value[$index] = $node;
             }
 
-            $document->setAttribute($key, ($array) ? $value : $value[0]);
+            $value = ($array) ? $value : $value[0];
+
+            $new->setAttribute($attributeKey, $value);
         }
 
-        return $document;
+        return $new;
     }
 
     /**
@@ -6801,7 +7024,7 @@ protected function decodeAttribute(string $filter, mixed $value, Document $docum
      *
      * @param Document $collection
      * @param array<Query> $queries
-     * @return array<string>
+     * @return array<Query>
      * @throws QueryException
      */
     private function validateSelections(Document $collection, array $queries): array
@@ -6810,18 +7033,18 @@ private function validateSelections(Document $collection, array $queries): array
             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;
+                if (\str_contains($query->getValue(), '.')) {
+                    $relationshipSelections[] = $query;
+                    continue;
                 }
+
+                $selections[] = $query;
             }
         }
 
@@ -6881,21 +7104,19 @@ public function getLimitForIndexes(): int
     }
 
     /**
-     * @param Document $collection
      * @param array<Query> $queries
      * @return array<Query>
-     * @throws QueryException
-     * @throws \Utopia\Database\Exception
+     * @throws Exception
      */
-    public static function convertQueries(Document $collection, array $queries): array
+    public static function convertQueries(QueryContext $context, array $queries): array
     {
         foreach ($queries as $index => $query) {
-            if ($query->isNested()) {
-                $values = self::convertQueries($collection, $query->getValues());
+            if ($query->isNested() || $query->isJoin()) {
+                $values = self::convertQueries($context, $query->getValues());
                 $query->setValues($values);
             }
 
-            $query = self::convertQuery($collection, $query);
+            $query = self::convertQuery($context, $query);
 
             $queries[$index] = $query;
         }
@@ -6904,14 +7125,20 @@ public static function convertQueries(Document $collection, array $queries): arr
     }
 
     /**
-     * @param Document $collection
-     * @param Query $query
-     * @return Query
-     * @throws QueryException
-     * @throws \Utopia\Database\Exception
+     * @throws Exception
      */
-    public static function convertQuery(Document $collection, Query $query): Query
+    public static function convertQuery(QueryContext $context, Query $query): Query
     {
+        if ($query->getMethod() == Query::TYPE_SELECT) {
+            return $query;
+        }
+
+        $collection = clone $context->getCollectionByAlias($query->getAlias());
+
+        if ($collection->isEmpty()) {
+            throw new \Exception('Unknown Alias context');
+        }
+
         /**
          * @var array<Document> $attributes
          */
@@ -6934,6 +7161,7 @@ public static function convertQuery(Document $collection, Query $query): Query
 
             if ($attribute->getAttribute('type') == Database::VAR_DATETIME) {
                 $values = $query->getValues();
+                var_dump($values);
                 foreach ($values as $valueIndex => $value) {
                     try {
                         $values[$valueIndex] = DateTime::setTimezone($value);
@@ -6979,7 +7207,7 @@ public function getSchemaAttributes(string $collection): array
     /**
      * @param string $collectionId
      * @param string|null $documentId
-     * @param array<string> $selects
+     * @param array<Query> $selects
      * @return array{0: ?string, 1: ?string, 2: ?string}
      */
     public function getCacheKeys(string $collectionId, ?string $documentId = null, array $selects = []): array
@@ -7007,7 +7235,7 @@ public function getCacheKeys(string $collectionId, ?string $documentId = null, a
             $documentKey = $documentHashKey = "{$collectionKey}:{$documentId}";
 
             if (!empty($selects)) {
-                $documentHashKey = $documentKey . ':' . \md5(\implode($selects));
+                $documentHashKey = $documentKey . ':' . \md5(\serialize($selects));
             }
         }
 
@@ -7041,85 +7269,80 @@ private function checkQueriesType(array $queries): void
      *
      * @param array<Document> $relationships
      * @param array<Query> $queries
-     * @return array<string, array<Query>> $selects
+     * @return array{0: array<Query>, 1: array<string, array<Query>>}
      */
     private function processRelationshipQueries(
         array $relationships,
-        array $queries,
+        array $queries
     ): array {
         $nestedSelections = [];
 
-        foreach ($queries as $query) {
+        foreach ($queries as $index => $query) {
             if ($query->getMethod() !== Query::TYPE_SELECT) {
                 continue;
             }
 
-            $values = $query->getValues();
-            foreach ($values as $valueIndex => $value) {
-                if (!\str_contains($value, '.')) {
-                    continue;
-                }
+            $value = $query->getAttribute();
 
-                $nesting = \explode('.', $value);
-                $selectedKey = \array_shift($nesting); // Remove and return first item
+            if (!\str_contains($value, '.')) {
+                continue;
+            }
 
-                $relationship = \array_values(\array_filter(
-                    $relationships,
-                    fn (Document $relationship) => $relationship->getAttribute('key') === $selectedKey,
-                ))[0] ?? null;
+            $nesting = \explode('.', $value);
+            $selectedKey = \array_shift($nesting);
 
-                if (!$relationship) {
-                    continue;
-                }
+            $relationship = \array_values(\array_filter(
+                $relationships,
+                fn (Document $relationship) => $relationship->getAttribute('key') === $selectedKey
+            ))[0] ?? null;
 
-                // Shift the top level off the dot-path to pass the selection down the chain
-                // 'foo.bar.baz' becomes 'bar.baz'
+            if (!$relationship) {
+                continue;
+            }
 
-                $nestingPath = \implode('.', $nesting);
-                // If nestingPath is empty, it means we want all fields (*) for this relationship
-                if (empty($nestingPath)) {
-                    $nestedSelections[$selectedKey][] = Query::select(['*']);
-                } else {
-                    $nestedSelections[$selectedKey][] = Query::select([$nestingPath]);
-                }
+            $nestingPath = \implode('.', $nesting);
 
-                $type = $relationship->getAttribute('options')['relationType'];
-                $side = $relationship->getAttribute('options')['side'];
+            if (empty($nestingPath)) {
+                $nestedSelections[$selectedKey][] = Query::select('*');
+            } else {
+                $nestedSelections[$selectedKey][] = Query::select($nestingPath);
+            }
 
-                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;
-                }
+            $type = $relationship->getAttribute('options')['relationType'];
+            $side = $relationship->getAttribute('options')['side'];
+
+            switch ($type) {
+                case Database::RELATION_MANY_TO_MANY:
+                    $value = null;
+                    break;
+                case Database::RELATION_ONE_TO_MANY:
+                    $value = ($side === Database::RELATION_SIDE_PARENT) ? null : $selectedKey;
+                    break;
+                case Database::RELATION_MANY_TO_ONE:
+                    $value = ($side === Database::RELATION_SIDE_PARENT) ? $selectedKey : null;
+                    break;
+                case Database::RELATION_ONE_TO_ONE:
+                    $value = $selectedKey;
+                    break;
             }
 
-            $finalValues = \array_values($values);
-            if ($query->getMethod() === Query::TYPE_SELECT) {
-                if (empty($finalValues)) {
-                    $finalValues = ['*'];
-                }
+            if ($value === null) {
+                unset($queries[$index]); // remove query if value is unset
+            } else {
+                $query->setAttribute($value);
             }
-            $query->setValues($finalValues);
         }
 
-        return $nestedSelections;
+        $queries = array_values($queries);
+
+        /**
+         * In order to populateDocumentRelationships we need $id
+         */
+        if (\count($queries) > 0) {
+            [$queries, $idAdded] = Query::addSelect($queries, Query::select('$id',  system: true));
+        }
+
+        return [$queries, $nestedSelections];
     }
 
     /**
diff --git a/src/Database/Query.php b/src/Database/Query.php
index 24f40eece..d1230de41 100644
--- a/src/Database/Query.php
+++ b/src/Database/Query.php
@@ -41,8 +41,12 @@ class Query
     public const TYPE_TOUCHES = 'touches';
     public const TYPE_NOT_TOUCHES = 'notTouches';
 
+    public const TYPE_RELATION_EQUAL = 'relationEqual';
+
     public const TYPE_SELECT = 'select';
 
+    //public const TYPE_SELECTION = 'selection';
+
     // Order methods
     public const TYPE_ORDER_DESC = 'orderDesc';
     public const TYPE_ORDER_ASC = 'orderAsc';
@@ -57,6 +61,13 @@ class Query
     public const TYPE_AND = 'and';
     public const TYPE_OR = 'or';
 
+    // Join methods
+    public const TYPE_INNER_JOIN = 'innerJoin';
+
+    public const TYPE_LEFT_JOIN = 'leftJoin';
+
+    public const TYPE_RIGHT_JOIN = 'rightJoin';
+
     public const DEFAULT_ALIAS = 'main';
 
     public const TYPES = [
@@ -106,8 +117,39 @@ class Query
         self::TYPE_OR,
     ];
 
+    protected const FILTER_TYPES = [
+        self::TYPE_EQUAL,
+        self::TYPE_NOT_EQUAL,
+        self::TYPE_LESSER,
+        self::TYPE_LESSER_EQUAL,
+        self::TYPE_GREATER,
+        self::TYPE_GREATER_EQUAL,
+        self::TYPE_GREATER_EQUAL,
+        self::TYPE_CONTAINS,
+        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_AND,
+        self::TYPE_OR,
+        self::TYPE_RELATION_EQUAL,
+    ];
+
     protected string $method = '';
+    protected string $collection = '';
+    protected string $alias = '';
     protected string $attribute = '';
+    protected string $aliasRight = '';
+    protected string $attributeRight = '';
+    protected string $as = '';
+    protected bool $system = false;
     protected bool $onArray = false;
 
     /**
@@ -122,15 +164,41 @@ class Query
      * @param string $attribute
      * @param array<mixed> $values
      */
-    public function __construct(string $method, string $attribute = '', array $values = [])
-    {
+    protected function __construct(
+        string $method,
+        string $attribute = '',
+        array $values = [],
+        string $alias = '',
+        string $attributeRight = '',
+        string $aliasRight = '',
+        string $collection = '',
+        string $as = '',
+        bool $system = false,
+    ) {
         if ($attribute === '' && \in_array($method, [Query::TYPE_ORDER_ASC, Query::TYPE_ORDER_DESC])) {
             $attribute = '$sequence';
         }
 
+        /**
+         * We can not make the fallback in the Query::static() calls , because parse method skips it
+         */
+        if (empty($alias)) {
+            $alias = Query::DEFAULT_ALIAS;
+        }
+
+        if (empty($aliasRight)) {
+            $aliasRight = Query::DEFAULT_ALIAS;
+        }
+
         $this->method = $method;
+        $this->alias = $alias;
         $this->attribute = $attribute;
         $this->values = $values;
+        $this->aliasRight = $aliasRight;
+        $this->attributeRight = $attributeRight;
+        $this->collection = $collection;
+        $this->as = $as;
+        $this->system = $system;
     }
 
     public function __clone(): void
@@ -175,6 +243,31 @@ public function getValue(mixed $default = null): mixed
         return $this->values[0] ?? $default;
     }
 
+    public function getAlias(): string
+    {
+        return $this->alias;
+    }
+
+    public function getRightAlias(): string
+    {
+        return $this->aliasRight;
+    }
+
+    public function getAttributeRight(): string
+    {
+        return $this->attributeRight;
+    }
+
+    public function getAs(): string
+    {
+        return $this->as;
+    }
+
+    public function getCollection(): string
+    {
+        return $this->collection;
+    }
+
     /**
      * Sets method
      *
@@ -201,6 +294,41 @@ public function setAttribute(string $attribute): self
         return $this;
     }
 
+    /**
+     * Sets right attribute
+     */
+    public function setAttributeRight(string $attribute): self
+    {
+        $this->attributeRight = $attribute;
+
+        return $this;
+    }
+
+    public function getCursorDirection(): string
+    {
+        if ($this->method === self::TYPE_CURSOR_AFTER) {
+            return Database::CURSOR_AFTER;
+        }
+
+        if ($this->method === self::TYPE_CURSOR_BEFORE) {
+            return Database::CURSOR_BEFORE;
+        }
+
+        throw new \Exception('Invalid method: Get cursor direction on "'.$this->method.'" Query');
+    }
+
+    public function getOrderDirection(): string
+    {
+        if ($this->method === self::TYPE_ORDER_ASC) {
+            return Database::ORDER_ASC;
+        }
+
+        if ($this->method === self::TYPE_ORDER_DESC) {
+            return Database::ORDER_DESC;
+        }
+
+        throw new \Exception('Invalid method: Get order direction on "'.$this->method.'" Query');
+    }
     /**
      * Sets values
      *
@@ -280,11 +408,12 @@ public static function isMethod(string $value): bool
 
     /**
      * Check if method is a spatial-only query method
+     * @param $method
      * @return bool
      */
-    public function isSpatialQuery(): bool
+    public static function isSpatialQuery($method): bool
     {
-        return match ($this->method) {
+        return match ($method) {
             self::TYPE_CROSSES,
             self::TYPE_NOT_CROSSES,
             self::TYPE_DISTANCE_EQUAL,
@@ -428,9 +557,9 @@ public function toString(): string
      * @param array<string|int|float|bool|array<mixed,mixed>> $values
      * @return Query
      */
-    public static function equal(string $attribute, array $values): self
+    public static function equal(string $attribute, array $values, string $alias = ''): self
     {
-        return new self(self::TYPE_EQUAL, $attribute, $values);
+        return new self(self::TYPE_EQUAL, $attribute, $values, alias: $alias);
     }
 
     /**
@@ -440,9 +569,9 @@ public static function equal(string $attribute, array $values): self
      * @param string|int|float|bool|array<mixed,mixed> $value
      * @return Query
      */
-    public static function notEqual(string $attribute, string|int|float|bool|array $value): self
+    public static function notEqual(string $attribute, string|int|float|bool|array $value, string $alias = ''): self
     {
-        return new self(self::TYPE_NOT_EQUAL, $attribute, is_array($value) ? $value : [$value]);
+        return new self(self::TYPE_NOT_EQUAL, $attribute, is_array($value) ? $value : [$value], alias: $alias);
     }
 
     /**
@@ -452,9 +581,9 @@ public static function notEqual(string $attribute, string|int|float|bool|array $
      * @param string|int|float|bool $value
      * @return Query
      */
-    public static function lessThan(string $attribute, string|int|float|bool $value): self
+    public static function lessThan(string $attribute, string|int|float|bool $value, string $alias = ''): self
     {
-        return new self(self::TYPE_LESSER, $attribute, [$value]);
+        return new self(self::TYPE_LESSER, $attribute, [$value], alias: $alias);
     }
 
     /**
@@ -464,9 +593,9 @@ public static function lessThan(string $attribute, string|int|float|bool $value)
      * @param string|int|float|bool $value
      * @return Query
      */
-    public static function lessThanEqual(string $attribute, string|int|float|bool $value): self
+    public static function lessThanEqual(string $attribute, string|int|float|bool $value, string $alias = ''): self
     {
-        return new self(self::TYPE_LESSER_EQUAL, $attribute, [$value]);
+        return new self(self::TYPE_LESSER_EQUAL, $attribute, [$value], alias: $alias);
     }
 
     /**
@@ -476,9 +605,9 @@ public static function lessThanEqual(string $attribute, string|int|float|bool $v
      * @param string|int|float|bool $value
      * @return Query
      */
-    public static function greaterThan(string $attribute, string|int|float|bool $value): self
+    public static function greaterThan(string $attribute, string|int|float|bool $value, string $alias = ''): self
     {
-        return new self(self::TYPE_GREATER, $attribute, [$value]);
+        return new self(self::TYPE_GREATER, $attribute, [$value], alias: $alias);
     }
 
     /**
@@ -488,9 +617,9 @@ public static function greaterThan(string $attribute, string|int|float|bool $val
      * @param string|int|float|bool $value
      * @return Query
      */
-    public static function greaterThanEqual(string $attribute, string|int|float|bool $value): self
+    public static function greaterThanEqual(string $attribute, string|int|float|bool $value, string $alias = ''): self
     {
-        return new self(self::TYPE_GREATER_EQUAL, $attribute, [$value]);
+        return new self(self::TYPE_GREATER_EQUAL, $attribute, [$value], alias: $alias);
     }
 
     /**
@@ -525,9 +654,9 @@ public static function notContains(string $attribute, array $values): self
      * @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
+    public static function between(string $attribute, string|int|float|bool $start, string|int|float|bool $end, string $alias = ''): self
     {
-        return new self(self::TYPE_BETWEEN, $attribute, [$start, $end]);
+        return new self(self::TYPE_BETWEEN, $attribute, [$start, $end], alias: $alias);
     }
 
     /**
@@ -573,20 +702,25 @@ public static function notSearch(string $attribute, string $value): self
      * @param array<string> $attributes
      * @return Query
      */
-    public static function select(array $attributes): self
+    public static function select_old(array $attributes): self
     {
         return new self(self::TYPE_SELECT, values: $attributes);
     }
 
+    public static function select(string $attribute, string $alias = '', string $as = '', string $function = '', bool $system = false): self
+    {
+        return new self(self::TYPE_SELECT, $attribute, [], alias: $alias, as: $as, system: $system);
+    }
+
     /**
      * Helper method to create Query with orderDesc method
      *
      * @param string $attribute
      * @return Query
      */
-    public static function orderDesc(string $attribute = ''): self
+    public static function orderDesc(string $attribute = '', string $alias = ''): self
     {
-        return new self(self::TYPE_ORDER_DESC, $attribute);
+        return new self(self::TYPE_ORDER_DESC, $attribute, alias: $alias);
     }
 
     /**
@@ -595,9 +729,9 @@ public static function orderDesc(string $attribute = ''): self
      * @param string $attribute
      * @return Query
      */
-    public static function orderAsc(string $attribute = ''): self
+    public static function orderAsc(string $attribute = '', string $alias = ''): self
     {
-        return new self(self::TYPE_ORDER_ASC, $attribute);
+        return new self(self::TYPE_ORDER_ASC, $attribute, alias: $alias);
     }
 
     /**
@@ -748,6 +882,55 @@ public static function and(array $queries): self
         return new self(self::TYPE_AND, '', $queries);
     }
 
+    /**
+     * @param string $collection
+     * @param string $alias
+     * @param array<Query> $queries
+     * @return self
+     */
+    public static function join(string $collection, string $alias, array $queries = []): self
+    {
+        return new self(self::TYPE_INNER_JOIN, values: $queries, alias: $alias, collection: $collection);
+    }
+
+    /**
+     * @param string $collection
+     * @param string $alias
+     * @param array<Query> $queries
+     * @return self
+     */
+    public static function innerJoin(string $collection, string $alias, array $queries = []): self
+    {
+        return new self(self::TYPE_INNER_JOIN, values: $queries, alias: $alias, collection: $collection);
+    }
+
+    /**
+     * @param string $collection
+     * @param string $alias
+     * @param array<Query> $queries
+     * @return self
+     */
+    public static function leftJoin(string $collection, string $alias, array $queries = []): self
+    {
+        return new self(self::TYPE_LEFT_JOIN, values: $queries, alias: $alias, collection: $collection);
+    }
+
+    /**
+     * @param string $collection
+     * @param string $alias
+     * @param array<Query> $queries
+     * @return self
+     */
+    public static function rightJoin(string $collection, string $alias, array $queries = []): self
+    {
+        return new self(self::TYPE_RIGHT_JOIN, values: $queries, alias: $alias, collection: $collection);
+    }
+
+    public static function relationEqual(string $leftAlias, string $leftColumn, string $rightAlias, string $rightColumn): self
+    {
+        return new self(self::TYPE_RELATION_EQUAL, $leftColumn, [], alias: $leftAlias, attributeRight: $rightColumn, aliasRight: $rightAlias);
+    }
+
     /**
      * Filters $queries for $types
      *
@@ -755,7 +938,7 @@ public static function and(array $queries): self
      * @param array<string> $types
      * @return array<Query>
      */
-    public static function getByType(array $queries, array $types): array
+    protected static function getByType(array $queries, array $types): array
     {
         $filtered = [];
 
@@ -768,6 +951,144 @@ public static function getByType(array $queries, array $types): array
         return $filtered;
     }
 
+    /**
+     * @param  array<Query>  $queries
+     * @return array<Query>
+     */
+    public static function getSelectQueries(array $queries): array
+    {
+        return self::getByType($queries, [
+            Query::TYPE_SELECT,
+        ]);
+    }
+
+    /**
+     * @param  array<Query>  $queries
+     * @return array<Query>
+     */
+    public static function getJoinQueries(array $queries): array
+    {
+        return self::getByType($queries, [
+            Query::TYPE_INNER_JOIN,
+            Query::TYPE_LEFT_JOIN,
+            Query::TYPE_RIGHT_JOIN,
+        ]);
+    }
+
+    /**
+     * @param  array<Query>  $queries
+     * @return array<Query>
+     */
+    public static function getLimitQueries(array $queries): array
+    {
+        foreach ($queries as $query) {
+            if ($query->getMethod() === Query::TYPE_LIMIT){
+                return [clone $query];
+            }
+        }
+
+        return [];
+    }
+
+    /**
+     * @param array<Query> $queries
+     * @param int|null $default
+     * @return int|null
+     */
+    public static function getLimitQuery(array $queries, ?int $default = null): ?int
+    {
+        $queries = self::getLimitQueries($queries);
+
+        if (empty($queries)) {
+            return $default;
+        }
+
+        return $queries[0]->getValue();
+    }
+
+    /**
+     * @param  array<Query> $queries
+     * @return array<Query>
+     */
+    public static function getOffsetQueries(array $queries): array
+    {
+        foreach ($queries as $query) {
+            if ($query->getMethod() === Query::TYPE_OFFSET){
+                return [clone $query];
+            }
+        }
+
+        return [];
+    }
+
+    /**
+     * @param array<Query> $queries
+     * @param int|null $default
+     * @return int|null
+     */
+    public static function getOffsetQuery(array $queries, ?int $default = null): ?int
+    {
+        $queries = self::getOffsetQueries($queries);
+
+        if (empty($queries)) {
+            return $default;
+        }
+
+        return $queries[0]->getValue();
+    }
+
+    /**
+     * @param  array<Query>  $queries
+     * @return array<Query>
+     */
+    public static function getOrderQueries(array $queries): array
+    {
+        return self::getByType($queries, [
+            Query::TYPE_ORDER_ASC,
+            Query::TYPE_ORDER_DESC,
+        ]);
+    }
+
+    /**
+     * @param array<Query> $queries
+     * @return Query|null
+     */
+    public static function getCursorQueries(array $queries): ?Query
+    {
+        $queries = self::getByType($queries, [
+            Query::TYPE_CURSOR_AFTER,
+            Query::TYPE_CURSOR_BEFORE,
+        ]);
+
+        if (empty($queries)) {
+            return null;
+        }
+
+        return $queries[0];
+    }
+
+    /**
+     * @param Query $query
+     * @return Document
+     */
+    public function getCursorDocument(?Query $query): Document
+    {
+        if (! is_null($query) && in_array($query->getMethod(), [Query::TYPE_CURSOR_AFTER, Query::TYPE_CURSOR_BEFORE])) {
+            return $query->getValue();
+        }
+
+        return new Document();
+    }
+
+    /**
+     * @param  array<Query>  $queries
+     * @return array<Query>
+     */
+    public static function getFilterQueries(array $queries): array
+    {
+        return self::getByType($queries, self::FILTER_TYPES);
+    }
+
     /**
      * Iterates through queries are groups them by type
      *
@@ -786,6 +1107,7 @@ public static function getByType(array $queries, array $types): array
     public static function groupByType(array $queries): array
     {
         $filters = [];
+        $joins = [];
         $selections = [];
         $limit = null;
         $offset = null;
@@ -879,8 +1201,24 @@ public function isNested(): bool
     }
 
     /**
-     * @return bool
+     * Is this query able to contain other queries
      */
+    public function isJoin(): bool
+    {
+        $types = [self::TYPE_INNER_JOIN, self::TYPE_LEFT_JOIN, self::TYPE_RIGHT_JOIN];
+
+        if (in_array($this->getMethod(), $types)) {
+            return true;
+        }
+
+        return false;
+    }
+
+    public static function isFilter(string $method): bool
+    {
+        return in_array($method, self::FILTER_TYPES);
+    }
+
     public function onArray(): bool
     {
         return $this->onArray;
@@ -1044,4 +1382,45 @@ public static function notTouches(string $attribute, array $values): self
     {
         return new self(self::TYPE_NOT_TOUCHES, $attribute, $values);
     }
+
+    /**
+     * @param array<Query> $queries
+     * @param Query $query
+     * @return array
+     * @throws \Exception
+     */
+    public static function addSelect(array $queries, Query $query): array
+    {
+        $merge = true;
+        $found = false;
+
+        foreach ($queries as $q) {
+            if ($q->getMethod() === self::TYPE_SELECT){
+                $found = true;
+
+                if ($q->getAlias() === $query->getAlias()){
+                    if ($q->getAttribute() === '*'){
+                        $merge = false;
+                    }
+
+                    if ($q->getAttribute() === $query->getAttribute()){
+                        if ($q->getAs() === $query->getAs()){
+                            $merge = false;
+                        }
+                    }
+                }
+            }
+        }
+
+        if ($found && $merge){
+            $queries = [
+                ...$queries,
+                $query
+            ];
+
+            return [$queries, true];
+        }
+
+        return [$queries, false];
+    }
 }
diff --git a/src/Database/QueryContext.php b/src/Database/QueryContext.php
new file mode 100644
index 000000000..167684b07
--- /dev/null
+++ b/src/Database/QueryContext.php
@@ -0,0 +1,89 @@
+<?php
+
+namespace Utopia\Database;
+
+use Utopia\Database\Exception\Query as QueryException;
+use Utopia\Database\Validator\Authorization;
+
+class QueryContext
+{
+    /**
+     * @var array<Document>
+     */
+    protected array $collections = [];
+
+    /**
+     * @var array<string>
+     */
+    protected array $aliases = [];
+
+    /**
+     * @var array<mixed>
+     */
+    protected array $skipAuthCollections = [];
+
+    public function __construct()
+    {
+    }
+
+    /**
+     * @return array<Document>
+     */
+    public function getCollections(): array
+    {
+        return $this->collections;
+    }
+
+    public function getCollectionByAlias(string $alias): Document
+    {
+        /**
+         * $alias can be an empty string
+         */
+        $collectionId = $this->aliases[$alias] ?? null;
+
+        if (is_null($collectionId)) {
+            return new Document();
+        }
+
+        foreach ($this->collections as $collection) {
+            if ($collection->getId() === $collectionId) {
+                return $collection;
+            }
+        }
+
+        return new Document();
+    }
+
+    /**
+     * @throws QueryException
+     */
+    public function add(Document $collection, string $alias = Query::DEFAULT_ALIAS): void
+    {
+        if (! empty($this->aliases[$alias])) {
+            throw new QueryException('Ambiguous alias for collection "'.$collection->getId().'".');
+        }
+
+        $this->collections[] = $collection;
+        $this->aliases[$alias] = $collection->getId();
+    }
+
+    public function addSkipAuth(string $collection, string $permission, bool $skipAuth): void
+    {
+        $this->skipAuthCollections[$collection][$permission] = $skipAuth;
+    }
+
+    public function skipAuth(string $collection, string $permission): bool
+    {
+        if (!Authorization::$status) { // for Authorization::disable();
+            return true;
+        }
+
+        if (empty($this->skipAuthCollections[$collection][$permission])) {
+            return false;
+        }
+
+        return true;
+    }
+
+
+}
diff --git a/src/Database/Validator/Alias.php b/src/Database/Validator/Alias.php
new file mode 100644
index 000000000..7e3ecf8f2
--- /dev/null
+++ b/src/Database/Validator/Alias.php
@@ -0,0 +1,70 @@
+<?php
+
+namespace Utopia\Database\Validator;
+
+use Utopia\Validator;
+
+class Alias extends Validator
+{
+    protected string $message = 'Alias must contain at most 64 chars. Valid chars are a-z, A-Z, 0-9, and underscore.';
+
+    /**
+     * Validator Description.
+     * @return string
+     */
+    public function getDescription(): string
+    {
+        return $this->message;
+    }
+
+    /**
+     * Is valid.
+     * Returns true if valid or false if not.
+     * @param mixed $value
+     * @return bool
+     */
+    public function isValid($value): bool
+    {
+        if (! \is_string($value)) {
+            return false;
+        }
+
+        if (empty($value)) {
+            return true;
+        }
+
+        if (! preg_match('/^[a-zA-Z0-9_]+$/', $value)) {
+            return false;
+        }
+
+        if (\mb_strlen($value) >= 64) {
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * Is array
+     *
+     * Function will return true if object is array.
+     *
+     * @return bool
+     */
+    public function isArray(): bool
+    {
+        return false;
+    }
+
+    /**
+     * Get Type
+     *
+     * Returns validator type.
+     *
+     * @return string
+     */
+    public function getType(): string
+    {
+        return self::TYPE_STRING;
+    }
+}
diff --git a/src/Database/Validator/AsQuery.php b/src/Database/Validator/AsQuery.php
new file mode 100644
index 000000000..84181dca3
--- /dev/null
+++ b/src/Database/Validator/AsQuery.php
@@ -0,0 +1,85 @@
+<?php
+
+namespace Utopia\Database\Validator;
+
+use Utopia\Validator;
+
+class AsQuery extends Validator
+{
+    protected string $message = '"as" must contain at most 64 chars. Valid chars are a-z, A-Z, 0-9, and underscore.';
+
+    /**
+     * @param string $attribute
+     */
+    public function __construct(
+        private readonly string $attribute,
+    )
+    {
+
+    }
+
+    /**
+     * Validator Description.
+     * @return string
+     */
+    public function getDescription(): string
+    {
+        return $this->message;
+    }
+
+    /**
+     * Is valid.
+     * Returns true if valid or false if not.
+     * @param mixed $value
+     * @return bool
+     */
+    public function isValid($value): bool
+    {
+        if (! \is_string($value)) {
+            return false;
+        }
+
+        if (empty($value)) {
+            return true;
+        }
+
+        if (! preg_match('/^[a-zA-Z0-9_]+$/', $value)) {
+            return false;
+        }
+
+        if (\mb_strlen($value) >= 64) {
+            return false;
+        }
+
+        if($this->attribute === '*'){
+            $this->message = 'Invalid "as" on attribute "*"';
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * Is array
+     *
+     * Function will return true if object is array.
+     *
+     * @return bool
+     */
+    public function isArray(): bool
+    {
+        return false;
+    }
+
+    /**
+     * Get Type
+     *
+     * Returns validator type.
+     *
+     * @return string
+     */
+    public function getType(): string
+    {
+        return self::TYPE_STRING;
+    }
+}
diff --git a/src/Database/Validator/IndexedQueries.php b/src/Database/Validator/IndexedQueries.php
index 8e324b215..da822be07 100644
--- a/src/Database/Validator/IndexedQueries.php
+++ b/src/Database/Validator/IndexedQueries.php
@@ -1,118 +1,115 @@
 <?php
 
-namespace Utopia\Database\Validator;
-
-use Exception;
-use Utopia\Database\Database;
-use Utopia\Database\Document;
-use Utopia\Database\Query;
-use Utopia\Database\Validator\Query\Base;
-
-class IndexedQueries extends Queries
-{
-    /**
-     * @var array<Document>
-     */
-    protected array $attributes = [];
-
-    /**
-     * @var array<Document>
-     */
-    protected array $indexes = [];
-
-    /**
-     * Expression constructor
-     *
-     * This Queries Validator filters indexes for only available indexes
-     *
-     * @param array<Document> $attributes
-     * @param array<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']
-        ]);
-
-        $this->indexes[] = new Document([
-            'type' => Database::INDEX_KEY,
-            'attributes' => ['$updatedAt']
-        ]);
-
-        foreach ($indexes as $index) {
-            $this->indexes[] = $index;
-        }
-
-        parent::__construct($validators);
-    }
-
-    /**
-     * @param mixed $value
-     * @return bool
-     * @throws Exception
-     */
-    public function isValid($value): bool
-    {
-        if (!parent::isValid($value)) {
-            return false;
-        }
-        $queries = [];
-        foreach ($value as $query) {
-            if (! $query instanceof Query) {
-                try {
-                    $query = Query::parse($query);
-                } catch (\Throwable $e) {
-                    $this->message = 'Invalid query: '.$e->getMessage();
-
-                    return false;
-                }
-            }
-
-            if ($query->isNested()) {
-                if (! self::isValid($query->getValues())) {
-                    return false;
-                }
-            }
-
-            $queries[] = $query;
-        }
-
-        $grouped = Query::groupByType($queries);
-        $filters = $grouped['filters'];
-
-        foreach ($filters as $filter) {
-            if (
-                $filter->getMethod() === Query::TYPE_SEARCH ||
-                $filter->getMethod() === Query::TYPE_NOT_SEARCH
-            ) {
-                $matched = false;
-
-                foreach ($this->indexes as $index) {
-                    if (
-                        $index->getAttribute('type') === Database::INDEX_FULLTEXT
-                        && $index->getAttribute('attributes') === [$filter->getAttribute()]
-                    ) {
-                        $matched = true;
-                    }
-                }
-
-                if (!$matched) {
-                    $this->message = "Searching by attribute \"{$filter->getAttribute()}\" requires a fulltext index.";
-                    return false;
-                }
-            }
-        }
-
-        return true;
-    }
-}
+//
+//namespace Utopia\Database\Validator;
+//
+//use Exception;
+//use Utopia\Database\Database;
+//use Utopia\Database\Document;
+//use Utopia\Database\Query;
+//use Utopia\Database\Validator\Query\Base;
+//
+//class IndexedQueries extends Queries
+//{
+//    /**
+//     * @var array<Document>
+//     */
+//    protected array $attributes = [];
+//
+//    /**
+//     * @var array<Document>
+//     */
+//    protected array $indexes = [];
+//
+//    /**
+//     * Expression constructor
+//     *
+//     * This Queries Validator filters indexes for only available indexes
+//     *
+//     * @param array<Document> $attributes
+//     * @param array<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']
+//        ]);
+//
+//        $this->indexes[] = new Document([
+//            'type' => Database::INDEX_KEY,
+//            'attributes' => ['$updatedAt']
+//        ]);
+//
+//        foreach ($indexes as $index) {
+//            $this->indexes[] = $index;
+//        }
+//
+//        parent::__construct($validators);
+//    }
+//
+//    /**
+//     * @param mixed $value
+//     * @return bool
+//     * @throws Exception
+//     */
+//    public function isValid($value): bool
+//    {
+//        if (!parent::isValid($value)) {
+//            return false;
+//        }
+//        $queries = [];
+//        foreach ($value as $query) {
+//            if (! $query instanceof Query) {
+//                try {
+//                    $query = Query::parse($query);
+//                } catch (\Throwable $e) {
+//                    $this->message = 'Invalid query: '.$e->getMessage();
+//
+//                    return false;
+//                }
+//            }
+//
+//            if ($query->isNested()) {
+//                if (! self::isValid($query->getValues())) {
+//                    return false;
+//                }
+//            }
+//
+//            $queries[] = $query;
+//        }
+//
+//        $filters = Query::getFilterQueries($queries);
+//
+//        foreach ($filters as $filter) {
+//            if ($filter->getMethod() === Query::TYPE_SEARCH) {
+//                $matched = false;
+//
+//                foreach ($this->indexes as $index) {
+//                    if (
+//                        $index->getAttribute('type') === Database::INDEX_FULLTEXT
+//                        && $index->getAttribute('attributes') === [$filter->getAttribute()]
+//                    ) {
+//                        $matched = true;
+//                    }
+//                }
+//
+//                if (! $matched) {
+//                    $this->message = "Searching by attribute \"{$filter->getAttribute()}\" requires a fulltext index.";
+//                    return false;
+//                }
+//            }
+//        }
+//
+//        return true;
+//    }
+//}
diff --git a/src/Database/Validator/Queries.php b/src/Database/Validator/Queries.php
index a2363101b..c13ccc034 100644
--- a/src/Database/Validator/Queries.php
+++ b/src/Database/Validator/Queries.php
@@ -1,169 +1,159 @@
 <?php
-
-namespace Utopia\Database\Validator;
-
-use Utopia\Database\Query;
-use Utopia\Database\Validator\Query\Base;
-use Utopia\Validator;
-
-class Queries extends Validator
-{
-    /**
-     * @var string
-     */
-    protected string $message = 'Invalid queries';
-
-    /**
-     * @var array<Base>
-     */
-    protected array $validators;
-
-    /**
-     * @var int
-     */
-    protected int $length;
-
-    /**
-     * Queries constructor
-     *
-     * @param array<Base> $validators
-     */
-    public function __construct(array $validators = [], int $length = 0)
-    {
-        $this->validators = $validators;
-        $this->length = $length;
-    }
-
-    /**
-     * Get Description.
-     *
-     * Returns validator description
-     *
-     * @return string
-     */
-    public function getDescription(): string
-    {
-        return $this->message;
-    }
-
-    /**
-     * @param array<Query|string> $value
-     * @return bool
-     */
-    public function isValid($value): bool
-    {
-        if (!is_array($value)) {
-            $this->message = 'Queries must be an array';
-            return false;
-        }
-
-        if ($this->length && \count($value) > $this->length) {
-            return false;
-        }
-
-        foreach ($value as $query) {
-            if (!$query instanceof Query) {
-                try {
-                    $query = Query::parse($query);
-                } catch (\Throwable $e) {
-                    $this->message = 'Invalid query: ' . $e->getMessage();
-                    return false;
-                }
-            }
-
-            if ($query->isNested()) {
-                if (!self::isValid($query->getValues())) {
-                    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 => 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_NOT_CONTAINS,
-                Query::TYPE_AND,
-                Query::TYPE_OR,
-                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 => Base::METHOD_TYPE_FILTER,
-                default => '',
-            };
-
-            $methodIsValid = false;
-            foreach ($this->validators as $validator) {
-                if ($validator->getMethodType() !== $methodType) {
-                    continue;
-                }
-                if (!$validator->isValid($query)) {
-                    $this->message = 'Invalid query: ' . $validator->getDescription();
-                    return false;
-                }
-
-                $methodIsValid = true;
-            }
-
-            if (!$methodIsValid) {
-                $this->message = 'Invalid query method: ' . $method;
-                return false;
-            }
-        }
-
-        return true;
-    }
-
-    /**
-     * Is array
-     *
-     * Function will return true if object is array.
-     *
-     * @return bool
-     */
-    public function isArray(): bool
-    {
-        return true;
-    }
-
-    /**
-     * Get Type
-     *
-     * Returns validator type.
-     *
-     * @return string
-     */
-    public function getType(): string
-    {
-        return self::TYPE_OBJECT;
-    }
-}
+//
+//namespace Utopia\Database\Validator;
+//
+//use Utopia\Database\Query;
+//use Utopia\Database\Validator\Query\Base;
+//use Utopia\Validator;
+//
+//class Queries extends Validator
+//{
+//    /**
+//     * @var string
+//     */
+//    protected string $message = 'Invalid queries';
+//
+//    /**
+//     * @var array<Base>
+//     */
+//    protected array $validators;
+//
+//    /**
+//     * @var int
+//     */
+//    protected int $length;
+//
+//    /**
+//     * Queries constructor
+//     *
+//     * @param array<Base> $validators
+//     */
+//    public function __construct(array $validators = [], int $length = 0)
+//    {
+//        $this->validators = $validators;
+//        $this->length = $length;
+//    }
+//
+//    /**
+//     * Get Description.
+//     *
+//     * Returns validator description
+//     *
+//     * @return string
+//     */
+//    public function getDescription(): string
+//    {
+//        return $this->message;
+//    }
+//
+//    /**
+//     * @param array<Query|string> $value
+//     * @return bool
+//     */
+//    public function isValid($value): bool
+//    {
+//        if (!is_array($value)) {
+//            $this->message = 'Queries must be an array';
+//            return false;
+//        }
+//
+//        if ($this->length && \count($value) > $this->length) {
+//            return false;
+//        }
+//
+//        foreach ($value as $query) {
+//            if (!$query instanceof Query) {
+//                try {
+//                    $query = Query::parse($query);
+//                } catch (\Throwable $e) {
+//                    $this->message = 'Invalid query: ' . $e->getMessage();
+//                    return false;
+//                }
+//            }
+//
+//            if ($query->isNested()) {
+//                if (!self::isValid($query->getValues())) {
+//                    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 => 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_IS_NULL,
+//                Query::TYPE_IS_NOT_NULL,
+//                Query::TYPE_BETWEEN,
+//                Query::TYPE_STARTS_WITH,
+//                Query::TYPE_CONTAINS,
+//                Query::TYPE_ENDS_WITH,
+//                Query::TYPE_AND,
+//                Query::TYPE_OR => Base::METHOD_TYPE_FILTER,
+//                Query::TYPE_JOIN => Base::METHOD_TYPE_JOIN,
+//                default => '',
+//            };
+//            var_dump('____________________________________');
+//            $methodIsValid = false;
+//            foreach ($this->validators as $validator) {
+//                var_dump('---');
+//                var_dump($method);
+//                var_dump($methodType);
+//                var_dump($validator->getMethodType());
+//                var_dump('---');
+//                if ($validator->getMethodType() !== $methodType) {
+//                    continue;
+//                }
+//
+//                if (!$validator->isValid($query)) {
+//                    $this->message = 'Invalid query: ' . $validator->getDescription();
+//                    return false;
+//                }
+//
+//                $methodIsValid = true;
+//            }
+//
+//            if (!$methodIsValid) {
+//                $this->message = 'Invalid query method: ' . $method;
+//                return false;
+//            }
+//        }
+//
+//        return true;
+//    }
+//
+//    /**
+//     * Is array
+//     *
+//     * Function will return true if object is array.
+//     *
+//     * @return bool
+//     */
+//    public function isArray(): bool
+//    {
+//        return true;
+//    }
+//
+//    /**
+//     * Get Type
+//     *
+//     * Returns validator type.
+//     *
+//     * @return string
+//     */
+//    public function getType(): string
+//    {
+//        return self::TYPE_OBJECT;
+//    }
+//}
diff --git a/src/Database/Validator/Queries/Document.php b/src/Database/Validator/Queries/Document.php
index 41c9f3f9b..8edf478d3 100644
--- a/src/Database/Validator/Queries/Document.php
+++ b/src/Database/Validator/Queries/Document.php
@@ -1,43 +1,44 @@
 <?php
 
-namespace Utopia\Database\Validator\Queries;
-
-use Exception;
-use Utopia\Database\Database;
-use Utopia\Database\Validator\Queries;
-use Utopia\Database\Validator\Query\Select;
-
-class Document extends Queries
-{
-    /**
-     * @param array<mixed> $attributes
-     * @throws Exception
-     */
-    public function __construct(array $attributes)
-    {
-        $attributes[] = new \Utopia\Database\Document([
-            '$id' => '$id',
-            'key' => '$id',
-            'type' => Database::VAR_STRING,
-            'array' => false,
-        ]);
-        $attributes[] = new \Utopia\Database\Document([
-            '$id' => '$createdAt',
-            'key' => '$createdAt',
-            'type' => Database::VAR_DATETIME,
-            'array' => false,
-        ]);
-        $attributes[] = new \Utopia\Database\Document([
-            '$id' => '$updatedAt',
-            'key' => '$updatedAt',
-            'type' => Database::VAR_DATETIME,
-            'array' => false,
-        ]);
-
-        $validators = [
-            new Select($attributes),
-        ];
-
-        parent::__construct($validators);
-    }
-}
+//
+//namespace Utopia\Database\Validator\Queries;
+//
+//use Exception;
+//use Utopia\Database\Database;
+//use Utopia\Database\Validator\Queries;
+//use Utopia\Database\Validator\Query\Select;
+//
+//class Document extends Queries
+//{
+//    /**
+//     * @param array<mixed> $attributes
+//     * @throws Exception
+//     */
+//    public function __construct(array $attributes)
+//    {
+//        $attributes[] = new \Utopia\Database\Document([
+//            '$id' => '$id',
+//            'key' => '$id',
+//            'type' => Database::VAR_STRING,
+//            'array' => false,
+//        ]);
+//        $attributes[] = new \Utopia\Database\Document([
+//            '$id' => '$createdAt',
+//            'key' => '$createdAt',
+//            'type' => Database::VAR_DATETIME,
+//            'array' => false,
+//        ]);
+//        $attributes[] = new \Utopia\Database\Document([
+//            '$id' => '$updatedAt',
+//            'key' => '$updatedAt',
+//            'type' => Database::VAR_DATETIME,
+//            'array' => false,
+//        ]);
+//
+//        $validators = [
+//            new Select($attributes),
+//        ];
+//
+//        parent::__construct($validators);
+//    }
+//}
diff --git a/src/Database/Validator/Queries/Documents.php b/src/Database/Validator/Queries/Documents.php
index 289ccbe5b..9f5b372b7 100644
--- a/src/Database/Validator/Queries/Documents.php
+++ b/src/Database/Validator/Queries/Documents.php
@@ -1,76 +1,74 @@
 <?php
 
-namespace Utopia\Database\Validator\Queries;
-
-use Exception;
-use Utopia\Database\Database;
-use Utopia\Database\Document;
-use Utopia\Database\Validator\IndexedQueries;
-use Utopia\Database\Validator\Query\Cursor;
-use Utopia\Database\Validator\Query\Filter;
-use Utopia\Database\Validator\Query\Limit;
-use Utopia\Database\Validator\Query\Offset;
-use Utopia\Database\Validator\Query\Order;
-use Utopia\Database\Validator\Query\Select;
-
-class Documents extends IndexedQueries
-{
-    /**
-     * Expression constructor
-     *
-     * @param array<mixed> $attributes
-     * @param array<mixed> $indexes
-     * @param string $idAttributeType
-     * @throws Exception
-     */
-    public function __construct(
-        array $attributes,
-        array $indexes,
-        string $idAttributeType,
-        int $maxValuesCount = 100,
-        \DateTime $minAllowedDate = new \DateTime('0000-01-01'),
-        \DateTime $maxAllowedDate = new \DateTime('9999-12-31'),
-    ) {
-        $attributes[] = new Document([
-            '$id' => '$id',
-            'key' => '$id',
-            'type' => Database::VAR_STRING,
-            'array' => false,
-        ]);
-        $attributes[] = new Document([
-            '$id' => '$sequence',
-            'key' => '$sequence',
-            'type' => Database::VAR_ID,
-            'array' => false,
-        ]);
-        $attributes[] = new Document([
-            '$id' => '$createdAt',
-            'key' => '$createdAt',
-            'type' => Database::VAR_DATETIME,
-            'array' => false,
-        ]);
-        $attributes[] = new Document([
-            '$id' => '$updatedAt',
-            'key' => '$updatedAt',
-            'type' => Database::VAR_DATETIME,
-            'array' => false,
-        ]);
-
-        $validators = [
-            new Limit(),
-            new Offset(),
-            new Cursor(),
-            new Filter(
-                $attributes,
-                $idAttributeType,
-                $maxValuesCount,
-                $minAllowedDate,
-                $maxAllowedDate,
-            ),
-            new Order($attributes),
-            new Select($attributes),
-        ];
-
-        parent::__construct($attributes, $indexes, $validators);
-    }
-}
+//
+//namespace Utopia\Database\Validator\Queries;
+//
+//use Exception;
+//use Utopia\Database\Database;
+//use Utopia\Database\Document;
+//use Utopia\Database\Validator\IndexedQueries;
+//use Utopia\Database\Validator\Query\Cursor;
+//use Utopia\Database\Validator\Query\Filter;
+//use Utopia\Database\Validator\Query\Limit;
+//use Utopia\Database\Validator\Query\Offset;
+//use Utopia\Database\Validator\Query\Order;
+//use Utopia\Database\Validator\Query\Select;
+//
+//class Documents extends IndexedQueries
+//{
+//    /**
+//     * Expression constructor
+//     *
+//     * @param array<mixed> $attributes
+//     * @param array<mixed> $indexes
+//     * @throws Exception
+//     */
+//    public function __construct(
+//        array $attributes,
+//        array $indexes,
+//        int $maxValuesCount = 100,
+//        \DateTime $minAllowedDate = new \DateTime('0000-01-01'),
+//        \DateTime $maxAllowedDate = new \DateTime('9999-12-31'),
+//    ) {
+//        $attributes[] = new Document([
+//            '$id' => '$id',
+//            'key' => '$id',
+//            'type' => Database::VAR_STRING,
+//            'array' => false,
+//        ]);
+//        $attributes[] = new Document([
+//            '$id' => '$sequence',
+//            'key' => '$sequence',
+//            'type' => Database::VAR_STRING,
+//            'array' => false,
+//        ]);
+//        $attributes[] = new Document([
+//            '$id' => '$createdAt',
+//            'key' => '$createdAt',
+//            'type' => Database::VAR_DATETIME,
+//            'array' => false,
+//        ]);
+//        $attributes[] = new Document([
+//            '$id' => '$updatedAt',
+//            'key' => '$updatedAt',
+//            'type' => Database::VAR_DATETIME,
+//            'array' => false,
+//        ]);
+//
+//        $validators = [
+//            new Limit(),
+//            new Offset(),
+//            new Cursor(),
+//            new Filter(
+//                $attributes,
+//                $maxValuesCount,
+//                $minAllowedDate,
+//                $maxAllowedDate,
+//            ),
+//            new Order($attributes),
+//            new Select($attributes),
+//        ];
+//
+//        parent::__construct($attributes, $indexes, $validators);
+//    }
+//}
diff --git a/src/Database/Validator/Queries/V2.php b/src/Database/Validator/Queries/V2.php
new file mode 100644
index 000000000..df8974bb9
--- /dev/null
+++ b/src/Database/Validator/Queries/V2.php
@@ -0,0 +1,696 @@
+<?php
+
+namespace Utopia\Database\Validator\Queries;
+
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Exception;
+use Utopia\Database\Query;
+use Utopia\Database\QueryContext;
+use Utopia\Database\Validator\Alias as AliasValidator;
+use Utopia\Database\Validator\AsQuery as AsValidator;
+use Utopia\Database\Validator\Datetime as DatetimeValidator;
+use Utopia\Database\Validator\Query\Cursor;
+use Utopia\Database\Validator\Query\Limit;
+use Utopia\Database\Validator\Query\Offset;
+use Utopia\Database\Validator\Sequence;
+use Utopia\Validator;
+use Utopia\Validator\Boolean;
+use Utopia\Validator\FloatValidator;
+use Utopia\Validator\Integer;
+use Utopia\Validator\Text;
+
+class V2 extends Validator
+{
+    protected string $message = 'Invalid query';
+
+    /**
+     * @var array<mixed>
+     */
+    protected array $schema = [];
+
+    protected int $maxQueriesCount;
+
+    private int $maxValuesCount;
+
+    protected int $maxLimit;
+
+    protected int $maxOffset;
+
+    protected QueryContext $context;
+
+    protected \DateTime $minAllowedDate;
+
+    protected \DateTime $maxAllowedDate;
+    protected string $idAttributeType;
+
+    /**
+     * @throws Exception
+     */
+    public function __construct(
+        QueryContext $context,
+        string $idAttributeType,
+        int $maxValuesCount = 100,
+        int $maxQueriesCount = 0,
+        \DateTime $minAllowedDate = new \DateTime('0000-01-01'),
+        \DateTime $maxAllowedDate = new \DateTime('9999-12-31'),
+        int $maxLimit = PHP_INT_MAX,
+        int $maxOffset = PHP_INT_MAX
+    ) {
+        $this->context = $context;
+        $this->idAttributeType = $idAttributeType;
+        $this->maxQueriesCount = $maxQueriesCount;
+        $this->maxValuesCount = $maxValuesCount;
+        $this->maxLimit = $maxLimit;
+        $this->maxOffset = $maxOffset;
+        $this->minAllowedDate = $minAllowedDate;
+        $this->maxAllowedDate = $maxAllowedDate;
+
+        //        $validators = [
+        //            new Limit(),
+        //            new Offset(),
+        //            new Cursor(),
+        //            new Filter($collections),
+        //            new Order($collections),
+        //            new Select($collections),
+        //            new Join($collections),
+        //        ];
+
+        /**
+         * Since $context includes Documents , clone if original data is changes.
+         */
+        foreach ($context->getCollections() as $collection) {
+            $collection = clone $collection;
+
+            $attributes = $collection->getAttribute('attributes', []);
+
+            $attributes[] = new Document([
+                '$id' => '$id',
+                'key' => '$id',
+                'type' => Database::VAR_STRING,
+                'array' => false,
+            ]);
+
+            $attributes[] = new Document([
+                '$id' => '$sequence',
+                'key' => '$sequence',
+                'type' => Database::VAR_STRING,
+                'array' => false,
+            ]);
+
+            $attributes[] = new Document([
+                '$id' => '$createdAt',
+                'key' => '$createdAt',
+                'type' => Database::VAR_DATETIME,
+                'array' => false,
+            ]);
+
+            $attributes[] = new Document([
+                '$id' => '$updatedAt',
+                'key' => '$updatedAt',
+                'type' => Database::VAR_DATETIME,
+                'array' => false,
+            ]);
+
+            foreach ($attributes as $attribute) {
+                $key = $attribute->getAttribute('key', $attribute->getAttribute('$id'));
+                $this->schema[$collection->getId()][$key] = $attribute->getArrayCopy();
+            }
+        }
+    }
+
+    /**
+     * Get Description.
+     *
+     * Returns validator description
+     */
+    public function getDescription(): string
+    {
+        return $this->message;
+    }
+
+    /**
+     * Is array
+     *
+     * Function will return true if object is array.
+     */
+    public function isArray(): bool
+    {
+        return true;
+    }
+
+    /**
+     * Get Type
+     *
+     * Returns validator type.
+     */
+    public function getType(): string
+    {
+        return self::TYPE_OBJECT;
+    }
+
+    /**
+     * @param  array<mixed>  $values
+     */
+    protected function isEmpty(array $values): bool
+    {
+        if (count($values) === 0) {
+            return true;
+        }
+
+        if (is_array($values[0]) && count($values[0]) === 0) {
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * @throws \Exception
+     */
+    protected function validateAttributeExist(string $attributeId, string $alias): void
+    {
+        /**
+         * This is for making query::select('$permissions')) pass
+         */
+        if($attributeId === '$permissions' || $attributeId === '$collection'){
+            return;
+        }
+
+        var_dump('=== validateAttributeExist');
+
+        //        if (\str_contains($attributeId, '.')) {
+        //            // Check for special symbol `.`
+        //            if (isset($this->schema[$attributeId])) {
+        //                return true;
+        //            }
+        //
+        //            // For relationships, just validate the top level.
+        //            // will validate each nested level during the recursive calls.
+        //            $attributeId = \explode('.', $attributeId)[0];
+        //
+        //            if (isset($this->schema[$attributeId])) {
+        //                $this->message = 'Cannot query nested attribute on: '.$attributeId;
+        //
+        //                return false;
+        //            }
+        //        }
+
+        $collection = $this->context->getCollectionByAlias($alias);
+        if ($collection->isEmpty()) {
+            throw new \Exception('Invalid query: Unknown Alias context');
+        }
+
+        if (! isset($this->schema[$collection->getId()][$attributeId])) {
+            throw new \Exception('Invalid query: Attribute not found in schema: '.$attributeId);
+        }
+    }
+
+    /**
+     * @throws \Exception
+     */
+    protected function validateAlias(Query $query): void
+    {
+        $validator = new AliasValidator();
+
+        if (! $validator->isValid($query->getAlias())) {
+            throw new \Exception('Query '.\ucfirst($query->getMethod()).': '.$validator->getDescription());
+        }
+
+        if (! $validator->isValid($query->getRightAlias())) {
+            throw new \Exception('Query '.\ucfirst($query->getMethod()).': '.$validator->getDescription());
+        }
+    }
+
+    /**
+     * @throws \Exception
+     */
+    protected function validateFilterQueries(Query $query): void
+    {
+        $filters = Query::getFilterQueries($query->getValues());
+
+        if (count($query->getValues()) !== count($filters)) {
+            throw new \Exception('Invalid query: '.\ucfirst($query->getMethod()).' queries can only contain filter queries');
+        }
+    }
+
+    /**
+     * @param string $attributeId
+     * @param string $alias
+     * @param array<mixed> $values
+     * @param string $method
+     * @return void
+     * @throws \Exception
+     */
+    protected function validateValues(string $attributeId, string $alias, array $values, string $method): void
+    {
+        if (count($values) > $this->maxValuesCount) {
+            throw new \Exception('Invalid query: Query on attribute has greater than '.$this->maxValuesCount.' values: '.$attributeId);
+        }
+
+        $collection = $this->context->getCollectionByAlias($alias);
+        if ($collection->isEmpty()) {
+            throw new \Exception('Unknown Alias context');
+        }
+
+        $attribute = $this->schema[$collection->getId()][$attributeId];
+
+        $array = $attribute['array'] ?? false;
+        $filters = $attribute['filters'] ?? [];
+
+        // If the query method is spatial-only, the attribute must be a spatial type
+
+        if (Query::isSpatialQuery($method) && !in_array($attribute['type'], Database::SPATIAL_TYPES, true)) {
+            throw new \Exception('Invalid query: Spatial query "' . $method . '" cannot be applied on non-spatial attribute: ' . $attribute);
+        }
+
+        foreach ($values as $value) {
+            $validator = null;
+
+            switch ($attribute['type']) {
+                case Database::VAR_ID:
+                    $validator = new Sequence($this->idAttributeType, $attribute === '$sequence');
+                    break;
+
+                case Database::VAR_STRING:
+                    $validator = new Text(0, 0);
+                    break;
+
+                case Database::VAR_INTEGER:
+                    $validator = new Integer();
+                    break;
+
+                case Database::VAR_FLOAT:
+                    $validator = new FloatValidator();
+                    break;
+
+                case Database::VAR_BOOLEAN:
+                    $validator = new Boolean();
+                    break;
+
+                case Database::VAR_DATETIME:
+                    $validator = new DatetimeValidator(
+                        min: $this->minAllowedDate,
+                        max: $this->maxAllowedDate
+                    );
+                    break;
+
+                case Database::VAR_RELATIONSHIP:
+                    $validator = new Text(255, 0); // The query is always on uid
+                    break;
+
+                case Database::VAR_POINT:
+                case Database::VAR_LINESTRING:
+                case Database::VAR_POLYGON:
+                    if (!is_array($value)) {
+                        throw new \Exception('Spatial data must be an array');
+                    }
+                    continue 2;
+
+                default:
+                    throw new \Exception('Unknown Data type');
+            }
+
+            if (! $validator->isValid($value)) {
+                throw new \Exception('Invalid query: Query value is invalid for attribute "'.$attributeId.'"');
+            }
+        }
+
+        if ($attribute['type'] === 'relationship') {
+            /**
+             * We can not disable relationship query since we have logic that use it,
+             * so instead we validate against the relation type
+             */
+            $options = $attribute['options'];
+
+            if ($options['relationType'] === Database::RELATION_ONE_TO_ONE && $options['twoWay'] === false && $options['side'] === Database::RELATION_SIDE_CHILD) {
+                throw new \Exception('Cannot query on virtual relationship attribute');
+            }
+
+            if ($options['relationType'] === Database::RELATION_ONE_TO_MANY && $options['side'] === Database::RELATION_SIDE_PARENT) {
+                throw new \Exception('Cannot query on virtual relationship attribute');
+            }
+
+            if ($options['relationType'] === Database::RELATION_MANY_TO_ONE && $options['side'] === Database::RELATION_SIDE_CHILD) {
+                throw new \Exception('Cannot query on virtual relationship attribute');
+            }
+
+            if ($options['relationType'] === Database::RELATION_MANY_TO_MANY) {
+                throw new \Exception('Cannot query on virtual relationship attribute');
+            }
+        }
+
+        if (
+            ! $array &&
+            in_array($method, [Query::TYPE_CONTAINS, Query::TYPE_NOT_CONTAINS]) &&
+            $attribute['type'] !== Database::VAR_STRING &&
+            !in_array($attribute['type'], Database::SPATIAL_TYPES)
+        ) {
+            throw new \Exception('Invalid query: Cannot query '.$method.' on attribute "'.$attributeId.'" because it is not an array or string.');
+        }
+
+        if (
+            $array &&
+            !in_array($method, [Query::TYPE_CONTAINS, Query::TYPE_NOT_CONTAINS, Query::TYPE_IS_NULL, Query::TYPE_IS_NOT_NULL])
+        ) {
+            throw new \Exception('Invalid query: Cannot query '.$method.' on attribute "'.$attributeId.'" because it is an array.');
+        }
+
+        if (Query::isFilter($method) && \in_array('encrypt', $filters)) {
+            throw new \Exception('Cannot query encrypted attribute: ' . $attributeId);
+        }
+    }
+
+    /**
+     * @throws \Exception
+     */
+    public function validateSelect(Query $query): void
+    {
+        $asValidator = new AsValidator($query->getAttribute());
+        if (! $asValidator->isValid($query->getAs())) {
+            throw new \Exception('Query '.\ucfirst($query->getMethod()).': '.$asValidator->getDescription());
+        }
+
+        $internalKeys = \array_map(
+            fn ($attr) => $attr['$id'],
+            Database::INTERNAL_ATTRIBUTES
+        );
+
+        $attribute = $query->getAttribute();
+
+        if ($attribute === '*') {
+            return;
+        }
+
+        if (\in_array($attribute, $internalKeys)) {
+            //return;
+        }
+
+        $alias = $query->getAlias();
+
+        if (\str_contains($attribute, '.')) {
+            if (\str_contains($attribute, '.')) {
+                try {
+                    /**
+                     * Special symbols with `dots`
+                     */
+                    $this->validateAttributeExist($attribute, $alias);
+                } catch (\Throwable $e) {
+                    /**
+                     * For relationships, just validate the top level.
+                     * Will validate each nested level during the recursive calls.
+                     */
+                    $attribute = \explode('.', $attribute)[0];
+                    $this->validateAttributeExist($attribute, $alias);
+                }
+            }
+        }
+
+        $this->validateAttributeExist($attribute, $alias);
+    }
+
+    /**
+     * @throws \Exception
+     */
+    public function validateFulltextIndex(Query $query): void
+    {
+        if ($query->getMethod() !== Query::TYPE_SEARCH) {
+            return;
+        }
+
+        $collection = $this->context->getCollectionByAlias($query->getAlias());
+        if ($collection->isEmpty()) {
+            throw new \Exception('Unknown Alias context');
+        }
+
+        $indexes = $collection->getAttribute('indexes', []);
+
+        foreach ($indexes as $index) {
+            if (
+                $index->getAttribute('type') === Database::INDEX_FULLTEXT &&
+                $index->getAttribute('attributes') === [$query->getAttribute()]
+            ) {
+                return;
+            }
+        }
+
+        throw new \Exception('Searching by attribute "'.$query->getAttribute().'" requires a fulltext index.');
+    }
+
+    /**
+     * @param array<Query> $queries
+     * @param string $alias
+     * @return bool
+     */
+    public function isRelationExist(array $queries, string $alias): bool
+    {
+        /**
+         * Do we want to validate only top lever or nesting as well?
+         */
+        foreach ($queries as $query) {
+            if ($query->isNested()) {
+                if ($this->isRelationExist($query->getValues(), $alias)) {
+                    return true;
+                }
+            }
+
+            if ($query->getMethod() === Query::TYPE_RELATION_EQUAL) {
+                if ($query->getAlias() === $alias || $query->getRightAlias() === $alias) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * @param  array<Query|string>  $value
+     *
+     * @throws \Utopia\Database\Exception\Query|\Throwable
+     */
+    public function isValid($value, string $scope = ''): bool
+    {
+        try {
+            if (! is_array($value)) {
+                throw new \Exception('Queries must be an array');
+            }
+
+            if (! array_is_list($value)) {
+                throw new \Exception('Queries must be an array list');
+            }
+
+            if ($this->maxQueriesCount > 0 && \count($value) > $this->maxQueriesCount) {
+                throw new \Exception('Queries count is greater than '.$this->maxQueriesCount);
+            }
+
+            $ambiguous = [];
+            $duplications = [];
+            foreach ($value as $query) {
+                if (!$query instanceof Query) {
+                    try {
+                        $query = Query::parse($query);
+                    } catch (\Throwable $e) {
+                        throw new \Exception('Invalid query: ' . $e->getMessage());
+                    }
+                }
+
+                //var_dump($query->getMethod(), $query->getCollection(), $query->getAlias());
+
+                $this->validateAlias($query);
+
+                if ($query->isNested()) {
+                    if (! self::isValid($query->getValues(), $scope)) {
+                        throw new \Exception($this->message);
+                    }
+                }
+
+                $method = $query->getMethod();
+
+                switch ($method) {
+                    case Query::TYPE_EQUAL:
+                    case Query::TYPE_CONTAINS:
+                    case Query::TYPE_NOT_CONTAINS:
+                        if ($this->isEmpty($query->getValues())) {
+                            throw new \Exception('Invalid query: '.\ucfirst($method).' queries require at least one value.');
+                        }
+
+                        $this->validateAttributeExist($query->getAttribute(), $query->getAlias());
+                        $this->validateValues($query->getAttribute(), $query->getAlias(), $query->getValues(), $method);
+
+                        break;
+                    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($query->getValues()) !== 1 || !is_array($query->getValues()[0]) || count($query->getValues()[0]) !== 2) {
+                            $this->message = 'Distance query requires [[geometry, distance]] parameters';
+                            return false;
+                        }
+
+                        $this->validateValues($query->getAttribute(), $query->getAlias(), $query->getValues(), $method);
+                    break;
+
+                    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:
+                        if (count($query->getValues()) != 1) {
+                            throw new \Exception('Invalid query: '.\ucfirst($method).' queries require exactly one value.');
+                        }
+
+                        $this->validateAttributeExist($query->getAttribute(), $query->getAlias());
+                        $this->validateValues($query->getAttribute(), $query->getAlias(), $query->getValues(), $method);
+                        $this->validateFulltextIndex($query);
+
+                        break;
+                    case Query::TYPE_BETWEEN:
+                    case Query::TYPE_NOT_BETWEEN:
+                        if (count($query->getValues()) != 2) {
+                            throw new \Exception('Invalid query: '.\ucfirst($method).' queries require exactly two values.');
+                        }
+
+                        $this->validateAttributeExist($query->getAttribute(), $query->getAlias());
+                        $this->validateValues($query->getAttribute(), $query->getAlias(), $query->getValues(), $method);
+
+                        break;
+                    case Query::TYPE_IS_NULL:
+                    case Query::TYPE_IS_NOT_NULL:
+                        $this->validateAttributeExist($query->getAttribute(), $query->getAlias());
+                        $this->validateValues($query->getAttribute(), $query->getAlias(), $query->getValues(), $method);
+
+                        break;
+                    case Query::TYPE_OR:
+                    case Query::TYPE_AND:
+                        $this->validateFilterQueries($query);
+
+                        $filters = Query::getFilterQueries($query->getValues());
+
+                        if (count($filters) < 2) {
+                            throw new \Exception('Invalid query: '.\ucfirst($method).' queries require at least two queries');
+                        }
+
+                        break;
+                    case Query::TYPE_INNER_JOIN:
+                    case Query::TYPE_LEFT_JOIN:
+                    case Query::TYPE_RIGHT_JOIN:
+                        $this->validateFilterQueries($query);
+
+                        if (! self::isValid($query->getValues(), 'joins')) {
+                            throw new \Exception($this->message);
+                        }
+
+                        if (! $this->isRelationExist($query->getValues(), $query->getAlias())) {
+                            throw new \Exception('Invalid query: At least one relation query is required on the joined collection.');
+                        }
+
+                        /**
+                         * todo:to all queries which uses aliases check that it is available in context scope, not just exists
+                         */
+                        break;
+                    case Query::TYPE_RELATION_EQUAL:
+                        if ($scope !== 'joins') {
+                            throw new \Exception('Invalid query: Relations are only valid within joins.');
+                        }
+
+                        $this->validateAttributeExist($query->getAttribute(), $query->getAlias());
+                        $this->validateAttributeExist($query->getAttributeRight(), $query->getRightAlias());
+
+                        break;
+                    case Query::TYPE_LIMIT:
+                        $validator = new Limit($this->maxLimit);
+                        if (! $validator->isValid($query)) {
+                            throw new \Exception($validator->getDescription());
+                        }
+
+                        break;
+                    case Query::TYPE_OFFSET:
+                        $validator = new Offset($this->maxOffset);
+                        if (! $validator->isValid($query)) {
+                            throw new \Exception($validator->getDescription());
+                        }
+
+                        break;
+                    case Query::TYPE_SELECT:
+                        $validator = new AsValidator($query->getAttribute());
+
+                        if (! $validator->isValid($query->getAs())) {
+                            throw new \Exception('Invalid Query Select: '.$validator->getDescription());
+                        }
+
+                        $this->validateSelect($query);
+
+                        if($query->getAttribute() === '*'){
+                            $collection = $this->context->getCollectionByAlias($query->getAlias());
+                            $attributes = $this->schema[$collection->getId()];
+                            foreach ($attributes as $attribute){
+                                if (($duplications[$query->getAlias()][$attribute['$id']] ?? false) === true){
+                                    //throw new \Exception('Ambiguous column using "*" for "'.$query->getAlias().'.'.$attribute['$id'].'"');
+                                }
+
+                                $duplications[$query->getAlias()][$attribute['$id']] = true;
+                            }
+                        } else {
+                            if (($duplications[$query->getAlias()][$query->getAttribute()] ?? false) === true){
+                                //throw new \Exception('Duplicate Query Select on "'.$query->getAlias().'.'.$query->getAttribute().'"');
+                            }
+                            $duplications[$query->getAlias()][$query->getAttribute()] = true;
+                        }
+
+                        if (!empty($query->getAs())){
+                            $needle = $query->getAs();
+                        } else {
+                            $needle = $query->getAttribute(); // todo: convert internal attribute from $id => _id
+                        }
+
+                        if (in_array($needle, $ambiguous)){
+                            //throw new \Exception('Invalid Query Select: ambiguous column "'.$needle.'"');
+                        }
+
+                        $ambiguous[] = $needle;
+
+                        break;
+                    case Query::TYPE_ORDER_ASC:
+                    case Query::TYPE_ORDER_DESC:
+                        $this->validateAttributeExist($query->getAttribute(), $query->getAlias());
+
+                        break;
+                    case Query::TYPE_CURSOR_AFTER:
+                    case Query::TYPE_CURSOR_BEFORE:
+                        $validator = new Cursor();
+                        if (! $validator->isValid($query)) {
+                            throw new \Exception($validator->getDescription());
+                        }
+
+                        break;
+                    default:
+                        if ($value->isSpatialQuery()) {
+                            if ($this->isEmpty($value->getValues())) {
+                                $this->message = \ucfirst($method) . ' queries require at least one value.';
+                                return false;
+                            }
+                            return $this->isValidAttributeAndValues($attribute, $value->getValues(), $method);
+                        }
+
+                        throw new \Exception('Invalid query: Method not found ');
+                }
+            }
+
+        } catch (\Throwable $e) {
+            $this->message = $e->getMessage();
+            var_dump($this->message);
+            var_dump($e);
+
+            return false;
+        }
+
+        return true;
+    }
+}
diff --git a/src/Database/Validator/Query/Base.php b/src/Database/Validator/Query/Base.php
index a37fdd65a..6b40c37af 100644
--- a/src/Database/Validator/Query/Base.php
+++ b/src/Database/Validator/Query/Base.php
@@ -12,6 +12,7 @@ abstract class Base extends Validator
     public const METHOD_TYPE_ORDER = 'order';
     public const METHOD_TYPE_FILTER = 'filter';
     public const METHOD_TYPE_SELECT = 'select';
+    public const METHOD_TYPE_JOIN = 'join';
 
     protected string $message = 'Invalid query';
 
diff --git a/src/Database/Validator/Query/Filter.php b/src/Database/Validator/Query/Filter.php
index 9f331d871..cce81ebcf 100644
--- a/src/Database/Validator/Query/Filter.php
+++ b/src/Database/Validator/Query/Filter.php
@@ -1,337 +1,289 @@
 <?php
-
-namespace Utopia\Database\Validator\Query;
-
-use Utopia\Database\Database;
-use Utopia\Database\Document;
-use Utopia\Database\Query;
-use Utopia\Database\Validator\Datetime as DatetimeValidator;
-use Utopia\Database\Validator\Sequence;
-use Utopia\Validator\Boolean;
-use Utopia\Validator\FloatValidator;
-use Utopia\Validator\Integer;
-use Utopia\Validator\Text;
-
-class Filter extends Base
-{
-    /**
-     * @var array<int|string, mixed>
-     */
-    protected array $schema = [];
-
-    /**
-     * @param array<Document> $attributes
-     * @param int $maxValuesCount
-     * @param \DateTime $minAllowedDate
-     * @param \DateTime $maxAllowedDate
-     */
-    public function __construct(
-        array $attributes,
-        private readonly string $idAttributeType,
-        private readonly int $maxValuesCount = 100,
-        private readonly \DateTime $minAllowedDate = new \DateTime('0000-01-01'),
-        private readonly \DateTime $maxAllowedDate = new \DateTime('9999-12-31'),
-    ) {
-        foreach ($attributes as $attribute) {
-            $this->schema[$attribute->getAttribute('key', $attribute->getAttribute('$id'))] = $attribute->getArrayCopy();
-        }
-    }
-
-    /**
-     * @param string $attribute
-     * @return bool
-     */
-    protected function isValidAttribute(string $attribute): bool
-    {
-        if (
-            \in_array('encrypt', $this->schema[$attribute]['filters'] ?? [])
-        ) {
-            $this->message = 'Cannot query encrypted attribute: ' . $attribute;
-            return false;
-        }
-
-        if (\str_contains($attribute, '.')) {
-            // Check for special symbol `.`
-            if (isset($this->schema[$attribute])) {
-                return true;
-            }
-
-            // For relationships, just validate the top level.
-            // will validate each nested level during the recursive calls.
-            $attribute = \explode('.', $attribute)[0];
-
-            if (isset($this->schema[$attribute])) {
-                $this->message = 'Cannot query nested attribute on: ' . $attribute;
-                return false;
-            }
-        }
-
-        // Search for attribute in schema
-        if (!isset($this->schema[$attribute])) {
-            $this->message = 'Attribute not found in schema: ' . $attribute;
-            return false;
-        }
-
-        return true;
-    }
-
-    /**
-     * @param string $attribute
-     * @param array<mixed> $values
-     * @param string $method
-     * @return bool
-     */
-    protected function isValidAttributeAndValues(string $attribute, array $values, string $method): bool
-    {
-        if (!$this->isValidAttribute($attribute)) {
-            return false;
-        }
-
-        // isset check if for special symbols "." in the attribute name
-        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];
-        }
-
-        $attributeSchema = $this->schema[$attribute];
-
-        if (count($values) > $this->maxValuesCount) {
-            $this->message = 'Query on attribute has greater than ' . $this->maxValuesCount . ' values: ' . $attribute;
-            return false;
-        }
-
-        $attributeType = $attributeSchema['type'];
-
-        // 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;
-            return false;
-        }
-
-        foreach ($values as $value) {
-            $validator = null;
-
-            switch ($attributeType) {
-                case Database::VAR_ID:
-                    $validator = new Sequence($this->idAttributeType, $attribute === '$sequence');
-                    break;
-
-                case Database::VAR_STRING:
-                    $validator = new Text(0, 0);
-                    break;
-
-                case Database::VAR_INTEGER:
-                    $validator = new Integer();
-                    break;
-
-                case Database::VAR_FLOAT:
-                    $validator = new FloatValidator();
-                    break;
-
-                case Database::VAR_BOOLEAN:
-                    $validator = new Boolean();
-                    break;
-
-                case Database::VAR_DATETIME:
-                    $validator = new DatetimeValidator(
-                        min: $this->minAllowedDate,
-                        max: $this->maxAllowedDate
-                    );
-                    break;
-
-                case Database::VAR_RELATIONSHIP:
-                    $validator = new Text(255, 0); // The query is always on uid
-                    break;
-
-                case Database::VAR_POINT:
-                case Database::VAR_LINESTRING:
-                case Database::VAR_POLYGON:
-                    if (!is_array($value)) {
-                        $this->message = 'Spatial data must be an array';
-                        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 . '"';
-                return false;
-            }
-        }
-
-        if ($attributeSchema['type'] === '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'];
-
-            if ($options['relationType'] === Database::RELATION_ONE_TO_ONE && $options['twoWay'] === false && $options['side'] === Database::RELATION_SIDE_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) {
-                $this->message = 'Cannot query on virtual relationship attribute';
-                return false;
-            }
-
-            if ($options['relationType'] === Database::RELATION_MANY_TO_ONE && $options['side'] === Database::RELATION_SIDE_CHILD) {
-                $this->message = 'Cannot query on virtual relationship attribute';
-                return false;
-            }
-
-            if ($options['relationType'] === Database::RELATION_MANY_TO_MANY) {
-                $this->message = 'Cannot query on virtual relationship attribute';
-                return false;
-            }
-        }
-
-        $array = $attributeSchema['array'] ?? false;
-
-        if (
-            !$array &&
-            in_array($method, [Query::TYPE_CONTAINS, Query::TYPE_NOT_CONTAINS]) &&
-            $attributeSchema['type'] !== Database::VAR_STRING &&
-            !in_array($attributeSchema['type'], Database::SPATIAL_TYPES)
-        ) {
-            $queryType = $method === Query::TYPE_NOT_CONTAINS ? 'notContains' : 'contains';
-            $this->message = 'Cannot query ' . $queryType . ' on attribute "' . $attribute . '" because it is not an array or string.';
-            return false;
-        }
-
-        if (
-            $array &&
-            !in_array($method, [Query::TYPE_CONTAINS, Query::TYPE_NOT_CONTAINS, Query::TYPE_IS_NULL, Query::TYPE_IS_NOT_NULL])
-        ) {
-            $this->message = 'Cannot query '. $method .' on attribute "' . $attribute . '" because it is an array.';
-            return false;
-        }
-
-        return true;
-    }
-
-    /**
-     * @param array<mixed> $values
-     * @return bool
-     */
-    protected function isEmpty(array $values): bool
-    {
-        if (count($values) === 0) {
-            return true;
-        }
-
-        if (is_array($values[0]) && count($values[0]) === 0) {
-            return true;
-        }
-
-        return false;
-    }
-
-    /**
-     * Is valid.
-     *
-     * Returns true if method is a filter method, attribute exists, and value matches attribute type
-     *
-     * Otherwise, returns false
-     *
-     * @param Query $value
-     * @return bool
-     */
-    public function isValid($value): bool
-    {
-        $method = $value->getMethod();
-        $attribute = $value->getAttribute();
-        switch ($method) {
-            case Query::TYPE_EQUAL:
-            case Query::TYPE_CONTAINS:
-            case Query::TYPE_NOT_CONTAINS:
-                if ($this->isEmpty($value->getValues())) {
-                    $this->message = \ucfirst($method) . ' 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]) !== 2) {
-                    $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:
-                if (count($value->getValues()) != 1) {
-                    $this->message = \ucfirst($method) . ' queries require exactly one value.';
-                    return false;
-                }
-
-                return $this->isValidAttributeAndValues($attribute, $value->getValues(), $method);
-
-            case Query::TYPE_BETWEEN:
-            case Query::TYPE_NOT_BETWEEN:
-                if (count($value->getValues()) != 2) {
-                    $this->message = \ucfirst($method) . ' 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:
-                return $this->isValidAttributeAndValues($attribute, $value->getValues(), $method);
-
-            case Query::TYPE_OR:
-            case Query::TYPE_AND:
-                $filters = Query::groupByType($value->getValues())['filters'];
-
-                if (count($value->getValues()) !== count($filters)) {
-                    $this->message = \ucfirst($method) . ' queries can only contain filter queries';
-                    return false;
-                }
-
-                if (count($filters) < 2) {
-                    $this->message = \ucfirst($method) . ' queries require at least two queries';
-                    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.';
-                        return false;
-                    }
-                    return $this->isValidAttributeAndValues($attribute, $value->getValues(), $method);
-                }
-
-                return false;
-        }
-    }
-
-    public function getMethodType(): string
-    {
-        return self::METHOD_TYPE_FILTER;
-    }
-}
+//
+//namespace Utopia\Database\Validator\Query;
+//
+//use Utopia\Database\Database;
+//use Utopia\Database\Document;
+//use Utopia\Database\Query;
+//use Utopia\Database\Validator\Datetime as DatetimeValidator;
+//use Utopia\Validator\Boolean;
+//use Utopia\Validator\FloatValidator;
+//use Utopia\Validator\Integer;
+//use Utopia\Validator\Text;
+//
+//class Filter extends Base
+//{
+//    /**
+//     * @var array<int|string, mixed>
+//     */
+//    protected array $schema = [];
+//
+//    /**
+//     * @param array<Document> $attributes
+//     * @param int $maxValuesCount
+//     * @param \DateTime $minAllowedDate
+//     * @param \DateTime $maxAllowedDate
+//     */
+//    public function __construct(
+//        array $attributes = [],
+//        private readonly int $maxValuesCount = 100,
+//        private readonly \DateTime $minAllowedDate = new \DateTime('0000-01-01'),
+//        private readonly \DateTime $maxAllowedDate = new \DateTime('9999-12-31'),
+//    ) {
+//        foreach ($attributes as $attribute) {
+//            $this->schema[$attribute->getAttribute('key', $attribute->getAttribute('$id'))] = $attribute->getArrayCopy();
+//        }
+//    }
+//
+//    /**
+//     * @param string $attribute
+//     * @return bool
+//     */
+//    protected function isValidAttribute(string $attribute): bool
+//    {
+//        if (
+//            \in_array('encrypt', $this->schema[$attribute]['filters'] ?? [])
+//        ) {
+//            $this->message = 'Cannot query encrypted attribute: ' . $attribute;
+//            return false;
+//        }
+//
+//        if (\str_contains($attribute, '.')) {
+//            // Check for special symbol `.`
+//            if (isset($this->schema[$attribute])) {
+//                return true;
+//            }
+//
+//            // For relationships, just validate the top level.
+//            // will validate each nested level during the recursive calls.
+//            $attribute = \explode('.', $attribute)[0];
+//
+//            if (isset($this->schema[$attribute])) {
+//                $this->message = 'Cannot query nested attribute on: ' . $attribute;
+//                return false;
+//            }
+//        }
+//
+//        // Search for attribute in schema
+//        if (!isset($this->schema[$attribute])) {
+//            $this->message = 'Attribute not found in schema: ' . $attribute;
+//            return false;
+//        }
+//
+//        return true;
+//    }
+//
+//    /**
+//     * @param string $attribute
+//     * @param array<mixed> $values
+//     * @param string $method
+//     * @return bool
+//     */
+//    protected function isValidAttributeAndValues(string $attribute, array $values, string $method): bool
+//    {
+//        if (!$this->isValidAttribute($attribute)) {
+//            return false;
+//        }
+//
+//        // isset check if for special symbols "." in the attribute name
+//        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];
+//        }
+//
+//        $attributeSchema = $this->schema[$attribute];
+//
+//        if (count($values) > $this->maxValuesCount) {
+//            $this->message = 'Query on attribute has greater than ' . $this->maxValuesCount . ' values: ' . $attribute;
+//            return false;
+//        }
+//
+//        // Extract the type of desired attribute from collection $schema
+//        $attributeType = $attributeSchema['type'];
+//
+//        foreach ($values as $value) {
+//            $validator = null;
+//
+//            switch ($attributeType) {
+//                case Database::VAR_STRING:
+//                    $validator = new Text(0, 0);
+//                    break;
+//
+//                case Database::VAR_INTEGER:
+//                    $validator = new Integer();
+//                    break;
+//
+//                case Database::VAR_FLOAT:
+//                    $validator = new FloatValidator();
+//                    break;
+//
+//                case Database::VAR_BOOLEAN:
+//                    $validator = new Boolean();
+//                    break;
+//
+//                case Database::VAR_DATETIME:
+//                    $validator = new DatetimeValidator(
+//                        min: $this->minAllowedDate,
+//                        max: $this->maxAllowedDate
+//                    );
+//                    break;
+//
+//                case Database::VAR_RELATIONSHIP:
+//                    $validator = new Text(255, 0); // The query is always on uid
+//                    break;
+//                default:
+//                    $this->message = 'Unknown Data type';
+//                    return false;
+//            }
+//
+//            if (!$validator->isValid($value)) {
+//                $this->message = 'Query value is invalid for attribute "' . $attribute . '"';
+//                return false;
+//            }
+//        }
+//
+//        if ($attributeSchema['type'] === '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'];
+//
+//            if ($options['relationType'] === Database::RELATION_ONE_TO_ONE && $options['twoWay'] === false && $options['side'] === Database::RELATION_SIDE_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) {
+//                $this->message = 'Cannot query on virtual relationship attribute';
+//                return false;
+//            }
+//
+//            if ($options['relationType'] === Database::RELATION_MANY_TO_ONE && $options['side'] === Database::RELATION_SIDE_CHILD) {
+//                $this->message = 'Cannot query on virtual relationship attribute';
+//                return false;
+//            }
+//
+//            if ($options['relationType'] === Database::RELATION_MANY_TO_MANY) {
+//                $this->message = 'Cannot query on virtual relationship attribute';
+//                return false;
+//            }
+//        }
+//
+//        $array = $attributeSchema['array'] ?? false;
+//
+//        if (
+//            !$array &&
+//            $method === Query::TYPE_CONTAINS &&
+//            $attributeSchema['type'] !==  Database::VAR_STRING
+//        ) {
+//            $this->message = 'Cannot query contains on attribute "' . $attribute . '" because it is not an array or string.';
+//            return false;
+//        }
+//
+//        if (
+//            $array &&
+//            !in_array($method, [Query::TYPE_CONTAINS, Query::TYPE_IS_NULL, Query::TYPE_IS_NOT_NULL])
+//        ) {
+//            $this->message = 'Cannot query '. $method .' on attribute "' . $attribute . '" because it is an array.';
+//            return false;
+//        }
+//
+//        return true;
+//    }
+//
+//    /**
+//     * @param array<mixed> $values
+//     * @return bool
+//     */
+//    protected function isEmpty(array $values): bool
+//    {
+//        if (count($values) === 0) {
+//            return true;
+//        }
+//
+//        if (is_array($values[0]) && count($values[0]) === 0) {
+//            return true;
+//        }
+//
+//        return false;
+//    }
+//
+//    /**
+//     * Is valid.
+//     *
+//     * Returns true if method is a filter method, attribute exists, and value matches attribute type
+//     *
+//     * Otherwise, returns false
+//     *
+//     * @param Query $value
+//     * @return bool
+//     */
+//    public function isValid($value): bool
+//    {
+//        $method = $value->getMethod();
+//        $attribute = $value->getAttribute();
+//        switch ($method) {
+//            case Query::TYPE_EQUAL:
+//            case Query::TYPE_CONTAINS:
+//                if ($this->isEmpty($value->getValues())) {
+//                    $this->message = \ucfirst($method) . ' queries require at least one value.';
+//                    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_STARTS_WITH:
+//            case Query::TYPE_ENDS_WITH:
+//                if (count($value->getValues()) != 1) {
+//                    $this->message = \ucfirst($method) . ' queries require exactly one value.';
+//                    return false;
+//                }
+//
+//                return $this->isValidAttributeAndValues($attribute, $value->getValues(), $method);
+//
+//            case Query::TYPE_BETWEEN:
+//                if (count($value->getValues()) != 2) {
+//                    $this->message = \ucfirst($method) . ' 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:
+//                return $this->isValidAttributeAndValues($attribute, $value->getValues(), $method);
+//
+//            case Query::TYPE_OR:
+//            case Query::TYPE_AND:
+//                $filters = Query::getFilterQueries($value->getValues());
+//
+//                if (count($value->getValues()) !== count($filters)) {
+//                    $this->message = \ucfirst($method) . ' queries can only contain filter queries';
+//                    return false;
+//                }
+//
+//                if (count($filters) < 2) {
+//                    $this->message = \ucfirst($method) . ' queries require at least two queries';
+//                    return false;
+//                }
+//
+//                return true;
+//
+//            default:
+//                return false;
+//        }
+//    }
+//
+//    public function getMethodType(): string
+//    {
+//        return self::METHOD_TYPE_FILTER;
+//    }
+//}
diff --git a/src/Database/Validator/Query/Offset.php b/src/Database/Validator/Query/Offset.php
index 8d59be4d0..8b302be47 100644
--- a/src/Database/Validator/Query/Offset.php
+++ b/src/Database/Validator/Query/Offset.php
@@ -39,7 +39,7 @@ public function isValid($value): bool
 
         $validator = new Numeric();
         if (!$validator->isValid($offset)) {
-            $this->message = 'Invalid limit: ' . $validator->getDescription();
+            $this->message = 'Invalid offset: ' . $validator->getDescription();
             return false;
         }
 
diff --git a/src/Database/Validator/Query/Order.php b/src/Database/Validator/Query/Order.php
index f0e7f2d56..003374864 100644
--- a/src/Database/Validator/Query/Order.php
+++ b/src/Database/Validator/Query/Order.php
@@ -1,70 +1,74 @@
 <?php
 
-namespace Utopia\Database\Validator\Query;
-
-use Utopia\Database\Document;
-use Utopia\Database\Query;
-
-class Order extends Base
-{
-    /**
-     * @var array<int|string, mixed>
-     */
-    protected array $schema = [];
-
-    /**
-     * @param array<Document> $attributes
-     */
-    public function __construct(array $attributes = [])
-    {
-        foreach ($attributes as $attribute) {
-            $this->schema[$attribute->getAttribute('key', $attribute->getAttribute('$id'))] = $attribute->getArrayCopy();
-        }
-    }
-
-    /**
-     * @param string $attribute
-     * @return bool
-     */
-    protected function isValidAttribute(string $attribute): bool
-    {
-        // Search for attribute in schema
-        if (!isset($this->schema[$attribute])) {
-            $this->message = 'Attribute not found in schema: ' . $attribute;
-            return false;
-        }
-
-        return true;
-    }
-
-    /**
-     * Is valid.
-     *
-     * Returns true if method is ORDER_ASC or ORDER_DESC and attributes are valid
-     *
-     * Otherwise, returns false
-     *
-     * @param Query $value
-     * @return bool
-     */
-    public function isValid($value): bool
-    {
-        if (!$value instanceof Query) {
-            return false;
-        }
-
-        $method = $value->getMethod();
-        $attribute = $value->getAttribute();
-
-        if ($method === Query::TYPE_ORDER_ASC || $method === Query::TYPE_ORDER_DESC) {
-            return $this->isValidAttribute($attribute);
-        }
-
-        return false;
-    }
-
-    public function getMethodType(): string
-    {
-        return self::METHOD_TYPE_ORDER;
-    }
-}
+//
+//namespace Utopia\Database\Validator\Query;
+//
+//use Utopia\Database\Document;
+//use Utopia\Database\Query;
+//
+//class Order extends Base
+//{
+//    /**
+//     * @var array<int|string, mixed>
+//     */
+//    protected array $schema = [];
+//
+//    /**
+//     * @param array<Document> $attributes
+//     */
+//    public function __construct(array $attributes = [])
+//    {
+//        foreach ($attributes as $attribute) {
+//            $this->schema[$attribute->getAttribute('key', $attribute->getAttribute('$id'))] = $attribute->getArrayCopy();
+//        }
+//    }
+//
+//    /**
+//     * @param string $attribute
+//     * @return bool
+//     */
+//    protected function isValidAttribute(string $attribute): bool
+//    {
+//        // Search for attribute in schema
+//        if (!isset($this->schema[$attribute])) {
+//            $this->message = 'Attribute not found in schema: ' . $attribute;
+//            return false;
+//        }
+//
+//        return true;
+//    }
+//
+//    /**
+//     * Is valid.
+//     *
+//     * Returns true if method is ORDER_ASC or ORDER_DESC and attributes are valid
+//     *
+//     * Otherwise, returns false
+//     *
+//     * @param Query $value
+//     * @return bool
+//     */
+//    public function isValid($value): bool
+//    {
+//        if (!$value instanceof Query) {
+//            return false;
+//        }
+//
+//        $method = $value->getMethod();
+//        $attribute = $value->getAttribute();
+//
+//        if ($method === Query::TYPE_ORDER_ASC || $method === Query::TYPE_ORDER_DESC) {
+//            if ($attribute === '') {
+//                return true;
+//            }
+//            return $this->isValidAttribute($attribute);
+//        }
+//
+//        return false;
+//    }
+//
+//    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 40572b828..169b66308 100644
--- a/src/Database/Validator/Query/Select.php
+++ b/src/Database/Validator/Query/Select.php
@@ -1,104 +1,95 @@
 <?php
 
-namespace Utopia\Database\Validator\Query;
-
-use Utopia\Database\Database;
-use Utopia\Database\Document;
-use Utopia\Database\Query;
-
-class Select extends Base
-{
-    /**
-     * @var array<int|string, mixed>
-     */
-    protected array $schema = [];
-
-    /**
-     * List of internal attributes
-     *
-     * @var array<string>
-     */
-    protected const INTERNAL_ATTRIBUTES = [
-        '$id',
-        '$sequence',
-        '$createdAt',
-        '$updatedAt',
-        '$permissions',
-        '$collection',
-    ];
-
-    /**
-     * @param array<Document> $attributes
-     */
-    public function __construct(array $attributes = [])
-    {
-        foreach ($attributes as $attribute) {
-            $this->schema[$attribute->getAttribute('key', $attribute->getAttribute('$id'))] = $attribute->getArrayCopy();
-        }
-    }
-
-    /**
-     * Is valid.
-     *
-     * Returns true if method is TYPE_SELECT selections are valid
-     *
-     * Otherwise, returns false
-     *
-     * @param Query $value
-     * @return bool
-     */
-    public function isValid($value): bool
-    {
-        if (!$value instanceof Query) {
-            return false;
-        }
-
-        if ($value->getMethod() !== Query::TYPE_SELECT) {
-            return false;
-        }
-
-        $internalKeys = \array_map(
-            fn ($attr) => $attr['$id'],
-            Database::INTERNAL_ATTRIBUTES
-        );
-
-        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) {
-            if (\str_contains($attribute, '.')) {
-                //special symbols with `dots`
-                if (isset($this->schema[$attribute])) {
-                    continue;
-                }
-
-                // For relationships, just validate the top level.
-                // Will validate each nested level during the recursive calls.
-                $attribute = \explode('.', $attribute)[0];
-            }
-
-            // Skip internal attributes
-            if (\in_array($attribute, $internalKeys)) {
-                continue;
-            }
-
-            if (!isset($this->schema[$attribute]) && $attribute !== '*') {
-                $this->message = 'Attribute not found in schema: ' . $attribute;
-                return false;
-            }
-        }
-        return true;
-    }
-
-    public function getMethodType(): string
-    {
-        return self::METHOD_TYPE_SELECT;
-    }
-}
+//
+//namespace Utopia\Database\Validator\Query;
+//
+//use Utopia\Database\Database;
+//use Utopia\Database\Document;
+//use Utopia\Database\Query;
+//
+//class Select extends Base
+//{
+//    /**
+//     * @var array<int|string, mixed>
+//     */
+//    protected array $schema = [];
+//
+//    /**
+//     * List of internal attributes
+//     *
+//     * @var array<string>
+//     */
+//    protected const INTERNAL_ATTRIBUTES = [
+//        '$id',
+//        '$sequence',
+//        '$createdAt',
+//        '$updatedAt',
+//        '$permissions',
+//        '$collection',
+//    ];
+//
+//    /**
+//     * @param array<Document> $attributes
+//     */
+//    public function __construct(array $attributes = [])
+//    {
+//        foreach ($attributes as $attribute) {
+//            $this->schema[$attribute->getAttribute('key', $attribute->getAttribute('$id'))] = $attribute->getArrayCopy();
+//        }
+//    }
+//
+//    /**
+//     * Is valid.
+//     *
+//     * Returns true if method is TYPE_SELECT selections are valid
+//     *
+//     * Otherwise, returns false
+//     *
+//     * @param Query $value
+//     * @return bool
+//     */
+//    public function isValid($value): bool
+//    {
+//        if (!$value instanceof Query) {
+//            return false;
+//        }
+//
+//        if ($value->getMethod() !== Query::TYPE_SELECT) {
+//            return false;
+//        }
+//
+//        $internalKeys = \array_map(
+//            fn ($attr) => $attr['$id'],
+//            Database::INTERNAL_ATTRIBUTES
+//        );
+//
+//        foreach ($value->getValues() as $attribute) {
+//            if (\str_contains($attribute, '.')) {
+//                //special symbols with `dots`
+//                if (isset($this->schema[$attribute])) {
+//                    continue;
+//                }
+//
+//                // For relationships, just validate the top level.
+//                // Will validate each nested level during the recursive calls.
+//                $attribute = \explode('.', $attribute)[0];
+//            }
+//
+//            // Skip internal attributes
+//            if (\in_array($attribute, $internalKeys)) {
+//                continue;
+//            }
+//
+//            if (!isset($this->schema[$attribute]) && $attribute !== '*') {
+//                $this->message = 'Attribute not found in schema: ' . $attribute;
+//                return false;
+//            }
+//        }
+//        return true;
+//    }
+//
+//    public function getMethodType(): string
+//    {
+//        return self::METHOD_TYPE_SELECT;
+//    }
+//}
diff --git a/tests/e2e/Adapter/Base.php b/tests/e2e/Adapter/Base.php
index 37ad7cce3..d8e8ab04d 100644
--- a/tests/e2e/Adapter/Base.php
+++ b/tests/e2e/Adapter/Base.php
@@ -8,6 +8,7 @@
 use Tests\E2E\Adapter\Scopes\DocumentTests;
 use Tests\E2E\Adapter\Scopes\GeneralTests;
 use Tests\E2E\Adapter\Scopes\IndexTests;
+use Tests\E2E\Adapter\Scopes\JoinsTests;
 use Tests\E2E\Adapter\Scopes\PermissionTests;
 use Tests\E2E\Adapter\Scopes\RelationshipTests;
 use Tests\E2E\Adapter\Scopes\SpatialTests;
@@ -18,12 +19,13 @@
 
 abstract class Base extends TestCase
 {
-    use CollectionTests;
-    use DocumentTests;
-    use AttributeTests;
-    use IndexTests;
-    use PermissionTests;
-    use RelationshipTests;
+//    use JoinsTests;
+//    use CollectionTests;
+//    use DocumentTests;
+//    use AttributeTests;
+//    use IndexTests;
+//    use PermissionTests;
+//    use RelationshipTests;
     use SpatialTests;
     use GeneralTests;
 
diff --git a/tests/e2e/Adapter/Scopes/AttributeTests.php b/tests/e2e/Adapter/Scopes/AttributeTests.php
index 89ab81a50..5875fffe4 100644
--- a/tests/e2e/Adapter/Scopes/AttributeTests.php
+++ b/tests/e2e/Adapter/Scopes/AttributeTests.php
@@ -63,6 +63,11 @@ public function testCreateDeleteAttribute(): void
 
         $database->createCollection('attributes');
 
+        $collection = $database->getCollection('attributes');
+        $this->assertEquals([], $collection->getAttribute('attributes'));
+        $this->assertEquals(true, $collection->getAttribute('documentSecurity'));
+        $this->assertEquals(['create("any")'], $collection->getAttribute('$permissions'));
+
         $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));
@@ -238,7 +243,7 @@ public function testAttributeNamesWithDots(): void
         ));
 
         $document = $database->find('dots.parent', [
-            Query::select(['dots.name']),
+            Query::select('dots.name'),
         ]);
         $this->assertEmpty($document);
 
@@ -279,7 +284,7 @@ public function testAttributeNamesWithDots(): void
         ]));
 
         $documents = $database->find('dots.parent', [
-            Query::select(['*']),
+            Query::select('*'),
         ]);
 
         $this->assertEquals('Bill clinton', $documents[0]['dots.name']);
diff --git a/tests/e2e/Adapter/Scopes/DocumentTests.php b/tests/e2e/Adapter/Scopes/DocumentTests.php
index bf7f2a905..043e9962c 100644
--- a/tests/e2e/Adapter/Scopes/DocumentTests.php
+++ b/tests/e2e/Adapter/Scopes/DocumentTests.php
@@ -18,6 +18,7 @@
 use Utopia\Database\Helpers\Permission;
 use Utopia\Database\Helpers\Role;
 use Utopia\Database\Query;
+use Utopia\Database\QueryContext;
 use Utopia\Database\Validator\Authorization;
 
 trait DocumentTests
@@ -1304,7 +1305,8 @@ public function testGetDocumentSelect(Document $document): Document
         $database = static::getDatabase();
 
         $document = $database->getDocument('documents', $documentId, [
-            Query::select(['string', 'integer_signed']),
+            Query::select('string'),
+            Query::select('integer_signed'),
         ]);
 
         $this->assertFalse($document->isEmpty());
@@ -1317,21 +1319,23 @@ public function testGetDocumentSelect(Document $document): Document
         $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->assertArrayNotHasKey('$sequence', $document);
+        $this->assertArrayNotHasKey('$createdAt', $document);
+        $this->assertArrayNotHasKey('$updatedAt', $document);
+        $this->assertArrayNotHasKey('$permissions', $document);
         $this->assertArrayHasKey('$collection', $document);
 
         $document = $database->getDocument('documents', $documentId, [
-            Query::select(['string', 'integer_signed', '$id']),
+            Query::select('string'),
+            Query::select('integer_signed'),
+            Query::select('$id'),
         ]);
 
         $this->assertArrayHasKey('$id', $document);
-        $this->assertArrayHasKey('$sequence', $document);
-        $this->assertArrayHasKey('$createdAt', $document);
-        $this->assertArrayHasKey('$updatedAt', $document);
-        $this->assertArrayHasKey('$permissions', $document);
+        $this->assertArrayNotHasKey('$sequence', $document);
+        $this->assertArrayNotHasKey('$createdAt', $document);
+        $this->assertArrayNotHasKey('$updatedAt', $document);
+        $this->assertArrayNotHasKey('$permissions', $document);
         $this->assertArrayHasKey('$collection', $document);
         $this->assertArrayHasKey('string', $document);
         $this->assertArrayHasKey('integer_signed', $document);
@@ -2922,7 +2926,7 @@ public function testOrNested(): void
         $database = static::getDatabase();
 
         $queries = [
-            Query::select(['director']),
+            Query::select('director'),
             Query::equal('director', ['Joe Johnston']),
             Query::or([
                 Query::equal('name', ['Frozen']),
@@ -3447,7 +3451,8 @@ public function testFindSelect(): void
         $database = static::getDatabase();
 
         $documents = $database->find('movies', [
-            Query::select(['name', 'year'])
+            Query::select('name'),
+            Query::select('year')
         ]);
 
         foreach ($documents as $document) {
@@ -3457,15 +3462,17 @@ public function testFindSelect(): void
             $this->assertArrayNotHasKey('price', $document);
             $this->assertArrayNotHasKey('active', $document);
             $this->assertArrayHasKey('$id', $document);
-            $this->assertArrayHasKey('$sequence', $document);
+            $this->assertArrayNotHasKey('$sequence', $document);
             $this->assertArrayHasKey('$collection', $document);
-            $this->assertArrayHasKey('$createdAt', $document);
-            $this->assertArrayHasKey('$updatedAt', $document);
-            $this->assertArrayHasKey('$permissions', $document);
+            $this->assertArrayNotHasKey('$createdAt', $document);
+            $this->assertArrayNotHasKey('$updatedAt', $document);
+            $this->assertArrayNotHasKey('$permissions', $document);
         }
 
         $documents = $database->find('movies', [
-            Query::select(['name', 'year', '$id'])
+            Query::select('name'),
+            Query::select('year'),
+            Query::select('$id')
         ]);
 
         foreach ($documents as $document) {
@@ -3475,15 +3482,17 @@ public function testFindSelect(): void
             $this->assertArrayNotHasKey('price', $document);
             $this->assertArrayNotHasKey('active', $document);
             $this->assertArrayHasKey('$id', $document);
-            $this->assertArrayHasKey('$sequence', $document);
+            $this->assertArrayNotHasKey('$sequence', $document);
             $this->assertArrayHasKey('$collection', $document);
-            $this->assertArrayHasKey('$createdAt', $document);
-            $this->assertArrayHasKey('$updatedAt', $document);
-            $this->assertArrayHasKey('$permissions', $document);
+            $this->assertArrayNotHasKey('$createdAt', $document);
+            $this->assertArrayNotHasKey('$updatedAt', $document);
+            $this->assertArrayNotHasKey('$permissions', $document);
         }
 
         $documents = $database->find('movies', [
-            Query::select(['name', 'year', '$sequence'])
+            Query::select('name'),
+            Query::select('year'),
+            Query::select('$sequence')
         ]);
 
         foreach ($documents as $document) {
@@ -3495,13 +3504,15 @@ public function testFindSelect(): void
             $this->assertArrayHasKey('$id', $document);
             $this->assertArrayHasKey('$sequence', $document);
             $this->assertArrayHasKey('$collection', $document);
-            $this->assertArrayHasKey('$createdAt', $document);
-            $this->assertArrayHasKey('$updatedAt', $document);
-            $this->assertArrayHasKey('$permissions', $document);
+            $this->assertArrayNotHasKey('$createdAt', $document);
+            $this->assertArrayNotHasKey('$updatedAt', $document);
+            $this->assertArrayNotHasKey('$permissions', $document);
         }
 
         $documents = $database->find('movies', [
-            Query::select(['name', 'year', '$collection'])
+            Query::select('name'),
+            Query::select('year'),
+            Query::select('$collection')
         ]);
 
         foreach ($documents as $document) {
@@ -3511,15 +3522,17 @@ public function testFindSelect(): void
             $this->assertArrayNotHasKey('price', $document);
             $this->assertArrayNotHasKey('active', $document);
             $this->assertArrayHasKey('$id', $document);
-            $this->assertArrayHasKey('$sequence', $document);
+            $this->assertArrayNotHasKey('$sequence', $document);
             $this->assertArrayHasKey('$collection', $document);
-            $this->assertArrayHasKey('$createdAt', $document);
-            $this->assertArrayHasKey('$updatedAt', $document);
-            $this->assertArrayHasKey('$permissions', $document);
+            $this->assertArrayNotHasKey('$createdAt', $document);
+            $this->assertArrayNotHasKey('$updatedAt', $document);
+            $this->assertArrayNotHasKey('$permissions', $document);
         }
 
-        $documents = $database->find('movies', [
-            Query::select(['name', 'year', '$createdAt'])
+        $documents = static::getDatabase()->find('movies', [
+            Query::select('name'),
+            Query::select('year'),
+            Query::select('$createdAt')
         ]);
 
         foreach ($documents as $document) {
@@ -3529,15 +3542,17 @@ public function testFindSelect(): void
             $this->assertArrayNotHasKey('price', $document);
             $this->assertArrayNotHasKey('active', $document);
             $this->assertArrayHasKey('$id', $document);
-            $this->assertArrayHasKey('$sequence', $document);
+            $this->assertArrayNotHasKey('$sequence', $document);
             $this->assertArrayHasKey('$collection', $document);
             $this->assertArrayHasKey('$createdAt', $document);
-            $this->assertArrayHasKey('$updatedAt', $document);
-            $this->assertArrayHasKey('$permissions', $document);
+            $this->assertArrayNotHasKey('$updatedAt', $document);
+            $this->assertArrayNotHasKey('$permissions', $document);
         }
 
         $documents = $database->find('movies', [
-            Query::select(['name', 'year', '$updatedAt'])
+            Query::select('name'),
+            Query::select('year'),
+            Query::select('$updatedAt')
         ]);
 
         foreach ($documents as $document) {
@@ -3547,15 +3562,17 @@ public function testFindSelect(): void
             $this->assertArrayNotHasKey('price', $document);
             $this->assertArrayNotHasKey('active', $document);
             $this->assertArrayHasKey('$id', $document);
-            $this->assertArrayHasKey('$sequence', $document);
+            $this->assertArrayNotHasKey('$sequence', $document);
             $this->assertArrayHasKey('$collection', $document);
-            $this->assertArrayHasKey('$createdAt', $document);
+            $this->assertArrayNotHasKey('$createdAt', $document);
             $this->assertArrayHasKey('$updatedAt', $document);
-            $this->assertArrayHasKey('$permissions', $document);
+            $this->assertArrayNotHasKey('$permissions', $document);
         }
 
-        $documents = $database->find('movies', [
-            Query::select(['name', 'year', '$permissions'])
+        $documents = static::getDatabase()->find('movies', [
+            Query::select('name'),
+            Query::select('year'),
+            Query::select('$permissions')
         ]);
 
         foreach ($documents as $document) {
@@ -3565,10 +3582,10 @@ public function testFindSelect(): void
             $this->assertArrayNotHasKey('price', $document);
             $this->assertArrayNotHasKey('active', $document);
             $this->assertArrayHasKey('$id', $document);
-            $this->assertArrayHasKey('$sequence', $document);
+            $this->assertArrayNotHasKey('$sequence', $document);
             $this->assertArrayHasKey('$collection', $document);
-            $this->assertArrayHasKey('$createdAt', $document);
-            $this->assertArrayHasKey('$updatedAt', $document);
+            $this->assertArrayNotHasKey('$createdAt', $document);
+            $this->assertArrayNotHasKey('$updatedAt', $document);
             $this->assertArrayHasKey('$permissions', $document);
         }
     }
@@ -3920,7 +3937,10 @@ public function testEncodeDecode(): void
         $this->assertEquals(['admin', 'developer', 'tester',], $result->getAttribute('roles'));
         $this->assertEquals(['{"$id":"1","label":"x"}', '{"$id":"2","label":"y"}', '{"$id":"3","label":"z"}',], $result->getAttribute('tags'));
 
-        $result = $database->decode($collection, $document);
+        $context = new QueryContext();
+        $context->add($collection);
+
+        $result = $database->decode($context, $document);
 
         $this->assertEquals('608fdbe51361a', $result->getAttribute('$id'));
         $this->assertContains('read("any")', $result->getAttribute('$permissions'));
@@ -4655,7 +4675,8 @@ public function testDeleteBulkDocuments(): void
         $count = $database->deleteDocuments(
             collection: 'bulk_delete',
             queries: [
-                Query::select([...$selects, '$createdAt']),
+                Query::select('$createdAt'),
+                ...array_map(fn ($f) => Query::select($f), $selects),
                 Query::cursorAfter($docs[6]),
                 Query::greaterThan('$createdAt', '2000-01-01'),
                 Query::orderAsc('$createdAt'),
@@ -4863,7 +4884,8 @@ public function testDeleteBulkDocumentsWithCallbackSupport(): void
             $database->deleteDocuments(
                 collection: 'bulk_delete_with_callback',
                 queries: [
-                    Query::select([...$selects, '$createdAt']),
+                    ...array_map(fn ($f) => Query::select($f), $selects),
+                    Query::select('$createdAt'),
                     Query::lessThan('$createdAt', '1800-01-01'),
                     Query::orderAsc('$createdAt'),
                     Query::orderAsc(),
@@ -4885,7 +4907,8 @@ public function testDeleteBulkDocumentsWithCallbackSupport(): void
         $count = $database->deleteDocuments(
             collection: 'bulk_delete_with_callback',
             queries: [
-                Query::select([...$selects, '$createdAt']),
+                ...array_map(fn ($f) => Query::select($f), $selects),
+                Query::select('$createdAt'),
                 Query::cursorAfter($docs[6]),
                 Query::greaterThan('$createdAt', '2000-01-01'),
                 Query::orderAsc('$createdAt'),
diff --git a/tests/e2e/Adapter/Scopes/JoinsTests.php b/tests/e2e/Adapter/Scopes/JoinsTests.php
new file mode 100644
index 000000000..14334ffad
--- /dev/null
+++ b/tests/e2e/Adapter/Scopes/JoinsTests.php
@@ -0,0 +1,565 @@
+<?php
+
+namespace Tests\E2E\Adapter\Scopes;
+
+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\Permission;
+use Utopia\Database\Helpers\Role;
+use Utopia\Database\Query;
+use Utopia\Database\Validator\Authorization;
+
+trait JoinsTests
+{
+    /**
+     * @throws AuthorizationException
+     * @throws ConflictException
+     * @throws TimeoutException
+     * @throws DuplicateException
+     * @throws LimitException
+     * @throws StructureException
+     * @throws DatabaseException
+     * @throws QueryException
+     */
+    public function testJoin(): void
+    {
+        /**
+         * @var Database $db
+         */
+        $db = static::getDatabase();
+
+        if (!$db->getAdapter()->getSupportForRelationships()) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        //Authorization::setRole('user:bob');
+
+        $db->createCollection('__users');
+        $db->createCollection('__sessions');
+
+        $db->createAttribute('__users', 'username', Database::VAR_STRING, 100, false);
+        $db->createAttribute('__sessions', 'user_id', Database::VAR_STRING, 100, false);
+        $db->createAttribute('__sessions', 'boolean', Database::VAR_BOOLEAN, 0, false);
+        $db->createAttribute('__sessions', 'float', Database::VAR_FLOAT, 0, false);
+
+        $user1 = $db->createDocument('__users', new Document([
+            'username' => 'Donald',
+            '$permissions' => [
+                Permission::read(Role::any()),
+                Permission::read(Role::user('bob')),
+            ],
+        ]));
+
+        $sessionNoPermissions = $db->createDocument('__sessions', new Document([
+            'user_id' => $user1->getId(),
+            '$permissions' => [],
+        ]));
+
+        /**
+         * Test $session1 does not have read permissions
+         * Test right attribute is internal attribute
+         */
+        $documents = $db->find(
+            '__users',
+            [
+                Query::join('__sessions', 'B',
+                    [
+                        Query::relationEqual('B', 'user_id', '', '$id'),
+                    ]
+                ),
+            ]
+        );
+        $this->assertCount(0, $documents);
+
+        $session2 = $db->createDocument('__sessions', new Document([
+            'user_id' => $user1->getId(),
+            '$permissions' => [
+                Permission::read(Role::any()),
+            ],
+            'boolean' => false,
+            'float' => 10.5,
+        ]));
+
+        $user2 = $db->createDocument('__users', new Document([
+            'username' => 'Abraham',
+            '$permissions' => [
+                Permission::read(Role::any()),
+                Permission::read(Role::user('bob')),
+            ],
+        ]));
+
+        $session3 = $db->createDocument('__sessions', new Document([
+            'user_id' => $user2->getId(),
+            '$permissions' => [
+                Permission::read(Role::any()),
+            ],
+            'boolean' => true,
+            'float' => 5.5,
+        ]));
+
+        /**
+         * Test $session2 has read permissions
+         * Test right attribute is internal attribute
+         */
+        $documents = $db->find(
+            '__users',
+            [
+                Query::join('__sessions', 'B',
+                    [
+                        Query::relationEqual('B', 'user_id', '', '$id'),
+                    ]
+                ),
+            ]
+        );
+        $this->assertCount(2, $documents);
+
+        $documents = $db->find(
+            '__users',
+            [
+                Query::join('__sessions', 'B',
+                    [
+                        Query::relationEqual('B', 'user_id', '', '$id'),
+                        Query::equal('user_id', [$user1->getId()], 'B'),
+                    ]
+                ),
+            ]
+        );
+        $this->assertCount(1, $documents);
+
+        /**
+         * Test alias does not exist
+         */
+        try {
+            $db->find(
+                '__sessions',
+                [
+                    Query::equal('user_id', ['bob'], 'alias_not_found')
+                ]
+            );
+            $this->fail('Failed to throw exception');
+        } catch (\Throwable $e) {
+            $this->assertTrue($e instanceof QueryException);
+            $this->assertEquals('Invalid query: Unknown Alias context', $e->getMessage());
+        }
+
+        /**
+         * Test Ambiguous alias
+         */
+        try {
+            $db->find(
+                '__users',
+                [
+                    Query::join('__sessions', Query::DEFAULT_ALIAS, []),
+                ]
+            );
+            $this->fail('Failed to throw exception');
+        } catch (\Throwable $e) {
+            $this->assertTrue($e instanceof QueryException);
+            $this->assertEquals('Ambiguous alias for collection "__sessions".', $e->getMessage());
+        }
+
+        /**
+         * Test relation query exist, but not on the join alias
+         */
+        try {
+            $db->find(
+                '__users',
+                [
+                    Query::join('__sessions', 'B',
+                        [
+                            Query::relationEqual('', '$id', '', '$id'),
+                        ]
+                    ),
+                ]
+            );
+            $this->fail('Failed to throw exception');
+        } catch (\Throwable $e) {
+            $this->assertTrue($e instanceof QueryException);
+            $this->assertEquals('Invalid query: At least one relation query is required on the joined collection.', $e->getMessage());
+        }
+
+        /**
+         * Test if relation query exists in the join queries list
+         */
+        try {
+            $db->find(
+                '__users',
+                [
+                    Query::join('__sessions', 'B', []),
+                ]
+            );
+            $this->fail('Failed to throw exception');
+        } catch (\Throwable $e) {
+            $this->assertTrue($e instanceof QueryException);
+            $this->assertEquals('Invalid query: At least one relation query is required on the joined collection.', $e->getMessage());
+        }
+
+        /**
+         * Test allow only filter queries in joins ON clause
+         */
+        try {
+            $db->find(
+                '__users',
+                [
+                    Query::join('__sessions', 'B', [
+                        Query::orderAsc()
+                    ]),
+                ]
+            );
+            $this->fail('Failed to throw exception');
+        } catch (\Throwable $e) {
+            $this->assertTrue($e instanceof QueryException);
+            $this->assertEquals('Invalid query: InnerJoin queries can only contain filter queries', $e->getMessage());
+        }
+
+        /**
+         * Test Relations are valid within joins
+         */
+        try {
+            $db->find(
+                '__users',
+                [
+                    Query::relationEqual('', '$id', '', '$sequence'),
+                ]
+            );
+            $this->fail('Failed to throw exception');
+        } catch (\Throwable $e) {
+            $this->assertTrue($e instanceof QueryException);
+            $this->assertEquals('Invalid query: Relations are only valid within joins.', $e->getMessage());
+        }
+
+        /**
+         * Test invalid alias name
+         */
+        try {
+            $alias = 'drop schema;';
+            $db->find(
+                '__users',
+                [
+                    Query::join('__sessions', $alias,
+                        [
+                            Query::relationEqual($alias, 'user_id', '', '$id'),
+                        ]
+                    ),
+                ]
+            );
+            $this->fail('Failed to throw exception');
+        } catch (\Throwable $e) {
+            $this->assertTrue($e instanceof QueryException);
+            $this->assertEquals('Query InnerJoin: Alias must contain at most 64 chars. Valid chars are a-z, A-Z, 0-9, and underscore.', $e->getMessage());
+        }
+
+        /**
+         * Test join same collection
+         */
+        $documents = $db->find(
+            '__users',
+            [
+                Query::join('__sessions', 'B',
+                    [
+                        Query::relationEqual('B', 'user_id', '', '$id'),
+                    ]
+                ),
+                Query::join('__sessions', 'C',
+                    [
+                        Query::relationEqual('C', 'user_id', 'B', 'user_id'),
+                    ]
+                ),
+            ]
+        );
+        $this->assertCount(2, $documents);
+
+        /**
+         * Test order by related collection
+         */
+        $documents = $db->find(
+            '__users',
+            [
+                Query::join('__sessions', 'B',
+                    [
+                        Query::relationEqual('B', 'user_id', '', '$id'),
+                    ]
+                ),
+                Query::orderAsc('$createdAt', 'B')
+            ]
+        );
+        $this->assertEquals('Donald', $documents[0]['username']);
+        $this->assertEquals('Abraham', $documents[1]['username']);
+
+        $documents = $db->find(
+            '__users',
+            [
+                Query::join('__sessions', 'B',
+                    [
+                        Query::relationEqual('B', 'user_id', '', '$id'),
+                    ]
+                ),
+                Query::orderDesc('$createdAt', 'B')
+            ]
+        );
+        $this->assertEquals('Abraham', $documents[0]['username']);
+        $this->assertEquals('Donald', $documents[1]['username']);
+
+        /**
+         * Select queries
+         */
+        $documents = $db->find(
+            '__users',
+            [
+                Query::select('*', 'main'),
+                Query::select('user_id', 'S'),
+                Query::select('float', 'S'),
+                Query::select('boolean', 'S'),
+                Query::join('__sessions', 'S',
+                    [
+                        Query::relationEqual('', '$id', 'S', 'user_id'),
+                        Query::greaterThan('float', 1.1, 'S'),
+                    ]
+                ),
+                Query::orderDesc('float', 'S'),
+            ]
+        );
+
+        $document = $documents[0];
+        var_dump($document);
+
+        /**
+         * Since we use main.* we should see all attributes
+         */
+        //$this->assertArrayHasKey('$id', $document);
+        $this->assertIsFloat($document->getAttribute('float'));
+        $this->assertEquals(10.5, $document->getAttribute('float'));
+
+        $this->assertIsBool($document->getAttribute('boolean'));
+        $this->assertEquals(false, $document->getAttribute('boolean'));
+        //$this->assertIsArray($document->getAttribute('colors'));
+        //$this->assertEquals(['pink', 'green', 'blue'], $document->getAttribute('colors'));
+
+        /**
+         * Test invalid as
+         */
+        try {
+            $db->find('__users', [
+                Query::select('$id', as: 'truncate schema;'),
+            ]);
+            $this->fail('Failed to throw exception');
+        } catch (\Throwable $e) {
+            $this->assertTrue($e instanceof QueryException);
+            $this->assertEquals('Invalid Query Select: "as" must contain at most 64 chars. Valid chars are a-z, A-Z, 0-9, and underscore.', $e->getMessage());
+        }
+
+        try {
+            $db->find('__users', [
+                Query::select('*', as: 'as'),
+            ]);
+            $this->fail('Failed to throw exception');
+        } catch (\Throwable $e) {
+            $this->assertTrue($e instanceof QueryException);
+            $this->assertEquals('Invalid Query Select: Invalid "as" on attribute "*"', $e->getMessage());
+        }
+
+
+        $document = $db->getDocument(
+            '__sessions',
+            $session2->getId()
+        );
+        var_dump($document);
+        $this->assertEquals('dsdsd', 'ds');
+
+        /**
+         * Simple `as` query getDocument
+         */
+        $document = $db->getDocument(
+            '__sessions',
+            $session2->getId(),
+            [
+                Query::select('$permissions', as: '___permissions'),
+                Query::select('$id', as: '___uid'),
+                Query::select('$sequence', as: '___id'),
+                Query::select('$createdAt', as: '___created'),
+                Query::select('user_id', as: 'user_id_as'),
+                Query::select('float', as: 'float_as'),
+                Query::select('boolean', as: 'boolean_as'),
+            ]
+        );
+
+        $this->assertArrayHasKey('$permissions', $document);
+        $this->assertArrayHasKey('___permissions', $document);
+        $this->assertArrayHasKey('___uid', $document);
+        $this->assertArrayNotHasKey('$id', $document);
+        $this->assertArrayHasKey('___id', $document);
+        $this->assertArrayNotHasKey('$sequence', $document);
+        $this->assertArrayHasKey('___created', $document);
+        $this->assertArrayNotHasKey('$createdAt', $document);
+        $this->assertArrayHasKey('user_id_as', $document);
+        $this->assertArrayNotHasKey('user_id', $document);
+        $this->assertArrayHasKey('float_as', $document);
+        $this->assertArrayNotHasKey('float', $document);
+        $this->assertIsFloat($document->getAttribute('float_as'));
+        $this->assertEquals(10.5, $document->getAttribute('float_as'));
+        $this->assertArrayHasKey('boolean_as', $document);
+        $this->assertArrayNotHasKey('boolean', $document);
+        $this->assertIsBool($document->getAttribute('boolean_as'));
+        $this->assertEquals(false, $document->getAttribute('boolean_as'));
+
+        /**
+         * Simple `as` query getDocument
+         */
+        $document = $db->getDocument(
+            '__sessions',
+            $session2->getId(),
+            [
+                Query::select('$permissions', as: '___permissions'),
+            ]
+        );
+
+        $this->assertArrayHasKey('$permissions', $document);
+        $this->assertArrayHasKey('$collection', $document);
+        $this->assertArrayHasKey('___permissions', $document);
+
+        /**
+         * Simple `as` query find
+         */
+        $document = $db->findOne(
+            '__sessions',
+            [
+                Query::select('$id', as: '___uid'),
+                Query::select('$sequence', as: '___id'),
+                Query::select('$createdAt', as: '___created'),
+                Query::select('user_id', as: 'user_id_as'),
+                Query::select('float', as: 'float_as'),
+                Query::select('boolean', as: 'boolean_as'),
+            ]
+        );
+
+        $this->assertArrayHasKey('___uid', $document);
+        $this->assertArrayNotHasKey('$id', $document);
+        $this->assertArrayHasKey('___id', $document);
+        $this->assertArrayNotHasKey('$sequence', $document);
+        $this->assertArrayHasKey('___created', $document);
+        $this->assertArrayNotHasKey('$createdAt', $document);
+        $this->assertArrayHasKey('user_id_as', $document);
+        $this->assertArrayNotHasKey('user_id', $document);
+        $this->assertArrayHasKey('float_as', $document);
+        $this->assertArrayNotHasKey('float', $document);
+        $this->assertIsFloat($document->getAttribute('float_as'));
+        $this->assertEquals(10.5, $document->getAttribute('float_as'));
+        $this->assertArrayHasKey('boolean_as', $document);
+        $this->assertArrayNotHasKey('boolean', $document);
+        $this->assertIsBool($document->getAttribute('boolean_as'));
+        $this->assertEquals(false, $document->getAttribute('boolean_as'));
+
+        /**
+         * Select queries
+         */
+        $document = $db->findOne(
+            '__users',
+            [
+                Query::select('username', '', as: 'as_username'),
+                Query::select('user_id', 'S', as: 'as_user_id'),
+                Query::select('float', 'S', as: 'as_float'),
+                Query::select('boolean', 'S', as: 'as_boolean'),
+                Query::select('$permissions', 'S', as: 'as_permissions'),
+                Query::join('__sessions', 'S',
+                    [
+                        Query::relationEqual('', '$id', 'S', 'user_id'),
+                    ]
+                )
+            ]
+        );
+
+        $this->assertArrayHasKey('as_username', $document);
+        $this->assertArrayHasKey('as_user_id', $document);
+        $this->assertArrayHasKey('as_float', $document);
+        $this->assertArrayHasKey('as_boolean', $document);
+        $this->assertArrayHasKey('as_permissions', $document);
+        $this->assertIsArray($document->getAttribute('as_permissions'));
+
+
+
+//        /**
+//         * ambiguous and duplications selects
+//         */
+//        try {
+//            $db->find(
+//                '__users',
+//                [
+//                    Query::select('$id', 'main'),
+//                    Query::select('$id', 'S'),
+//                    Query::join('__sessions', 'S',
+//                        [
+//                            Query::relationEqual('', '$id', 'S', 'user_id'),
+//                        ]
+//                    )
+//                ]
+//            );
+//            $this->fail('Failed to throw exception');
+//        } catch (\Throwable $e) {
+//            $this->assertTrue($e instanceof QueryException);
+//            $this->assertEquals('Invalid Query Select: ambiguous column "$id"', $e->getMessage());
+//        }
+//
+//        try {
+//            $db->find(
+//                '__users',
+//                [
+//                    Query::select('*', 'main'),
+//                    Query::select('*', 'S'),
+//                    Query::join('__sessions', 'S',
+//                        [
+//                            Query::relationEqual('', '$id', 'S', 'user_id'),
+//                        ]
+//                    )
+//                ]
+//            );
+//            $this->fail('Failed to throw exception');
+//        } catch (\Throwable $e) {
+//            $this->assertTrue($e instanceof QueryException);
+//            $this->assertEquals('Invalid Query Select: ambiguous column "*"', $e->getMessage());
+//        }
+//
+//        try {
+//            $db->find('__users',
+//                [
+//                    Query::select('$id'),
+//                    Query::select('$id'),
+//                ]
+//            );
+//            $this->fail('Failed to throw exception');
+//        } catch (\Throwable $e) {
+//            $this->assertTrue($e instanceof QueryException);
+//            $this->assertEquals('Duplicate Query Select on "main.$id"', $e->getMessage());
+//        }
+//
+//        /**
+//         * This should fail? since 2 _uid attributes will be returned?
+//         */
+//        try {
+//            $db->find(
+//                '__users',
+//                [
+//                    Query::select('*', 'main'),
+//                    Query::select('$id', 'S'),
+//                    Query::join('__sessions', 'S',
+//                        [
+//                            Query::relationEqual('', '$id', 'S', 'user_id'),
+//                        ]
+//                    )
+//                ]
+//            );
+//            $this->fail('Failed to throw exception');
+//        } catch (\Throwable $e) {
+//            $this->assertTrue($e instanceof QueryException);
+//            $this->assertEquals('Invalid Query Select: ambiguous column "$id"', $e->getMessage());
+//        }
+    }
+}
diff --git a/tests/e2e/Adapter/Scopes/RelationshipTests.php b/tests/e2e/Adapter/Scopes/RelationshipTests.php
index 9e6077b35..df69f209f 100644
--- a/tests/e2e/Adapter/Scopes/RelationshipTests.php
+++ b/tests/e2e/Adapter/Scopes/RelationshipTests.php
@@ -320,10 +320,8 @@ public function testZoo(): void
         $this->assertEquals(0, count($president['votes']));
 
         $president = $database->findOne('presidents', [
-            Query::select([
-                '*',
-                'votes.*',
-            ]),
+            Query::select('*'),
+            Query::select('votes.*'),
             Query::equal('$id', ['trump'])
         ]);
 
@@ -333,11 +331,9 @@ public function testZoo(): void
         $this->assertArrayNotHasKey('animals', $president['votes'][0]); // Not exist
 
         $president = $database->findOne('presidents', [
-            Query::select([
-                '*',
-                'votes.*',
-                'votes.animals.*',
-            ]),
+            Query::select('*'),
+            Query::select('votes.*'),
+            Query::select('votes.animals.*'),
             Query::equal('$id', ['trump'])
         ]);
 
@@ -350,7 +346,7 @@ public function testZoo(): void
          * Check Selects queries
          */
         $veterinarian = $database->findOne('veterinarians', [
-            Query::select(['*']), // No resolving
+            Query::select('*'), // No resolving
             Query::equal('$id', ['dr.pol']),
         ]);
 
@@ -361,9 +357,7 @@ public function testZoo(): void
         $veterinarian = $database->findOne(
             'veterinarians',
             [
-                Query::select([
-                    'animals.*',
-                ])
+                Query::select('animals.*')
             ]
         );
 
@@ -381,11 +375,9 @@ public function testZoo(): void
         $veterinarian = $database->findOne(
             'veterinarians',
             [
-                Query::select([
-                    'animals.*',
-                    'animals.zoo.*',
-                    'animals.president.*',
-                ])
+                Query::select('animals.*'),
+                Query::select('animals.zoo.*'),
+                Query::select('animals.president.*'),
             ]
         );
 
@@ -1347,7 +1339,8 @@ public function testSelectRelationshipAttributes(): void
 
         // Select some parent attributes, some child attributes
         $make = $database->findOne('make', [
-            Query::select(['name', 'models.name']),
+            Query::select('name'),
+            Query::select('models.name'),
         ]);
 
         if ($make->isEmpty()) {
@@ -1360,16 +1353,17 @@ public function testSelectRelationshipAttributes(): void
         $this->assertEquals('Focus', $make['models'][1]['name']);
         $this->assertArrayNotHasKey('year', $make['models'][0]);
         $this->assertArrayNotHasKey('year', $make['models'][1]);
-        $this->assertArrayHasKey('$id', $make);
-        $this->assertArrayHasKey('$sequence', $make);
-        $this->assertArrayHasKey('$permissions', $make);
+        $this->assertArrayHasKey('$id', $make); // Was added by system in processRelationshipQueries
+        $this->assertArrayNotHasKey('$sequence', $make);
+        $this->assertArrayNotHasKey('$permissions', $make);
         $this->assertArrayHasKey('$collection', $make);
-        $this->assertArrayHasKey('$createdAt', $make);
-        $this->assertArrayHasKey('$updatedAt', $make);
+        $this->assertArrayNotHasKey('$createdAt', $make);
+        $this->assertArrayNotHasKey('$updatedAt', $make);
 
         // Select internal attributes
         $make = $database->findOne('make', [
-            Query::select(['name', '$id']),
+            Query::select('name'),
+            Query::select('$id'),
         ]);
 
         if ($make->isEmpty()) {
@@ -1378,14 +1372,15 @@ public function testSelectRelationshipAttributes(): void
 
         $this->assertArrayHasKey('name', $make);
         $this->assertArrayHasKey('$id', $make);
-        $this->assertArrayHasKey('$sequence', $make);
+        $this->assertArrayNotHasKey('$sequence', $make);
         $this->assertArrayHasKey('$collection', $make);
-        $this->assertArrayHasKey('$createdAt', $make);
-        $this->assertArrayHasKey('$updatedAt', $make);
-        $this->assertArrayHasKey('$permissions', $make);
+        $this->assertArrayNotHasKey('$createdAt', $make);
+        $this->assertArrayNotHasKey('$updatedAt', $make);
+        $this->assertArrayNotHasKey('$permissions', $make);
 
         $make = $database->findOne('make', [
-            Query::select(['name', '$sequence']),
+            Query::select('name'),
+            Query::select('$sequence'),
         ]);
 
         if ($make->isEmpty()) {
@@ -1396,12 +1391,13 @@ public function testSelectRelationshipAttributes(): void
         $this->assertArrayHasKey('$id', $make);
         $this->assertArrayHasKey('$sequence', $make);
         $this->assertArrayHasKey('$collection', $make);
-        $this->assertArrayHasKey('$createdAt', $make);
-        $this->assertArrayHasKey('$updatedAt', $make);
-        $this->assertArrayHasKey('$permissions', $make);
+        $this->assertArrayNotHasKey('$createdAt', $make);
+        $this->assertArrayNotHasKey('$updatedAt', $make);
+        $this->assertArrayNotHasKey('$permissions', $make);
 
         $make = $database->findOne('make', [
-            Query::select(['name', '$collection']),
+            Query::select('name'),
+            Query::select('$collection'),
         ]);
 
         if ($make->isEmpty()) {
@@ -1410,14 +1406,15 @@ public function testSelectRelationshipAttributes(): void
 
         $this->assertArrayHasKey('name', $make);
         $this->assertArrayHasKey('$id', $make);
-        $this->assertArrayHasKey('$sequence', $make);
+        $this->assertArrayNotHasKey('$sequence', $make);
         $this->assertArrayHasKey('$collection', $make);
-        $this->assertArrayHasKey('$createdAt', $make);
-        $this->assertArrayHasKey('$updatedAt', $make);
-        $this->assertArrayHasKey('$permissions', $make);
+        $this->assertArrayNotHasKey('$createdAt', $make);
+        $this->assertArrayNotHasKey('$updatedAt', $make);
+        $this->assertArrayNotHasKey('$permissions', $make);
 
         $make = $database->findOne('make', [
-            Query::select(['name', '$createdAt']),
+            Query::select('name'),
+            Query::select('$createdAt'),
         ]);
 
         if ($make->isEmpty()) {
@@ -1426,14 +1423,15 @@ public function testSelectRelationshipAttributes(): void
 
         $this->assertArrayHasKey('name', $make);
         $this->assertArrayHasKey('$id', $make);
-        $this->assertArrayHasKey('$sequence', $make);
+        $this->assertArrayNotHasKey('$sequence', $make);
         $this->assertArrayHasKey('$collection', $make);
         $this->assertArrayHasKey('$createdAt', $make);
-        $this->assertArrayHasKey('$updatedAt', $make);
-        $this->assertArrayHasKey('$permissions', $make);
+        $this->assertArrayNotHasKey('$updatedAt', $make);
+        $this->assertArrayNotHasKey('$permissions', $make);
 
         $make = $database->findOne('make', [
-            Query::select(['name', '$updatedAt']),
+            Query::select('name'),
+            Query::select('$updatedAt'),
         ]);
 
         if ($make->isEmpty()) {
@@ -1442,14 +1440,15 @@ public function testSelectRelationshipAttributes(): void
 
         $this->assertArrayHasKey('name', $make);
         $this->assertArrayHasKey('$id', $make);
-        $this->assertArrayHasKey('$sequence', $make);
+        $this->assertArrayNotHasKey('$sequence', $make);
         $this->assertArrayHasKey('$collection', $make);
-        $this->assertArrayHasKey('$createdAt', $make);
+        $this->assertArrayNotHasKey('$createdAt', $make);
         $this->assertArrayHasKey('$updatedAt', $make);
-        $this->assertArrayHasKey('$permissions', $make);
+        $this->assertArrayNotHasKey('$permissions', $make);
 
         $make = $database->findOne('make', [
-            Query::select(['name', '$permissions']),
+            Query::select('name'),
+            Query::select('$permissions'),
         ]);
 
         if ($make->isEmpty()) {
@@ -1458,15 +1457,16 @@ public function testSelectRelationshipAttributes(): void
 
         $this->assertArrayHasKey('name', $make);
         $this->assertArrayHasKey('$id', $make);
-        $this->assertArrayHasKey('$sequence', $make);
+        $this->assertArrayNotHasKey('$sequence', $make);
         $this->assertArrayHasKey('$collection', $make);
-        $this->assertArrayHasKey('$createdAt', $make);
-        $this->assertArrayHasKey('$updatedAt', $make);
+        $this->assertArrayNotHasKey('$createdAt', $make);
+        $this->assertArrayNotHasKey('$updatedAt', $make);
         $this->assertArrayHasKey('$permissions', $make);
 
         // Select all parent attributes, some child attributes
         $make = $database->findOne('make', [
-            Query::select(['*', 'models.year']),
+            Query::select('*'),
+            Query::select('models.year'),
         ]);
 
         if ($make->isEmpty()) {
@@ -1474,6 +1474,8 @@ public function testSelectRelationshipAttributes(): void
         }
 
         $this->assertEquals('Ford', $make['name']);
+        $this->assertEquals('USA', $make['origin']);
+        $this->assertArrayHasKey('$createdAt', $make);
         $this->assertEquals(2, \count($make['models']));
         $this->assertArrayNotHasKey('name', $make['models'][0]);
         $this->assertArrayNotHasKey('name', $make['models'][1]);
@@ -1482,7 +1484,8 @@ public function testSelectRelationshipAttributes(): void
 
         // Select all parent attributes, all child attributes
         $make = $database->findOne('make', [
-            Query::select(['*', 'models.*']),
+            Query::select('*'),
+            Query::select('models.*'),
         ]);
 
         if ($make->isEmpty()) {
@@ -1490,6 +1493,29 @@ public function testSelectRelationshipAttributes(): void
         }
 
         $this->assertEquals('Ford', $make['name']);
+        $this->assertEquals('USA', $make['origin']);
+        $this->assertArrayHasKey('$createdAt', $make);
+        $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 queries only on nested will Select all parent attributes as well.
+         * In getDocument we add $permissions by system, check we add it after processRelationshipQueries
+         */
+        $make = $database->getDocument('make', 'ford', [
+            Query::select('models.*'),
+        ]);
+var_dump($make);
+        if ($make->isEmpty()) {
+            throw new Exception('Make not found');
+        }
+
+        $this->assertEquals('Ford', $make['name']);
+        $this->assertEquals('USA', $make['origin']);
+        $this->assertArrayHasKey('$createdAt', $make);
         $this->assertEquals(2, \count($make['models']));
         $this->assertEquals('Fiesta', $make['models'][0]['name']);
         $this->assertEquals('Focus', $make['models'][1]['name']);
@@ -1499,7 +1525,7 @@ public function testSelectRelationshipAttributes(): void
         // Select all parent attributes, all child attributes
         // Must select parent if selecting children
         $make = $database->findOne('make', [
-            Query::select(['models.*']),
+            Query::select('models.*'),
         ]);
 
         if ($make->isEmpty()) {
@@ -1507,6 +1533,8 @@ public function testSelectRelationshipAttributes(): void
         }
 
         $this->assertEquals('Ford', $make['name']);
+        $this->assertEquals('USA', $make['origin']);
+        $this->assertArrayHasKey('$createdAt', $make);
         $this->assertEquals(2, \count($make['models']));
         $this->assertEquals('Fiesta', $make['models'][0]['name']);
         $this->assertEquals('Focus', $make['models'][1]['name']);
@@ -1515,7 +1543,7 @@ public function testSelectRelationshipAttributes(): void
 
         // Select all parent attributes, no child attributes
         $make = $database->findOne('make', [
-            Query::select(['name']),
+            Query::select('name'),
         ]);
 
         if ($make->isEmpty()) {
@@ -1526,7 +1554,8 @@ public function testSelectRelationshipAttributes(): void
 
         // Select some parent attributes, all child attributes
         $make = $database->findOne('make', [
-            Query::select(['name', 'models.*']),
+            Query::select('name'),
+            Query::select('models.*'),
         ]);
 
         $this->assertEquals('Ford', $make['name']);
@@ -1538,7 +1567,8 @@ public function testSelectRelationshipAttributes(): void
 
         // Select some parent attributes, some child attributes
         $model = $database->findOne('model', [
-            Query::select(['name', 'make.name']),
+            Query::select('name'),
+            Query::select('make.name'),
         ]);
 
         $this->assertEquals('Fiesta', $model['name']);
@@ -1549,7 +1579,8 @@ public function testSelectRelationshipAttributes(): void
 
         // Select all parent attributes, some child attributes
         $model = $database->findOne('model', [
-            Query::select(['*', 'make.name']),
+            Query::select('*'),
+            Query::select('make.name'),
         ]);
 
         $this->assertEquals('Fiesta', $model['name']);
@@ -1558,7 +1589,8 @@ public function testSelectRelationshipAttributes(): void
 
         // Select all parent attributes, all child attributes
         $model = $database->findOne('model', [
-            Query::select(['*', 'make.*']),
+            Query::select('*'),
+            Query::select('make.*'),
         ]);
 
         $this->assertEquals('Fiesta', $model['name']);
@@ -1568,7 +1600,7 @@ public function testSelectRelationshipAttributes(): void
 
         // Select all parent attributes, no child attributes
         $model = $database->findOne('model', [
-            Query::select(['*']),
+            Query::select('*'),
         ]);
 
         $this->assertEquals('Fiesta', $model['name']);
@@ -1577,7 +1609,8 @@ public function testSelectRelationshipAttributes(): void
 
         // Select some parent attributes, all child attributes
         $model = $database->findOne('model', [
-            Query::select(['name', 'make.*']),
+            Query::select('name'),
+            Query::select('make.*'),
         ]);
 
         $this->assertEquals('Fiesta', $model['name']);
diff --git a/tests/e2e/Adapter/Scopes/Relationships/ManyToManyTests.php b/tests/e2e/Adapter/Scopes/Relationships/ManyToManyTests.php
index 90d5dcad0..4484a8235 100644
--- a/tests/e2e/Adapter/Scopes/Relationships/ManyToManyTests.php
+++ b/tests/e2e/Adapter/Scopes/Relationships/ManyToManyTests.php
@@ -108,8 +108,8 @@ public function testManyToManyOneWayRelationship(): void
         // Assert document does not contain non existing relation document.
         $this->assertEquals(1, \count($playlist1Document->getAttribute('songs')));
 
-        $documents = $database->find('playlist', [
-            Query::select(['name']),
+        $documents = static::getDatabase()->find('playlist', [
+            Query::select('name'),
             Query::limit(1)
         ]);
 
@@ -139,18 +139,20 @@ public function testManyToManyOneWayRelationship(): void
 
         // Select related document attributes
         $playlist = $database->findOne('playlist', [
-            Query::select(['*', 'songs.name'])
+            Query::select('*'),
+            Query::select('songs.name')
         ]);
 
         if ($playlist->isEmpty()) {
             throw new Exception('Playlist not found');
         }
-
+var_dump($playlist);
         $this->assertEquals('Song 1', $playlist->getAttribute('songs')[0]->getAttribute('name'));
         $this->assertArrayNotHasKey('length', $playlist->getAttribute('songs')[0]);
 
         $playlist = $database->getDocument('playlist', 'playlist1', [
-            Query::select(['*', 'songs.name'])
+            Query::select('*'),
+            Query::select('songs.name')
         ]);
 
         $this->assertEquals('Song 1', $playlist->getAttribute('songs')[0]->getAttribute('name'));
@@ -524,7 +526,8 @@ public function testManyToManyTwoWayRelationship(): void
 
         // Select related document attributes
         $student = $database->findOne('students', [
-            Query::select(['*', 'classes.name'])
+            Query::select('*'),
+            Query::select('classes.name')
         ]);
 
         if ($student->isEmpty()) {
@@ -535,7 +538,8 @@ public function testManyToManyTwoWayRelationship(): void
         $this->assertArrayNotHasKey('number', $student->getAttribute('classes')[0]);
 
         $student = $database->getDocument('students', 'student1', [
-            Query::select(['*', 'classes.name'])
+            Query::select('*'),
+            Query::select('classes.name')
         ]);
 
         $this->assertEquals('Class 1', $student->getAttribute('classes')[0]->getAttribute('name'));
@@ -1581,7 +1585,8 @@ public function testSelectManyToMany(): void
 
         // Use select query to get only name of the related documents
         $docs = $database->find('select_m2m_collection1', [
-            Query::select(['name', 'select_m2m_collection2.name']),
+            Query::select('name'),
+            Query::select('select_m2m_collection2.name'),
         ]);
 
         $this->assertCount(1, $docs);
@@ -1685,7 +1690,9 @@ public function testSelectAcrossMultipleCollections(): void
 
         // Query with nested select
         $artists = $database->find('artists', [
-            Query::select(['name', 'albums.name', 'albums.tracks.title'])
+            Query::select('name'),
+            Query::select('albums.name'),
+            Query::select('albums.tracks.title')
         ]);
 
         $this->assertCount(1, $artists);
diff --git a/tests/e2e/Adapter/Scopes/Relationships/ManyToOneTests.php b/tests/e2e/Adapter/Scopes/Relationships/ManyToOneTests.php
index 73a1c7a6f..5d3fee5bb 100644
--- a/tests/e2e/Adapter/Scopes/Relationships/ManyToOneTests.php
+++ b/tests/e2e/Adapter/Scopes/Relationships/ManyToOneTests.php
@@ -145,7 +145,8 @@ public function testManyToOneOneWayRelationship(): void
         $this->assertArrayNotHasKey('reviews', $movie);
 
         $documents = $database->find('review', [
-            Query::select(['date', 'movie.date'])
+            Query::select('date'),
+            Query::select('movie.date')
         ]);
 
         $this->assertCount(3, $documents);
@@ -176,7 +177,8 @@ public function testManyToOneOneWayRelationship(): void
 
         // Select related document attributes
         $review = $database->findOne('review', [
-            Query::select(['*', 'movie.name'])
+            Query::select('*'),
+            Query::select('movie.name')
         ]);
 
         if ($review->isEmpty()) {
@@ -187,7 +189,8 @@ public function testManyToOneOneWayRelationship(): void
         $this->assertArrayNotHasKey('length', $review->getAttribute('movie'));
 
         $review = $database->getDocument('review', 'review1', [
-            Query::select(['*', 'movie.name'])
+            Query::select('*'),
+            Query::select('movie.name')
         ]);
 
         $this->assertEquals('Movie 1', $review->getAttribute('movie')->getAttribute('name'));
@@ -556,7 +559,8 @@ public function testManyToOneTwoWayRelationship(): void
 
         // Select related document attributes
         $product = $database->findOne('product', [
-            Query::select(['*', 'store.name'])
+            Query::select('*'),
+            Query::select('store.name')
         ]);
 
         if ($product->isEmpty()) {
@@ -567,7 +571,8 @@ public function testManyToOneTwoWayRelationship(): void
         $this->assertArrayNotHasKey('opensAt', $product->getAttribute('store'));
 
         $product = $database->getDocument('product', 'product1', [
-            Query::select(['*', 'store.name'])
+            Query::select('*'),
+            Query::select('store.name')
         ]);
 
         $this->assertEquals('Store 1', $product->getAttribute('store')->getAttribute('name'));
diff --git a/tests/e2e/Adapter/Scopes/Relationships/OneToManyTests.php b/tests/e2e/Adapter/Scopes/Relationships/OneToManyTests.php
index b29bf2087..75b13a950 100644
--- a/tests/e2e/Adapter/Scopes/Relationships/OneToManyTests.php
+++ b/tests/e2e/Adapter/Scopes/Relationships/OneToManyTests.php
@@ -117,7 +117,7 @@ public function testOneToManyOneWayRelationship(): void
         ]));
 
         $documents = $database->find('artist', [
-            Query::select(['name']),
+            Query::select('name'),
             Query::limit(1)
         ]);
         $this->assertArrayNotHasKey('albums', $documents[0]);
@@ -148,7 +148,8 @@ public function testOneToManyOneWayRelationship(): void
 
         // Select related document attributes
         $artist = $database->findOne('artist', [
-            Query::select(['*', 'albums.name'])
+            Query::select('*'),
+            Query::select('albums.name')
         ]);
 
         if ($artist->isEmpty()) {
@@ -159,7 +160,8 @@ public function testOneToManyOneWayRelationship(): void
         $this->assertArrayNotHasKey('price', $artist->getAttribute('albums')[0]);
 
         $artist = $database->getDocument('artist', 'artist1', [
-            Query::select(['*', 'albums.name'])
+            Query::select('*'),
+            Query::select('albums.name')
         ]);
 
         $this->assertEquals('Album 1', $artist->getAttribute('albums')[0]->getAttribute('name'));
@@ -584,7 +586,8 @@ public function testOneToManyTwoWayRelationship(): void
 
         // Select related document attributes
         $customer = $database->findOne('customer', [
-            Query::select(['*', 'accounts.name'])
+            Query::select('*'),
+            Query::select('accounts.name')
         ]);
 
         if ($customer->isEmpty()) {
@@ -595,7 +598,8 @@ public function testOneToManyTwoWayRelationship(): void
         $this->assertArrayNotHasKey('number', $customer->getAttribute('accounts')[0]);
 
         $customer = $database->getDocument('customer', 'customer1', [
-            Query::select(['*', 'accounts.name'])
+            Query::select('*'),
+            Query::select('accounts.name')
         ]);
 
         $this->assertEquals('Account 1', $customer->getAttribute('accounts')[0]->getAttribute('name'));
@@ -918,21 +922,23 @@ public function testNestedOneToMany_OneToOneRelationship(): void
         $this->assertEquals('Mayor 1', $documents[0]['cities'][0]['mayor']['name']);
 
         $documents = $database->find('countries', [
-            Query::select(['name']),
+            Query::select('name'),
             Query::limit(1)
         ]);
         $this->assertArrayHasKey('name', $documents[0]);
         $this->assertArrayNotHasKey('cities', $documents[0]);
 
         $documents = $database->find('countries', [
-            Query::select(['*']),
+            Query::select('*'),
             Query::limit(1)
         ]);
         $this->assertArrayHasKey('name', $documents[0]);
         $this->assertArrayNotHasKey('cities', $documents[0]);
 
         $documents = $database->find('countries', [
-            Query::select(['*', 'cities.*', 'cities.mayor.*']),
+            Query::select('*'),
+            Query::select('cities.*'),
+            Query::select('cities.mayor.*'),
             Query::limit(1)
         ]);
 
diff --git a/tests/e2e/Adapter/Scopes/Relationships/OneToOneTests.php b/tests/e2e/Adapter/Scopes/Relationships/OneToOneTests.php
index 52881707b..7849a40d9 100644
--- a/tests/e2e/Adapter/Scopes/Relationships/OneToOneTests.php
+++ b/tests/e2e/Adapter/Scopes/Relationships/OneToOneTests.php
@@ -169,7 +169,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,7 +179,8 @@ public function testOneToOneOneWayRelationship(): void
 
         // Select related document attributes
         $person = $database->findOne('person', [
-            Query::select(['*', 'library.name'])
+            Query::select('*'),
+            Query::select('library.name')
         ]);
 
         if ($person->isEmpty()) {
@@ -190,7 +191,9 @@ public function testOneToOneOneWayRelationship(): void
         $this->assertArrayNotHasKey('area', $person->getAttribute('library'));
 
         $person = $database->getDocument('person', 'person1', [
-            Query::select(['*', 'library.name', '$id'])
+            Query::select('*'),
+            Query::select('library.name'),
+            Query::select('$id')
         ]);
 
         $this->assertEquals('Library 1', $person->getAttribute('library')->getAttribute('name'));
@@ -199,18 +202,18 @@ public function testOneToOneOneWayRelationship(): void
 
 
         $document = $database->getDocument('person', $person->getId(), [
-            Query::select(['name']),
+            Query::select('name'),
         ]);
         $this->assertArrayNotHasKey('library', $document);
         $this->assertEquals('Person 1', $document['name']);
 
         $document = $database->getDocument('person', $person->getId(), [
-            Query::select(['*']),
+            Query::select('*'),
         ]);
         $this->assertEquals('library1', $document['library']);
 
         $document = $database->getDocument('person', $person->getId(), [
-            Query::select(['library.*']),
+            Query::select('library.*'),
         ]);
         $this->assertEquals('Library 1', $document['library']['name']);
         $this->assertArrayNotHasKey('name', $document);
@@ -658,7 +661,8 @@ public function testOneToOneTwoWayRelationship(): void
 
         // Select related document attributes
         $country = $database->findOne('country', [
-            Query::select(['*', 'city.name'])
+            Query::select('*'),
+            Query::select('city.name')
         ]);
 
         if ($country->isEmpty()) {
@@ -669,7 +673,8 @@ public function testOneToOneTwoWayRelationship(): void
         $this->assertArrayNotHasKey('code', $country->getAttribute('city'));
 
         $country = $database->getDocument('country', 'country1', [
-            Query::select(['*', 'city.name'])
+            Query::select('*'),
+            Query::select('city.name')
         ]);
 
         $this->assertEquals('London', $country->getAttribute('city')->getAttribute('name'));
diff --git a/tests/e2e/Adapter/Scopes/SpatialTests.php b/tests/e2e/Adapter/Scopes/SpatialTests.php
index 63f1b3c49..0ad52dc34 100644
--- a/tests/e2e/Adapter/Scopes/SpatialTests.php
+++ b/tests/e2e/Adapter/Scopes/SpatialTests.php
@@ -138,6 +138,22 @@ public function testSpatialTypeDocuments(): void
                 'notIntersects' => Query::notIntersects('pointAttr', [[1.0, 1.0]])
             ];
 
+            $result = $database->find($collectionName);
+
+            function decodePoint(string $wkb): array {
+                // WKB format: 1-byte byte order + 4-byte type + 8-byte X + 8-byte Y
+                // Skip first 5 bytes (1 byte byte order + 4 bytes type)
+                $coords = unpack('dX/dY', substr($wkb, 5, 16));
+                return ['lon' => $coords['X'], 'lat' => $coords['Y']];
+            }
+
+// Example usage:
+            $pointBinary = "\000\000\000\000\000\000\000\000\000\000\000\000\000@\000\000\000\000\000\000@";
+            $coords = decodePoint($pointBinary);
+            print_r($coords);
+
+            var_dump($result);
+            $this->assertEquals(999,888);
             foreach ($pointQueries as $queryType => $query) {
                 $result = $database->find($collectionName, [$query], Database::PERMISSION_READ);
                 $this->assertNotEmpty($result, sprintf('Failed spatial query: %s on pointAttr', $queryType));
diff --git a/tests/unit/QueryTest.php b/tests/unit/QueryTest.php
index 3084abaa0..1e18ac1a3 100644
--- a/tests/unit/QueryTest.php
+++ b/tests/unit/QueryTest.php
@@ -19,19 +19,21 @@ public function tearDown(): void
 
     public function testCreate(): void
     {
-        $query = new Query(Query::TYPE_EQUAL, 'title', ['Iron Man']);
+        $query = Query::equal('title', ['Iron Man'], 'users');
 
         $this->assertEquals(Query::TYPE_EQUAL, $query->getMethod());
         $this->assertEquals('title', $query->getAttribute());
         $this->assertEquals('Iron Man', $query->getValues()[0]);
+        $this->assertEquals('users', $query->getAlias());
 
-        $query = new Query(Query::TYPE_ORDER_DESC, 'score');
+        $query = Query::orderDesc('score', 'users');
 
         $this->assertEquals(Query::TYPE_ORDER_DESC, $query->getMethod());
         $this->assertEquals('score', $query->getAttribute());
         $this->assertEquals([], $query->getValues());
+        $this->assertEquals('users', $query->getAlias());
 
-        $query = new Query(Query::TYPE_LIMIT, values: [10]);
+        $query = Query::limit(10);
 
         $this->assertEquals(Query::TYPE_LIMIT, $query->getMethod());
         $this->assertEquals('', $query->getAttribute());
@@ -144,7 +146,6 @@ public function testCreate(): void
     }
 
     /**
-     * @return void
      * @throws QueryException
      */
     public function testParse(): void
@@ -245,10 +246,12 @@ public function testParse(): void
         $this->assertEquals('director', $query->getAttribute());
         $this->assertEquals(['Tarantino'], $query->getValues());
 
-        $query = Query::parse(Query::select(['title', 'director'])->toString());
+        $query = Query::parse(Query::select('title', alias: 'alias', as: 'as')->toString());
         $this->assertEquals('select', $query->getMethod());
-        $this->assertEquals(null, $query->getAttribute());
-        $this->assertEquals(['title', 'director'], $query->getValues());
+        $this->assertEquals('title', $query->getAttribute());
+        $this->assertEquals('alias', $query->getAlias());
+        $this->assertEquals('as', $query->getAs());
+        //$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());
@@ -303,7 +306,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);
@@ -416,4 +419,42 @@ public function testNewQueryTypesInTypesArray(): void
         $this->assertContains(Query::TYPE_NOT_ENDS_WITH, Query::TYPES);
         $this->assertContains(Query::TYPE_NOT_BETWEEN, Query::TYPES);
     }
+
+
+    /**
+     * @throws QueryException
+     */
+    public function testJoins(): void
+    {
+        $query =
+            Query::join(
+                'users',
+                'u',
+                [
+                    Query::relationEqual('', 'id', 'u', 'user_id'),
+                    Query::equal('id', ['usa'], 'u'),
+                ]
+            );
+
+        $this->assertEquals(Query::TYPE_INNER_JOIN, $query->getMethod());
+        $this->assertEquals('users', $query->getCollection());
+        $this->assertEquals('u', $query->getAlias());
+        $this->assertCount(2, $query->getValues());
+
+        /** @var Query $query0 */
+        $query0 = $query->getValues()[0];
+        $this->assertEquals(Query::TYPE_RELATION_EQUAL, $query0->getMethod());
+        $this->assertEquals(Query::DEFAULT_ALIAS, $query0->getAlias());
+        $this->assertEquals('id', $query0->getAttribute());
+        $this->assertEquals('u', $query0->getRightAlias());
+        $this->assertEquals('user_id', $query0->getAttributeRight());
+
+        /** @var Query $query1 */
+        $query1 = $query->getValues()[1];
+        $this->assertEquals(Query::TYPE_EQUAL, $query1->getMethod());
+        $this->assertEquals('u', $query1->getAlias());
+        $this->assertEquals('id', $query1->getAttribute());
+        $this->assertEquals(Query::DEFAULT_ALIAS, $query1->getRightAlias());
+        $this->assertEquals('', $query1->getAttributeRight());
+    }
 }
diff --git a/tests/unit/Validator/DocumentQueriesTest.php b/tests/unit/Validator/DocumentQueriesTest.php
index 558d0b455..b8ac467b5 100644
--- a/tests/unit/Validator/DocumentQueriesTest.php
+++ b/tests/unit/Validator/DocumentQueriesTest.php
@@ -8,21 +8,19 @@
 use Utopia\Database\Document;
 use Utopia\Database\Helpers\ID;
 use Utopia\Database\Query;
-use Utopia\Database\Validator\Queries\Document as DocumentQueries;
+use Utopia\Database\QueryContext;
+use Utopia\Database\Validator\Queries\V2 as DocumentsValidator;
 
 class DocumentQueriesTest extends TestCase
 {
-    /**
-     * @var array<string, mixed>
-     */
-    protected array $collection = [];
+    protected QueryContext $context;
 
     /**
      * @throws Exception
      */
     public function setUp(): void
     {
-        $this->collection = [
+        $collection = [
             '$collection' => ID::custom(Database::METADATA),
             '$id' => ID::custom('movies'),
             'name' => 'movies',
@@ -49,6 +47,13 @@ public function setUp(): void
                 ])
             ]
         ];
+
+        $collection = new Document($collection);
+
+        $context = new QueryContext();
+        $context->add($collection);
+
+        $this->context = $context;
     }
 
     public function tearDown(): void
@@ -60,15 +65,15 @@ public function tearDown(): void
      */
     public function testValidQueries(): void
     {
-        $validator = new DocumentQueries($this->collection['attributes']);
+        $validator = new DocumentsValidator($this->context);
 
         $queries = [
-            Query::select(['title']),
+            Query::select('title'),
         ];
 
         $this->assertEquals(true, $validator->isValid($queries));
 
-        $queries[] = Query::select(['price.relation']);
+        $queries[] = Query::select('price.relation');
         $this->assertEquals(true, $validator->isValid($queries));
     }
 
@@ -77,8 +82,16 @@ public function testValidQueries(): void
      */
     public function testInvalidQueries(): void
     {
-        $validator = new DocumentQueries($this->collection['attributes']);
-        $queries = [Query::limit(1)];
-        $this->assertEquals(false, $validator->isValid($queries));
+        $validator = new DocumentsValidator($this->context);
+
+        $queries = [
+            Query::limit(1)
+        ];
+
+        /**
+         * Think what to do about this?
+         */
+        //$this->assertEquals(false, $validator->isValid($queries));
+        $this->assertEquals(true, $validator->isValid($queries));
     }
 }
diff --git a/tests/unit/Validator/DocumentsQueriesTest.php b/tests/unit/Validator/DocumentsQueriesTest.php
index 6530ad299..3469107cb 100644
--- a/tests/unit/Validator/DocumentsQueriesTest.php
+++ b/tests/unit/Validator/DocumentsQueriesTest.php
@@ -8,21 +8,19 @@
 use Utopia\Database\Document;
 use Utopia\Database\Helpers\ID;
 use Utopia\Database\Query;
-use Utopia\Database\Validator\Queries\Documents;
+use Utopia\Database\QueryContext;
+use Utopia\Database\Validator\Queries\V2 as DocumentsValidator;
 
 class DocumentsQueriesTest extends TestCase
 {
-    /**
-     * @var array<string, mixed>
-     */
-    protected array $collection = [];
+    protected QueryContext $context;
 
     /**
      * @throws Exception
      */
     public function setUp(): void
     {
-        $this->collection = [
+        $collection = [
             '$id' => Database::METADATA,
             '$collection' => Database::METADATA,
             'name' => 'movies',
@@ -112,6 +110,13 @@ public function setUp(): void
                 ]),
             ],
         ];
+
+        $collection = new Document($collection);
+
+        $context = new QueryContext();
+        $context->add($collection);
+
+        $this->context = $context;
     }
 
     public function tearDown(): void
@@ -123,9 +128,8 @@ public function tearDown(): void
      */
     public function testValidQueries(): void
     {
-        $validator = new Documents(
-            $this->collection['attributes'],
-            $this->collection['indexes'],
+        $validator = new DocumentsValidator(
+            $this->context,
             Database::VAR_INTEGER
         );
 
@@ -161,9 +165,8 @@ public function testValidQueries(): void
      */
     public function testInvalidQueries(): void
     {
-        $validator = new Documents(
-            $this->collection['attributes'],
-            $this->collection['indexes'],
+        $validator = new DocumentsValidator(
+            $this->context,
             Database::VAR_INTEGER
         );
 
@@ -181,7 +184,7 @@ 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 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));
diff --git a/tests/unit/Validator/IndexedQueriesTest.php b/tests/unit/Validator/IndexedQueriesTest.php
index 409fcf365..dc2a7d10a 100644
--- a/tests/unit/Validator/IndexedQueriesTest.php
+++ b/tests/unit/Validator/IndexedQueriesTest.php
@@ -7,17 +7,28 @@
 use Utopia\Database\Document;
 use Utopia\Database\Exception;
 use Utopia\Database\Query;
-use Utopia\Database\Validator\IndexedQueries;
-use Utopia\Database\Validator\Query\Cursor;
-use Utopia\Database\Validator\Query\Filter;
-use Utopia\Database\Validator\Query\Limit;
-use Utopia\Database\Validator\Query\Offset;
-use Utopia\Database\Validator\Query\Order;
+use Utopia\Database\QueryContext;
+use Utopia\Database\Validator\Queries\V2 as DocumentsValidator;
 
 class IndexedQueriesTest extends TestCase
 {
+    protected Document $collection;
+
+    /**
+     * @throws Exception
+     * @throws Exception\Query
+     */
     public function setUp(): void
     {
+        $collection = new Document([
+            '$id' => Database::METADATA,
+            '$collection' => Database::METADATA,
+            'name' => 'movies',
+            'attributes' => [],
+            'indexes' => [],
+        ]);
+
+        $this->collection = $collection;
     }
 
     public function tearDown(): void
@@ -26,45 +37,58 @@ public function tearDown(): void
 
     public function testEmptyQueries(): void
     {
-        $validator = new IndexedQueries();
+        $context = new QueryContext();
+        $context->add($this->collection);
+
+        $validator = new DocumentsValidator($context);
 
         $this->assertEquals(true, $validator->isValid([]));
     }
 
     public function testInvalidQuery(): void
     {
-        $validator = new IndexedQueries();
+        $context = new QueryContext();
+        $context->add($this->collection);
+
+        $validator = new DocumentsValidator($context);
 
         $this->assertEquals(false, $validator->isValid(["this.is.invalid"]));
     }
 
     public function testInvalidMethod(): void
     {
-        $validator = new IndexedQueries();
-        $this->assertEquals(false, $validator->isValid(['equal("attr", "value")']));
+        $context = new QueryContext();
+        $context->add($this->collection);
+
+        $validator = new DocumentsValidator($context);
 
-        $validator = new IndexedQueries([], [], [new Limit()]);
         $this->assertEquals(false, $validator->isValid(['equal("attr", "value")']));
     }
 
     public function testInvalidValue(): void
     {
-        $validator = new IndexedQueries([], [], [new Limit()]);
+        $context = new QueryContext();
+        $context->add($this->collection);
+
+        $validator = new DocumentsValidator($context);
+
         $this->assertEquals(false, $validator->isValid(['limit(-1)']));
     }
 
     public function testValid(): void
     {
-        $attributes = [
+        $collection = $this->collection;
+
+        $collection->setAttribute('attributes', [
             new Document([
                 '$id' => 'name',
                 'key' => 'name',
                 'type' => Database::VAR_STRING,
                 'array' => false,
             ]),
-        ];
+        ]);
 
-        $indexes = [
+        $collection->setAttribute('indexes', [
             new Document([
                 'type' => Database::INDEX_KEY,
                 'attributes' => ['name'],
@@ -73,18 +97,15 @@ public function testValid(): void
                 'type' => Database::INDEX_FULLTEXT,
                 'attributes' => ['name'],
             ]),
-        ];
-
-        $validator = new IndexedQueries(
-            $attributes,
-            $indexes,
-            [
-                new Cursor(),
-                new Filter($attributes, Database::VAR_INTEGER),
-                new Limit(),
-                new Offset(),
-                new Order($attributes)
-            ]
+        ]);
+
+        $context = new QueryContext();
+
+        $context->add($this->collection);
+
+        $validator = new DocumentsValidator(
+            $context,
+            Database::VAR_INTEGER
         );
 
         $query = Query::cursorAfter(new Document(['$id' => 'abc']));
@@ -123,32 +144,28 @@ public function testValid(): void
 
     public function testMissingIndex(): void
     {
-        $attributes = [
+        $collection = $this->collection;
+
+        $collection->setAttribute('attributes', [
             new Document([
                 'key' => 'name',
                 'type' => Database::VAR_STRING,
                 'array' => false,
             ]),
-        ];
+        ]);
 
-        $indexes = [
+        $collection->setAttribute('indexes', [
             new Document([
                 'type' => Database::INDEX_KEY,
                 'attributes' => ['name'],
             ]),
-        ];
-
-        $validator = new IndexedQueries(
-            $attributes,
-            $indexes,
-            [
-                new Cursor(),
-                new Filter($attributes, Database::VAR_INTEGER),
-                new Limit(),
-                new Offset(),
-                new Order($attributes)
-            ]
-        );
+        ]);
+
+        $context = new QueryContext();
+
+        $context->add($this->collection);
+
+        $validator = new DocumentsValidator($context);
 
         $query = Query::equal('dne', ['value']);
         $this->assertEquals(false, $validator->isValid([$query]));
@@ -169,7 +186,9 @@ public function testMissingIndex(): void
 
     public function testTwoAttributesFulltext(): void
     {
-        $attributes = [
+        $collection = $this->collection;
+
+        $collection->setAttribute('attributes', [
             new Document([
                 '$id' => 'ft1',
                 'key' => 'ft1',
@@ -182,26 +201,20 @@ public function testTwoAttributesFulltext(): void
                 'type' => Database::VAR_STRING,
                 'array' => false,
             ]),
-        ];
+        ]);
 
-        $indexes = [
+        $collection->setAttribute('indexes', [
             new Document([
                 'type' => Database::INDEX_FULLTEXT,
                 'attributes' => ['ft1','ft2'],
             ]),
-        ];
-
-        $validator = new IndexedQueries(
-            $attributes,
-            $indexes,
-            [
-                new Cursor(),
-                new Filter($attributes, Database::VAR_INTEGER),
-                new Limit(),
-                new Offset(),
-                new Order($attributes)
-            ]
-        );
+        ]);
+
+        $context = new QueryContext();
+
+        $context->add($this->collection);
+
+        $validator = new DocumentsValidator($context);
 
         $this->assertEquals(false, $validator->isValid([Query::search('ft1', 'value')]));
     }
diff --git a/tests/unit/Validator/QueriesTest.php b/tests/unit/Validator/QueriesTest.php
index 265e9cbd0..31752ba0c 100644
--- a/tests/unit/Validator/QueriesTest.php
+++ b/tests/unit/Validator/QueriesTest.php
@@ -1,79 +1,80 @@
 <?php
 
-namespace Tests\Unit\Validator;
-
-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\Cursor;
-use Utopia\Database\Validator\Query\Filter;
-use Utopia\Database\Validator\Query\Limit;
-use Utopia\Database\Validator\Query\Offset;
-use Utopia\Database\Validator\Query\Order;
-
-class QueriesTest extends TestCase
-{
-    public function setUp(): void
-    {
-    }
-
-    public function tearDown(): void
-    {
-    }
-
-    public function testEmptyQueries(): void
-    {
-        $validator = new Queries();
-
-        $this->assertEquals(true, $validator->isValid([]));
-    }
-
-    public function testInvalidMethod(): void
-    {
-        $validator = new Queries();
-        $this->assertEquals(false, $validator->isValid([Query::equal('attr', ["value"])]));
-
-        $validator = new Queries([new Limit()]);
-        $this->assertEquals(false, $validator->isValid([Query::equal('attr', ["value"])]));
-    }
-
-    public function testInvalidValue(): void
-    {
-        $validator = new Queries([new Limit()]);
-        $this->assertEquals(false, $validator->isValid([Query::limit(-1)]));
-    }
-
-    /**
-     * @throws Exception
-     */
-    public function testValid(): void
-    {
-        $attributes = [
-            new Document([
-                '$id' => 'name',
-                'key' => 'name',
-                'type' => Database::VAR_STRING,
-                'array' => false,
-            ])
-        ];
-
-        $validator = new Queries(
-            [
-                new Cursor(),
-                new Filter($attributes, Database::VAR_INTEGER),
-                new Limit(),
-                new Offset(),
-                new Order($attributes)
-            ]
-        );
-
-        $this->assertEquals(true, $validator->isValid([Query::cursorAfter(new Document(['$id' => 'asdf']))]), $validator->getDescription());
-        $this->assertEquals(true, $validator->isValid([Query::equal('name', ['value'])]), $validator->getDescription());
-        $this->assertEquals(true, $validator->isValid([Query::limit(10)]), $validator->getDescription());
-        $this->assertEquals(true, $validator->isValid([Query::offset(10)]), $validator->getDescription());
-        $this->assertEquals(true, $validator->isValid([Query::orderAsc('name')]), $validator->getDescription());
-    }
-}
+//
+//namespace Tests\Unit\Validator;
+//
+//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\Cursor;
+//use Utopia\Database\Validator\Query\Filter;
+//use Utopia\Database\Validator\Query\Limit;
+//use Utopia\Database\Validator\Query\Offset;
+//use Utopia\Database\Validator\Query\Order;
+//
+//class QueriesTest extends TestCase
+//{
+//    public function setUp(): void
+//    {
+//    }
+//
+//    public function tearDown(): void
+//    {
+//    }
+//
+//    public function testEmptyQueries(): void
+//    {
+//        $validator = new Queries();
+//
+//        $this->assertEquals(true, $validator->isValid([]));
+//    }
+//
+//    public function testInvalidMethod(): void
+//    {
+//        $validator = new Queries();
+//        $this->assertEquals(false, $validator->isValid([Query::equal('attr', ["value"])]));
+//
+//        $validator = new Queries([new Limit()]);
+//        $this->assertEquals(false, $validator->isValid([Query::equal('attr', ["value"])]));
+//    }
+//
+//    public function testInvalidValue(): void
+//    {
+//        $validator = new Queries([new Limit()]);
+//        $this->assertEquals(false, $validator->isValid([Query::limit(-1)]));
+//    }
+//
+//    /**
+//     * @throws Exception
+//     */
+//    public function testValid(): void
+//    {
+//        $attributes = [
+//            new Document([
+//                '$id' => 'name',
+//                'key' => 'name',
+//                'type' => Database::VAR_STRING,
+//                'array' => false,
+//            ])
+//        ];
+//
+//        $validator = new Queries(
+//            [
+//                new Cursor(),
+//                new Filter($attributes),
+//                new Limit(),
+//                new Offset(),
+//                new Order($attributes)
+//            ]
+//        );
+//
+//        $this->assertEquals(true, $validator->isValid([Query::cursorAfter(new Document(['$id' => 'asdf']))]), $validator->getDescription());
+//        $this->assertEquals(true, $validator->isValid([Query::equal('name', ['value'])]), $validator->getDescription());
+//        $this->assertEquals(true, $validator->isValid([Query::limit(10)]), $validator->getDescription());
+//        $this->assertEquals(true, $validator->isValid([Query::offset(10)]), $validator->getDescription());
+//        $this->assertEquals(true, $validator->isValid([Query::orderAsc('name')]), $validator->getDescription());
+//    }
+//}
diff --git a/tests/unit/Validator/Query/CursorTest.php b/tests/unit/Validator/Query/CursorTest.php
index 7f1806549..bb2c1ffe3 100644
--- a/tests/unit/Validator/Query/CursorTest.php
+++ b/tests/unit/Validator/Query/CursorTest.php
@@ -3,20 +3,25 @@
 namespace Tests\Unit\Validator\Query;
 
 use PHPUnit\Framework\TestCase;
+use Utopia\Database\Document;
+use Utopia\Database\Exception;
 use Utopia\Database\Query;
 use Utopia\Database\Validator\Query\Cursor;
 
 class CursorTest extends TestCase
 {
-    public function testValueSuccess(): void
+    /**
+     * @throws Exception
+     */
+    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(Query::cursorAfter(new Document(['$id' => 'asb']))));
+        $this->assertTrue($validator->isValid(Query::cursorBefore(new Document(['$id' => 'asb']))));
     }
 
-    public function testValueFailure(): void
+    public function test_value_failure(): void
     {
         $validator = new Cursor();
 
diff --git a/tests/unit/Validator/Query/FilterTest.php b/tests/unit/Validator/Query/FilterTest.php
index ff7bd2630..e5a34f270 100644
--- a/tests/unit/Validator/Query/FilterTest.php
+++ b/tests/unit/Validator/Query/FilterTest.php
@@ -6,19 +6,27 @@
 use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Query;
-use Utopia\Database\Validator\Query\Base;
-use Utopia\Database\Validator\Query\Filter;
+use Utopia\Database\QueryContext;
+use Utopia\Database\Validator\Queries\V2 as DocumentsValidator;
 
 class FilterTest extends TestCase
 {
-    protected Base|null $validator = null;
+    protected DocumentsValidator $validator;
 
     /**
      * @throws \Utopia\Database\Exception
      */
     public function setUp(): void
     {
-        $attributes = [
+        $collection = new Document([
+            '$id' => Database::METADATA,
+            '$collection' => Database::METADATA,
+            'name' => 'movies',
+            'attributes' => [],
+            'indexes' => [],
+        ]);
+
+        $collection->setAttribute('attributes', [
             new Document([
                 '$id' => 'string',
                 'key' => 'string',
@@ -43,65 +51,73 @@ public function setUp(): void
                 'type' => Database::VAR_INTEGER,
                 'array' => false,
             ]),
-        ];
+        ]);
 
-        $this->validator = new Filter($attributes, Database::VAR_INTEGER);
+        $context = new QueryContext();
+
+        $context->add($collection);
+
+        $this->validator = new DocumentsValidator($context);
     }
 
     public function testSuccess(): void
     {
-        $this->assertTrue($this->validator->isValid(Query::between('string', '1975-12-06', '2050-12-06')));
-        $this->assertTrue($this->validator->isValid(Query::isNotNull('string')));
-        $this->assertTrue($this->validator->isValid(Query::isNull('string')));
-        $this->assertTrue($this->validator->isValid(Query::startsWith('string', 'super')));
-        $this->assertTrue($this->validator->isValid(Query::endsWith('string', 'man')));
-        $this->assertTrue($this->validator->isValid(Query::contains('string_array', ['super'])));
-        $this->assertTrue($this->validator->isValid(Query::contains('integer_array', [100,10,-1])));
-        $this->assertTrue($this->validator->isValid(Query::contains('string_array', ["1","10","-1"])));
-        $this->assertTrue($this->validator->isValid(Query::contains('string', ['super'])));
+        $this->assertTrue($this->validator->isValid([Query::between('string', '1975-12-06', '2050-12-06')]));
+        $this->assertTrue($this->validator->isValid([Query::isNotNull('string')]));
+        $this->assertTrue($this->validator->isValid([Query::isNull('string')]));
+        $this->assertTrue($this->validator->isValid([Query::startsWith('string', 'super')]));
+        $this->assertTrue($this->validator->isValid([Query::endsWith('string', 'man')]));
+        $this->assertTrue($this->validator->isValid([Query::contains('string_array', ['super'])]));
+        $this->assertTrue($this->validator->isValid([Query::contains('integer_array', [100,10,-1])]));
+        $this->assertTrue($this->validator->isValid([Query::contains('string_array', ["1","10","-1"])]));
+        $this->assertTrue($this->validator->isValid([Query::contains('string', ['super'])]));
+
+        /**
+         * Non filters, Now we allow all types
+         */
+
+        $this->assertTrue($this->validator->isValid([Query::limit(1)]));
+        $this->assertTrue($this->validator->isValid([Query::limit(5000)]));
+        $this->assertTrue($this->validator->isValid([Query::offset(1)]));
+        $this->assertTrue($this->validator->isValid([Query::offset(5000)]));
+        $this->assertTrue($this->validator->isValid([Query::offset(0)]));
+        $this->assertTrue($this->validator->isValid([Query::orderAsc('string')]));
+        $this->assertTrue($this->validator->isValid([Query::orderDesc('string')]));
+
     }
 
     public function testFailure(): void
     {
-        $this->assertFalse($this->validator->isValid(Query::select(['attr'])));
-        $this->assertEquals('Invalid query', $this->validator->getDescription());
-        $this->assertFalse($this->validator->isValid(Query::limit(1)));
-        $this->assertFalse($this->validator->isValid(Query::limit(0)));
-        $this->assertFalse($this->validator->isValid(Query::limit(100)));
-        $this->assertFalse($this->validator->isValid(Query::limit(-1)));
-        $this->assertFalse($this->validator->isValid(Query::limit(101)));
-        $this->assertFalse($this->validator->isValid(Query::offset(1)));
-        $this->assertFalse($this->validator->isValid(Query::offset(0)));
-        $this->assertFalse($this->validator->isValid(Query::offset(5000)));
-        $this->assertFalse($this->validator->isValid(Query::offset(-1)));
-        $this->assertFalse($this->validator->isValid(Query::offset(5001)));
-        $this->assertFalse($this->validator->isValid(Query::equal('dne', ['v'])));
-        $this->assertFalse($this->validator->isValid(Query::equal('', ['v'])));
-        $this->assertFalse($this->validator->isValid(Query::orderAsc('string')));
-        $this->assertFalse($this->validator->isValid(Query::orderDesc('string')));
-        $this->assertFalse($this->validator->isValid(new Query(Query::TYPE_CURSOR_AFTER, values: ['asdf'])));
-        $this->assertFalse($this->validator->isValid(new Query(Query::TYPE_CURSOR_BEFORE, values: ['asdf'])));
-        $this->assertFalse($this->validator->isValid(Query::contains('integer', ['super'])));
-        $this->assertFalse($this->validator->isValid(Query::equal('integer_array', [100,-1])));
-        $this->assertFalse($this->validator->isValid(Query::contains('integer_array', [10.6])));
+        $this->assertFalse($this->validator->isValid([Query::select('attr')]));
+        $this->assertEquals('Invalid query: Attribute not found in schema: attr', $this->validator->getDescription());
+        $this->assertFalse($this->validator->isValid([Query::limit(0)]));
+        $this->assertFalse($this->validator->isValid([Query::limit(-1)]));
+        $this->assertFalse($this->validator->isValid([Query::offset(-1)]));
+        $this->assertFalse($this->validator->isValid([Query::equal('dne', ['v'])]));
+        $this->assertFalse($this->validator->isValid([Query::equal('', ['v'])]));
+        $this->assertFalse($this->validator->isValid([Query::cursorAfter(new Document(['$uid'=>'asdf']))]));
+        $this->assertFalse($this->validator->isValid([Query::cursorBefore(new Document(['$uid'=>'asdf']))]));
+        $this->assertFalse($this->validator->isValid([Query::contains('integer', ['super'])]));
+        $this->assertFalse($this->validator->isValid([Query::equal('integer_array', [100,-1])]));
+        $this->assertFalse($this->validator->isValid([Query::contains('integer_array', [10.6])]));
     }
 
     public function testTypeMismatch(): void
     {
-        $this->assertFalse($this->validator->isValid(Query::equal('string', [false])));
-        $this->assertEquals('Query value is invalid for attribute "string"', $this->validator->getDescription());
+        $this->assertFalse($this->validator->isValid([Query::equal('string', [false])]));
+        $this->assertEquals('Invalid query: Query value is invalid for attribute "string"', $this->validator->getDescription());
 
-        $this->assertFalse($this->validator->isValid(Query::equal('string', [1])));
-        $this->assertEquals('Query value is invalid for attribute "string"', $this->validator->getDescription());
+        $this->assertFalse($this->validator->isValid([Query::equal('string', [1])]));
+        $this->assertEquals('Invalid query: Query value is invalid for attribute "string"', $this->validator->getDescription());
     }
 
     public function testEmptyValues(): void
     {
-        $this->assertFalse($this->validator->isValid(Query::contains('string', [])));
-        $this->assertEquals('Contains queries require at least one value.', $this->validator->getDescription());
+        $this->assertFalse($this->validator->isValid([Query::contains('string', [])]));
+        $this->assertEquals('Invalid query: Contains queries require at least one value.', $this->validator->getDescription());
 
-        $this->assertFalse($this->validator->isValid(Query::equal('string', [])));
-        $this->assertEquals('Equal queries require at least one value.', $this->validator->getDescription());
+        $this->assertFalse($this->validator->isValid([Query::equal('string', [])]));
+        $this->assertEquals('Invalid query: Equal queries require at least one value.', $this->validator->getDescription());
     }
 
     public function testMaxValuesCount(): void
@@ -111,8 +127,8 @@ public function testMaxValuesCount(): void
             $values[] = $i;
         }
 
-        $this->assertFalse($this->validator->isValid(Query::equal('integer', $values)));
-        $this->assertEquals('Query on attribute has greater than 100 values: integer', $this->validator->getDescription());
+        $this->assertFalse($this->validator->isValid([Query::equal('integer', $values)]));
+        $this->assertEquals('Invalid query: Query on attribute has greater than 100 values: integer', $this->validator->getDescription());
     }
 
     public function testNotContains(): void
diff --git a/tests/unit/Validator/Query/OrderTest.php b/tests/unit/Validator/Query/OrderTest.php
index b84d896d1..75f136026 100644
--- a/tests/unit/Validator/Query/OrderTest.php
+++ b/tests/unit/Validator/Query/OrderTest.php
@@ -7,55 +7,68 @@
 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\Database\QueryContext;
+use Utopia\Database\Validator\Queries\V2 as DocumentsValidator;
 
 class OrderTest extends TestCase
 {
-    protected Base|null $validator = null;
+    protected DocumentsValidator $validator;
 
     /**
      * @throws Exception
      */
     public function setUp(): void
     {
-        $this->validator = new Order(
-            attributes: [
-                new Document([
-                    '$id' => 'attr',
-                    'key' => 'attr',
-                    'type' => Database::VAR_STRING,
-                    'array' => false,
-                ]),
-                new Document([
-                    '$id' => '$sequence',
-                    'key' => '$sequence',
-                    'type' => Database::VAR_STRING,
-                    'array' => false,
-                ]),
-            ],
-        );
+        $collection = new Document([
+            '$id' => Database::METADATA,
+            '$collection' => Database::METADATA,
+            'name' => 'movies',
+            'attributes' => [],
+            'indexes' => [],
+        ]);
+
+        $collection->setAttribute('attributes', [
+            new Document([
+                '$id' => 'attr',
+                'key' => 'attr',
+                'type' => Database::VAR_STRING,
+                'array' => false,
+            ]),
+            new Document([
+                '$id' => '$sequence',
+                'key' => '$sequence',
+                'type' => Database::VAR_STRING,
+                'array' => false,
+            ]),
+        ]);
+
+        $context = new QueryContext();
+
+        $context->add($collection);
+
+        $this->validator = new DocumentsValidator($context);
     }
 
     public function testValueSuccess(): void
     {
-        $this->assertTrue($this->validator->isValid(Query::orderAsc('attr')));
-        $this->assertTrue($this->validator->isValid(Query::orderAsc()));
-        $this->assertTrue($this->validator->isValid(Query::orderDesc('attr')));
-        $this->assertTrue($this->validator->isValid(Query::orderDesc()));
+        $this->assertTrue($this->validator->isValid([Query::orderAsc('attr')]));
+        $this->assertTrue($this->validator->isValid([Query::orderAsc()]));
+        $this->assertTrue($this->validator->isValid([Query::orderDesc('attr')]));
+        $this->assertTrue($this->validator->isValid([Query::orderDesc()]));
+        $this->assertTrue($this->validator->isValid([Query::limit(101)]));
+        $this->assertTrue($this->validator->isValid([Query::offset(5001)]));
+        $this->assertTrue($this->validator->isValid([Query::equal('attr', ['v'])]));
     }
 
     public function testValueFailure(): void
     {
-        $this->assertFalse($this->validator->isValid(Query::limit(-1)));
-        $this->assertEquals('Invalid query', $this->validator->getDescription());
-        $this->assertFalse($this->validator->isValid(Query::limit(101)));
-        $this->assertFalse($this->validator->isValid(Query::offset(-1)));
-        $this->assertFalse($this->validator->isValid(Query::offset(5001)));
-        $this->assertFalse($this->validator->isValid(Query::equal('attr', ['v'])));
-        $this->assertFalse($this->validator->isValid(Query::equal('dne', ['v'])));
-        $this->assertFalse($this->validator->isValid(Query::equal('', ['v'])));
-        $this->assertFalse($this->validator->isValid(Query::orderDesc('dne')));
-        $this->assertFalse($this->validator->isValid(Query::orderAsc('dne')));
+        $this->assertFalse($this->validator->isValid([Query::limit(-1)]));
+        $this->assertFalse($this->validator->isValid([Query::limit(0)]));
+        $this->assertEquals('Invalid limit: Value must be a valid range between 1 and 9,223,372,036,854,775,807', $this->validator->getDescription());
+        $this->assertFalse($this->validator->isValid([Query::offset(-1)]));
+        $this->assertFalse($this->validator->isValid([Query::equal('dne', ['v'])]));
+        $this->assertFalse($this->validator->isValid([Query::equal('', ['v'])]));
+        $this->assertFalse($this->validator->isValid([Query::orderDesc('dne')]));
+        $this->assertFalse($this->validator->isValid([Query::orderAsc('dne')]));
     }
 }
diff --git a/tests/unit/Validator/Query/SelectTest.php b/tests/unit/Validator/Query/SelectTest.php
index 2dafdb94c..fb0d72a1d 100644
--- a/tests/unit/Validator/Query/SelectTest.php
+++ b/tests/unit/Validator/Query/SelectTest.php
@@ -7,46 +7,58 @@
 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\Database\QueryContext;
+use Utopia\Database\Validator\Queries\V2 as DocumentsValidator;
 
 class SelectTest extends TestCase
 {
-    protected Base|null $validator = null;
+    protected DocumentsValidator $validator;
 
     /**
      * @throws Exception
      */
     public function setUp(): void
     {
-        $this->validator = new Select(
-            attributes: [
-                new Document([
-                    '$id' => 'attr',
-                    'key' => 'attr',
-                    'type' => Database::VAR_STRING,
-                    'array' => false,
-                ]),
-                new Document([
-                    '$id' => 'artist',
-                    'key' => 'artist',
-                    'type' => Database::VAR_RELATIONSHIP,
-                    'array' => false,
-                ]),
-            ],
-        );
+        $collection = new Document([
+            '$id' => Database::METADATA,
+            '$collection' => Database::METADATA,
+            'name' => 'movies',
+            'attributes' => [],
+            'indexes' => [],
+        ]);
+
+        $collection->setAttribute('attributes', [
+            new Document([
+                '$id' => 'attr',
+                'key' => 'attr',
+                'type' => Database::VAR_STRING,
+                'array' => false,
+            ]),
+            new Document([
+                '$id' => 'artist',
+                'key' => 'artist',
+                'type' => Database::VAR_RELATIONSHIP,
+                'array' => false,
+            ]),
+        ]);
+
+        $context = new QueryContext();
+
+        $context->add($collection);
+
+        $this->validator = new DocumentsValidator($context);
     }
 
     public function testValueSuccess(): void
     {
-        $this->assertTrue($this->validator->isValid(Query::select(['*', 'attr'])));
-        $this->assertTrue($this->validator->isValid(Query::select(['artist.name'])));
+        $this->assertTrue($this->validator->isValid([Query::select('*'), Query::select('attr')]));
+        $this->assertTrue($this->validator->isValid([Query::select('artist.name')]));
+        $this->assertTrue($this->validator->isValid([Query::limit(1)]));
     }
 
     public function testValueFailure(): void
     {
-        $this->assertFalse($this->validator->isValid(Query::limit(1)));
         $this->assertEquals('Invalid query', $this->validator->getDescription());
-        $this->assertFalse($this->validator->isValid(Query::select(['name.artist'])));
+        $this->assertFalse($this->validator->isValid([Query::select('name.artist')]));
     }
 }
diff --git a/tests/unit/Validator/QueryTest.php b/tests/unit/Validator/QueryTest.php
index dbe7a6b52..65faf45d3 100644
--- a/tests/unit/Validator/QueryTest.php
+++ b/tests/unit/Validator/QueryTest.php
@@ -7,14 +7,12 @@
 use Utopia\Database\Database;
 use Utopia\Database\Document;
 use Utopia\Database\Query;
-use Utopia\Database\Validator\Queries\Documents;
+use Utopia\Database\QueryContext;
+use Utopia\Database\Validator\Queries\V2 as DocumentsValidator;
 
 class QueryTest extends TestCase
 {
-    /**
-     * @var array<Document>
-     */
-    protected array $attributes;
+    protected QueryContext $context;
 
     /**
      * @throws Exception
@@ -94,9 +92,23 @@ public function setUp(): void
             ],
         ];
 
-        foreach ($attributes as $attribute) {
-            $this->attributes[] = new Document($attribute);
-        }
+        $attributes = array_map(
+            fn ($attribute) => new Document($attribute),
+            $attributes
+        );
+
+        $collection = new Document([
+            '$id' => Database::METADATA,
+            '$collection' => Database::METADATA,
+            'name' => 'movies',
+            'attributes' => $attributes,
+            'indexes' => [],
+        ]);
+
+        $context = new QueryContext();
+        $context->add($collection);
+
+        $this->context = $context;
     }
 
     public function tearDown(): void
@@ -108,7 +120,7 @@ public function tearDown(): void
      */
     public function testQuery(): void
     {
-        $validator = new Documents($this->attributes, [], Database::VAR_INTEGER);
+        $validator = new DocumentsValidator($this->context, Database::VAR_INTEGER);
 
         $this->assertEquals(true, $validator->isValid([Query::equal('$id', ['Iron Man', 'Ant Man'])]));
         $this->assertEquals(true, $validator->isValid([Query::equal('$id', ['Iron Man'])]));
@@ -129,7 +141,10 @@ public function testQuery(): void
         $this->assertEquals(true, $validator->isValid([Query::between('birthDay', '2024-01-01', '2023-01-01')]));
         $this->assertEquals(true, $validator->isValid([Query::startsWith('title', 'Fro')]));
         $this->assertEquals(true, $validator->isValid([Query::endsWith('title', 'Zen')]));
-        $this->assertEquals(true, $validator->isValid([Query::select(['title', 'description'])]));
+        $this->assertEquals(true, $validator->isValid([
+            Query::select('title'),
+            Query::select('description')
+        ]));
         $this->assertEquals(true, $validator->isValid([Query::notEqual('title', '')]));
     }
 
@@ -138,7 +153,7 @@ public function testQuery(): void
      */
     public function testAttributeNotFound(): void
     {
-        $validator = new Documents($this->attributes, [], Database::VAR_INTEGER);
+        $validator = new DocumentsValidator($this->context, Database::VAR_INTEGER);
 
         $response = $validator->isValid([Query::equal('name', ['Iron Man'])]);
         $this->assertEquals(false, $response);
@@ -154,7 +169,7 @@ public function testAttributeNotFound(): void
      */
     public function testAttributeWrongType(): void
     {
-        $validator = new Documents($this->attributes, [], Database::VAR_INTEGER);
+        $validator = new DocumentsValidator($this->context, Database::VAR_INTEGER);
 
         $response = $validator->isValid([Query::equal('title', [1776])]);
         $this->assertEquals(false, $response);
@@ -166,7 +181,7 @@ public function testAttributeWrongType(): void
      */
     public function testQueryDate(): void
     {
-        $validator = new Documents($this->attributes, [], Database::VAR_INTEGER);
+        $validator = new DocumentsValidator($this->context, Database::VAR_INTEGER);
 
         $response = $validator->isValid([Query::greaterThan('birthDay', '1960-01-01 10:10:10')]);
         $this->assertEquals(true, $response);
@@ -177,7 +192,7 @@ public function testQueryDate(): void
      */
     public function testQueryLimit(): void
     {
-        $validator = new Documents($this->attributes, [], Database::VAR_INTEGER);
+        $validator = new DocumentsValidator($this->context, Database::VAR_INTEGER);
 
         $response = $validator->isValid([Query::limit(25)]);
         $this->assertEquals(true, $response);
@@ -191,7 +206,7 @@ public function testQueryLimit(): void
      */
     public function testQueryOffset(): void
     {
-        $validator = new Documents($this->attributes, [], Database::VAR_INTEGER);
+        $validator = new DocumentsValidator($this->context, Database::VAR_INTEGER);
 
         $response = $validator->isValid([Query::offset(25)]);
         $this->assertEquals(true, $response);
@@ -205,7 +220,7 @@ public function testQueryOffset(): void
      */
     public function testQueryOrder(): void
     {
-        $validator = new Documents($this->attributes, [], Database::VAR_INTEGER);
+        $validator = new DocumentsValidator($this->context, Database::VAR_INTEGER);
 
         $response = $validator->isValid([Query::orderAsc('title')]);
         $this->assertEquals(true, $response);
@@ -225,7 +240,7 @@ public function testQueryOrder(): void
      */
     public function testQueryCursor(): void
     {
-        $validator = new Documents($this->attributes, [], Database::VAR_INTEGER);
+        $validator = new DocumentsValidator($this->context, Database::VAR_INTEGER);
 
         $response = $validator->isValid([Query::cursorAfter(new Document(['$id' => 'asdf']))]);
         $this->assertEquals(true, $response);
@@ -238,16 +253,18 @@ public function testQueryGetByType(): void
     {
         $queries = [
             Query::equal('key', ['value']),
-            Query::select(['attr1', 'attr2']),
+            Query::select('attr1'),
+            Query::select('attr2'),
             Query::cursorBefore(new Document([])),
             Query::cursorAfter(new Document([])),
         ];
 
-        $queries = Query::getByType($queries, [Query::TYPE_CURSOR_AFTER, Query::TYPE_CURSOR_BEFORE]);
-        $this->assertCount(2, $queries);
-        foreach ($queries as $query) {
-            $this->assertEquals(true, in_array($query->getMethod(), [Query::TYPE_CURSOR_AFTER, Query::TYPE_CURSOR_BEFORE]));
-        }
+        $query = Query::getCursorQueries($queries);
+
+        $this->assertNotNull($query);
+        $this->assertInstanceOf(Query::class, $query);
+        $this->assertEquals($query->getMethod(), Query::TYPE_CURSOR_BEFORE);
+        $this->assertNotEquals($query->getMethod(), Query::TYPE_CURSOR_AFTER);
     }
 
     /**
@@ -255,7 +272,7 @@ public function testQueryGetByType(): void
      */
     public function testQueryEmpty(): void
     {
-        $validator = new Documents($this->attributes, [], Database::VAR_INTEGER);
+        $validator = new DocumentsValidator($this->context, Database::VAR_INTEGER);
 
         $response = $validator->isValid([Query::equal('title', [''])]);
         $this->assertEquals(true, $response);
@@ -284,7 +301,7 @@ public function testQueryEmpty(): void
      */
     public function testOrQuery(): void
     {
-        $validator = new Documents($this->attributes, [], Database::VAR_INTEGER);
+        $validator = new DocumentsValidator($this->context, Database::VAR_INTEGER);
 
         $this->assertFalse($validator->isValid(
             [Query::or(
@@ -311,7 +328,7 @@ public function testOrQuery(): void
                 Query::equal('price', [10]),
                 Query::or(
                     [
-                        Query::select(['price']),
+                        Query::select('price'),
                         Query::limit(1)
                     ]
                 )]