Add routes

src/Appwrite/Platform/Modules/Databases/Http/Databases/Collections/Attributes/Action.php

@@ -265,6 +265,22 @@ abstract class Action extends UtopiaAction
                 ? UtopiaResponse::MODEL_ATTRIBUTE_POLYGON
                 : UtopiaResponse::MODEL_COLUMN_POLYGON,
 
+            Database::VAR_VARCHAR => $isCollections
+                ? UtopiaResponse::MODEL_ATTRIBUTE_VARCHAR
+                : UtopiaResponse::MODEL_COLUMN_VARCHAR,
+
+            Database::VAR_TEXT => $isCollections
+                ? UtopiaResponse::MODEL_ATTRIBUTE_TEXT
+                : UtopiaResponse::MODEL_COLUMN_TEXT,
+
+            Database::VAR_MEDIUMTEXT => $isCollections
+                ? UtopiaResponse::MODEL_ATTRIBUTE_MEDIUMTEXT
+                : UtopiaResponse::MODEL_COLUMN_MEDIUMTEXT,
+
+            Database::VAR_LONGTEXT => $isCollections
+                ? UtopiaResponse::MODEL_ATTRIBUTE_LONGTEXT
+                : UtopiaResponse::MODEL_COLUMN_LONGTEXT,
+
             Database::VAR_STRING => match ($format) {
                 APP_DATABASE_ATTRIBUTE_EMAIL => $isCollections
                     ? UtopiaResponse::MODEL_ATTRIBUTE_EMAIL

src/Appwrite/Platform/Modules/Databases/Http/Databases/Collections/Attributes/Longtext/Create.php

@@ -0,0 +1,108 @@
+<?php
+
+namespace Appwrite\Platform\Modules\Databases\Http\Databases\Collections\Attributes\Longtext;
+
+use Appwrite\Event\Database as EventDatabase;
+use Appwrite\Event\Event;
+use Appwrite\Platform\Modules\Databases\Http\Databases\Collections\Attributes\Action;
+use Appwrite\SDK\AuthType;
+use Appwrite\SDK\Method;
+use Appwrite\SDK\Response as SDKResponse;
+use Appwrite\Utopia\Response as UtopiaResponse;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Validator\Authorization;
+use Utopia\Database\Validator\Key;
+use Utopia\Database\Validator\UID;
+use Utopia\Swoole\Response as SwooleResponse;
+use Utopia\Validator\Boolean;
+use Utopia\Validator\Nullable;
+use Utopia\Validator\Text;
+
+class Create extends Action
+{
+    public static function getName(): string
+    {
+        return 'createLongtextAttribute';
+    }
+
+    protected function getResponseModel(): string|array
+    {
+        return UtopiaResponse::MODEL_ATTRIBUTE_LONGTEXT;
+    }
+
+    public function __construct()
+    {
+        $this
+            ->setHttpMethod(self::HTTP_REQUEST_METHOD_POST)
+            ->setHttpPath('/v1/databases/:databaseId/collections/:collectionId/attributes/longtext')
+            ->desc('Create longtext attribute')
+            ->groups(['api', 'database', 'schema'])
+            ->label('scope', 'collections.write')
+            ->label('resourceType', RESOURCE_TYPE_DATABASES)
+            ->label('event', 'databases.[databaseId].collections.[collectionId].attributes.[attributeId].create')
+            ->label('audits.event', 'attribute.create')
+            ->label('audits.resource', 'database/{request.databaseId}/collection/{request.collectionId}')
+            ->label('sdk', new Method(
+                namespace: $this->getSDKNamespace(),
+                group: $this->getSDKGroup(),
+                name: self::getName(),
+                description: '/docs/references/databases/create-longtext-attribute.md',
+                auth: [AuthType::ADMIN, AuthType::KEY],
+                responses: [
+                    new SDKResponse(
+                        code: SwooleResponse::STATUS_CODE_ACCEPTED,
+                        model: $this->getResponseModel()
+                    )
+                ],
+            ))
+            ->param('databaseId', '', new UID(), 'Database ID.')
+            ->param('collectionId', '', new UID(), 'Collection ID. You can create a new collection using the Database service [server integration](https://appwrite.io/docs/server/databases#databasesCreateCollection).')
+            ->param('key', '', new Key(), 'Attribute Key.')
+            ->param('required', null, new Boolean(), 'Is attribute required?')
+            ->param('default', null, new Nullable(new Text(0, 0)), 'Default value for attribute when not provided. Cannot be set when attribute is required.', true)
+            ->param('array', false, new Boolean(), 'Is attribute an array?', true)
+            ->inject('response')
+            ->inject('dbForProject')
+            ->inject('queueForDatabase')
+            ->inject('queueForEvents')
+            ->inject('authorization')
+            ->callback($this->action(...));
+    }
+
+    public function action(
+        string         $databaseId,
+        string         $collectionId,
+        string         $key,
+        ?bool          $required,
+        ?string        $default,
+        bool           $array,
+        UtopiaResponse $response,
+        Database       $dbForProject,
+        EventDatabase  $queueForDatabase,
+        Event          $queueForEvents,
+        Authorization $authorization
+    ): void {
+        $attribute = $this->createAttribute(
+            $databaseId,
+            $collectionId,
+            new Document([
+                'key' => $key,
+                'type' => Database::VAR_LONGTEXT,
+                'size' => 4294967295,
+                'required' => $required,
+                'default' => $default,
+                'array' => $array,
+            ]),
+            $response,
+            $dbForProject,
+            $queueForDatabase,
+            $queueForEvents,
+            $authorization
+        );
+
+        $response
+            ->setStatusCode(SwooleResponse::STATUS_CODE_ACCEPTED)
+            ->dynamic($attribute, $this->getResponseModel());
+    }
+}

src/Appwrite/Platform/Modules/Databases/Http/Databases/Collections/Attributes/Longtext/Update.php

@@ -0,0 +1,101 @@
+<?php
+
+namespace Appwrite\Platform\Modules\Databases\Http\Databases\Collections\Attributes\Longtext;
+
+use Appwrite\Event\Event;
+use Appwrite\Platform\Modules\Databases\Http\Databases\Collections\Attributes\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\Database\Database;
+use Utopia\Database\Validator\Authorization;
+use Utopia\Database\Validator\Key;
+use Utopia\Database\Validator\UID;
+use Utopia\Swoole\Response as SwooleResponse;
+use Utopia\Validator\Boolean;
+use Utopia\Validator\Nullable;
+use Utopia\Validator\Text;
+
+class Update extends Action
+{
+    public static function getName(): string
+    {
+        return 'updateLongtextAttribute';
+    }
+
+    protected function getResponseModel(): string|array
+    {
+        return UtopiaResponse::MODEL_ATTRIBUTE_LONGTEXT;
+    }
+
+    public function __construct()
+    {
+        $this
+            ->setHttpMethod(self::HTTP_REQUEST_METHOD_PATCH)
+            ->setHttpPath('/v1/databases/:databaseId/collections/:collectionId/attributes/longtext/:key')
+            ->desc('Update longtext attribute')
+            ->groups(['api', 'database', 'schema'])
+            ->label('scope', 'collections.write')
+            ->label('resourceType', RESOURCE_TYPE_DATABASES)
+            ->label('event', 'databases.[databaseId].collections.[collectionId].attributes.[attributeId].update')
+            ->label('audits.event', 'attribute.update')
+            ->label('audits.resource', 'database/{request.databaseId}/collection/{request.collectionId}')
+            ->label('sdk', new Method(
+                namespace: $this->getSDKNamespace(),
+                group: $this->getSDKGroup(),
+                name: self::getName(),
+                description: '/docs/references/databases/update-longtext-attribute.md',
+                auth: [AuthType::ADMIN, 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. You can create a new collection using the Database service [server integration](https://appwrite.io/docs/server/databases#databasesCreateCollection).')
+            ->param('key', '', new Key(), 'Attribute Key.')
+            ->param('required', null, new Boolean(), 'Is attribute required?')
+            ->param('default', null, new Nullable(new Text(0, 0)), 'Default value for attribute when not provided. Cannot be set when attribute is required.')
+            ->param('newKey', null, new Nullable(new Key()), 'New Attribute Key.', true)
+            ->inject('response')
+            ->inject('dbForProject')
+            ->inject('queueForEvents')
+            ->inject('authorization')
+            ->callback($this->action(...));
+    }
+
+    public function action(
+        string         $databaseId,
+        string         $collectionId,
+        string         $key,
+        ?bool          $required,
+        ?string        $default,
+        ?string        $newKey,
+        UtopiaResponse $response,
+        Database       $dbForProject,
+        Event          $queueForEvents,
+        Authorization  $authorization
+    ): void {
+        $attribute = $this->updateAttribute(
+            databaseId: $databaseId,
+            collectionId: $collectionId,
+            key: $key,
+            dbForProject: $dbForProject,
+            queueForEvents: $queueForEvents,
+            authorization: $authorization,
+            type: Database::VAR_LONGTEXT,
+            default: $default,
+            required: $required,
+            newKey: $newKey
+        );
+
+        $response
+            ->setStatusCode(SwooleResponse::STATUS_CODE_OK)
+            ->dynamic($attribute, $this->getResponseModel());
+    }
+}

src/Appwrite/Platform/Modules/Databases/Http/Databases/Collections/Attributes/Mediumtext/Create.php

@@ -0,0 +1,108 @@
+<?php
+
+namespace Appwrite\Platform\Modules\Databases\Http\Databases\Collections\Attributes\Mediumtext;
+
+use Appwrite\Event\Database as EventDatabase;
+use Appwrite\Event\Event;
+use Appwrite\Platform\Modules\Databases\Http\Databases\Collections\Attributes\Action;
+use Appwrite\SDK\AuthType;
+use Appwrite\SDK\Method;
+use Appwrite\SDK\Response as SDKResponse;
+use Appwrite\Utopia\Response as UtopiaResponse;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Validator\Authorization;
+use Utopia\Database\Validator\Key;
+use Utopia\Database\Validator\UID;
+use Utopia\Swoole\Response as SwooleResponse;
+use Utopia\Validator\Boolean;
+use Utopia\Validator\Nullable;
+use Utopia\Validator\Text;
+
+class Create extends Action
+{
+    public static function getName(): string
+    {
+        return 'createMediumtextAttribute';
+    }
+
+    protected function getResponseModel(): string|array
+    {
+        return UtopiaResponse::MODEL_ATTRIBUTE_MEDIUMTEXT;
+    }
+
+    public function __construct()
+    {
+        $this
+            ->setHttpMethod(self::HTTP_REQUEST_METHOD_POST)
+            ->setHttpPath('/v1/databases/:databaseId/collections/:collectionId/attributes/mediumtext')
+            ->desc('Create mediumtext attribute')
+            ->groups(['api', 'database', 'schema'])
+            ->label('scope', 'collections.write')
+            ->label('resourceType', RESOURCE_TYPE_DATABASES)
+            ->label('event', 'databases.[databaseId].collections.[collectionId].attributes.[attributeId].create')
+            ->label('audits.event', 'attribute.create')
+            ->label('audits.resource', 'database/{request.databaseId}/collection/{request.collectionId}')
+            ->label('sdk', new Method(
+                namespace: $this->getSDKNamespace(),
+                group: $this->getSDKGroup(),
+                name: self::getName(),
+                description: '/docs/references/databases/create-mediumtext-attribute.md',
+                auth: [AuthType::ADMIN, AuthType::KEY],
+                responses: [
+                    new SDKResponse(
+                        code: SwooleResponse::STATUS_CODE_ACCEPTED,
+                        model: $this->getResponseModel()
+                    )
+                ],
+            ))
+            ->param('databaseId', '', new UID(), 'Database ID.')
+            ->param('collectionId', '', new UID(), 'Collection ID. You can create a new collection using the Database service [server integration](https://appwrite.io/docs/server/databases#databasesCreateCollection).')
+            ->param('key', '', new Key(), 'Attribute Key.')
+            ->param('required', null, new Boolean(), 'Is attribute required?')
+            ->param('default', null, new Nullable(new Text(0, 0)), 'Default value for attribute when not provided. Cannot be set when attribute is required.', true)
+            ->param('array', false, new Boolean(), 'Is attribute an array?', true)
+            ->inject('response')
+            ->inject('dbForProject')
+            ->inject('queueForDatabase')
+            ->inject('queueForEvents')
+            ->inject('authorization')
+            ->callback($this->action(...));
+    }
+
+    public function action(
+        string         $databaseId,
+        string         $collectionId,
+        string         $key,
+        ?bool          $required,
+        ?string        $default,
+        bool           $array,
+        UtopiaResponse $response,
+        Database       $dbForProject,
+        EventDatabase  $queueForDatabase,
+        Event          $queueForEvents,
+        Authorization $authorization
+    ): void {
+        $attribute = $this->createAttribute(
+            $databaseId,
+            $collectionId,
+            new Document([
+                'key' => $key,
+                'type' => Database::VAR_MEDIUMTEXT,
+                'size' => 16777215,
+                'required' => $required,
+                'default' => $default,
+                'array' => $array,
+            ]),
+            $response,
+            $dbForProject,
+            $queueForDatabase,
+            $queueForEvents,
+            $authorization
+        );
+
+        $response
+            ->setStatusCode(SwooleResponse::STATUS_CODE_ACCEPTED)
+            ->dynamic($attribute, $this->getResponseModel());
+    }
+}

src/Appwrite/Platform/Modules/Databases/Http/Databases/Collections/Attributes/Mediumtext/Update.php

@@ -0,0 +1,101 @@
+<?php
+
+namespace Appwrite\Platform\Modules\Databases\Http\Databases\Collections\Attributes\Mediumtext;
+
+use Appwrite\Event\Event;
+use Appwrite\Platform\Modules\Databases\Http\Databases\Collections\Attributes\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\Database\Database;
+use Utopia\Database\Validator\Authorization;
+use Utopia\Database\Validator\Key;
+use Utopia\Database\Validator\UID;
+use Utopia\Swoole\Response as SwooleResponse;
+use Utopia\Validator\Boolean;
+use Utopia\Validator\Nullable;
+use Utopia\Validator\Text;
+
+class Update extends Action
+{
+    public static function getName(): string
+    {
+        return 'updateMediumtextAttribute';
+    }
+
+    protected function getResponseModel(): string|array
+    {
+        return UtopiaResponse::MODEL_ATTRIBUTE_MEDIUMTEXT;
+    }
+
+    public function __construct()
+    {
+        $this
+            ->setHttpMethod(self::HTTP_REQUEST_METHOD_PATCH)
+            ->setHttpPath('/v1/databases/:databaseId/collections/:collectionId/attributes/mediumtext/:key')
+            ->desc('Update mediumtext attribute')
+            ->groups(['api', 'database', 'schema'])
+            ->label('scope', 'collections.write')
+            ->label('resourceType', RESOURCE_TYPE_DATABASES)
+            ->label('event', 'databases.[databaseId].collections.[collectionId].attributes.[attributeId].update')
+            ->label('audits.event', 'attribute.update')
+            ->label('audits.resource', 'database/{request.databaseId}/collection/{request.collectionId}')
+            ->label('sdk', new Method(
+                namespace: $this->getSDKNamespace(),
+                group: $this->getSDKGroup(),
+                name: self::getName(),
+                description: '/docs/references/databases/update-mediumtext-attribute.md',
+                auth: [AuthType::ADMIN, 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. You can create a new collection using the Database service [server integration](https://appwrite.io/docs/server/databases#databasesCreateCollection).')
+            ->param('key', '', new Key(), 'Attribute Key.')
+            ->param('required', null, new Boolean(), 'Is attribute required?')
+            ->param('default', null, new Nullable(new Text(0, 0)), 'Default value for attribute when not provided. Cannot be set when attribute is required.')
+            ->param('newKey', null, new Nullable(new Key()), 'New Attribute Key.', true)
+            ->inject('response')
+            ->inject('dbForProject')
+            ->inject('queueForEvents')
+            ->inject('authorization')
+            ->callback($this->action(...));
+    }
+
+    public function action(
+        string         $databaseId,
+        string         $collectionId,
+        string         $key,
+        ?bool          $required,
+        ?string        $default,
+        ?string        $newKey,
+        UtopiaResponse $response,
+        Database       $dbForProject,
+        Event          $queueForEvents,
+        Authorization  $authorization
+    ): void {
+        $attribute = $this->updateAttribute(
+            databaseId: $databaseId,
+            collectionId: $collectionId,
+            key: $key,
+            dbForProject: $dbForProject,
+            queueForEvents: $queueForEvents,
+            authorization: $authorization,
+            type: Database::VAR_MEDIUMTEXT,
+            default: $default,
+            required: $required,
+            newKey: $newKey
+        );
+
+        $response
+            ->setStatusCode(SwooleResponse::STATUS_CODE_OK)
+            ->dynamic($attribute, $this->getResponseModel());
+    }
+}

src/Appwrite/Platform/Modules/Databases/Http/Databases/Collections/Attributes/Text/Create.php

@@ -0,0 +1,108 @@
+<?php
+
+namespace Appwrite\Platform\Modules\Databases\Http\Databases\Collections\Attributes\Text;
+
+use Appwrite\Event\Database as EventDatabase;
+use Appwrite\Event\Event;
+use Appwrite\Platform\Modules\Databases\Http\Databases\Collections\Attributes\Action;
+use Appwrite\SDK\AuthType;
+use Appwrite\SDK\Method;
+use Appwrite\SDK\Response as SDKResponse;
+use Appwrite\Utopia\Response as UtopiaResponse;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Validator\Authorization;
+use Utopia\Database\Validator\Key;
+use Utopia\Database\Validator\UID;
+use Utopia\Swoole\Response as SwooleResponse;
+use Utopia\Validator\Boolean;
+use Utopia\Validator\Nullable;
+use Utopia\Validator\Text;
+
+class Create extends Action
+{
+    public static function getName(): string
+    {
+        return 'createTextAttribute';
+    }
+
+    protected function getResponseModel(): string|array
+    {
+        return UtopiaResponse::MODEL_ATTRIBUTE_TEXT;
+    }
+
+    public function __construct()
+    {
+        $this
+            ->setHttpMethod(self::HTTP_REQUEST_METHOD_POST)
+            ->setHttpPath('/v1/databases/:databaseId/collections/:collectionId/attributes/text')
+            ->desc('Create text attribute')
+            ->groups(['api', 'database', 'schema'])
+            ->label('scope', 'collections.write')
+            ->label('resourceType', RESOURCE_TYPE_DATABASES)
+            ->label('event', 'databases.[databaseId].collections.[collectionId].attributes.[attributeId].create')
+            ->label('audits.event', 'attribute.create')
+            ->label('audits.resource', 'database/{request.databaseId}/collection/{request.collectionId}')
+            ->label('sdk', new Method(
+                namespace: $this->getSDKNamespace(),
+                group: $this->getSDKGroup(),
+                name: self::getName(),
+                description: '/docs/references/databases/create-text-attribute.md',
+                auth: [AuthType::ADMIN, AuthType::KEY],
+                responses: [
+                    new SDKResponse(
+                        code: SwooleResponse::STATUS_CODE_ACCEPTED,
+                        model: $this->getResponseModel()
+                    )
+                ],
+            ))
+            ->param('databaseId', '', new UID(), 'Database ID.')
+            ->param('collectionId', '', new UID(), 'Collection ID. You can create a new collection using the Database service [server integration](https://appwrite.io/docs/server/databases#databasesCreateCollection).')
+            ->param('key', '', new Key(), 'Attribute Key.')
+            ->param('required', null, new Boolean(), 'Is attribute required?')
+            ->param('default', null, new Nullable(new Text(0, 0)), 'Default value for attribute when not provided. Cannot be set when attribute is required.', true)
+            ->param('array', false, new Boolean(), 'Is attribute an array?', true)
+            ->inject('response')
+            ->inject('dbForProject')
+            ->inject('queueForDatabase')
+            ->inject('queueForEvents')
+            ->inject('authorization')
+            ->callback($this->action(...));
+    }
+
+    public function action(
+        string         $databaseId,
+        string         $collectionId,
+        string         $key,
+        ?bool          $required,
+        ?string        $default,
+        bool           $array,
+        UtopiaResponse $response,
+        Database       $dbForProject,
+        EventDatabase  $queueForDatabase,
+        Event          $queueForEvents,
+        Authorization $authorization
+    ): void {
+        $attribute = $this->createAttribute(
+            $databaseId,
+            $collectionId,
+            new Document([
+                'key' => $key,
+                'type' => Database::VAR_TEXT,
+                'size' => 65535,
+                'required' => $required,
+                'default' => $default,
+                'array' => $array,
+            ]),
+            $response,
+            $dbForProject,
+            $queueForDatabase,
+            $queueForEvents,
+            $authorization
+        );
+
+        $response
+            ->setStatusCode(SwooleResponse::STATUS_CODE_ACCEPTED)
+            ->dynamic($attribute, $this->getResponseModel());
+    }
+}

src/Appwrite/Platform/Modules/Databases/Http/Databases/Collections/Attributes/Text/Update.php

@@ -0,0 +1,101 @@
+<?php
+
+namespace Appwrite\Platform\Modules\Databases\Http\Databases\Collections\Attributes\Text;
+
+use Appwrite\Event\Event;
+use Appwrite\Platform\Modules\Databases\Http\Databases\Collections\Attributes\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\Database\Database;
+use Utopia\Database\Validator\Authorization;
+use Utopia\Database\Validator\Key;
+use Utopia\Database\Validator\UID;
+use Utopia\Swoole\Response as SwooleResponse;
+use Utopia\Validator\Boolean;
+use Utopia\Validator\Nullable;
+use Utopia\Validator\Text;
+
+class Update extends Action
+{
+    public static function getName(): string
+    {
+        return 'updateTextAttribute';
+    }
+
+    protected function getResponseModel(): string|array
+    {
+        return UtopiaResponse::MODEL_ATTRIBUTE_TEXT;
+    }
+
+    public function __construct()
+    {
+        $this
+            ->setHttpMethod(self::HTTP_REQUEST_METHOD_PATCH)
+            ->setHttpPath('/v1/databases/:databaseId/collections/:collectionId/attributes/text/:key')
+            ->desc('Update text attribute')
+            ->groups(['api', 'database', 'schema'])
+            ->label('scope', 'collections.write')
+            ->label('resourceType', RESOURCE_TYPE_DATABASES)
+            ->label('event', 'databases.[databaseId].collections.[collectionId].attributes.[attributeId].update')
+            ->label('audits.event', 'attribute.update')
+            ->label('audits.resource', 'database/{request.databaseId}/collection/{request.collectionId}')
+            ->label('sdk', new Method(
+                namespace: $this->getSDKNamespace(),
+                group: $this->getSDKGroup(),
+                name: self::getName(),
+                description: '/docs/references/databases/update-text-attribute.md',
+                auth: [AuthType::ADMIN, 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. You can create a new collection using the Database service [server integration](https://appwrite.io/docs/server/databases#databasesCreateCollection).')
+            ->param('key', '', new Key(), 'Attribute Key.')
+            ->param('required', null, new Boolean(), 'Is attribute required?')
+            ->param('default', null, new Nullable(new Text(0, 0)), 'Default value for attribute when not provided. Cannot be set when attribute is required.')
+            ->param('newKey', null, new Nullable(new Key()), 'New Attribute Key.', true)
+            ->inject('response')
+            ->inject('dbForProject')
+            ->inject('queueForEvents')
+            ->inject('authorization')
+            ->callback($this->action(...));
+    }
+
+    public function action(
+        string         $databaseId,
+        string         $collectionId,
+        string         $key,
+        ?bool          $required,
+        ?string        $default,
+        ?string        $newKey,
+        UtopiaResponse $response,
+        Database       $dbForProject,
+        Event          $queueForEvents,
+        Authorization  $authorization
+    ): void {
+        $attribute = $this->updateAttribute(
+            databaseId: $databaseId,
+            collectionId: $collectionId,
+            key: $key,
+            dbForProject: $dbForProject,
+            queueForEvents: $queueForEvents,
+            authorization: $authorization,
+            type: Database::VAR_TEXT,
+            default: $default,
+            required: $required,
+            newKey: $newKey
+        );
+
+        $response
+            ->setStatusCode(SwooleResponse::STATUS_CODE_OK)
+            ->dynamic($attribute, $this->getResponseModel());
+    }
+}

src/Appwrite/Platform/Modules/Databases/Http/Databases/Collections/Attributes/Varchar/Create.php

@@ -0,0 +1,119 @@
+<?php
+
+namespace Appwrite\Platform\Modules\Databases\Http\Databases\Collections\Attributes\Varchar;
+
+use Appwrite\Event\Database as EventDatabase;
+use Appwrite\Event\Event;
+use Appwrite\Extend\Exception;
+use Appwrite\Platform\Modules\Databases\Http\Databases\Collections\Attributes\Action;
+use Appwrite\SDK\AuthType;
+use Appwrite\SDK\Method;
+use Appwrite\SDK\Response as SDKResponse;
+use Appwrite\Utopia\Response as UtopiaResponse;
+use Utopia\Database\Database;
+use Utopia\Database\Document;
+use Utopia\Database\Validator\Authorization;
+use Utopia\Database\Validator\Key;
+use Utopia\Database\Validator\UID;
+use Utopia\Swoole\Response as SwooleResponse;
+use Utopia\Validator;
+use Utopia\Validator\Boolean;
+use Utopia\Validator\Nullable;
+use Utopia\Validator\Range;
+use Utopia\Validator\Text;
+
+class Create extends Action
+{
+    public static function getName(): string
+    {
+        return 'createVarcharAttribute';
+    }
+
+    protected function getResponseModel(): string|array
+    {
+        return UtopiaResponse::MODEL_ATTRIBUTE_VARCHAR;
+    }
+
+    public function __construct()
+    {
+        $this
+            ->setHttpMethod(self::HTTP_REQUEST_METHOD_POST)
+            ->setHttpPath('/v1/databases/:databaseId/collections/:collectionId/attributes/varchar')
+            ->desc('Create varchar attribute')
+            ->groups(['api', 'database', 'schema'])
+            ->label('scope', 'collections.write')
+            ->label('resourceType', RESOURCE_TYPE_DATABASES)
+            ->label('event', 'databases.[databaseId].collections.[collectionId].attributes.[attributeId].create')
+            ->label('audits.event', 'attribute.create')
+            ->label('audits.resource', 'database/{request.databaseId}/collection/{request.collectionId}')
+            ->label('sdk', new Method(
+                namespace: $this->getSDKNamespace(),
+                group: $this->getSDKGroup(),
+                name: self::getName(),
+                description: '/docs/references/databases/create-varchar-attribute.md',
+                auth: [AuthType::ADMIN, AuthType::KEY],
+                responses: [
+                    new SDKResponse(
+                        code: SwooleResponse::STATUS_CODE_ACCEPTED,
+                        model: $this->getResponseModel()
+                    )
+                ],
+            ))
+            ->param('databaseId', '', new UID(), 'Database ID.')
+            ->param('collectionId', '', new UID(), 'Collection ID. You can create a new collection using the Database service [server integration](https://appwrite.io/docs/server/databases#databasesCreateCollection).')
+            ->param('key', '', new Key(), 'Attribute Key.')
+            ->param('size', null, new Range(1, 16381, Validator::TYPE_INTEGER), 'Attribute size for text attributes, in number of characters. Maximum size is 16381.')
+            ->param('required', null, new Boolean(), 'Is attribute required?')
+            ->param('default', null, new Nullable(new Text(0, 0)), 'Default value for attribute when not provided. Cannot be set when attribute is required.', true)
+            ->param('array', false, new Boolean(), 'Is attribute an array?', true)
+            ->inject('response')
+            ->inject('dbForProject')
+            ->inject('queueForDatabase')
+            ->inject('queueForEvents')
+            ->inject('authorization')
+            ->callback($this->action(...));
+    }
+
+    public function action(
+        string         $databaseId,
+        string         $collectionId,
+        string         $key,
+        ?int           $size,
+        ?bool          $required,
+        ?string        $default,
+        bool           $array,
+        UtopiaResponse $response,
+        Database       $dbForProject,
+        EventDatabase  $queueForDatabase,
+        Event          $queueForEvents,
+        Authorization $authorization
+    ): void {
+        // Ensure default fits in the given size
+        $validator = new Text($size, 0);
+        if (!is_null($default) && !$validator->isValid($default)) {
+            throw new Exception($this->getInvalidValueException(), $validator->getDescription());
+        }
+
+        $attribute = $this->createAttribute(
+            $databaseId,
+            $collectionId,
+            new Document([
+                'key' => $key,
+                'type' => Database::VAR_VARCHAR,
+                'size' => $size,
+                'required' => $required,
+                'default' => $default,
+                'array' => $array,
+            ]),
+            $response,
+            $dbForProject,
+            $queueForDatabase,
+            $queueForEvents,
+            $authorization
+        );
+
+        $response
+            ->setStatusCode(SwooleResponse::STATUS_CODE_ACCEPTED)
+            ->dynamic($attribute, $this->getResponseModel());
+    }
+}

src/Appwrite/Platform/Modules/Databases/Http/Databases/Collections/Attributes/Varchar/Update.php

@@ -0,0 +1,106 @@
+<?php
+
+namespace Appwrite\Platform\Modules\Databases\Http\Databases\Collections\Attributes\Varchar;
+
+use Appwrite\Event\Event;
+use Appwrite\Platform\Modules\Databases\Http\Databases\Collections\Attributes\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\Database\Database;
+use Utopia\Database\Validator\Authorization;
+use Utopia\Database\Validator\Key;
+use Utopia\Database\Validator\UID;
+use Utopia\Swoole\Response as SwooleResponse;
+use Utopia\Validator;
+use Utopia\Validator\Boolean;
+use Utopia\Validator\Nullable;
+use Utopia\Validator\Range;
+use Utopia\Validator\Text;
+
+class Update extends Action
+{
+    public static function getName(): string
+    {
+        return 'updateVarcharAttribute';
+    }
+
+    protected function getResponseModel(): string|array
+    {
+        return UtopiaResponse::MODEL_ATTRIBUTE_VARCHAR;
+    }
+
+    public function __construct()
+    {
+        $this
+            ->setHttpMethod(self::HTTP_REQUEST_METHOD_PATCH)
+            ->setHttpPath('/v1/databases/:databaseId/collections/:collectionId/attributes/varchar/:key')
+            ->desc('Update varchar attribute')
+            ->groups(['api', 'database', 'schema'])
+            ->label('scope', 'collections.write')
+            ->label('resourceType', RESOURCE_TYPE_DATABASES)
+            ->label('event', 'databases.[databaseId].collections.[collectionId].attributes.[attributeId].update')
+            ->label('audits.event', 'attribute.update')
+            ->label('audits.resource', 'database/{request.databaseId}/collection/{request.collectionId}')
+            ->label('sdk', new Method(
+                namespace: $this->getSDKNamespace(),
+                group: $this->getSDKGroup(),
+                name: self::getName(),
+                description: '/docs/references/databases/update-varchar-attribute.md',
+                auth: [AuthType::ADMIN, 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. You can create a new collection using the Database service [server integration](https://appwrite.io/docs/server/databases#databasesCreateCollection).')
+            ->param('key', '', new Key(), 'Attribute Key.')
+            ->param('required', null, new Boolean(), 'Is attribute required?')
+            ->param('default', null, new Nullable(new Text(0, 0)), 'Default value for attribute when not provided. Cannot be set when attribute is required.')
+            ->param('size', null, new Nullable(new Range(1, 16381, Validator::TYPE_INTEGER)), 'Maximum size of the varchar attribute.', true)
+            ->param('newKey', null, new Nullable(new Key()), 'New Attribute Key.', true)
+            ->inject('response')
+            ->inject('dbForProject')
+            ->inject('queueForEvents')
+            ->inject('authorization')
+            ->callback($this->action(...));
+    }
+
+    public function action(
+        string         $databaseId,
+        string         $collectionId,
+        string         $key,
+        ?bool          $required,
+        ?string        $default,
+        ?int           $size,
+        ?string        $newKey,
+        UtopiaResponse $response,
+        Database       $dbForProject,
+        Event          $queueForEvents,
+        Authorization  $authorization
+    ): void {
+        $attribute = $this->updateAttribute(
+            databaseId: $databaseId,
+            collectionId: $collectionId,
+            key: $key,
+            dbForProject: $dbForProject,
+            queueForEvents: $queueForEvents,
+            authorization: $authorization,
+            type: Database::VAR_VARCHAR,
+            size: $size,
+            default: $default,
+            required: $required,
+            newKey: $newKey
+        );
+
+        $response
+            ->setStatusCode(SwooleResponse::STATUS_CODE_OK)
+            ->dynamic($attribute, $this->getResponseModel());
+    }
+}

src/Appwrite/Platform/Modules/Databases/Http/TablesDB/Tables/Columns/Longtext/Create.php

@@ -0,0 +1,67 @@
+<?php
+
+namespace Appwrite\Platform\Modules\Databases\Http\TablesDB\Tables\Columns\Longtext;
+
+use Appwrite\Platform\Modules\Databases\Http\Databases\Collections\Attributes\Longtext\Create as LongtextCreate;
+use Appwrite\SDK\AuthType;
+use Appwrite\SDK\Method;
+use Appwrite\SDK\Response as SDKResponse;
+use Appwrite\Utopia\Response as UtopiaResponse;
+use Utopia\Database\Validator\Key;
+use Utopia\Database\Validator\UID;
+use Utopia\Swoole\Response as SwooleResponse;
+use Utopia\Validator\Boolean;
+use Utopia\Validator\Nullable;
+use Utopia\Validator\Text;
+
+class Create extends LongtextCreate
+{
+    public static function getName(): string
+    {
+        return 'createLongtextColumn';
+    }
+
+    protected function getResponseModel(): string|array
+    {
+        return UtopiaResponse::MODEL_COLUMN_LONGTEXT;
+    }
+
+    public function __construct()
+    {
+        $this
+            ->setHttpMethod(self::HTTP_REQUEST_METHOD_POST)
+            ->setHttpPath('/v1/tablesdb/:databaseId/tables/:tableId/columns/longtext')
+            ->desc('Create longtext column')
+            ->groups(['api', 'database', 'schema'])
+            ->label('scope', ['tables.write', 'collections.write'])
+            ->label('resourceType', RESOURCE_TYPE_DATABASES)
+            ->label('event', 'databases.[databaseId].tables.[tableId].columns.[columnId].create')
+            ->label('audits.event', 'column.create')
+            ->label('audits.resource', 'database/{request.databaseId}/table/{request.tableId}')
+            ->label('sdk', new Method(
+                namespace: $this->getSDKNamespace(),
+                group: $this->getSDKGroup(),
+                name: self::getName(),
+                description: '/docs/references/tablesdb/create-longtext-column.md',
+                auth: [AuthType::ADMIN, AuthType::KEY],
+                responses: [
+                    new SDKResponse(
+                        code: SwooleResponse::STATUS_CODE_ACCEPTED,
+                        model: $this->getResponseModel()
+                    )
+                ]
+            ))
+            ->param('databaseId', '', new UID(), 'Database ID.')
+            ->param('tableId', '', new UID(), 'Table ID. You can create a new table using the Database service [server integration](https://appwrite.io/docs/references/cloud/server-dart/tablesDB#createTable).')
+            ->param('key', '', new Key(), 'Column Key.')
+            ->param('required', null, new Boolean(), 'Is column required?')
+            ->param('default', null, new Nullable(new Text(0, 0)), 'Default value for column when not provided. Cannot be set when column is required.', true)
+            ->param('array', false, new Boolean(), 'Is column an array?', true)
+            ->inject('response')
+            ->inject('dbForProject')
+            ->inject('queueForDatabase')
+            ->inject('queueForEvents')
+            ->inject('authorization')
+            ->callback($this->action(...));
+    }
+}

src/Appwrite/Platform/Modules/Databases/Http/TablesDB/Tables/Columns/Longtext/Update.php

@@ -0,0 +1,68 @@
+<?php
+
+namespace Appwrite\Platform\Modules\Databases\Http\TablesDB\Tables\Columns\Longtext;
+
+use Appwrite\Platform\Modules\Databases\Http\Databases\Collections\Attributes\Longtext\Update as LongtextUpdate;
+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\Validator\Key;
+use Utopia\Database\Validator\UID;
+use Utopia\Swoole\Response as SwooleResponse;
+use Utopia\Validator\Boolean;
+use Utopia\Validator\Nullable;
+use Utopia\Validator\Text;
+
+class Update extends LongtextUpdate
+{
+    public static function getName(): string
+    {
+        return 'updateLongtextColumn';
+    }
+
+    protected function getResponseModel(): string|array
+    {
+        return UtopiaResponse::MODEL_COLUMN_LONGTEXT;
+    }
+
+    public function __construct()
+    {
+        $this
+            ->setHttpMethod(self::HTTP_REQUEST_METHOD_PATCH)
+            ->setHttpPath('/v1/tablesdb/:databaseId/tables/:tableId/columns/longtext/:key')
+            ->desc('Update longtext column')
+            ->groups(['api', 'database', 'schema'])
+            ->label('scope', ['tables.write', 'collections.write'])
+            ->label('resourceType', RESOURCE_TYPE_DATABASES)
+            ->label('event', 'databases.[databaseId].tables.[tableId].columns.[columnId].update')
+            ->label('audits.event', 'column.update')
+            ->label('audits.resource', 'database/{request.databaseId}/table/{request.tableId}')
+            ->label('sdk', new Method(
+                namespace: $this->getSDKNamespace(),
+                group: $this->getSDKGroup(),
+                name: self::getName(),
+                description: '/docs/references/tablesdb/update-longtext-column.md',
+                auth: [AuthType::ADMIN, AuthType::KEY],
+                responses: [
+                    new SDKResponse(
+                        code: SwooleResponse::STATUS_CODE_OK,
+                        model: $this->getResponseModel(),
+                    )
+                ],
+                contentType: ContentType::JSON,
+            ))
+            ->param('databaseId', '', new UID(), 'Database ID.')
+            ->param('tableId', '', new UID(), 'Table ID. You can create a new table using the Database service [server integration](https://appwrite.io/docs/references/cloud/server-dart/tablesDB#createTable).')
+            ->param('key', '', new Key(), 'Column Key.')
+            ->param('required', null, new Boolean(), 'Is column required?')
+            ->param('default', null, new Nullable(new Text(0, 0)), 'Default value for column when not provided. Cannot be set when column is required.')
+            ->param('newKey', null, new Nullable(new Key()), 'New Column Key.', true)
+            ->inject('response')
+            ->inject('dbForProject')
+            ->inject('queueForEvents')
+            ->inject('authorization')
+            ->callback($this->action(...));
+    }
+}

src/Appwrite/Platform/Modules/Databases/Http/TablesDB/Tables/Columns/Mediumtext/Create.php

@@ -0,0 +1,67 @@
+<?php
+
+namespace Appwrite\Platform\Modules\Databases\Http\TablesDB\Tables\Columns\Mediumtext;
+
+use Appwrite\Platform\Modules\Databases\Http\Databases\Collections\Attributes\Mediumtext\Create as MediumtextCreate;
+use Appwrite\SDK\AuthType;
+use Appwrite\SDK\Method;
+use Appwrite\SDK\Response as SDKResponse;
+use Appwrite\Utopia\Response as UtopiaResponse;
+use Utopia\Database\Validator\Key;
+use Utopia\Database\Validator\UID;
+use Utopia\Swoole\Response as SwooleResponse;
+use Utopia\Validator\Boolean;
+use Utopia\Validator\Nullable;
+use Utopia\Validator\Text;
+
+class Create extends MediumtextCreate
+{
+    public static function getName(): string
+    {
+        return 'createMediumtextColumn';
+    }
+
+    protected function getResponseModel(): string|array
+    {
+        return UtopiaResponse::MODEL_COLUMN_MEDIUMTEXT;
+    }
+
+    public function __construct()
+    {
+        $this
+            ->setHttpMethod(self::HTTP_REQUEST_METHOD_POST)
+            ->setHttpPath('/v1/tablesdb/:databaseId/tables/:tableId/columns/mediumtext')
+            ->desc('Create mediumtext column')
+            ->groups(['api', 'database', 'schema'])
+            ->label('scope', ['tables.write', 'collections.write'])
+            ->label('resourceType', RESOURCE_TYPE_DATABASES)
+            ->label('event', 'databases.[databaseId].tables.[tableId].columns.[columnId].create')
+            ->label('audits.event', 'column.create')
+            ->label('audits.resource', 'database/{request.databaseId}/table/{request.tableId}')
+            ->label('sdk', new Method(
+                namespace: $this->getSDKNamespace(),
+                group: $this->getSDKGroup(),
+                name: self::getName(),
+                description: '/docs/references/tablesdb/create-mediumtext-column.md',
+                auth: [AuthType::ADMIN, AuthType::KEY],
+                responses: [
+                    new SDKResponse(
+                        code: SwooleResponse::STATUS_CODE_ACCEPTED,
+                        model: $this->getResponseModel()
+                    )
+                ]
+            ))
+            ->param('databaseId', '', new UID(), 'Database ID.')
+            ->param('tableId', '', new UID(), 'Table ID. You can create a new table using the Database service [server integration](https://appwrite.io/docs/references/cloud/server-dart/tablesDB#createTable).')
+            ->param('key', '', new Key(), 'Column Key.')
+            ->param('required', null, new Boolean(), 'Is column required?')
+            ->param('default', null, new Nullable(new Text(0, 0)), 'Default value for column when not provided. Cannot be set when column is required.', true)
+            ->param('array', false, new Boolean(), 'Is column an array?', true)
+            ->inject('response')
+            ->inject('dbForProject')
+            ->inject('queueForDatabase')
+            ->inject('queueForEvents')
+            ->inject('authorization')
+            ->callback($this->action(...));
+    }
+}

src/Appwrite/Platform/Modules/Databases/Http/TablesDB/Tables/Columns/Mediumtext/Update.php

@@ -0,0 +1,68 @@
+<?php
+
+namespace Appwrite\Platform\Modules\Databases\Http\TablesDB\Tables\Columns\Mediumtext;
+
+use Appwrite\Platform\Modules\Databases\Http\Databases\Collections\Attributes\Mediumtext\Update as MediumtextUpdate;
+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\Validator\Key;
+use Utopia\Database\Validator\UID;
+use Utopia\Swoole\Response as SwooleResponse;
+use Utopia\Validator\Boolean;
+use Utopia\Validator\Nullable;
+use Utopia\Validator\Text;
+
+class Update extends MediumtextUpdate
+{
+    public static function getName(): string
+    {
+        return 'updateMediumtextColumn';
+    }
+
+    protected function getResponseModel(): string|array
+    {
+        return UtopiaResponse::MODEL_COLUMN_MEDIUMTEXT;
+    }
+
+    public function __construct()
+    {
+        $this
+            ->setHttpMethod(self::HTTP_REQUEST_METHOD_PATCH)
+            ->setHttpPath('/v1/tablesdb/:databaseId/tables/:tableId/columns/mediumtext/:key')
+            ->desc('Update mediumtext column')
+            ->groups(['api', 'database', 'schema'])
+            ->label('scope', ['tables.write', 'collections.write'])
+            ->label('resourceType', RESOURCE_TYPE_DATABASES)
+            ->label('event', 'databases.[databaseId].tables.[tableId].columns.[columnId].update')
+            ->label('audits.event', 'column.update')
+            ->label('audits.resource', 'database/{request.databaseId}/table/{request.tableId}')
+            ->label('sdk', new Method(
+                namespace: $this->getSDKNamespace(),
+                group: $this->getSDKGroup(),
+                name: self::getName(),
+                description: '/docs/references/tablesdb/update-mediumtext-column.md',
+                auth: [AuthType::ADMIN, AuthType::KEY],
+                responses: [
+                    new SDKResponse(
+                        code: SwooleResponse::STATUS_CODE_OK,
+                        model: $this->getResponseModel(),
+                    )
+                ],
+                contentType: ContentType::JSON,
+            ))
+            ->param('databaseId', '', new UID(), 'Database ID.')
+            ->param('tableId', '', new UID(), 'Table ID. You can create a new table using the Database service [server integration](https://appwrite.io/docs/references/cloud/server-dart/tablesDB#createTable).')
+            ->param('key', '', new Key(), 'Column Key.')
+            ->param('required', null, new Boolean(), 'Is column required?')
+            ->param('default', null, new Nullable(new Text(0, 0)), 'Default value for column when not provided. Cannot be set when column is required.')
+            ->param('newKey', null, new Nullable(new Key()), 'New Column Key.', true)
+            ->inject('response')
+            ->inject('dbForProject')
+            ->inject('queueForEvents')
+            ->inject('authorization')
+            ->callback($this->action(...));
+    }
+}

src/Appwrite/Platform/Modules/Databases/Http/TablesDB/Tables/Columns/Text/Create.php

@@ -0,0 +1,67 @@
+<?php
+
+namespace Appwrite\Platform\Modules\Databases\Http\TablesDB\Tables\Columns\Text;
+
+use Appwrite\Platform\Modules\Databases\Http\Databases\Collections\Attributes\Text\Create as TextCreate;
+use Appwrite\SDK\AuthType;
+use Appwrite\SDK\Method;
+use Appwrite\SDK\Response as SDKResponse;
+use Appwrite\Utopia\Response as UtopiaResponse;
+use Utopia\Database\Validator\Key;
+use Utopia\Database\Validator\UID;
+use Utopia\Swoole\Response as SwooleResponse;
+use Utopia\Validator\Boolean;
+use Utopia\Validator\Nullable;
+use Utopia\Validator\Text;
+
+class Create extends TextCreate
+{
+    public static function getName(): string
+    {
+        return 'createTextColumn';
+    }
+
+    protected function getResponseModel(): string|array
+    {
+        return UtopiaResponse::MODEL_COLUMN_TEXT;
+    }
+
+    public function __construct()
+    {
+        $this
+            ->setHttpMethod(self::HTTP_REQUEST_METHOD_POST)
+            ->setHttpPath('/v1/tablesdb/:databaseId/tables/:tableId/columns/text')
+            ->desc('Create text column')
+            ->groups(['api', 'database', 'schema'])
+            ->label('scope', ['tables.write', 'collections.write'])
+            ->label('resourceType', RESOURCE_TYPE_DATABASES)
+            ->label('event', 'databases.[databaseId].tables.[tableId].columns.[columnId].create')
+            ->label('audits.event', 'column.create')
+            ->label('audits.resource', 'database/{request.databaseId}/table/{request.tableId}')
+            ->label('sdk', new Method(
+                namespace: $this->getSDKNamespace(),
+                group: $this->getSDKGroup(),
+                name: self::getName(),
+                description: '/docs/references/tablesdb/create-text-column.md',
+                auth: [AuthType::ADMIN, AuthType::KEY],
+                responses: [
+                    new SDKResponse(
+                        code: SwooleResponse::STATUS_CODE_ACCEPTED,
+                        model: $this->getResponseModel()
+                    )
+                ]
+            ))
+            ->param('databaseId', '', new UID(), 'Database ID.')
+            ->param('tableId', '', new UID(), 'Table ID. You can create a new table using the Database service [server integration](https://appwrite.io/docs/references/cloud/server-dart/tablesDB#createTable).')
+            ->param('key', '', new Key(), 'Column Key.')
+            ->param('required', null, new Boolean(), 'Is column required?')
+            ->param('default', null, new Nullable(new Text(0, 0)), 'Default value for column when not provided. Cannot be set when column is required.', true)
+            ->param('array', false, new Boolean(), 'Is column an array?', true)
+            ->inject('response')
+            ->inject('dbForProject')
+            ->inject('queueForDatabase')
+            ->inject('queueForEvents')
+            ->inject('authorization')
+            ->callback($this->action(...));
+    }
+}

src/Appwrite/Platform/Modules/Databases/Http/TablesDB/Tables/Columns/Text/Update.php

@@ -0,0 +1,68 @@
+<?php
+
+namespace Appwrite\Platform\Modules\Databases\Http\TablesDB\Tables\Columns\Text;
+
+use Appwrite\Platform\Modules\Databases\Http\Databases\Collections\Attributes\Text\Update as TextUpdate;
+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\Validator\Key;
+use Utopia\Database\Validator\UID;
+use Utopia\Swoole\Response as SwooleResponse;
+use Utopia\Validator\Boolean;
+use Utopia\Validator\Nullable;
+use Utopia\Validator\Text;
+
+class Update extends TextUpdate
+{
+    public static function getName(): string
+    {
+        return 'updateTextColumn';
+    }
+
+    protected function getResponseModel(): string|array
+    {
+        return UtopiaResponse::MODEL_COLUMN_TEXT;
+    }
+
+    public function __construct()
+    {
+        $this
+            ->setHttpMethod(self::HTTP_REQUEST_METHOD_PATCH)
+            ->setHttpPath('/v1/tablesdb/:databaseId/tables/:tableId/columns/text/:key')
+            ->desc('Update text column')
+            ->groups(['api', 'database', 'schema'])
+            ->label('scope', ['tables.write', 'collections.write'])
+            ->label('resourceType', RESOURCE_TYPE_DATABASES)
+            ->label('event', 'databases.[databaseId].tables.[tableId].columns.[columnId].update')
+            ->label('audits.event', 'column.update')
+            ->label('audits.resource', 'database/{request.databaseId}/table/{request.tableId}')
+            ->label('sdk', new Method(
+                namespace: $this->getSDKNamespace(),
+                group: $this->getSDKGroup(),
+                name: self::getName(),
+                description: '/docs/references/tablesdb/update-text-column.md',
+                auth: [AuthType::ADMIN, AuthType::KEY],
+                responses: [
+                    new SDKResponse(
+                        code: SwooleResponse::STATUS_CODE_OK,
+                        model: $this->getResponseModel(),
+                    )
+                ],
+                contentType: ContentType::JSON,
+            ))
+            ->param('databaseId', '', new UID(), 'Database ID.')
+            ->param('tableId', '', new UID(), 'Table ID. You can create a new table using the Database service [server integration](https://appwrite.io/docs/references/cloud/server-dart/tablesDB#createTable).')
+            ->param('key', '', new Key(), 'Column Key.')
+            ->param('required', null, new Boolean(), 'Is column required?')
+            ->param('default', null, new Nullable(new Text(0, 0)), 'Default value for column when not provided. Cannot be set when column is required.')
+            ->param('newKey', null, new Nullable(new Key()), 'New Column Key.', true)
+            ->inject('response')
+            ->inject('dbForProject')
+            ->inject('queueForEvents')
+            ->inject('authorization')
+            ->callback($this->action(...));
+    }
+}

src/Appwrite/Platform/Modules/Databases/Http/TablesDB/Tables/Columns/Varchar/Create.php

@@ -0,0 +1,70 @@
+<?php
+
+namespace Appwrite\Platform\Modules\Databases\Http\TablesDB\Tables\Columns\Varchar;
+
+use Appwrite\Platform\Modules\Databases\Http\Databases\Collections\Attributes\Varchar\Create as VarcharCreate;
+use Appwrite\SDK\AuthType;
+use Appwrite\SDK\Method;
+use Appwrite\SDK\Response as SDKResponse;
+use Appwrite\Utopia\Response as UtopiaResponse;
+use Utopia\Database\Validator\Key;
+use Utopia\Database\Validator\UID;
+use Utopia\Swoole\Response as SwooleResponse;
+use Utopia\Validator;
+use Utopia\Validator\Boolean;
+use Utopia\Validator\Nullable;
+use Utopia\Validator\Range;
+use Utopia\Validator\Text;
+
+class Create extends VarcharCreate
+{
+    public static function getName(): string
+    {
+        return 'createVarcharColumn';
+    }
+
+    protected function getResponseModel(): string|array
+    {
+        return UtopiaResponse::MODEL_COLUMN_VARCHAR;
+    }
+
+    public function __construct()
+    {
+        $this
+            ->setHttpMethod(self::HTTP_REQUEST_METHOD_POST)
+            ->setHttpPath('/v1/tablesdb/:databaseId/tables/:tableId/columns/varchar')
+            ->desc('Create varchar column')
+            ->groups(['api', 'database', 'schema'])
+            ->label('scope', ['tables.write', 'collections.write'])
+            ->label('resourceType', RESOURCE_TYPE_DATABASES)
+            ->label('event', 'databases.[databaseId].tables.[tableId].columns.[columnId].create')
+            ->label('audits.event', 'column.create')
+            ->label('audits.resource', 'database/{request.databaseId}/table/{request.tableId}')
+            ->label('sdk', new Method(
+                namespace: $this->getSDKNamespace(),
+                group: $this->getSDKGroup(),
+                name: self::getName(),
+                description: '/docs/references/tablesdb/create-varchar-column.md',
+                auth: [AuthType::ADMIN, AuthType::KEY],
+                responses: [
+                    new SDKResponse(
+                        code: SwooleResponse::STATUS_CODE_ACCEPTED,
+                        model: $this->getResponseModel()
+                    )
+                ]
+            ))
+            ->param('databaseId', '', new UID(), 'Database ID.')
+            ->param('tableId', '', new UID(), 'Table ID. You can create a new table using the Database service [server integration](https://appwrite.io/docs/references/cloud/server-dart/tablesDB#createTable).')
+            ->param('key', '', new Key(), 'Column Key.')
+            ->param('size', null, new Range(1, 16381, Validator::TYPE_INTEGER), 'Column size for varchar columns, in number of characters. Maximum size is 16381.')
+            ->param('required', null, new Boolean(), 'Is column required?')
+            ->param('default', null, new Nullable(new Text(0, 0)), 'Default value for column when not provided. Cannot be set when column is required.', true)
+            ->param('array', false, new Boolean(), 'Is column an array?', true)
+            ->inject('response')
+            ->inject('dbForProject')
+            ->inject('queueForDatabase')
+            ->inject('queueForEvents')
+            ->inject('authorization')
+            ->callback($this->action(...));
+    }
+}

src/Appwrite/Platform/Modules/Databases/Http/TablesDB/Tables/Columns/Varchar/Update.php

@@ -0,0 +1,71 @@
+<?php
+
+namespace Appwrite\Platform\Modules\Databases\Http\TablesDB\Tables\Columns\Varchar;
+
+use Appwrite\Platform\Modules\Databases\Http\Databases\Collections\Attributes\Varchar\Update as VarcharUpdate;
+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\Validator\Key;
+use Utopia\Database\Validator\UID;
+use Utopia\Swoole\Response as SwooleResponse;
+use Utopia\Validator;
+use Utopia\Validator\Boolean;
+use Utopia\Validator\Nullable;
+use Utopia\Validator\Range;
+use Utopia\Validator\Text;
+
+class Update extends VarcharUpdate
+{
+    public static function getName(): string
+    {
+        return 'updateVarcharColumn';
+    }
+
+    protected function getResponseModel(): string|array
+    {
+        return UtopiaResponse::MODEL_COLUMN_VARCHAR;
+    }
+
+    public function __construct()
+    {
+        $this
+            ->setHttpMethod(self::HTTP_REQUEST_METHOD_PATCH)
+            ->setHttpPath('/v1/tablesdb/:databaseId/tables/:tableId/columns/varchar/:key')
+            ->desc('Update varchar column')
+            ->groups(['api', 'database', 'schema'])
+            ->label('scope', ['tables.write', 'collections.write'])
+            ->label('resourceType', RESOURCE_TYPE_DATABASES)
+            ->label('event', 'databases.[databaseId].tables.[tableId].columns.[columnId].update')
+            ->label('audits.event', 'column.update')
+            ->label('audits.resource', 'database/{request.databaseId}/table/{request.tableId}')
+            ->label('sdk', new Method(
+                namespace: $this->getSDKNamespace(),
+                group: $this->getSDKGroup(),
+                name: self::getName(),
+                description: '/docs/references/tablesdb/update-varchar-column.md',
+                auth: [AuthType::ADMIN, AuthType::KEY],
+                responses: [
+                    new SDKResponse(
+                        code: SwooleResponse::STATUS_CODE_OK,
+                        model: $this->getResponseModel(),
+                    )
+                ],
+                contentType: ContentType::JSON,
+            ))
+            ->param('databaseId', '', new UID(), 'Database ID.')
+            ->param('tableId', '', new UID(), 'Table ID. You can create a new table using the Database service [server integration](https://appwrite.io/docs/references/cloud/server-dart/tablesDB#createTable).')
+            ->param('key', '', new Key(), 'Column Key.')
+            ->param('required', null, new Boolean(), 'Is column required?')
+            ->param('default', null, new Nullable(new Text(0, 0)), 'Default value for column when not provided. Cannot be set when column is required.')
+            ->param('size', null, new Nullable(new Range(1, 16381, Validator::TYPE_INTEGER)), 'Maximum size of the varchar column.', true)
+            ->param('newKey', null, new Nullable(new Key()), 'New Column Key.', true)
+            ->inject('response')
+            ->inject('dbForProject')
+            ->inject('queueForEvents')
+            ->inject('authorization')
+            ->callback($this->action(...));
+    }
+}

src/Appwrite/Platform/Modules/Databases/Services/Registry/Legacy.php

@@ -28,8 +28,16 @@ use Appwrite\Platform\Modules\Databases\Http\Databases\Collections\Attributes\Re
 use Appwrite\Platform\Modules\Databases\Http\Databases\Collections\Attributes\Relationship\Update as UpdateRelationshipAttribute;
 use Appwrite\Platform\Modules\Databases\Http\Databases\Collections\Attributes\String\Create as CreateStringAttribute;
 use Appwrite\Platform\Modules\Databases\Http\Databases\Collections\Attributes\String\Update as UpdateStringAttribute;
+use Appwrite\Platform\Modules\Databases\Http\Databases\Collections\Attributes\Text\Create as CreateTextAttribute;
+use Appwrite\Platform\Modules\Databases\Http\Databases\Collections\Attributes\Text\Update as UpdateTextAttribute;
 use Appwrite\Platform\Modules\Databases\Http\Databases\Collections\Attributes\URL\Create as CreateURLAttribute;
 use Appwrite\Platform\Modules\Databases\Http\Databases\Collections\Attributes\URL\Update as UpdateURLAttribute;
+use Appwrite\Platform\Modules\Databases\Http\Databases\Collections\Attributes\Varchar\Create as CreateVarcharAttribute;
+use Appwrite\Platform\Modules\Databases\Http\Databases\Collections\Attributes\Varchar\Update as UpdateVarcharAttribute;
+use Appwrite\Platform\Modules\Databases\Http\Databases\Collections\Attributes\Mediumtext\Create as CreateMediumtextAttribute;
+use Appwrite\Platform\Modules\Databases\Http\Databases\Collections\Attributes\Mediumtext\Update as UpdateMediumtextAttribute;
+use Appwrite\Platform\Modules\Databases\Http\Databases\Collections\Attributes\Longtext\Create as CreateLongtextAttribute;
+use Appwrite\Platform\Modules\Databases\Http\Databases\Collections\Attributes\Longtext\Update as UpdateLongtextAttribute;
 use Appwrite\Platform\Modules\Databases\Http\Databases\Collections\Attributes\XList as ListAttributes;
 use Appwrite\Platform\Modules\Databases\Http\Databases\Collections\Create as CreateCollection;
 use Appwrite\Platform\Modules\Databases\Http\Databases\Collections\Delete as DeleteCollection;
@@ -190,6 +198,22 @@ class Legacy extends Base
         // Attribute: URL
         $service->addAction(CreateURLAttribute::getName(), new CreateURLAttribute());
         $service->addAction(UpdateURLAttribute::getName(), new UpdateURLAttribute());
+
+        // Attribute: Varchar
+        $service->addAction(CreateVarcharAttribute::getName(), new CreateVarcharAttribute());
+        $service->addAction(UpdateVarcharAttribute::getName(), new UpdateVarcharAttribute());
+
+        // Attribute: Text
+        $service->addAction(CreateTextAttribute::getName(), new CreateTextAttribute());
+        $service->addAction(UpdateTextAttribute::getName(), new UpdateTextAttribute());
+
+        // Attribute: Mediumtext
+        $service->addAction(CreateMediumtextAttribute::getName(), new CreateMediumtextAttribute());
+        $service->addAction(UpdateMediumtextAttribute::getName(), new UpdateMediumtextAttribute());
+
+        // Attribute: Longtext
+        $service->addAction(CreateLongtextAttribute::getName(), new CreateLongtextAttribute());
+        $service->addAction(UpdateLongtextAttribute::getName(), new UpdateLongtextAttribute());
     }
 
     private function registerIndexActions(Service $service): void

src/Appwrite/Platform/Modules/Databases/Services/Registry/TablesDB.php

@@ -31,8 +31,16 @@ use Appwrite\Platform\Modules\Databases\Http\TablesDB\Tables\Columns\Relationshi
 use Appwrite\Platform\Modules\Databases\Http\TablesDB\Tables\Columns\Relationship\Update as UpdateRelationship;
 use Appwrite\Platform\Modules\Databases\Http\TablesDB\Tables\Columns\String\Create as CreateString;
 use Appwrite\Platform\Modules\Databases\Http\TablesDB\Tables\Columns\String\Update as UpdateString;
+use Appwrite\Platform\Modules\Databases\Http\TablesDB\Tables\Columns\Text\Create as CreateText;
+use Appwrite\Platform\Modules\Databases\Http\TablesDB\Tables\Columns\Text\Update as UpdateText;
 use Appwrite\Platform\Modules\Databases\Http\TablesDB\Tables\Columns\URL\Create as CreateURL;
 use Appwrite\Platform\Modules\Databases\Http\TablesDB\Tables\Columns\URL\Update as UpdateURL;
+use Appwrite\Platform\Modules\Databases\Http\TablesDB\Tables\Columns\Varchar\Create as CreateVarchar;
+use Appwrite\Platform\Modules\Databases\Http\TablesDB\Tables\Columns\Varchar\Update as UpdateVarchar;
+use Appwrite\Platform\Modules\Databases\Http\TablesDB\Tables\Columns\Mediumtext\Create as CreateMediumtext;
+use Appwrite\Platform\Modules\Databases\Http\TablesDB\Tables\Columns\Mediumtext\Update as UpdateMediumtext;
+use Appwrite\Platform\Modules\Databases\Http\TablesDB\Tables\Columns\Longtext\Create as CreateLongtext;
+use Appwrite\Platform\Modules\Databases\Http\TablesDB\Tables\Columns\Longtext\Update as UpdateLongtext;
 use Appwrite\Platform\Modules\Databases\Http\TablesDB\Tables\Columns\XList as ListColumns;
 use Appwrite\Platform\Modules\Databases\Http\TablesDB\Tables\Create as CreateTable;
 use Appwrite\Platform\Modules\Databases\Http\TablesDB\Tables\Delete as DeleteTable;
@@ -170,6 +178,22 @@ class TablesDB extends Base
         // Column: URL
         $service->addAction(CreateURL::getName(), new CreateURL());
         $service->addAction(UpdateURL::getName(), new UpdateURL());
+
+        // Column: Varchar
+        $service->addAction(CreateVarchar::getName(), new CreateVarchar());
+        $service->addAction(UpdateVarchar::getName(), new UpdateVarchar());
+
+        // Column: Text
+        $service->addAction(CreateText::getName(), new CreateText());
+        $service->addAction(UpdateText::getName(), new UpdateText());
+
+        // Column: Mediumtext
+        $service->addAction(CreateMediumtext::getName(), new CreateMediumtext());
+        $service->addAction(UpdateMediumtext::getName(), new UpdateMediumtext());
+
+        // Column: Longtext
+        $service->addAction(CreateLongtext::getName(), new CreateLongtext());
+        $service->addAction(UpdateLongtext::getName(), new UpdateLongtext());
     }
 
     private function registerIndexActions(Service $service): void

src/Appwrite/Utopia/Response.php

@@ -75,6 +75,10 @@ class Response extends SwooleResponse
     public const MODEL_ATTRIBUTE_POINT = 'attributePoint';
     public const MODEL_ATTRIBUTE_LINE = 'attributeLine';
     public const MODEL_ATTRIBUTE_POLYGON = 'attributePolygon';
+    public const MODEL_ATTRIBUTE_VARCHAR = 'attributeVarchar';
+    public const MODEL_ATTRIBUTE_TEXT = 'attributeText';
+    public const MODEL_ATTRIBUTE_MEDIUMTEXT = 'attributeMediumtext';
+    public const MODEL_ATTRIBUTE_LONGTEXT = 'attributeLongtext';
 
     // Database Columns
     public const MODEL_COLUMN = 'column';
@@ -92,6 +96,10 @@ class Response extends SwooleResponse
     public const MODEL_COLUMN_POINT = 'columnPoint';
     public const MODEL_COLUMN_LINE = 'columnLine';
     public const MODEL_COLUMN_POLYGON = 'columnPolygon';
+    public const MODEL_COLUMN_VARCHAR = 'columnVarchar';
+    public const MODEL_COLUMN_TEXT = 'columnText';
+    public const MODEL_COLUMN_MEDIUMTEXT = 'columnMediumtext';
+    public const MODEL_COLUMN_LONGTEXT = 'columnLongtext';
 
     // Transactions
     public const MODEL_TRANSACTION = 'transaction';