From 0f94b800a52201e18426bc97f683db3a8259dd2b Mon Sep 17 00:00:00 2001
From: Darshan <itznotabug@gmail.com>
Date: Wed, 7 May 2025 17:02:24 +0530
Subject: [PATCH] update: abstraction over table and collection apis.

---
 .../Databases/Http/Collections/Action.php     | 124 ++++++++++++++
 .../Databases/Http/Collections/Create.php     | 123 +++++++++++++
 .../Databases/Http/Collections/Delete.php     | 109 ++++++++++++
 .../Databases/Http/Collections/Get.php        |  81 +++++++++
 .../Databases/Http/Collections/Logs/XList.php | 161 ++++++++++++++++++
 .../Databases/Http/Collections/Update.php     | 117 +++++++++++++
 .../Databases/Http/Collections/Usage/Get.php  | 143 ++++++++++++++++
 .../Databases/Http/Collections/XList.php      | 128 ++++++++++++++
 .../Modules/Databases/Http/Tables/Create.php  |  75 ++------
 .../Modules/Databases/Http/Tables/Delete.php  |  55 ++----
 .../Modules/Databases/Http/Tables/Get.php     |  42 ++---
 .../Databases/Http/Tables/Logs/XList.php      | 113 ++----------
 .../Modules/Databases/Http/Tables/Update.php  |  64 ++-----
 .../Databases/Http/Tables/Usage/Get.php       |  95 ++---------
 .../Modules/Databases/Http/Tables/XList.php   |  82 ++-------
 .../Modules/Databases/Services/Http.php       |  21 ++-
 16 files changed, 1116 insertions(+), 417 deletions(-)
 create mode 100644 src/Appwrite/Platform/Modules/Databases/Http/Collections/Action.php
 create mode 100644 src/Appwrite/Platform/Modules/Databases/Http/Collections/Create.php
 create mode 100644 src/Appwrite/Platform/Modules/Databases/Http/Collections/Delete.php
 create mode 100644 src/Appwrite/Platform/Modules/Databases/Http/Collections/Get.php
 create mode 100644 src/Appwrite/Platform/Modules/Databases/Http/Collections/Logs/XList.php
 create mode 100644 src/Appwrite/Platform/Modules/Databases/Http/Collections/Update.php
 create mode 100644 src/Appwrite/Platform/Modules/Databases/Http/Collections/Usage/Get.php
 create mode 100644 src/Appwrite/Platform/Modules/Databases/Http/Collections/XList.php

diff --git a/src/Appwrite/Platform/Modules/Databases/Http/Collections/Action.php b/src/Appwrite/Platform/Modules/Databases/Http/Collections/Action.php
new file mode 100644
index 0000000000..d2129f31ea
--- /dev/null
+++ b/src/Appwrite/Platform/Modules/Databases/Http/Collections/Action.php
@@ -0,0 +1,124 @@
+<?php
+
+namespace Appwrite\Platform\Modules\Databases\Http\Collections;
+
+use Appwrite\Extend\Exception;
+use Utopia\Platform\Action as UtopiaAction;
+
+/**
+ * Abstract base action for Collection and Table database routes.
+ *
+ * Provides shared utilities to determine API type, response model,
+ * SDK group, and context-specific exceptions.
+ */
+abstract class Action extends UtopiaAction
+{
+    /**
+     * Valid context identifiers.
+     */
+    public const TABLE = 'table';
+    public const COLLECTION = 'collection';
+
+    /**
+     * The current API context (either 'table' or 'collection').
+     */
+    private ?string $context = null;
+
+    /**
+     * Set the current API context.
+     *
+     * @param string $context Must be either `self::TABLE` or `self::COLLECTION`.
+     */
+    final protected function setContext(string $context): void
+    {
+        if (!\in_array($context, [self::TABLE, self::COLLECTION], true)) {
+            throw new \InvalidArgumentException("Invalid context '$context'. Must be either `Action::TABLE` or `Action::COLLECTION`.");
+        }
+
+        $this->context = $context;
+    }
+
+    /**
+     * Get the current API context.
+     *
+     * @throws \Exception if context has not been set.
+     */
+    final protected function getContext(): string
+    {
+        if ($this->context === null) {
+            throw new \Exception('Missing context: you must call setContext() with either `Action::TABLE` or `Action::COLLECTION` before using this method.');
+        }
+
+        return $this->context;
+    }
+
+    /**
+     * Get the key used in event parameters (e.g., 'collectionId' or 'tableId').
+     */
+    final protected function getEventsParamKey(): string
+    {
+        return $this->getContext() . 'Id';
+    }
+
+    /**
+     * Get the response model used in the SDK and HTTP responses.
+     */
+    abstract protected function getResponseModel(): string;
+
+    /**
+     * Determine if the current action is for the Collections API.
+     */
+    final protected function isCollectionsAPI(): bool
+    {
+        return $this->getContext() === self::COLLECTION;
+    }
+
+    /**
+     * Get the SDK group name for the current action.
+     */
+    final protected function getSdkGroup(): string
+    {
+        return $this->isCollectionsAPI() ? 'collections' : 'tables';
+    }
+
+    /**
+     * Get the exception to throw when the resource already exists.
+     */
+    final protected function getDuplicateException(): string
+    {
+        return $this->isCollectionsAPI()
+            ? Exception::COLLECTION_ALREADY_EXISTS
+            : Exception::TABLE_ALREADY_EXISTS;
+    }
+
+    /**
+     * Get the exception to throw when the resource is not found.
+     */
+    final protected function getNotFoundException(): string
+    {
+        return $this->isCollectionsAPI()
+            ? Exception::COLLECTION_NOT_FOUND
+            : Exception::TABLE_NOT_FOUND;
+    }
+
+    /**
+     * Get the exception to throw when the resource limit is exceeded.
+     */
+    final protected function getLimitException(): string
+    {
+        return $this->isCollectionsAPI()
+            ? Exception::COLLECTION_LIMIT_EXCEEDED
+            : Exception::TABLE_LIMIT_EXCEEDED;
+    }
+
+    /**
+     * Ensures that a valid context has been set.
+     *
+     * @throws \Exception if context is missing
+     */
+    final protected function validateContext(): void
+    {
+        $this->getContext(); // Triggers exception if not set
+    }
+
+}
diff --git a/src/Appwrite/Platform/Modules/Databases/Http/Collections/Create.php b/src/Appwrite/Platform/Modules/Databases/Http/Collections/Create.php
new file mode 100644
index 0000000000..d0320c6dd0
--- /dev/null
+++ b/src/Appwrite/Platform/Modules/Databases/Http/Collections/Create.php
@@ -0,0 +1,123 @@
+<?php
+
+namespace Appwrite\Platform\Modules\Databases\Http\Collections;
+
+use Appwrite\Event\Event;
+use Appwrite\Extend\Exception;
+use Appwrite\SDK\AuthType;
+use Appwrite\SDK\ContentType;
+use Appwrite\SDK\Method;
+use Appwrite\SDK\Response as SDKResponse;
+use Appwrite\Utopia\Database\Validator\CustomId;
+use Appwrite\Utopia\Response as UtopiaResponse;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Exception\Duplicate as DuplicateException;
+use Utopia\Database\Exception\Limit as LimitException;
+use Utopia\Database\Helpers\ID;
+use Utopia\Database\Helpers\Permission;
+use Utopia\Database\Validator\Authorization;
+use Utopia\Database\Validator\Permissions;
+use Utopia\Database\Validator\UID;
+use Utopia\Platform\Scope\HTTP;
+use Utopia\Swoole\Response as SwooleResponse;
+use Utopia\Validator\Boolean;
+use Utopia\Validator\Text;
+
+class Create extends Action
+{
+    use HTTP;
+
+    public static function getName(): string
+    {
+        return 'createCollection';
+    }
+
+    protected function getResponseModel(): string
+    {
+        return UtopiaResponse::MODEL_COLLECTION;
+    }
+
+    public function __construct()
+    {
+        $this->setContext(Action::COLLECTION);
+
+        $this
+            ->setHttpMethod(self::HTTP_REQUEST_METHOD_POST)
+            ->setHttpPath('/v1/databases/:databaseId/collections')
+            ->desc('Create collections')
+            ->groups(['api', 'database'])
+            ->label('event', 'databases.[databaseId].collections.[collectionId].create')
+            ->label('scope', 'collections.write')
+            ->label('resourceType', RESOURCE_TYPE_DATABASES)
+            ->label('audits.event', 'collection.create')
+            ->label('audits.resource', 'database/{request.databaseId}/collection/{response.$id}')
+            ->label('sdk', new Method(
+                namespace: 'databases',
+                group: $this->getSdkGroup(),
+                name: self::getName(),
+                description: '/docs/references/databases/create-collection.md',
+                auth: [AuthType::KEY],
+                responses: [
+                    new SDKResponse(
+                        code: SwooleResponse::STATUS_CODE_CREATED,
+                        model: $this->getResponseModel(),
+                    )
+                ],
+                contentType: ContentType::JSON
+            ))
+            ->param('databaseId', '', new UID(), 'Database ID.')
+            ->param('collectionId', '', new CustomId(), 'Unique Id. Choose a custom ID or generate a random ID with `ID.unique()`. Valid chars are a-z, A-Z, 0-9, period, hyphen, and underscore. Can\'t start with a special char. Max length is 36 chars.')
+            ->param('name', '', new Text(128), 'Collection name. Max length: 128 chars.')
+            ->param('permissions', null, new Permissions(APP_LIMIT_ARRAY_PARAMS_SIZE), 'An array of permissions strings. By default, no user is granted with any permissions. [Learn more about permissions](https://appwrite.io/docs/permissions).', true)
+            ->param('documentSecurity', false, new Boolean(true), 'Enables configuring permissions for individual documents. A user needs one of document or collection level permissions to access a document. [Learn more about permissions](https://appwrite.io/docs/permissions).', true)
+            ->param('enabled', true, new Boolean(), 'Is collection enabled? When set to \'disabled\', users cannot access the collection but Server SDKs with and API key can still read and write to the collection. No data is lost when this is toggled.', true)
+            ->inject('response')
+            ->inject('dbForProject')
+            ->inject('queueForEvents')
+            ->callback([$this, 'action']);
+    }
+
+    public function action(string $databaseId, string $collectionId, string $name, ?array $permissions, bool $documentSecurity, bool $enabled, UtopiaResponse $response, Database $dbForProject, Event $queueForEvents): void
+    {
+        $this->validateContext();
+
+        $database = Authorization::skip(fn () => $dbForProject->getDocument('databases', $databaseId));
+
+        if ($database->isEmpty()) {
+            throw new Exception(Exception::DATABASE_NOT_FOUND);
+        }
+
+        $collectionId = $collectionId === 'unique()' ? ID::unique() : $collectionId;
+
+        $permissions = Permission::aggregate($permissions) ?? [];
+
+        try {
+            $collection = $dbForProject->createDocument('database_' . $database->getInternalId(), new Document([
+                '$id' => $collectionId,
+                'databaseInternalId' => $database->getInternalId(),
+                'databaseId' => $databaseId,
+                '$permissions' => $permissions,
+                'documentSecurity' => $documentSecurity,
+                'enabled' => $enabled,
+                'name' => $name,
+                'search' => \implode(' ', [$collectionId, $name]),
+            ]));
+
+            $dbForProject->createCollection('database_' . $database->getInternalId() . '_collection_' . $collection->getInternalId(), permissions: $permissions, documentSecurity: $documentSecurity);
+        } catch (DuplicateException) {
+            throw new Exception($this->getDuplicateException());
+        } catch (LimitException) {
+            throw new Exception($this->getLimitException());
+        }
+
+        $queueForEvents
+            ->setContext('database', $database)
+            ->setParam('databaseId', $databaseId)
+            ->setParam($this->getEventsParamKey(), $collection->getId());
+
+        $response
+            ->setStatusCode(SwooleResponse::STATUS_CODE_CREATED)
+            ->dynamic($collection, $this->getResponseModel());
+    }
+}
diff --git a/src/Appwrite/Platform/Modules/Databases/Http/Collections/Delete.php b/src/Appwrite/Platform/Modules/Databases/Http/Collections/Delete.php
new file mode 100644
index 0000000000..d30c37efed
--- /dev/null
+++ b/src/Appwrite/Platform/Modules/Databases/Http/Collections/Delete.php
@@ -0,0 +1,109 @@
+<?php
+
+namespace Appwrite\Platform\Modules\Databases\Http\Collections;
+
+use Appwrite\Event\Database as EventDatabase;
+use Appwrite\Event\Event;
+use Appwrite\Extend\Exception;
+use Appwrite\SDK\AuthType;
+use Appwrite\SDK\ContentType;
+use Appwrite\SDK\Method;
+use Appwrite\SDK\Response as SDKResponse;
+use Appwrite\Utopia\Response as UtopiaResponse;
+use Utopia\Database\Database;
+use Utopia\Database\Validator\Authorization;
+use Utopia\Database\Validator\UID;
+use Utopia\Platform\Scope\HTTP;
+use Utopia\Swoole\Response as SwooleResponse;
+
+class Delete extends Action
+{
+    use HTTP;
+
+    public static function getName(): string
+    {
+        return 'deleteCollection';
+    }
+
+    protected function getResponseModel(): string
+    {
+        return UtopiaResponse::MODEL_COLLECTION;
+    }
+
+    public function __construct()
+    {
+        $this->setContext(Action::COLLECTION);
+
+        $this
+            ->setHttpMethod(self::HTTP_REQUEST_METHOD_DELETE)
+            ->setHttpPath('/v1/databases/:databaseId/collections/:collectionId')
+            ->desc('Delete collection')
+            ->groups(['api', 'database', 'schema'])
+            ->label('scope', 'collections.write')
+            ->label('resourceType', RESOURCE_TYPE_DATABASES)
+            ->label('event', 'databases.[databaseId].collections.[collectionId].delete')
+            ->label('audits.event', 'collection.delete')
+            ->label('audits.resource', 'database/{request.databaseId}/collection/{request.collectionId}')
+            ->label('sdk', new Method(
+                namespace: 'databases',
+                group: $this->getSdkGroup(),
+                name: self::getName(),
+                description: '/docs/references/databases/delete-collection.md',
+                auth: [AuthType::KEY],
+                responses: [
+                    new SDKResponse(
+                        code: SwooleResponse::STATUS_CODE_NOCONTENT,
+                        model: UtopiaResponse::MODEL_NONE,
+                    )
+                ],
+                contentType: ContentType::NONE
+            ))
+            ->param('databaseId', '', new UID(), 'Database ID.')
+            ->param('collectionId', '', new UID(), 'Collection ID.')
+            ->inject('response')
+            ->inject('dbForProject')
+            ->inject('queueForDatabase')
+            ->inject('queueForEvents')
+            ->callback([$this, 'action']);
+    }
+
+    public function action(string $databaseId, string $collectionId, UtopiaResponse $response, Database $dbForProject, EventDatabase $queueForDatabase, Event $queueForEvents): void
+    {
+        $this->validateContext();
+
+        $database = Authorization::skip(fn () => $dbForProject->getDocument('databases', $databaseId));
+        if ($database->isEmpty()) {
+            throw new Exception(Exception::DATABASE_NOT_FOUND);
+        }
+
+        $collection = $dbForProject->getDocument('database_' . $database->getInternalId(), $collectionId);
+        if ($collection->isEmpty()) {
+            throw new Exception($this->getNotFoundException());
+        }
+
+        if (!$dbForProject->deleteDocument('database_' . $database->getInternalId(), $collectionId)) {
+            $type = $this->getContext();
+            throw new Exception(Exception::GENERAL_SERVER_ERROR, "Failed to remove $type from DB");
+        }
+
+        $dbForProject->purgeCachedCollection('database_' . $database->getInternalId() . '_collection_' . $collection->getInternalId());
+
+        $queueForDatabase
+            ->setType(DATABASE_TYPE_DELETE_COLLECTION)
+            ->setDatabase($database);
+
+        if ($this->isCollectionsAPI()) {
+            $queueForDatabase->setCollection($collection);
+        } else {
+            $queueForDatabase->setTable($collection);
+        }
+
+        $queueForEvents
+            ->setParam('databaseId', $databaseId)
+            ->setContext('database', $database)
+            ->setParam($this->getEventsParamKey(), $collection->getId())
+            ->setPayload($response->output($collection, $this->getResponseModel()));
+
+        $response->noContent();
+    }
+}
diff --git a/src/Appwrite/Platform/Modules/Databases/Http/Collections/Get.php b/src/Appwrite/Platform/Modules/Databases/Http/Collections/Get.php
new file mode 100644
index 0000000000..962ad3d21d
--- /dev/null
+++ b/src/Appwrite/Platform/Modules/Databases/Http/Collections/Get.php
@@ -0,0 +1,81 @@
+<?php
+
+namespace Appwrite\Platform\Modules\Databases\Http\Collections;
+
+use Appwrite\Extend\Exception;
+use Appwrite\SDK\AuthType;
+use Appwrite\SDK\ContentType;
+use Appwrite\SDK\Method;
+use Appwrite\SDK\Response as SDKResponse;
+use Appwrite\Utopia\Response as UtopiaResponse;
+use Utopia\Database\Database;
+use Utopia\Database\Validator\Authorization;
+use Utopia\Database\Validator\UID;
+use Utopia\Platform\Scope\HTTP;
+use Utopia\Swoole\Response as SwooleResponse;
+
+class Get extends Action
+{
+    use HTTP;
+
+    public static function getName(): string
+    {
+        return 'getCollection';
+    }
+
+    protected function getResponseModel(): string
+    {
+        return UtopiaResponse::MODEL_COLLECTION;
+    }
+
+    public function __construct()
+    {
+        $this->setContext(Action::COLLECTION);
+
+        $this
+            ->setHttpMethod(self::HTTP_REQUEST_METHOD_GET)
+            ->setHttpPath('/v1/databases/:databaseId/collections/:collectionId')
+            ->desc('Get collection')
+            ->groups(['api', 'database'])
+            ->label('scope', 'collections.read')
+            ->label('resourceType', RESOURCE_TYPE_DATABASES)
+            ->label('sdk', new Method(
+                namespace: 'databases',
+                group: $this->getSdkGroup(),
+                name: self::getName(),
+                description: '/docs/references/databases/get-collection.md',
+                auth: [AuthType::KEY],
+                responses: [
+                    new SDKResponse(
+                        code: SwooleResponse::STATUS_CODE_OK,
+                        model: $this->getResponseModel(),
+                    )
+                ],
+                contentType: ContentType::JSON
+            ))
+            ->param('databaseId', '', new UID(), 'Database ID.')
+            ->param('collectionId', '', new UID(), 'Collection ID.')
+            ->inject('response')
+            ->inject('dbForProject')
+            ->callback([$this, 'action']);
+    }
+
+    public function action(string $databaseId, string $collectionId, UtopiaResponse $response, Database $dbForProject): void
+    {
+        $this->validateContext();
+
+        $database = Authorization::skip(fn () => $dbForProject->getDocument('databases', $databaseId));
+
+        if ($database->isEmpty()) {
+            throw new Exception(Exception::DATABASE_NOT_FOUND);
+        }
+
+        $collection = $dbForProject->getDocument('database_' . $database->getInternalId(), $collectionId);
+
+        if ($collection->isEmpty()) {
+            throw new Exception($this->getNotFoundException());
+        }
+
+        $response->dynamic($collection, $this->getResponseModel());
+    }
+}
diff --git a/src/Appwrite/Platform/Modules/Databases/Http/Collections/Logs/XList.php b/src/Appwrite/Platform/Modules/Databases/Http/Collections/Logs/XList.php
new file mode 100644
index 0000000000..429c39dc44
--- /dev/null
+++ b/src/Appwrite/Platform/Modules/Databases/Http/Collections/Logs/XList.php
@@ -0,0 +1,161 @@
+<?php
+
+namespace Appwrite\Platform\Modules\Databases\Http\Collections\Logs;
+
+use Appwrite\Extend\Exception;
+use Appwrite\Platform\Modules\Databases\Http\Collections\Action;
+use Appwrite\SDK\AuthType;
+use Appwrite\SDK\ContentType;
+use Appwrite\SDK\Method;
+use Appwrite\SDK\Response as SDKResponse;
+use Appwrite\Utopia\Response as UtopiaResponse;
+use DeviceDetector\DeviceDetector as Detector;
+use MaxMind\Db\Reader;
+use Utopia\Audit\Audit;
+use Utopia\Database\Database;
+use Utopia\Database\DateTime;
+use Utopia\Database\Document;
+use Utopia\Database\Exception\Query as QueryException;
+use Utopia\Database\Query;
+use Utopia\Database\Validator\Authorization;
+use Utopia\Database\Validator\Queries;
+use Utopia\Database\Validator\Query\Limit;
+use Utopia\Database\Validator\Query\Offset;
+use Utopia\Database\Validator\UID;
+use Utopia\Locale\Locale;
+use Utopia\Platform\Scope\HTTP;
+use Utopia\Swoole\Response as SwooleResponse;
+
+class XList extends Action
+{
+    use HTTP;
+
+    public static function getName(): string
+    {
+        return 'listCollectionLogs';
+    }
+
+    protected function getResponseModel(): string
+    {
+        return UtopiaResponse::MODEL_LOG_LIST;
+    }
+
+    public function __construct()
+    {
+        $this->setContext(Action::COLLECTION);
+
+        $this
+            ->setHttpMethod(self::HTTP_REQUEST_METHOD_GET)
+            ->setHttpPath('/v1/databases/:databaseId/collections/:collectionId/logs')
+            ->desc('List collection logs')
+            ->groups(['api', 'database'])
+            ->label('scope', 'collections.read')
+            ->label('resourceType', RESOURCE_TYPE_DATABASES)
+            ->label('sdk', new Method(
+                namespace: 'databases',
+                group: $this->getSdkGroup(),
+                name: self::getName(),
+                description: '/docs/references/databases/get-collection-logs.md',
+                auth: [AuthType::ADMIN],
+                responses: [
+                    new SDKResponse(
+                        code: SwooleResponse::STATUS_CODE_OK,
+                        model: $this->getResponseModel(),
+                    )
+                ],
+                contentType: ContentType::JSON
+            ))
+            ->param('databaseId', '', new UID(), 'Database ID.')
+            ->param('collectionId', '', new UID(), 'Collection ID.')
+            ->param('queries', [], new Queries([new Limit(), new Offset()]), 'Array of query strings generated using the Query class provided by the SDK. [Learn more about queries](https://appwrite.io/docs/queries). Only supported methods are limit and offset', true)
+            ->inject('response')
+            ->inject('dbForProject')
+            ->inject('locale')
+            ->inject('geodb')
+            ->callback([$this, 'action']);
+    }
+
+    public function action(string $databaseId, string $collectionId, array $queries, UtopiaResponse $response, Database $dbForProject, Locale $locale, Reader $geodb): void
+    {
+        $this->validateContext();
+
+        $database = Authorization::skip(fn () => $dbForProject->getDocument('databases', $databaseId));
+
+        if ($database->isEmpty()) {
+            throw new Exception(Exception::DATABASE_NOT_FOUND);
+        }
+
+        $collectionDocument = $dbForProject->getDocument('database_' . $database->getInternalId(), $collectionId);
+        $collection = $dbForProject->getCollection('database_' . $database->getInternalId() . '_collection_' . $collectionDocument->getInternalId());
+
+        if ($collection->isEmpty()) {
+            throw new Exception($this->getNotFoundException());
+        }
+
+        try {
+            $queries = Query::parseQueries($queries);
+        } catch (QueryException $e) {
+            throw new Exception(Exception::GENERAL_QUERY_INVALID, $e->getMessage());
+        }
+
+        // Temp fix for logs
+        $queries[] = Query::or([
+            Query::greaterThan('$createdAt', DateTime::format(new \DateTime('2025-02-26T01:30+00:00'))),
+            Query::lessThan('$createdAt', DateTime::format(new \DateTime('2025-02-13T00:00+00:00'))),
+        ]);
+
+        $audit = new Audit($dbForProject);
+        $resource = 'database/' . $databaseId . '/' . $this->getContext() . '/' . $collectionId;
+        $logs = $audit->getLogsByResource($resource, $queries);
+
+        $output = [];
+
+        foreach ($logs as $i => &$log) {
+            $log['userAgent'] = (!empty($log['userAgent'])) ? $log['userAgent'] : 'UNKNOWN';
+
+            $detector = new Detector($log['userAgent']);
+            $detector->skipBotDetection(); // OPTIONAL: If called, bot detection will completely be skipped (bots will be detected as regular devices then)
+
+            $os = $detector->getOS();
+            $client = $detector->getClient();
+            $device = $detector->getDevice();
+
+            $output[$i] = new Document([
+                'event' => $log['event'],
+                'userId' => $log['data']['userId'],
+                'userEmail' => $log['data']['userEmail'] ?? null,
+                'userName' => $log['data']['userName'] ?? null,
+                'mode' => $log['data']['mode'] ?? null,
+                'ip' => $log['ip'],
+                'time' => $log['time'],
+                'osCode' => $os['osCode'],
+                'osName' => $os['osName'],
+                'osVersion' => $os['osVersion'],
+                'clientType' => $client['clientType'],
+                'clientCode' => $client['clientCode'],
+                'clientName' => $client['clientName'],
+                'clientVersion' => $client['clientVersion'],
+                'clientEngine' => $client['clientEngine'],
+                'clientEngineVersion' => $client['clientEngineVersion'],
+                'deviceName' => $device['deviceName'],
+                'deviceBrand' => $device['deviceBrand'],
+                'deviceModel' => $device['deviceModel']
+            ]);
+
+            $record = $geodb->get($log['ip']);
+
+            if ($record) {
+                $output[$i]['countryCode'] = $locale->getText('countries.' . strtolower($record['country']['iso_code']), false) ? \strtolower($record['country']['iso_code']) : '--';
+                $output[$i]['countryName'] = $locale->getText('countries.' . strtolower($record['country']['iso_code']), $locale->getText('locale.country.unknown'));
+            } else {
+                $output[$i]['countryCode'] = '--';
+                $output[$i]['countryName'] = $locale->getText('locale.country.unknown');
+            }
+        }
+
+        $response->dynamic(new Document([
+            'logs' => $output,
+            'total' => $audit->countLogsByResource($resource, $queries),
+        ]), $this->getResponseModel());
+    }
+}
diff --git a/src/Appwrite/Platform/Modules/Databases/Http/Collections/Update.php b/src/Appwrite/Platform/Modules/Databases/Http/Collections/Update.php
new file mode 100644
index 0000000000..582f0e84a3
--- /dev/null
+++ b/src/Appwrite/Platform/Modules/Databases/Http/Collections/Update.php
@@ -0,0 +1,117 @@
+<?php
+
+namespace Appwrite\Platform\Modules\Databases\Http\Collections;
+
+use Appwrite\Event\Event;
+use Appwrite\Extend\Exception;
+use Appwrite\SDK\AuthType;
+use Appwrite\SDK\ContentType;
+use Appwrite\SDK\Method;
+use Appwrite\SDK\Response as SDKResponse;
+use Appwrite\Utopia\Response as UtopiaResponse;
+use Utopia\Database\Database;
+use Utopia\Database\Helpers\Permission;
+use Utopia\Database\Validator\Authorization;
+use Utopia\Database\Validator\Permissions;
+use Utopia\Database\Validator\UID;
+use Utopia\Platform\Scope\HTTP;
+use Utopia\Swoole\Response as SwooleResponse;
+use Utopia\Validator\Boolean;
+use Utopia\Validator\Text;
+
+class Update extends Action
+{
+    use HTTP;
+
+    public static function getName(): string
+    {
+        return 'updateCollection';
+    }
+
+    protected function getResponseModel(): string
+    {
+        return UtopiaResponse::MODEL_COLLECTION;
+    }
+
+    public function __construct()
+    {
+        $this->setContext(Action::COLLECTION);
+
+        $this
+            ->setHttpMethod(self::HTTP_REQUEST_METHOD_PUT)
+            ->setHttpPath('/v1/databases/:databaseId/collections/:collectionId')
+            ->desc('Update collection')
+            ->groups(['api', 'database', 'schema'])
+            ->label('scope', 'collections.write')
+            ->label('resourceType', RESOURCE_TYPE_DATABASES)
+            ->label('event', 'databases.[databaseId].collections.[collectionId].update')
+            ->label('audits.event', 'collection.update')
+            ->label('audits.resource', 'database/{request.databaseId}/collections/{request.collectionId}')
+            ->label('sdk', new Method(
+                namespace: 'databases',
+                group: $this->getSdkGroup(),
+                name: self::getName(),
+                description: '/docs/references/databases/update-collection.md',
+                auth: [AuthType::KEY],
+                responses: [
+                    new SDKResponse(
+                        code: SwooleResponse::STATUS_CODE_OK,
+                        model: $this->getResponseModel(),
+                    )
+                ],
+                contentType: ContentType::JSON
+            ))
+            ->param('databaseId', '', new UID(), 'Database ID.')
+            ->param('collectionId', '', new UID(), 'Collection ID.')
+            ->param('name', null, new Text(128), 'Collection name. Max length: 128 chars.')
+            ->param('permissions', null, new Permissions(APP_LIMIT_ARRAY_PARAMS_SIZE), 'An array of permission strings. By default, the current permissions are inherited. [Learn more about permissions](https://appwrite.io/docs/permissions).', true)
+            ->param('documentSecurity', false, new Boolean(true), 'Enables configuring permissions for individual documents. A user needs one of document or collection level permissions to access a document. [Learn more about permissions](https://appwrite.io/docs/permissions).', true)
+            ->param('enabled', true, new Boolean(), 'Is collection enabled? When set to \'disabled\', users cannot access the collection but Server SDKs with and API key can still read and write to the collection. No data is lost when this is toggled.', true)
+            ->inject('response')
+            ->inject('dbForProject')
+            ->inject('queueForEvents')
+            ->callback([$this, 'action']);
+    }
+
+    public function action(string $databaseId, string $collectionId, string $name, ?array $permissions, bool $documentSecurity, bool $enabled, UtopiaResponse $response, Database $dbForProject, Event $queueForEvents): void
+    {
+        $this->validateContext();
+
+        $database = Authorization::skip(fn () => $dbForProject->getDocument('databases', $databaseId));
+        if ($database->isEmpty()) {
+            throw new Exception(Exception::DATABASE_NOT_FOUND);
+        }
+
+        $collection = $dbForProject->getDocument('database_' . $database->getInternalId(), $collectionId);
+        if ($collection->isEmpty()) {
+            throw new Exception($this->getNotFoundException());
+        }
+
+        $permissions ??= $collection->getPermissions() ?? [];
+
+        // Map aggregate permissions into the multiple permissions they represent.
+        $permissions = Permission::aggregate($permissions);
+
+        $enabled ??= $collection->getAttribute('enabled', true);
+
+        $collection = $dbForProject->updateDocument(
+            'database_' . $database->getInternalId(),
+            $collectionId,
+            $collection
+                ->setAttribute('name', $name)
+                ->setAttribute('$permissions', $permissions)
+                ->setAttribute('documentSecurity', $documentSecurity)
+                ->setAttribute('enabled', $enabled)
+                ->setAttribute('search', \implode(' ', [$collectionId, $name]))
+        );
+
+        $dbForProject->updateCollection('database_' . $database->getInternalId() . '_collection_' . $collection->getInternalId(), $permissions, $documentSecurity);
+
+        $queueForEvents
+            ->setContext('database', $database)
+            ->setParam('databaseId', $databaseId)
+            ->setParam($this->getEventsParamKey(), $collection->getId());
+
+        $response->dynamic($collection, $this->getResponseModel());
+    }
+}
diff --git a/src/Appwrite/Platform/Modules/Databases/Http/Collections/Usage/Get.php b/src/Appwrite/Platform/Modules/Databases/Http/Collections/Usage/Get.php
new file mode 100644
index 0000000000..a9a924114f
--- /dev/null
+++ b/src/Appwrite/Platform/Modules/Databases/Http/Collections/Usage/Get.php
@@ -0,0 +1,143 @@
+<?php
+
+namespace Appwrite\Platform\Modules\Databases\Http\Collections\Usage;
+
+use Appwrite\Extend\Exception;
+use Appwrite\Platform\Modules\Databases\Http\Collections\Action;
+use Appwrite\SDK\AuthType;
+use Appwrite\SDK\ContentType;
+use Appwrite\SDK\Method;
+use Appwrite\SDK\Response as SDKResponse;
+use Appwrite\Utopia\Response as UtopiaResponse;
+use Utopia\Config\Config;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Query;
+use Utopia\Database\Validator\Authorization;
+use Utopia\Database\Validator\UID;
+use Utopia\Platform\Scope\HTTP;
+use Utopia\Swoole\Response as SwooleResponse;
+use Utopia\Validator\WhiteList;
+
+class Get extends Action
+{
+    use HTTP;
+
+    public static function getName(): string
+    {
+        return 'getCollectionUsage';
+    }
+
+    protected function getResponseModel(): string
+    {
+        return UtopiaResponse::MODEL_USAGE_COLLECTION;
+    }
+
+    public function __construct()
+    {
+        $this->setContext(Action::COLLECTION);
+
+        $this
+            ->setHttpMethod(self::HTTP_REQUEST_METHOD_GET)
+            ->setHttpPath('/v1/databases/:databaseId/collections/:collectionId/usage')
+            ->desc('Get collection usage stats')
+            ->groups(['api', 'database', 'usage'])
+            ->label('scope', 'collections.read')
+            ->label('resourceType', RESOURCE_TYPE_DATABASES)
+            ->label('sdk', new Method(
+                namespace: 'databases',
+                group: null,
+                name: self::getName(),
+                description: '/docs/references/databases/get-collection-usage.md',
+                auth: [AuthType::ADMIN],
+                responses: [
+                    new SDKResponse(
+                        code: SwooleResponse::STATUS_CODE_OK,
+                        model: $this->getResponseModel()
+                    )
+                ],
+                contentType: ContentType::JSON,
+            ))
+            ->param('databaseId', '', new UID(), 'Database ID.')
+            ->param('range', '30d', new WhiteList(['24h', '30d', '90d'], true), 'Date range.', true)
+            ->param('collectionId', '', new UID(), 'Collection ID.')
+            ->inject('response')
+            ->inject('dbForProject')
+            ->callback([$this, 'action']);
+    }
+
+    public function action(string $databaseId, string $range, string $collectionId, UtopiaResponse $response, Database $dbForProject): void
+    {
+        $this->validateContext();
+
+        $database = $dbForProject->getDocument('databases', $databaseId);
+        $collectionDocument = $dbForProject->getDocument('database_' . $database->getInternalId(), $collectionId);
+        $collection = $dbForProject->getCollection('database_' . $database->getInternalId() . '_collection_' . $collectionDocument->getInternalId());
+
+        if ($collection->isEmpty()) {
+            throw new Exception($this->getNotFoundException());
+        }
+
+        $periods = Config::getParam('usage', []);
+        $stats = $usage = [];
+        $days = $periods[$range];
+        $metrics = [
+            str_replace(['{databaseInternalId}', '{collectionInternalId}'], [$database->getInternalId(), $collectionDocument->getInternalId()], METRIC_DATABASE_ID_COLLECTION_ID_DOCUMENTS),
+        ];
+
+        Authorization::skip(function () use ($dbForProject, $days, $metrics, &$stats) {
+            foreach ($metrics as $metric) {
+                $result = $dbForProject->findOne('stats', [
+                    Query::equal('metric', [$metric]),
+                    Query::equal('period', ['inf'])
+                ]);
+
+                $stats[$metric]['total'] = $result['value'] ?? 0;
+                $limit = $days['limit'];
+                $period = $days['period'];
+                $results = $dbForProject->find('stats', [
+                    Query::equal('metric', [$metric]),
+                    Query::equal('period', [$period]),
+                    Query::limit($limit),
+                    Query::orderDesc('time'),
+                ]);
+                $stats[$metric]['data'] = [];
+                foreach ($results as $result) {
+                    $stats[$metric]['data'][$result->getAttribute('time')] = [
+                        'value' => $result->getAttribute('value'),
+                    ];
+                }
+            }
+        });
+
+        $format = match ($days['period']) {
+            '1h' => 'Y-m-d\TH:00:00.000P',
+            '1d' => 'Y-m-d\T00:00:00.000P',
+        };
+
+        foreach ($metrics as $metric) {
+            $usage[$metric]['total'] = $stats[$metric]['total'];
+            $usage[$metric]['data'] = [];
+            $leap = time() - ($days['limit'] * $days['factor']);
+            while ($leap < time()) {
+                $leap += $days['factor'];
+                $formatDate = date($format, $leap);
+                $usage[$metric]['data'][] = [
+                    'value' => $stats[$metric]['data'][$formatDate]['value'] ?? 0,
+                    'date' => $formatDate,
+                ];
+            }
+        }
+
+        $prefix = $this->isCollectionsAPI() ? 'documents' : 'rows';
+
+        // prefix, prefixTotal
+        $usageDocument = new Document([
+            'range' => $range,
+            $prefix => $usage[$metrics[0]]['data'],
+            $prefix . 'Total' => $usage[$metrics[0]]['total'],
+        ]);
+
+        $response->dynamic($usageDocument, $this->getResponseModel());
+    }
+}
diff --git a/src/Appwrite/Platform/Modules/Databases/Http/Collections/XList.php b/src/Appwrite/Platform/Modules/Databases/Http/Collections/XList.php
new file mode 100644
index 0000000000..e540e86c06
--- /dev/null
+++ b/src/Appwrite/Platform/Modules/Databases/Http/Collections/XList.php
@@ -0,0 +1,128 @@
+<?php
+
+namespace Appwrite\Platform\Modules\Databases\Http\Collections;
+
+use Appwrite\Extend\Exception;
+use Appwrite\SDK\AuthType;
+use Appwrite\SDK\ContentType;
+use Appwrite\SDK\Method;
+use Appwrite\SDK\Response as SDKResponse;
+use Appwrite\Utopia\Database\Validator\Queries\Collections;
+use Appwrite\Utopia\Response as UtopiaResponse;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Exception\Order as OrderException;
+use Utopia\Database\Query;
+use Utopia\Database\Validator\Authorization;
+use Utopia\Database\Validator\Query\Cursor;
+use Utopia\Database\Validator\UID;
+use Utopia\Platform\Scope\HTTP;
+use Utopia\Swoole\Response as SwooleResponse;
+use Utopia\Validator\Text;
+
+class XList extends Action
+{
+    use HTTP;
+
+    public static function getName(): string
+    {
+        return 'listCollections';
+    }
+
+    protected function getResponseModel(): string
+    {
+        return UtopiaResponse::MODEL_COLLECTION_LIST;
+    }
+
+    public function __construct()
+    {
+        $this->setContext(Action::COLLECTION);
+
+        $this
+            ->setHttpMethod(self::HTTP_REQUEST_METHOD_GET)
+            ->setHttpPath('/v1/databases/:databaseId/collections')
+            ->desc('List collections')
+            ->groups(['api', 'database'])
+            ->label('scope', 'collections.read')
+            ->label('resourceType', RESOURCE_TYPE_DATABASES)
+            ->label('sdk', new Method(
+                namespace: 'databases',
+                group: $this->getSdkGroup(),
+                name: self::getName(),
+                description: '/docs/references/databases/list-collections.md',
+                auth: [AuthType::KEY],
+                responses: [
+                    new SDKResponse(
+                        code: SwooleResponse::STATUS_CODE_OK,
+                        model: $this->getResponseModel(),
+                    )
+                ],
+                contentType: ContentType::JSON
+            ))
+            ->param('databaseId', '', new UID(), 'Database ID.')
+            ->param('queries', [], new Collections(), 'Array of query strings generated using the Query class provided by the SDK. [Learn more about queries](https://appwrite.io/docs/queries). Maximum of ' . APP_LIMIT_ARRAY_PARAMS_SIZE . ' queries are allowed, each ' . APP_LIMIT_ARRAY_ELEMENT_SIZE . ' characters long. You may filter on the following attributes: ' . implode(', ', Collections::ALLOWED_ATTRIBUTES), true)
+            ->param('search', '', new Text(256), 'Search term to filter your list results. Max length: 256 chars.', true)
+            ->inject('response')
+            ->inject('dbForProject')
+            ->callback([$this, 'action']);
+    }
+
+    public function action(string $databaseId, array $queries, string $search, UtopiaResponse $response, Database $dbForProject): void
+    {
+        $this->validateContext();
+
+        $database = Authorization::skip(fn () => $dbForProject->getDocument('databases', $databaseId));
+
+        if ($database->isEmpty()) {
+            throw new Exception(Exception::DATABASE_NOT_FOUND);
+        }
+
+        $queries = Query::parseQueries($queries);
+
+        if (!empty($search)) {
+            $queries[] = Query::search('search', $search);
+        }
+
+        /**
+         * Get cursor document if there was a cursor query, we use array_filter and reset for reference $cursor to $queries
+         */
+        $cursor = \array_filter($queries, function ($query) {
+            return \in_array($query->getMethod(), [Query::TYPE_CURSOR_AFTER, Query::TYPE_CURSOR_BEFORE]);
+        });
+        $cursor = reset($cursor);
+
+        if ($cursor) {
+            $validator = new Cursor();
+            if (!$validator->isValid($cursor)) {
+                throw new Exception(Exception::GENERAL_QUERY_INVALID, $validator->getDescription());
+            }
+
+            $collectionIdId = $cursor->getValue();
+            $cursorDocument = $dbForProject->getDocument('database_' . $database->getInternalId(), $collectionIdId);
+
+            if ($cursorDocument->isEmpty()) {
+                $message =
+                    throw new Exception(Exception::GENERAL_CURSOR_NOT_FOUND, ucfirst($this->getContext()) . " '$collectionIdId' for the 'cursor' value not found.");
+            }
+
+            $cursor->setValue($cursorDocument);
+        }
+
+        $filterQueries = Query::groupByType($queries)['filters'];
+
+        try {
+            $collections = $dbForProject->find('database_' . $database->getInternalId(), $queries);
+            $total = $dbForProject->count('database_' . $database->getInternalId(), $filterQueries, APP_LIMIT_COUNT);
+        } catch (OrderException $e) {
+            $documents = $this->isCollectionsAPI() ? 'documents' : 'rows';
+            $attribute = $this->isCollectionsAPI() ? 'attribute' : 'column';
+            $message = "The order $attribute '{$e->getAttribute()}' had a null value. Cursor pagination requires all $documents order $attribute values are non-null.";
+            throw new Exception(Exception::DATABASE_QUERY_ORDER_NULL, $message);
+        }
+
+        $response->dynamic(new Document([
+            'total' => $total,
+            $this->getSdkGroup() => $collections,
+        ]), $this->getResponseModel());
+    }
+}
diff --git a/src/Appwrite/Platform/Modules/Databases/Http/Tables/Create.php b/src/Appwrite/Platform/Modules/Databases/Http/Tables/Create.php
index dc3f7b8574..6f30c897b4 100644
--- a/src/Appwrite/Platform/Modules/Databases/Http/Tables/Create.php
+++ b/src/Appwrite/Platform/Modules/Databases/Http/Tables/Create.php
@@ -3,7 +3,8 @@
 namespace Appwrite\Platform\Modules\Databases\Http\Tables;
 
 use Appwrite\Event\Event;
-use Appwrite\Extend\Exception;
+use Appwrite\Platform\Modules\Databases\Http\Collections\Action;
+use Appwrite\Platform\Modules\Databases\Http\Collections\Create as CollectionCreate;
 use Appwrite\SDK\AuthType;
 use Appwrite\SDK\ContentType;
 use Appwrite\SDK\Method;
@@ -11,21 +12,14 @@ use Appwrite\SDK\Response as SDKResponse;
 use Appwrite\Utopia\Database\Validator\CustomId;
 use Appwrite\Utopia\Response as UtopiaResponse;
 use Utopia\Database\Database;
-use Utopia\Database\Document;
-use Utopia\Database\Exception\Duplicate as DuplicateException;
-use Utopia\Database\Exception\Limit as LimitException;
-use Utopia\Database\Helpers\ID;
-use Utopia\Database\Helpers\Permission;
-use Utopia\Database\Validator\Authorization;
 use Utopia\Database\Validator\Permissions;
 use Utopia\Database\Validator\UID;
-use Utopia\Platform\Action;
 use Utopia\Platform\Scope\HTTP;
 use Utopia\Swoole\Response as SwooleResponse;
 use Utopia\Validator\Boolean;
 use Utopia\Validator\Text;
 
-class Create extends Action
+class Create extends CollectionCreate
 {
     use HTTP;
 
@@ -34,12 +28,18 @@ class Create extends Action
         return 'createTable';
     }
 
+    protected function getResponseModel(): string
+    {
+        return UtopiaResponse::MODEL_TABLE;
+    }
+
     public function __construct()
     {
+        $this->setContext(Action::TABLE);
+
         $this
             ->setHttpMethod(self::HTTP_REQUEST_METHOD_POST)
             ->setHttpPath('/v1/databases/:databaseId/tables')
-            ->httpAlias('/v1/databases/:databaseId/collections')
             ->desc('Create table')
             ->groups(['api', 'database'])
             ->label('event', 'databases.[databaseId].tables.[tableId].create')
@@ -49,14 +49,14 @@ class Create extends Action
             ->label('audits.resource', 'database/{request.databaseId}/table/{response.$id}')
             ->label('sdk', new Method(
                 namespace: 'databases',
-                group: 'tables',
-                name: 'createTable',
+                group: $this->getSdkGroup(),
+                name: self::getName(),
                 description: '/docs/references/databases/create-collection.md',
                 auth: [AuthType::KEY],
                 responses: [
                     new SDKResponse(
                         code: SwooleResponse::STATUS_CODE_CREATED,
-                        model: UtopiaResponse::MODEL_TABLE,
+                        model: $this->getResponseModel(),
                     )
                 ],
                 contentType: ContentType::JSON
@@ -65,52 +65,13 @@ class Create extends Action
             ->param('tableId', '', new CustomId(), 'Unique Id. Choose a custom ID or generate a random ID with `ID.unique()`. Valid chars are a-z, A-Z, 0-9, period, hyphen, and underscore. Can\'t start with a special char. Max length is 36 chars.')
             ->param('name', '', new Text(128), 'Table name. Max length: 128 chars.')
             ->param('permissions', null, new Permissions(APP_LIMIT_ARRAY_PARAMS_SIZE), 'An array of permissions strings. By default, no user is granted with any permissions. [Learn more about permissions](https://appwrite.io/docs/permissions).', true)
-            ->param('documentSecurity', false, new Boolean(true), 'Enables configuring permissions for individual documents. A user needs one of document or collection level permissions to access a document. [Learn more about permissions](https://appwrite.io/docs/permissions).', true)
-            ->param('enabled', true, new Boolean(), 'Is collection enabled? When set to \'disabled\', users cannot access the collection but Server SDKs with and API key can still read and write to the collection. No data is lost when this is toggled.', true)
+            ->param('documentSecurity', false, new Boolean(true), 'Enables configuring permissions for individual documents. A user needs one of document or table level permissions to access a document. [Learn more about permissions](https://appwrite.io/docs/permissions).', true)
+            ->param('enabled', true, new Boolean(), 'Is table enabled? When set to \'disabled\', users cannot access the table but Server SDKs with and API key can still read and write to the table. No data is lost when this is toggled.', true)
             ->inject('response')
             ->inject('dbForProject')
             ->inject('queueForEvents')
-            ->callback([$this, 'action']);
-    }
-
-    public function action(string $databaseId, string $tableId, string $name, ?array $permissions, bool $documentSecurity, bool $enabled, UtopiaResponse $response, Database $dbForProject, Event $queueForEvents): void
-    {
-        $database = Authorization::skip(fn () => $dbForProject->getDocument('databases', $databaseId));
-
-        if ($database->isEmpty()) {
-            throw new Exception(Exception::DATABASE_NOT_FOUND);
-        }
-
-        $tableId = $tableId === 'unique()' ? ID::unique() : $tableId;
-
-        $permissions = Permission::aggregate($permissions) ?? [];
-
-        try {
-            $table = $dbForProject->createDocument('database_' . $database->getInternalId(), new Document([
-                '$id' => $tableId,
-                'databaseInternalId' => $database->getInternalId(),
-                'databaseId' => $databaseId,
-                '$permissions' => $permissions,
-                'documentSecurity' => $documentSecurity,
-                'enabled' => $enabled,
-                'name' => $name,
-                'search' => \implode(' ', [$tableId, $name]),
-            ]));
-
-            $dbForProject->createCollection('database_' . $database->getInternalId() . '_collection_' . $table->getInternalId(), permissions: $permissions, documentSecurity: $documentSecurity);
-        } catch (DuplicateException) {
-            throw new Exception(Exception::TABLE_ALREADY_EXISTS);
-        } catch (LimitException) {
-            throw new Exception(Exception::TABLE_LIMIT_EXCEEDED);
-        }
-
-        $queueForEvents
-            ->setContext('database', $database)
-            ->setParam('databaseId', $databaseId)
-            ->setParam('tableId', $table->getId());
-
-        $response
-            ->setStatusCode(SwooleResponse::STATUS_CODE_CREATED)
-            ->dynamic($table, UtopiaResponse::MODEL_TABLE);
+            ->callback(function (string $databaseId, string $tableId, string $name, ?array $permissions, bool $documentSecurity, bool $enabled, UtopiaResponse $response, Database $dbForProject, Event $queueForEvents) {
+                parent::action($databaseId, $tableId, $name, $permissions, $documentSecurity, $enabled, $response, $dbForProject, $queueForEvents);
+            });
     }
 }
diff --git a/src/Appwrite/Platform/Modules/Databases/Http/Tables/Delete.php b/src/Appwrite/Platform/Modules/Databases/Http/Tables/Delete.php
index b7e8f6ecf7..810edf7f21 100644
--- a/src/Appwrite/Platform/Modules/Databases/Http/Tables/Delete.php
+++ b/src/Appwrite/Platform/Modules/Databases/Http/Tables/Delete.php
@@ -4,20 +4,19 @@ namespace Appwrite\Platform\Modules\Databases\Http\Tables;
 
 use Appwrite\Event\Database as EventDatabase;
 use Appwrite\Event\Event;
-use Appwrite\Extend\Exception;
+use Appwrite\Platform\Modules\Databases\Http\Collections\Action;
+use Appwrite\Platform\Modules\Databases\Http\Collections\Delete as CollectionDelete;
 use Appwrite\SDK\AuthType;
 use Appwrite\SDK\ContentType;
 use Appwrite\SDK\Method;
 use Appwrite\SDK\Response as SDKResponse;
 use Appwrite\Utopia\Response as UtopiaResponse;
 use Utopia\Database\Database;
-use Utopia\Database\Validator\Authorization;
 use Utopia\Database\Validator\UID;
-use Utopia\Platform\Action;
 use Utopia\Platform\Scope\HTTP;
 use Utopia\Swoole\Response as SwooleResponse;
 
-class Delete extends Action
+class Delete extends CollectionDelete
 {
     use HTTP;
 
@@ -26,12 +25,18 @@ class Delete extends Action
         return 'deleteTable';
     }
 
+    protected function getResponseModel(): string
+    {
+        return UtopiaResponse::MODEL_TABLE;
+    }
+
     public function __construct()
     {
+        $this->setContext(Action::TABLE);
+
         $this
             ->setHttpMethod(self::HTTP_REQUEST_METHOD_DELETE)
             ->setHttpPath('/v1/databases/:databaseId/tables/:tableId')
-            ->httpAlias('/v1/databases/:databaseId/collections/:tableId')
             ->desc('Delete table')
             ->groups(['api', 'database', 'schema'])
             ->label('scope', 'collections.write')
@@ -41,8 +46,8 @@ class Delete extends Action
             ->label('audits.resource', 'database/{request.databaseId}/table/{request.tableId}')
             ->label('sdk', new Method(
                 namespace: 'databases',
-                group: 'tables',
-                name: 'deleteTable',
+                group: $this->getSdkGroup(),
+                name: self::getName(),
                 description: '/docs/references/databases/delete-collection.md',
                 auth: [AuthType::KEY],
                 responses: [
@@ -59,38 +64,8 @@ class Delete extends Action
             ->inject('dbForProject')
             ->inject('queueForDatabase')
             ->inject('queueForEvents')
-            ->callback([$this, 'action']);
-    }
-
-    public function action(string $databaseId, string $tableId, UtopiaResponse $response, Database $dbForProject, EventDatabase $queueForDatabase, Event $queueForEvents): void
-    {
-        $database = Authorization::skip(fn () => $dbForProject->getDocument('databases', $databaseId));
-        if ($database->isEmpty()) {
-            throw new Exception(Exception::DATABASE_NOT_FOUND);
-        }
-
-        $table = $dbForProject->getDocument('database_' . $database->getInternalId(), $tableId);
-        if ($table->isEmpty()) {
-            throw new Exception(Exception::TABLE_NOT_FOUND);
-        }
-
-        if (!$dbForProject->deleteDocument('database_' . $database->getInternalId(), $tableId)) {
-            throw new Exception(Exception::GENERAL_SERVER_ERROR, 'Failed to remove collection from DB');
-        }
-
-        $dbForProject->purgeCachedCollection('database_' . $database->getInternalId() . '_collection_' . $table->getInternalId());
-
-        $queueForDatabase
-            ->setType(DATABASE_TYPE_DELETE_COLLECTION)
-            ->setDatabase($database)
-            ->setTable($table);
-
-        $queueForEvents
-            ->setContext('database', $database)
-            ->setParam('databaseId', $databaseId)
-            ->setParam('tableId', $table->getId())
-            ->setPayload($response->output($table, UtopiaResponse::MODEL_TABLE));
-
-        $response->noContent();
+            ->callback(function (string $databaseId, string $tableId, UtopiaResponse $response, Database $dbForProject, EventDatabase $queueForDatabase, Event $queueForEvents) {
+                parent::action($databaseId, $tableId, $response, $dbForProject, $queueForDatabase, $queueForEvents);
+            });
     }
 }
diff --git a/src/Appwrite/Platform/Modules/Databases/Http/Tables/Get.php b/src/Appwrite/Platform/Modules/Databases/Http/Tables/Get.php
index 4c76c1f89d..80798a4516 100644
--- a/src/Appwrite/Platform/Modules/Databases/Http/Tables/Get.php
+++ b/src/Appwrite/Platform/Modules/Databases/Http/Tables/Get.php
@@ -2,20 +2,19 @@
 
 namespace Appwrite\Platform\Modules\Databases\Http\Tables;
 
-use Appwrite\Extend\Exception;
+use Appwrite\Platform\Modules\Databases\Http\Collections\Action;
+use Appwrite\Platform\Modules\Databases\Http\Collections\Get as CollectionGet;
 use Appwrite\SDK\AuthType;
 use Appwrite\SDK\ContentType;
 use Appwrite\SDK\Method;
 use Appwrite\SDK\Response as SDKResponse;
 use Appwrite\Utopia\Response as UtopiaResponse;
 use Utopia\Database\Database;
-use Utopia\Database\Validator\Authorization;
 use Utopia\Database\Validator\UID;
-use Utopia\Platform\Action;
 use Utopia\Platform\Scope\HTTP;
 use Utopia\Swoole\Response as SwooleResponse;
 
-class Get extends Action
+class Get extends CollectionGet
 {
     use HTTP;
 
@@ -24,26 +23,32 @@ class Get extends Action
         return 'getTable';
     }
 
+    protected function getResponseModel(): string
+    {
+        return UtopiaResponse::MODEL_TABLE;
+    }
+
     public function __construct()
     {
+        $this->setContext(Action::TABLE);
+
         $this
             ->setHttpMethod(self::HTTP_REQUEST_METHOD_GET)
             ->setHttpPath('/v1/databases/:databaseId/tables/:tableId')
-            ->httpAlias('/v1/databases/:databaseId/collections/:tableId')
             ->desc('Get table')
             ->groups(['api', 'database'])
             ->label('scope', 'collections.read')
             ->label('resourceType', RESOURCE_TYPE_DATABASES)
             ->label('sdk', new Method(
                 namespace: 'databases',
-                group: 'tables',
-                name: 'getTable',
+                group: $this->getSdkGroup(),
+                name: self::getName(),
                 description: '/docs/references/databases/get-collection.md',
                 auth: [AuthType::KEY],
                 responses: [
                     new SDKResponse(
                         code: SwooleResponse::STATUS_CODE_OK,
-                        model: UtopiaResponse::MODEL_TABLE,
+                        model: $this->getResponseModel(),
                     )
                 ],
                 contentType: ContentType::JSON
@@ -52,23 +57,8 @@ class Get extends Action
             ->param('tableId', '', new UID(), 'Table ID.')
             ->inject('response')
             ->inject('dbForProject')
-            ->callback([$this, 'action']);
-    }
-
-    public function action(string $databaseId, string $tableId, UtopiaResponse $response, Database $dbForProject): void
-    {
-        $database = Authorization::skip(fn () => $dbForProject->getDocument('databases', $databaseId));
-
-        if ($database->isEmpty()) {
-            throw new Exception(Exception::DATABASE_NOT_FOUND);
-        }
-
-        $table = $dbForProject->getDocument('database_' . $database->getInternalId(), $tableId);
-
-        if ($table->isEmpty()) {
-            throw new Exception(Exception::TABLE_NOT_FOUND);
-        }
-
-        $response->dynamic($table, UtopiaResponse::MODEL_TABLE);
+            ->callback(function (string $databaseId, string $tableId, UtopiaResponse $response, Database $dbForProject) {
+                parent::action($databaseId, $tableId, $response, $dbForProject);
+            });
     }
 }
diff --git a/src/Appwrite/Platform/Modules/Databases/Http/Tables/Logs/XList.php b/src/Appwrite/Platform/Modules/Databases/Http/Tables/Logs/XList.php
index 1dba2493cf..b3ce8cd272 100644
--- a/src/Appwrite/Platform/Modules/Databases/Http/Tables/Logs/XList.php
+++ b/src/Appwrite/Platform/Modules/Databases/Http/Tables/Logs/XList.php
@@ -2,31 +2,24 @@
 
 namespace Appwrite\Platform\Modules\Databases\Http\Tables\Logs;
 
-use Appwrite\Extend\Exception;
+use Appwrite\Platform\Modules\Databases\Http\Collections\Action;
+use Appwrite\Platform\Modules\Databases\Http\Collections\Logs\XList as CollectionLogXList;
 use Appwrite\SDK\AuthType;
 use Appwrite\SDK\ContentType;
 use Appwrite\SDK\Method;
 use Appwrite\SDK\Response as SDKResponse;
 use Appwrite\Utopia\Response as UtopiaResponse;
-use DeviceDetector\DeviceDetector as Detector;
 use MaxMind\Db\Reader;
-use Utopia\Audit\Audit;
 use Utopia\Database\Database;
-use Utopia\Database\DateTime;
-use Utopia\Database\Document;
-use Utopia\Database\Exception\Query as QueryException;
-use Utopia\Database\Query;
-use Utopia\Database\Validator\Authorization;
 use Utopia\Database\Validator\Queries;
 use Utopia\Database\Validator\Query\Limit;
 use Utopia\Database\Validator\Query\Offset;
 use Utopia\Database\Validator\UID;
 use Utopia\Locale\Locale;
-use Utopia\Platform\Action;
 use Utopia\Platform\Scope\HTTP;
 use Utopia\Swoole\Response as SwooleResponse;
 
-class XList extends Action
+class XList extends CollectionLogXList
 {
     use HTTP;
 
@@ -35,26 +28,32 @@ class XList extends Action
         return 'listTableLogs';
     }
 
+    protected function getResponseModel(): string
+    {
+        return UtopiaResponse::MODEL_LOG_LIST;
+    }
+
     public function __construct()
     {
+        $this->setContext(Action::TABLE);
+
         $this
             ->setHttpMethod(self::HTTP_REQUEST_METHOD_GET)
             ->setHttpPath('/v1/databases/:databaseId/tables/:tableId/logs')
-            ->httpAlias('/v1/databases/:databaseId/collections/:tableId/logs')
             ->desc('List table logs')
             ->groups(['api', 'database'])
             ->label('scope', 'collections.read')
             ->label('resourceType', RESOURCE_TYPE_DATABASES)
             ->label('sdk', new Method(
                 namespace: 'databases',
-                group: 'tables',
-                name: 'listTableLogs',
+                group: $this->getSdkGroup(),
+                name: self::getName(),
                 description: '/docs/references/databases/get-collection-logs.md',
                 auth: [AuthType::ADMIN],
                 responses: [
                     new SDKResponse(
                         code: SwooleResponse::STATUS_CODE_OK,
-                        model: UtopiaResponse::MODEL_LOG_LIST,
+                        model: $this->getResponseModel(),
                     )
                 ],
                 contentType: ContentType::JSON
@@ -66,88 +65,8 @@ class XList extends Action
             ->inject('dbForProject')
             ->inject('locale')
             ->inject('geodb')
-            ->callback([$this, 'action']);
-    }
-
-    public function action(string $databaseId, string $tableId, array $queries, UtopiaResponse $response, Database $dbForProject, Locale $locale, Reader $geodb): void
-    {
-        $database = Authorization::skip(fn () => $dbForProject->getDocument('databases', $databaseId));
-
-        if ($database->isEmpty()) {
-            throw new Exception(Exception::DATABASE_NOT_FOUND);
-        }
-
-        $tableDocument = $dbForProject->getDocument('database_' . $database->getInternalId(), $tableId);
-        $table = $dbForProject->getCollection('database_' . $database->getInternalId() . '_collection_' . $tableDocument->getInternalId());
-
-        if ($table->isEmpty()) {
-            throw new Exception(Exception::TABLE_NOT_FOUND);
-        }
-
-        try {
-            $queries = Query::parseQueries($queries);
-        } catch (QueryException $e) {
-            throw new Exception(Exception::GENERAL_QUERY_INVALID, $e->getMessage());
-        }
-
-        // Temp fix for logs
-        $queries[] = Query::or([
-            Query::greaterThan('$createdAt', DateTime::format(new \DateTime('2025-02-26T01:30+00:00'))),
-            Query::lessThan('$createdAt', DateTime::format(new \DateTime('2025-02-13T00:00+00:00'))),
-        ]);
-
-        $audit = new Audit($dbForProject);
-        $resource = 'database/' . $databaseId . '/table/' . $tableId;
-        $logs = $audit->getLogsByResource($resource, $queries);
-
-        $output = [];
-
-        foreach ($logs as $i => &$log) {
-            $log['userAgent'] = (!empty($log['userAgent'])) ? $log['userAgent'] : 'UNKNOWN';
-
-            $detector = new Detector($log['userAgent']);
-            $detector->skipBotDetection(); // OPTIONAL: If called, bot detection will completely be skipped (bots will be detected as regular devices then)
-
-            $os = $detector->getOS();
-            $client = $detector->getClient();
-            $device = $detector->getDevice();
-
-            $output[$i] = new Document([
-                'event' => $log['event'],
-                'userId' => $log['data']['userId'],
-                'userEmail' => $log['data']['userEmail'] ?? null,
-                'userName' => $log['data']['userName'] ?? null,
-                'mode' => $log['data']['mode'] ?? null,
-                'ip' => $log['ip'],
-                'time' => $log['time'],
-                'osCode' => $os['osCode'],
-                'osName' => $os['osName'],
-                'osVersion' => $os['osVersion'],
-                'clientType' => $client['clientType'],
-                'clientCode' => $client['clientCode'],
-                'clientName' => $client['clientName'],
-                'clientVersion' => $client['clientVersion'],
-                'clientEngine' => $client['clientEngine'],
-                'clientEngineVersion' => $client['clientEngineVersion'],
-                'deviceName' => $device['deviceName'],
-                'deviceBrand' => $device['deviceBrand'],
-                'deviceModel' => $device['deviceModel']
-            ]);
-
-            $record = $geodb->get($log['ip']);
-
-            if ($record) {
-                $output[$i]['countryCode'] = $locale->getText('countries.' . strtolower($record['country']['iso_code']), false) ? \strtolower($record['country']['iso_code']) : '--';
-                $output[$i]['countryName'] = $locale->getText('countries.' . strtolower($record['country']['iso_code']), $locale->getText('locale.country.unknown'));
-            } else {
-                $output[$i]['countryCode'] = '--';
-                $output[$i]['countryName'] = $locale->getText('locale.country.unknown');
-            }
-        }
-
-        $response->dynamic(new Document([
-            'total' => $audit->countLogsByResource($resource, $queries),
-            'logs' => $output,
-        ]), UtopiaResponse::MODEL_LOG_LIST);
+            ->callback(function (string $databaseId, string $tableId, array $queries, UtopiaResponse $response, Database $dbForProject, Locale $locale, Reader $geodb) {
+                parent::action($databaseId, $tableId, $queries, $response, $dbForProject, $locale, $geodb);
+            });
     }
 }
diff --git a/src/Appwrite/Platform/Modules/Databases/Http/Tables/Update.php b/src/Appwrite/Platform/Modules/Databases/Http/Tables/Update.php
index f5621feab3..fde9114e59 100644
--- a/src/Appwrite/Platform/Modules/Databases/Http/Tables/Update.php
+++ b/src/Appwrite/Platform/Modules/Databases/Http/Tables/Update.php
@@ -3,24 +3,22 @@
 namespace Appwrite\Platform\Modules\Databases\Http\Tables;
 
 use Appwrite\Event\Event;
-use Appwrite\Extend\Exception;
+use Appwrite\Platform\Modules\Databases\Http\Collections\Action;
+use Appwrite\Platform\Modules\Databases\Http\Collections\Update as CollectionUpdate;
 use Appwrite\SDK\AuthType;
 use Appwrite\SDK\ContentType;
 use Appwrite\SDK\Method;
 use Appwrite\SDK\Response as SDKResponse;
 use Appwrite\Utopia\Response as UtopiaResponse;
 use Utopia\Database\Database;
-use Utopia\Database\Helpers\Permission;
-use Utopia\Database\Validator\Authorization;
 use Utopia\Database\Validator\Permissions;
 use Utopia\Database\Validator\UID;
-use Utopia\Platform\Action;
 use Utopia\Platform\Scope\HTTP;
 use Utopia\Swoole\Response as SwooleResponse;
 use Utopia\Validator\Boolean;
 use Utopia\Validator\Text;
 
-class Update extends Action
+class Update extends CollectionUpdate
 {
     use HTTP;
 
@@ -29,12 +27,18 @@ class Update extends Action
         return 'updateTable';
     }
 
+    protected function getResponseModel(): string
+    {
+        return UtopiaResponse::MODEL_TABLE;
+    }
+
     public function __construct()
     {
+        $this->setContext(Action::TABLE);
+
         $this
             ->setHttpMethod(self::HTTP_REQUEST_METHOD_PUT)
             ->setHttpPath('/v1/databases/:databaseId/tables/:tableId')
-            ->httpAlias('/v1/databases/:databaseId/collections/:tableId')
             ->desc('Update table')
             ->groups(['api', 'database', 'schema'])
             ->label('scope', 'collections.write')
@@ -44,8 +48,8 @@ class Update extends Action
             ->label('audits.resource', 'database/{request.databaseId}/table/{request.tableId}')
             ->label('sdk', new Method(
                 namespace: 'databases',
-                group: 'tables',
-                name: 'updateTable',
+                group: $this->getSdkGroup(),
+                name: self::getName(),
                 description: '/docs/references/databases/update-collection.md',
                 auth: [AuthType::KEY],
                 responses: [
@@ -65,46 +69,8 @@ class Update extends Action
             ->inject('response')
             ->inject('dbForProject')
             ->inject('queueForEvents')
-            ->callback([$this, 'action']);
-    }
-
-    public function action(string $databaseId, string $tableId, string $name, ?array $permissions, bool $documentSecurity, bool $enabled, UtopiaResponse $response, Database $dbForProject, Event $queueForEvents): void
-    {
-        $database = Authorization::skip(fn () => $dbForProject->getDocument('databases', $databaseId));
-        if ($database->isEmpty()) {
-            throw new Exception(Exception::DATABASE_NOT_FOUND);
-        }
-
-        $table = $dbForProject->getDocument('database_' . $database->getInternalId(), $tableId);
-        if ($table->isEmpty()) {
-            throw new Exception(Exception::TABLE_NOT_FOUND);
-        }
-
-        $permissions ??= $table->getPermissions() ?? [];
-
-        // Map aggregate permissions into the multiple permissions they represent.
-        $permissions = Permission::aggregate($permissions);
-
-        $enabled ??= $table->getAttribute('enabled', true);
-
-        $table = $dbForProject->updateDocument(
-            'database_' . $database->getInternalId(),
-            $tableId,
-            $table
-                ->setAttribute('name', $name)
-                ->setAttribute('$permissions', $permissions)
-                ->setAttribute('documentSecurity', $documentSecurity)
-                ->setAttribute('enabled', $enabled)
-                ->setAttribute('search', \implode(' ', [$tableId, $name]))
-        );
-
-        $dbForProject->updateCollection('database_' . $database->getInternalId() . '_collection_' . $table->getInternalId(), $permissions, $documentSecurity);
-
-        $queueForEvents
-            ->setContext('database', $database)
-            ->setParam('databaseId', $databaseId)
-            ->setParam('tableId', $table->getId());
-
-        $response->dynamic($table, UtopiaResponse::MODEL_TABLE);
+            ->callback(function (string $databaseId, string $tableId, string $name, ?array $permissions, bool $documentSecurity, bool $enabled, UtopiaResponse $response, Database $dbForProject, Event $queueForEvents) {
+                parent::action($databaseId, $tableId, $name, $permissions, $documentSecurity, $enabled, $response, $dbForProject, $queueForEvents);
+            });
     }
 }
diff --git a/src/Appwrite/Platform/Modules/Databases/Http/Tables/Usage/Get.php b/src/Appwrite/Platform/Modules/Databases/Http/Tables/Usage/Get.php
index b528fee7cf..9ba99d32e1 100644
--- a/src/Appwrite/Platform/Modules/Databases/Http/Tables/Usage/Get.php
+++ b/src/Appwrite/Platform/Modules/Databases/Http/Tables/Usage/Get.php
@@ -2,24 +2,20 @@
 
 namespace Appwrite\Platform\Modules\Databases\Http\Tables\Usage;
 
-use Appwrite\Extend\Exception;
+use Appwrite\Platform\Modules\Databases\Http\Collections\Action;
+use Appwrite\Platform\Modules\Databases\Http\Collections\Usage\Get as CollectionUsageGet;
 use Appwrite\SDK\AuthType;
 use Appwrite\SDK\ContentType;
 use Appwrite\SDK\Method;
 use Appwrite\SDK\Response as SDKResponse;
 use Appwrite\Utopia\Response as UtopiaResponse;
-use Utopia\Config\Config;
 use Utopia\Database\Database;
-use Utopia\Database\Document;
-use Utopia\Database\Query;
-use Utopia\Database\Validator\Authorization;
 use Utopia\Database\Validator\UID;
-use Utopia\Platform\Action;
 use Utopia\Platform\Scope\HTTP;
 use Utopia\Swoole\Response as SwooleResponse;
 use Utopia\Validator\WhiteList;
 
-class Get extends Action
+class Get extends CollectionUsageGet
 {
     use HTTP;
 
@@ -28,12 +24,18 @@ class Get extends Action
         return 'getTableUsage';
     }
 
+    protected function getResponseModel(): string
+    {
+        return UtopiaResponse::MODEL_USAGE_TABLE;
+    }
+
     public function __construct()
     {
+        $this->setContext(Action::TABLE);
+
         $this
             ->setHttpMethod(self::HTTP_REQUEST_METHOD_GET)
             ->setHttpPath('/v1/databases/:databaseId/tables/:tableId/usage')
-            ->httpAlias('/v1/databases/:databaseId/collections/:tableId/usage')
             ->desc('Get table usage stats')
             ->groups(['api', 'database', 'usage'])
             ->label('scope', 'collections.read')
@@ -41,13 +43,13 @@ class Get extends Action
             ->label('sdk', new Method(
                 namespace: 'databases',
                 group: null,
-                name: 'getTableUsage',
+                name: self::getName(),
                 description: '/docs/references/databases/get-collection-usage.md',
                 auth: [AuthType::ADMIN],
                 responses: [
                     new SDKResponse(
                         code: SwooleResponse::STATUS_CODE_OK,
-                        model: UtopiaResponse::MODEL_USAGE_TABLE,
+                        model: $this->getResponseModel(),
                     )
                 ],
                 contentType: ContentType::JSON,
@@ -57,75 +59,8 @@ class Get extends Action
             ->param('tableId', '', new UID(), 'Collection ID.')
             ->inject('response')
             ->inject('dbForProject')
-            ->callback([$this, 'action']);
-    }
-
-    public function action(string $databaseId, string $range, string $tableId, UtopiaResponse $response, Database $dbForProject): void
-    {
-
-        $database = $dbForProject->getDocument('databases', $databaseId);
-        $tableDocument = $dbForProject->getDocument('database_' . $database->getInternalId(), $tableId);
-        $table = $dbForProject->getCollection('database_' . $database->getInternalId() . '_collection_' . $tableDocument->getInternalId());
-
-        if ($table->isEmpty()) {
-            throw new Exception(Exception::TABLE_NOT_FOUND);
-        }
-
-        $periods = Config::getParam('usage', []);
-        $stats = $usage = [];
-        $days = $periods[$range];
-        $metrics = [
-            str_replace(['{databaseInternalId}', '{collectionInternalId}'], [$database->getInternalId(), $tableDocument->getInternalId()], METRIC_DATABASE_ID_COLLECTION_ID_DOCUMENTS),
-        ];
-
-        Authorization::skip(function () use ($dbForProject, $days, $metrics, &$stats) {
-            foreach ($metrics as $metric) {
-                $result = $dbForProject->findOne('stats', [
-                    Query::equal('metric', [$metric]),
-                    Query::equal('period', ['inf'])
-                ]);
-
-                $stats[$metric]['total'] = $result['value'] ?? 0;
-                $limit = $days['limit'];
-                $period = $days['period'];
-                $results = $dbForProject->find('stats', [
-                    Query::equal('metric', [$metric]),
-                    Query::equal('period', [$period]),
-                    Query::limit($limit),
-                    Query::orderDesc('time'),
-                ]);
-                $stats[$metric]['data'] = [];
-                foreach ($results as $result) {
-                    $stats[$metric]['data'][$result->getAttribute('time')] = [
-                        'value' => $result->getAttribute('value'),
-                    ];
-                }
-            }
-        });
-
-        $format = match ($days['period']) {
-            '1h' => 'Y-m-d\TH:00:00.000P',
-            '1d' => 'Y-m-d\T00:00:00.000P',
-        };
-
-        foreach ($metrics as $metric) {
-            $usage[$metric]['total'] = $stats[$metric]['total'];
-            $usage[$metric]['data'] = [];
-            $leap = time() - ($days['limit'] * $days['factor']);
-            while ($leap < time()) {
-                $leap += $days['factor'];
-                $formatDate = date($format, $leap);
-                $usage[$metric]['data'][] = [
-                    'value' => $stats[$metric]['data'][$formatDate]['value'] ?? 0,
-                    'date' => $formatDate,
-                ];
-            }
-        }
-
-        $response->dynamic(new Document([
-            'range' => $range,
-            'rows' => $usage[$metrics[0]]['data'],
-            'rowsTotal' => $usage[$metrics[0]]['total'],
-        ]), UtopiaResponse::MODEL_USAGE_TABLE);
+            ->callback(function (string $databaseId, string $range, string $tableId, UtopiaResponse $response, Database $dbForProject) {
+                parent::action($databaseId, $range, $tableId, $response, $dbForProject);
+            });
     }
 }
diff --git a/src/Appwrite/Platform/Modules/Databases/Http/Tables/XList.php b/src/Appwrite/Platform/Modules/Databases/Http/Tables/XList.php
index e6d2a2d02a..f90a1f66f2 100644
--- a/src/Appwrite/Platform/Modules/Databases/Http/Tables/XList.php
+++ b/src/Appwrite/Platform/Modules/Databases/Http/Tables/XList.php
@@ -2,7 +2,8 @@
 
 namespace Appwrite\Platform\Modules\Databases\Http\Tables;
 
-use Appwrite\Extend\Exception;
+use Appwrite\Platform\Modules\Databases\Http\Collections\Action;
+use Appwrite\Platform\Modules\Databases\Http\Collections\XList as CollectionXList;
 use Appwrite\SDK\AuthType;
 use Appwrite\SDK\ContentType;
 use Appwrite\SDK\Method;
@@ -10,18 +11,12 @@ use Appwrite\SDK\Response as SDKResponse;
 use Appwrite\Utopia\Database\Validator\Queries\Tables;
 use Appwrite\Utopia\Response as UtopiaResponse;
 use Utopia\Database\Database;
-use Utopia\Database\Document;
-use Utopia\Database\Exception\Order as OrderException;
-use Utopia\Database\Query;
-use Utopia\Database\Validator\Authorization;
-use Utopia\Database\Validator\Query\Cursor;
 use Utopia\Database\Validator\UID;
-use Utopia\Platform\Action;
 use Utopia\Platform\Scope\HTTP;
 use Utopia\Swoole\Response as SwooleResponse;
 use Utopia\Validator\Text;
 
-class XList extends Action
+class XList extends CollectionXList
 {
     use HTTP;
 
@@ -30,26 +25,32 @@ class XList extends Action
         return 'listTables';
     }
 
+    protected function getResponseModel(): string
+    {
+        return UtopiaResponse::MODEL_TABLE_LIST;
+    }
+
     public function __construct()
     {
+        $this->setContext(Action::TABLE);
+
         $this
             ->setHttpMethod(self::HTTP_REQUEST_METHOD_GET)
             ->setHttpPath('/v1/databases/:databaseId/tables')
-            ->httpAlias('/v1/databases/:databaseId/collections')
             ->desc('List tables')
             ->groups(['api', 'database'])
             ->label('scope', 'collections.read')
             ->label('resourceType', RESOURCE_TYPE_DATABASES)
             ->label('sdk', new Method(
                 namespace: 'databases',
-                group: 'tables',
-                name: 'listTables',
+                group: $this->getSdkGroup(),
+                name: self::getName(),
                 description: '/docs/references/databases/list-collections.md',
                 auth: [AuthType::KEY],
                 responses: [
                     new SDKResponse(
                         code: SwooleResponse::STATUS_CODE_OK,
-                        model: UtopiaResponse::MODEL_TABLE_LIST,
+                        model: $this->getResponseModel(),
                     )
                 ],
                 contentType: ContentType::JSON
@@ -59,59 +60,8 @@ class XList extends Action
             ->param('search', '', new Text(256), 'Search term to filter your list results. Max length: 256 chars.', true)
             ->inject('response')
             ->inject('dbForProject')
-            ->callback([$this, 'action']);
-    }
-
-    public function action(string $databaseId, array $queries, string $search, UtopiaResponse $response, Database $dbForProject): void
-    {
-        $database = Authorization::skip(fn () => $dbForProject->getDocument('databases', $databaseId));
-
-        if ($database->isEmpty()) {
-            throw new Exception(Exception::DATABASE_NOT_FOUND);
-        }
-
-        $queries = Query::parseQueries($queries);
-
-        if (!empty($search)) {
-            $queries[] = Query::search('search', $search);
-        }
-
-        /**
-         * Get cursor document if there was a cursor query, we use array_filter and reset for reference $cursor to $queries
-         */
-        $cursor = \array_filter($queries, function ($query) {
-            return \in_array($query->getMethod(), [Query::TYPE_CURSOR_AFTER, Query::TYPE_CURSOR_BEFORE]);
-        });
-        $cursor = reset($cursor);
-
-        if ($cursor) {
-            $validator = new Cursor();
-            if (!$validator->isValid($cursor)) {
-                throw new Exception(Exception::GENERAL_QUERY_INVALID, $validator->getDescription());
-            }
-
-            $tableId = $cursor->getValue();
-            $cursorDocument = $dbForProject->getDocument('database_' . $database->getInternalId(), $tableId);
-
-            if ($cursorDocument->isEmpty()) {
-                throw new Exception(Exception::GENERAL_CURSOR_NOT_FOUND, "Table '{$tableId}' for the 'cursor' value not found.");
-            }
-
-            $cursor->setValue($cursorDocument);
-        }
-
-        $filterQueries = Query::groupByType($queries)['filters'];
-
-        try {
-            $tables = $dbForProject->find('database_' . $database->getInternalId(), $queries);
-            $total = $dbForProject->count('database_' . $database->getInternalId(), $filterQueries, APP_LIMIT_COUNT);
-        } catch (OrderException $e) {
-            throw new Exception(Exception::DATABASE_QUERY_ORDER_NULL, "The order column '{$e->getAttribute()}' had a null value. Cursor pagination requires all rows order column values are non-null.");
-        }
-
-        $response->dynamic(new Document([
-            'tables' => $tables,
-            'total' => $total,
-        ]), UtopiaResponse::MODEL_TABLE_LIST);
+            ->callback(function (string $databaseId, array $queries, string $search, UtopiaResponse $response, Database $dbForProject) {
+                parent::action($databaseId, $queries, $search, $response, $dbForProject);
+            });
     }
 }
diff --git a/src/Appwrite/Platform/Modules/Databases/Services/Http.php b/src/Appwrite/Platform/Modules/Databases/Services/Http.php
index ffdd4f1903..26a4aa0942 100644
--- a/src/Appwrite/Platform/Modules/Databases/Services/Http.php
+++ b/src/Appwrite/Platform/Modules/Databases/Services/Http.php
@@ -2,6 +2,13 @@
 
 namespace Appwrite\Platform\Modules\Databases\Services;
 
+use Appwrite\Platform\Modules\Databases\Http\Collections\Create as CreateCollection;
+use Appwrite\Platform\Modules\Databases\Http\Collections\Delete as DeleteCollection;
+use Appwrite\Platform\Modules\Databases\Http\Collections\Get as GetCollection;
+use Appwrite\Platform\Modules\Databases\Http\Collections\Logs\XList as ListCollectionLogs;
+use Appwrite\Platform\Modules\Databases\Http\Collections\Update as UpdateCollection;
+use Appwrite\Platform\Modules\Databases\Http\Collections\Usage\Get as GetCollectionUsage;
+use Appwrite\Platform\Modules\Databases\Http\Collections\XList as ListCollections;
 use Appwrite\Platform\Modules\Databases\Http\Columns\Boolean\Create as CreateBoolean;
 use Appwrite\Platform\Modules\Databases\Http\Columns\Boolean\Update as UpdateBoolean;
 use Appwrite\Platform\Modules\Databases\Http\Columns\Datetime\Create as CreateDatetime;
@@ -59,7 +66,7 @@ class Http extends Service
         $this->type = Service::TYPE_HTTP;
 
         $this->registerDatabaseActions();
-        $this->registerTableActions();
+        $this->registerCollectionAndTableActions();
         $this->registerColumnActions();
         $this->registerIndexActions();
         $this->registerRowActions();
@@ -77,8 +84,18 @@ class Http extends Service
         $this->addAction(ListDatabaseUsage::getName(), new ListDatabaseUsage());
     }
 
-    private function registerTableActions(): void
+    private function registerCollectionAndTableActions(): void
     {
+        // Collections
+        $this->addAction(CreateCollection::getName(), new CreateCollection());
+        $this->addAction(GetCollection::getName(), new GetCollection());
+        $this->addAction(UpdateCollection::getName(), new UpdateCollection());
+        $this->addAction(DeleteCollection::getName(), new DeleteCollection());
+        $this->addAction(ListCollections::getName(), new ListCollections());
+        $this->addAction(ListCollectionLogs::getName(), new ListCollectionLogs());
+        $this->addAction(GetCollectionUsage::getName(), new GetCollectionUsage());
+
+        // Tables
         $this->addAction(CreateTable::getName(), new CreateTable());
         $this->addAction(GetTable::getName(), new GetTable());
         $this->addAction(UpdateTable::getName(), new UpdateTable());