Appwrite.php

<?php

namespace Utopia\Migration\Destinations;

use Appwrite\AppwriteException;
use Appwrite\Client;
use Appwrite\Enums\Adapter;
use Appwrite\Enums\BuildRuntime;
use Appwrite\Enums\Compression;
use Appwrite\Enums\Framework;
use Appwrite\Enums\PasswordHash;
use Appwrite\Enums\Runtime;
use Appwrite\Enums\SmtpEncryption;
use Appwrite\InputFile;
use Appwrite\Services\Functions;
use Appwrite\Services\Messaging;
use Appwrite\Services\Sites;
use Appwrite\Services\Storage;
use Appwrite\Services\Teams;
use Appwrite\Services\Users;
use Override;
use Utopia\Database\Database as UtopiaDatabase;
use Utopia\Database\DateTime;
use Utopia\Database\Document as UtopiaDocument;
use Utopia\Database\Exception as DatabaseException;
use Utopia\Database\Exception\Authorization as AuthorizationException;
use Utopia\Database\Exception\Duplicate as DuplicateException;
use Utopia\Database\Exception\Limit as LimitException;
use Utopia\Database\Exception\Structure as StructureException;
use Utopia\Database\Helpers\ID;
use Utopia\Database\Helpers\Permission;
use Utopia\Database\Helpers\Role;
use Utopia\Database\Query;
use Utopia\Database\Validator\Index as IndexValidator;
use Utopia\Database\Validator\Structure;
use Utopia\Database\Validator\UID;
use Utopia\Migration\Destination;
use Utopia\Migration\Exception;
use Utopia\Migration\Resource;
use Utopia\Migration\Resources\Auth\Hash;
use Utopia\Migration\Resources\Auth\Membership;
use Utopia\Migration\Resources\Auth\Team;
use Utopia\Migration\Resources\Auth\User;
use Utopia\Migration\Resources\Database\Attribute;
use Utopia\Migration\Resources\Database\Column;
use Utopia\Migration\Resources\Database\Database;
use Utopia\Migration\Resources\Database\Index;
use Utopia\Migration\Resources\Database\Row;
use Utopia\Migration\Resources\Database\Table;
use Utopia\Migration\Resources\Functions\Deployment;
use Utopia\Migration\Resources\Functions\EnvVar;
use Utopia\Migration\Resources\Functions\Func;
use Utopia\Migration\Resources\Messaging\Message;
use Utopia\Migration\Resources\Messaging\Provider;
use Utopia\Migration\Resources\Messaging\Subscriber;
use Utopia\Migration\Resources\Messaging\Topic;
use Utopia\Migration\Resources\Sites\Deployment as SiteDeployment;
use Utopia\Migration\Resources\Sites\EnvVar as SiteEnvVar;
use Utopia\Migration\Resources\Sites\Site;
use Utopia\Migration\Resources\Storage\Bucket;
use Utopia\Migration\Resources\Storage\File;
use Utopia\Migration\Transfer;

class Appwrite extends Destination
{
    protected Client $client;
    protected string $project;

    protected string $key;

    private Functions $functions;
    private Messaging $messaging;
    private Sites $sites;
    private Storage $storage;
    private Teams $teams;
    private Users $users;

    /**
     * @var callable(UtopiaDocument $database): UtopiaDatabase
    */
    protected $getDatabasesDB;

    /**
     * @var array<UtopiaDocument>
     */
    private array $rowBuffer = [];

    /**
     * @param string $project
     * @param string $endpoint
     * @param string $key
     * @param UtopiaDatabase $dbForProject
     * @param callable(UtopiaDocument $database):UtopiaDatabase $getDatabasesDB
     * @param array<array<string, mixed>> $collectionStructure
     */
    public function __construct(
        string $project,
        string $endpoint,
        string $key,
        protected UtopiaDatabase $dbForProject,
        callable $getDatabasesDB,
        protected array $collectionStructure
    ) {
        $this->project = $project;
        $this->endpoint = $endpoint;
        $this->key = $key;

        $this->client = (new Client())
            ->setEndpoint($endpoint)
            ->setProject($project)
            ->setKey($key);

        $this->functions = new Functions($this->client);
        $this->messaging = new Messaging($this->client);
        $this->sites = new Sites($this->client);
        $this->storage = new Storage($this->client);
        $this->teams = new Teams($this->client);
        $this->users = new Users($this->client);

        $this->getDatabasesDB = $getDatabasesDB;
    }

    public static function getName(): string
    {
        return 'Appwrite';
    }

    /**
     * @return array<string>
     */
    public static function getSupportedResources(): array
    {
        return [
            // Auth
            Resource::TYPE_USER,
            Resource::TYPE_TEAM,
            Resource::TYPE_MEMBERSHIP,

            // Database
            Resource::TYPE_DATABASE,
            Resource::TYPE_DATABASE_DOCUMENTSDB,
            Resource::TYPE_DATABASE_VECTORSDB,
            Resource::TYPE_TABLE,
            Resource::TYPE_COLUMN,
            Resource::TYPE_INDEX,
            Resource::TYPE_ROW,

            // legacy
            Resource::TYPE_DOCUMENT,
            Resource::TYPE_ATTRIBUTE,
            Resource::TYPE_COLLECTION,

            // Storage
            Resource::TYPE_BUCKET,
            Resource::TYPE_FILE,

            // Functions
            Resource::TYPE_FUNCTION,
            Resource::TYPE_DEPLOYMENT,
            Resource::TYPE_ENVIRONMENT_VARIABLE,

            // Messaging
            Resource::TYPE_PROVIDER,
            Resource::TYPE_TOPIC,
            Resource::TYPE_SUBSCRIBER,
            Resource::TYPE_MESSAGE,

            // Sites
            Resource::TYPE_SITE,
            Resource::TYPE_SITE_DEPLOYMENT,
            Resource::TYPE_SITE_VARIABLE,
        ];
    }

    /**
     * @param array<string> $resources
     * @return array<string, int>
     * @throws AppwriteException
     */
    #[Override]
    public function report(array $resources = [], array $resourceIds = []): array
    {
        if (empty($resources)) {
            $resources = $this->getSupportedResources();
        }

        $scope = '';

        // Most of these API calls are purposely wrong. Appwrite will throw a 403 before a 400.
        // We want to make sure the API key has full read and write access to the project.
        try {
            // Auth
            if (\in_array(Resource::TYPE_USER, $resources)) {
                $scope = 'users.read';
                $this->users->list();

                $scope = 'users.write';
                $this->users->create('');
            }

            if (\in_array(Resource::TYPE_TEAM, $resources)) {
                $scope = 'teams.read';
                $this->teams->list();

                $scope = 'teams.write';
                $this->teams->create('', '');
            }

            if (\in_array(Resource::TYPE_MEMBERSHIP, $resources)) {
                $scope = 'memberships.read';
                $this->teams->listMemberships('');

                $scope = 'memberships.write';
                $this->teams->createMembership('', [], '');
            }

            // Storage
            if (\in_array(Resource::TYPE_BUCKET, $resources)) {
                $scope = 'storage.read';
                $this->storage->listBuckets();

                $scope = 'storage.write';
                $this->storage->createBucket('', '');
            }

            if (\in_array(Resource::TYPE_FILE, $resources)) {
                $scope = 'files.read';
                $this->storage->listFiles('');

                $scope = 'files.write';
                $this->storage->createFile('', '', new InputFile());
            }

            // Functions
            if (\in_array(Resource::TYPE_FUNCTION, $resources)) {
                $scope = 'functions.read';
                $this->functions->list();

                $scope = 'functions.write';
                $this->functions->create('', '', Runtime::NODE180());
            }

            // Messaging
            if (\in_array(Resource::TYPE_PROVIDER, $resources)) {
                $scope = 'providers.read';
                $this->messaging->listProviders();

                $scope = 'providers.write';
                $this->messaging->createSendgridProvider('', '');
            }

            if (\in_array(Resource::TYPE_TOPIC, $resources)) {
                $scope = 'topics.read';
                $this->messaging->listTopics();

                $scope = 'topics.write';
                $this->messaging->createTopic('', '');
            }

            if (\in_array(Resource::TYPE_SUBSCRIBER, $resources)) {
                $scope = 'subscribers.read';
                $this->messaging->listSubscribers('');

                $scope = 'subscribers.write';
                $this->messaging->createSubscriber('', '', '');
            }

            if (\in_array(Resource::TYPE_MESSAGE, $resources)) {
                $scope = 'messages.read';
                $this->messaging->listMessages();

                $scope = 'messages.write';
                $this->messaging->createEmail('', '', '', draft: true);
            }

            // Sites
            if (\in_array(Resource::TYPE_SITE, $resources)) {
                $scope = 'sites.read';
                $this->sites->list();

                $scope = 'sites.write';
                $this->sites->create('', '', Framework::OTHER(), BuildRuntime::STATIC1());
            }

        } catch (AppwriteException $e) {
            if ($e->getCode() === 403) {
                throw new \Exception(
                    'Missing scope: ' . $scope,
                    (int) $e->getCode() ?: Exception::CODE_FORBIDDEN,
                    $e
                );
            }
            throw $e;
        }

        return [];
    }

    /**
     * @param array<Resource> $resources
     * @param callable(array<Resource>): void $callback
     * @return void
     */
    #[Override]
    protected function import(array $resources, callable $callback): void
    {
        if (empty($resources)) {
            return;
        }

        $total = \count($resources);

        foreach ($resources as $index => $resource) {
            $resource->setStatus(Resource::STATUS_PROCESSING);

            $isLast = $index === $total - 1;

            try {
                $this->dbForProject->setPreserveDates(true);

                $responseResource = match ($resource->getGroup()) {
                    Transfer::GROUP_DATABASES => $this->importDatabaseResource($resource, $isLast),
                    Transfer::GROUP_STORAGE => $this->importFileResource($resource),
                    Transfer::GROUP_AUTH => $this->importAuthResource($resource),
                    Transfer::GROUP_FUNCTIONS => $this->importFunctionResource($resource),
                    Transfer::GROUP_MESSAGING => $this->importMessagingResource($resource),
                    Transfer::GROUP_SITES => $this->importSiteResource($resource),
                    default => throw new \Exception('Invalid resource group', Exception::CODE_VALIDATION),
                };
            } catch (\Throwable $e) {
                $resource->setStatus(Resource::STATUS_ERROR, $e->getMessage());

                $this->addError(new Exception(
                    resourceName: $resource->getName(),
                    resourceGroup: $resource->getGroup(),
                    resourceId: $resource->getId(),
                    message: $e->getMessage(),
                    code: $e->getCode(),
                    previous: $e
                ));

                $responseResource = $resource;
            } finally {
                $this->dbForProject->setPreserveDates(false);
            }

            $this->cache->update($responseResource);
        }

        $callback($resources);
    }

    /**
     * @throws AppwriteException
     * @throws \Exception
     * @throws \Throwable
     */
    public function importDatabaseResource(Resource $resource, bool $isLast): Resource
    {
        switch ($resource->getName()) {
            case Resource::TYPE_DATABASE:
            case Resource::TYPE_DATABASE_DOCUMENTSDB:
            case Resource::TYPE_DATABASE_VECTORSDB:
                /** @var Database $resource */
                $success = $this->createDatabase($resource);
                break;
            case Resource::TYPE_TABLE:
            case Resource::TYPE_COLLECTION:
                /** @var Table $resource */
                $success = $this->createEntity($resource);
                break;
            case Resource::TYPE_COLUMN:
            case Resource::TYPE_ATTRIBUTE:
                /** @var Column $resource */
                $success = $this->createField($resource);
                break;
            case Resource::TYPE_INDEX:
                /** @var Index $resource */
                $success = $this->createIndex($resource);
                break;
            case Resource::TYPE_ROW:
            case Resource::TYPE_DOCUMENT:
                /** @var Row $resource */
                $success = $this->createRecord($resource, $isLast);
                break;
            default:
                $success = false;
                break;
        }

        if ($success) {
            $resource->setStatus(Resource::STATUS_SUCCESS);
        }

        return $resource;
    }

    /**
     * @throws AuthorizationException
     * @throws StructureException
     * @throws DatabaseException|Exception
     */
    protected function createDatabase(Database $resource): bool
    {
        if ($resource->getId() == 'unique()') {
            $resource->setId(ID::unique());
        }

        $validator = new UID();

        if (!$validator->isValid($resource->getId())) {
            throw new Exception(
                resourceName: $resource->getName(),
                resourceGroup: $resource->getGroup(),
                resourceId: $resource->getId(),
                message: $validator->getDescription(),
            );
        }

        $createdAt = $this->normalizeDateTime($resource->getCreatedAt());
        $updatedAt = $this->normalizeDateTime($resource->getUpdatedAt(), $createdAt);

        $database = $this->dbForProject->createDocument('databases', new UtopiaDocument([
            '$id' => $resource->getId(),
            'name' => $resource->getDatabaseName(),
            'enabled' => $resource->getEnabled(),
            'search' => implode(' ', [$resource->getId(), $resource->getDatabaseName()]),
            '$createdAt' => $createdAt,
            '$updatedAt' => $updatedAt,
            'originalId' => empty($resource->getOriginalId()) ? null : $resource->getOriginalId(),
            'type' => empty($resource->getType()) ? 'legacy' : $resource->getType(),
            // source and destination can be in different location
            'database' => $resource->getDatabase()
        ]));

        $resource->setSequence($database->getSequence());

        $columns = \array_map(
            fn ($attr) => new UtopiaDocument($attr),
            $this->collectionStructure['attributes']
        );

        $indexes = \array_map(
            fn ($index) => new UtopiaDocument($index),
            $this->collectionStructure['indexes']
        );

        $this->dbForProject->createCollection(
            'database_' . $database->getSequence(),
            $columns,
            $indexes
        );

        return true;
    }

    /**
     * @throws AuthorizationException
     * @throws DatabaseException
     * @throws StructureException
     * @throws Exception
     */
    protected function createEntity(Table $resource): bool
    {
        if ($resource->getId() == 'unique()') {
            $resource->setId(ID::unique());
        }

        $validator = new UID();

        if (!$validator->isValid($resource->getId())) {
            throw new Exception(
                resourceName: $resource->getName(),
                resourceGroup: $resource->getGroup(),
                resourceId: $resource->getId(),
                message: $validator->getDescription(),
            );
        }

        $database = $this->dbForProject->getDocument(
            'databases',
            $resource->getDatabase()->getId()
        );

        if ($database->isEmpty()) {
            throw new Exception(
                resourceName: $resource->getName(),
                resourceGroup: $resource->getGroup(),
                resourceId: $resource->getId(),
                message: 'Database not found',
            );
        }

        $createdAt = $this->normalizeDateTime($resource->getCreatedAt());
        $updatedAt = $this->normalizeDateTime($resource->getUpdatedAt(), $createdAt);

        $dbForDatabases = ($this->getDatabasesDB)($database);

        // passing null in creates only creates the metadata collection
        if (!$dbForDatabases->exists(null, UtopiaDatabase::METADATA)) {
            $dbForDatabases->create();
        }

        $table = $this->dbForProject->createDocument('database_' . $database->getSequence(), new UtopiaDocument([
            '$id' => $resource->getId(),
            'databaseInternalId' => $database->getSequence(),
            'databaseId' => $resource->getDatabase()->getId(),
            '$permissions' => Permission::aggregate($resource->getPermissions()),
            'documentSecurity' => $resource->getRowSecurity(),
            'enabled' => $resource->getEnabled(),
            'name' => $resource->getTableName(),
            'search' => implode(' ', [$resource->getId(), $resource->getTableName()]),
            '$createdAt' => $createdAt,
            '$updatedAt' => $updatedAt,
        ]));

        $resource->setSequence($table->getSequence());

        $dbForDatabases->createCollection(
            'database_' . $database->getSequence() . '_collection_' . $resource->getSequence(),
            permissions: $resource->getPermissions(),
            documentSecurity: $resource->getRowSecurity()
        );

        return true;
    }

    /**
     * @throws AppwriteException
     * @throws \Exception
     * @throws \Throwable
     */
    protected function createField(Column|Attribute $resource): bool
    {
        if ($resource->getTable()->getDatabase()->getType() === Resource::TYPE_DATABASE_DOCUMENTSDB) {
            $resource->setStatus(Resource::STATUS_SKIPPED, 'Columns not supported for DocumentsDB');
            return false;
        }
        // column will be matching attribute as well
        // column type will be matching attribute type as well
        $type = match ($resource->getType()) {
            Column::TYPE_DATETIME => UtopiaDatabase::VAR_DATETIME,
            Column::TYPE_BOOLEAN => UtopiaDatabase::VAR_BOOLEAN,
            Column::TYPE_INTEGER => UtopiaDatabase::VAR_INTEGER,
            Column::TYPE_FLOAT => UtopiaDatabase::VAR_FLOAT,
            Column::TYPE_RELATIONSHIP => UtopiaDatabase::VAR_RELATIONSHIP,

            Column::TYPE_STRING,
            Column::TYPE_IP,
            Column::TYPE_EMAIL,
            Column::TYPE_URL,
            Column::TYPE_ENUM => UtopiaDatabase::VAR_STRING,

            Column::TYPE_POINT => UtopiaDatabase::VAR_POINT,
            Column::TYPE_LINE => UtopiaDatabase::VAR_LINESTRING,
            Column::TYPE_POLYGON => UtopiaDatabase::VAR_POLYGON,
            Column::TYPE_TEXT => UtopiaDatabase::VAR_TEXT,
            Column::TYPE_VARCHAR => UtopiaDatabase::VAR_VARCHAR,
            Column::TYPE_MEDIUMTEXT => UtopiaDatabase::VAR_MEDIUMTEXT,
            Column::TYPE_LONGTEXT => UtopiaDatabase::VAR_LONGTEXT,
            Column::TYPE_OBJECT => UtopiaDatabase::VAR_OBJECT,
            Column::TYPE_VECTOR => UtopiaDatabase::VAR_VECTOR,

            default => throw new \Exception('Invalid resource type ' . $resource->getType(), Exception::CODE_VALIDATION),
        };

        $database = $this->dbForProject->getDocument(
            'databases',
            $resource->getTable()->getDatabase()->getId(),
        );

        if ($database->isEmpty()) {
            throw new Exception(
                resourceName: $resource->getName(),
                resourceGroup: $resource->getGroup(),
                resourceId: $resource->getId(),
                message: 'Database not found',
            );
        }

        $table = $this->dbForProject->getDocument(
            'database_' . $database->getSequence(),
            $resource->getTable()->getId(),
        );

        if ($table->isEmpty()) {
            throw new Exception(
                resourceName: $resource->getName(),
                resourceGroup: $resource->getGroup(),
                resourceId: $resource->getId(),
                message: 'Table not found',
            );
        }

        if (!empty($resource->getFormat())) {
            if (!Structure::hasFormat($resource->getFormat(), $type)) {
                throw new Exception(
                    resourceName: $resource->getName(),
                    resourceGroup: $resource->getGroup(),
                    resourceId: $resource->getId(),
                    message: "Format {$resource->getFormat()} not available for column type {$type}",
                );
            }
        }

        if ($resource->isRequired() && $resource->getDefault() !== null) {
            throw new Exception(
                resourceName: $resource->getName(),
                resourceGroup: $resource->getGroup(),
                resourceId: $resource->getId(),
                message: 'Cannot set default value for required column',
            );
        }

        if ($resource->isArray() && $resource->getDefault() !== null) {
            throw new Exception(
                resourceName: $resource->getName(),
                resourceGroup: $resource->getGroup(),
                resourceId: $resource->getId(),
                message: 'Cannot set default value for array column',
            );
        }

        if ($type === UtopiaDatabase::VAR_RELATIONSHIP) {
            $resource->getOptions()['side'] = UtopiaDatabase::RELATION_SIDE_PARENT;
            $relatedTable = $this->dbForProject->getDocument(
                'database_' . $database->getSequence(),
                $resource->getOptions()['relatedCollection']
            );
            if ($relatedTable->isEmpty()) {
                throw new Exception(
                    resourceName: $resource->getName(),
                    resourceGroup: $resource->getGroup(),
                    resourceId: $resource->getId(),
                    message: 'Related table not found',
                );
            }
        }

        $createdAt = $this->normalizeDateTime($resource->getCreatedAt());
        $updatedAt = $this->normalizeDateTime($resource->getUpdatedAt(), $createdAt);
        $dbForDatabases = ($this->getDatabasesDB)($database);
        try {
            $column = new UtopiaDocument([
                '$id' => ID::custom($database->getSequence() . '_' . $table->getSequence() . '_' . $resource->getKey()),
                'key' => $resource->getKey(),
                'databaseInternalId' => $database->getSequence(),
                'databaseId' => $database->getId(),
                'collectionInternalId' => $table->getSequence(),
                'collectionId' => $table->getId(),
                'type' => $type,
                'status' => 'available',
                'size' => $resource->getSize(),
                'required' => $resource->isRequired(),
                'signed' => $resource->isSigned(),
                'default' => $resource->getDefault(),
                'array' => $resource->isArray(),
                'format' => $resource->getFormat(),
                'formatOptions' => $resource->getFormatOptions(),
                'filters' => $resource->getFilters(),
                'options' => $resource->getOptions(),
                '$createdAt' => $createdAt,
                '$updatedAt' => $updatedAt,
            ]);

            $this->dbForProject->checkAttribute($table, $column);

            $column = $this->dbForProject->createDocument('attributes', $column);
        } catch (DuplicateException) {
            throw new Exception(
                resourceName: $resource->getName(),
                resourceGroup: $resource->getGroup(),
                resourceId: $resource->getId(),
                message: 'Attribute already exists',
            );
        } catch (LimitException) {
            throw new Exception(
                resourceName: $resource->getName(),
                resourceGroup: $resource->getGroup(),
                resourceId: $resource->getId(),
                message: 'Attribute limit exceeded',
            );
        } catch (\Throwable $e) {
            $this->dbForProject->purgeCachedDocument('database_' . $database->getSequence(), $table->getId());
            $dbForDatabases->purgeCachedCollection('database_' . $database->getSequence() . '_collection_' . $table->getSequence());
            throw $e;
        }

        $this->dbForProject->purgeCachedDocument('database_' . $database->getSequence(), $table->getId());
        $dbForDatabases->purgeCachedCollection('database_' . $database->getSequence() . '_collection_' . $table->getSequence());
        $options = $resource->getOptions();

        $twoWayKey = null;

        if ($type === UtopiaDatabase::VAR_RELATIONSHIP && $options['twoWay']) {
            $twoWayKey = $options['twoWayKey'];
            $options['relatedCollection'] = $table->getId();
            $options['twoWayKey'] = $resource->getKey();
            $options['side'] = UtopiaDatabase::RELATION_SIDE_CHILD;

            try {
                $twoWayAttribute = new UtopiaDocument([
                    '$id' => ID::custom($database->getSequence() . '_' . $relatedTable->getSequence() . '_' . $twoWayKey),
                    'key' => $twoWayKey,
                    'databaseInternalId' => $database->getSequence(),
                    'databaseId' => $database->getId(),
                    'collectionInternalId' => $relatedTable->getSequence(),
                    'collectionId' => $relatedTable->getId(),
                    'type' => $type,
                    'status' => 'available',
                    'size' => $resource->getSize(),
                    'required' => $resource->isRequired(),
                    'signed' => $resource->isSigned(),
                    'default' => $resource->getDefault(),
                    'array' => $resource->isArray(),
                    'format' => $resource->getFormat(),
                    'formatOptions' => $resource->getFormatOptions(),
                    'filters' => $resource->getFilters(),
                    'options' => $options,
                    '$createdAt' => $createdAt,
                    '$updatedAt' => $updatedAt,
                ]);

                $this->dbForProject->createDocument('attributes', $twoWayAttribute);
            } catch (DuplicateException) {
                $this->dbForProject->deleteDocument('attributes', $column->getId());

                throw new Exception(
                    resourceName: $resource->getName(),
                    resourceGroup: $resource->getGroup(),
                    resourceId: $resource->getId(),
                    message: 'Attribute already exists',
                );
            } catch (LimitException) {
                $this->dbForProject->deleteDocument('attributes', $column->getId());

                throw new Exception(
                    resourceName: $resource->getName(),
                    resourceGroup: $resource->getGroup(),
                    resourceId: $resource->getId(),
                    message: 'Column limit exceeded',
                );
            } catch (\Throwable $e) {
                $this->dbForProject->purgeCachedDocument('database_' . $database->getSequence(), $relatedTable->getId());
                $dbForDatabases->purgeCachedCollection('database_' . $database->getSequence() . '_collection_' . $relatedTable->getSequence());
                throw $e;
            }
        }

        try {
            switch ($type) {
                case UtopiaDatabase::VAR_RELATIONSHIP:
                    if (!$dbForDatabases->createRelationship(
                        collection: 'database_' . $database->getSequence() . '_collection_' . $table->getSequence(),
                        relatedCollection: 'database_' . $database->getSequence() . '_collection_' . $relatedTable->getSequence(),
                        type: $options['relationType'],
                        twoWay: $options['twoWay'],
                        id: $resource->getKey(),
                        twoWayKey: $options['twoWay'] ? $twoWayKey : $options['twoWayKey'] ?? null,
                        onDelete: $options['onDelete'],
                    )) {
                        throw new Exception(
                            resourceName: $resource->getName(),
                            resourceGroup: $resource->getGroup(),
                            resourceId: $resource->getId(),
                            message: 'Failed to create relationship',
                        );
                    }
                    break;
                default:
                    if (!$dbForDatabases->createAttribute(
                        'database_' . $database->getSequence() . '_collection_' . $table->getSequence(),
                        $resource->getKey(),
                        $type,
                        $resource->getSize(),
                        $resource->isRequired(),
                        $resource->getDefault(),
                        $resource->isSigned(),
                        $resource->isArray(),
                        $resource->getFormat(),
                        $resource->getFormatOptions(),
                        $resource->getFilters(),
                    )) {
                        throw new \Exception('Failed to create Column', Exception::CODE_INTERNAL);
                    }
            }
        } catch (\Throwable) {
            $this->dbForProject->deleteDocument('attributes', $column->getId());

            if (isset($twoWayAttribute)) {
                $this->dbForProject->deleteDocument('attributes', $twoWayAttribute->getId());
            }

            throw new Exception(
                resourceName: $resource->getName(),
                resourceGroup: $resource->getGroup(),
                resourceId: $resource->getId(),
                message: 'Failed to create column',
            );
        }

        if ($type === UtopiaDatabase::VAR_RELATIONSHIP && $options['twoWay']) {
            $this->dbForProject->purgeCachedDocument('database_' . $database->getSequence(), $relatedTable->getId());
        }

        $this->dbForProject->purgeCachedDocument('database_' . $database->getSequence(), $table->getId());
        $dbForDatabases->purgeCachedCollection('database_' . $database->getSequence() . '_collection_' . $table->getSequence());

        return true;
    }

    /**
     * @throws Exception
     * @throws \Throwable
     */
    protected function createIndex(Index $resource): bool
    {
        $database = $this->dbForProject->getDocument(
            'databases',
            $resource->getTable()->getDatabase()->getId(),
        );
        if ($database->isEmpty()) {
            throw new Exception(
                resourceName: $resource->getName(),
                resourceGroup: $resource->getGroup(),
                resourceId: $resource->getId(),
                message: 'Database not found',
            );
        }

        $table = $this->dbForProject->getDocument(
            'database_' . $database->getSequence(),
            $resource->getTable()->getId(),
        );
        if ($table->isEmpty()) {
            throw new Exception(
                resourceName: $resource->getName(),
                resourceGroup: $resource->getGroup(),
                resourceId: $resource->getId(),
                message: 'Table not found',
            );
        }
        $dbForDatabases = ($this->getDatabasesDB)($database);

        $count = $this->dbForProject->count('indexes', [
            Query::equal('collectionInternalId', [$table->getSequence()]),
            Query::equal('databaseInternalId', [$database->getSequence()])
        ], $dbForDatabases->getLimitForIndexes());

        if ($count >= $dbForDatabases->getLimitForIndexes()) {
            throw new Exception(
                resourceName: $resource->getName(),
                resourceGroup: $resource->getGroup(),
                resourceId: $resource->getId(),
                message: 'Index limit reached for table',
            );
        }

        // Lengths hidden by default
        $lengths = [];

        if ($dbForDatabases->getAdapter()->getSupportForAttributes()) {
            $this->validateFieldsForIndexes($resource, $table, $lengths);
        }

        $createdAt = $this->normalizeDateTime($resource->getCreatedAt());
        $updatedAt = $this->normalizeDateTime($resource->getUpdatedAt(), $createdAt);

        $index = new UtopiaDocument([
            '$id' => ID::custom($database->getSequence() . '_' . $table->getSequence() . '_' . $resource->getKey()),
            'key' => $resource->getKey(),
            'status' => 'available', // processing, available, failed, deleting, stuck
            'databaseInternalId' => $database->getSequence(),
            'databaseId' => $database->getId(),
            'collectionInternalId' => $table->getSequence(),
            'collectionId' => $table->getId(),
            'type' => $resource->getType(),
            'attributes' => $resource->getColumns(),
            'lengths' => $lengths,
            'orders' => $resource->getOrders(),
            '$createdAt' => $createdAt,
            '$updatedAt' => $updatedAt,
        ]);

        /**
         * @var array<UtopiaDocument> $tableColumns
         */
        $tableColumns = $table->getAttribute('attributes', []);
        $tableIndexes = $table->getAttribute('indexes', []);

        $validator = new IndexValidator(
            $tableColumns,
            $tableIndexes,
            $dbForDatabases->getAdapter()->getMaxIndexLength(),
            $dbForDatabases->getAdapter()->getInternalIndexesKeys(),
            $dbForDatabases->getAdapter()->getSupportForIndexArray(),
            $dbForDatabases->getAdapter()->getSupportForSpatialIndexNull(),
            $dbForDatabases->getAdapter()->getSupportForSpatialIndexOrder(),
            $dbForDatabases->getAdapter()->getSupportForVectors(),
            $dbForDatabases->getAdapter()->getSupportForAttributes(),
            $dbForDatabases->getAdapter()->getSupportForMultipleFulltextIndexes(),
            $dbForDatabases->getAdapter()->getSupportForIdenticalIndexes(),
            $dbForDatabases->getAdapter()->getSupportForObjectIndexes(),
            $dbForDatabases->getAdapter()->getSupportForTrigramIndex(),
            $dbForDatabases->getAdapter()->getSupportForSpatialAttributes(),
            $dbForDatabases->getAdapter()->getSupportForIndex(),
            $dbForDatabases->getAdapter()->getSupportForUniqueIndex(),
            $dbForDatabases->getAdapter()->getSupportForFulltextIndex()
        );


        if (!$validator->isValid($index)) {
            throw new Exception(
                resourceName: $resource->getName(),
                resourceGroup: $resource->getGroup(),
                resourceId: $resource->getId(),
                message: 'Invalid index: ' . $validator->getDescription(),
            );
        }

        $index = $this->dbForProject->createDocument('indexes', $index);

        try {
            $result = $dbForDatabases->createIndex(
                'database_' . $database->getSequence() . '_collection_' . $table->getSequence(),
                $resource->getKey(),
                $resource->getType(),
                $resource->getColumns(),
                $lengths,
                $resource->getOrders()
            );

            if (!$result) {
                throw new Exception(
                    resourceName: $resource->getName(),
                    resourceGroup: $resource->getGroup(),
                    resourceId: $resource->getId(),
                    message: 'Failed to create index',
                );
            }
        } catch (\Throwable $th) {
            $this->dbForProject->deleteDocument('indexes', $index->getId());

            throw new Exception(
                resourceName: $resource->getName(),
                resourceGroup: $resource->getGroup(),
                resourceId: $resource->getId(),
                message: 'Failed to create index',
            );
        }

        $this->dbForProject->purgeCachedDocument(
            'database_' . $database->getSequence(),
            $table->getId()
        );

        return true;
    }

    /**
     * @throws AuthorizationException
     * @throws DatabaseException
     * @throws StructureException
     * @throws Exception
     */
    protected function createRecord(Row $resource, bool $isLast): bool
    {
        if ($resource->getId() == 'unique()') {
            $resource->setId(ID::unique());
        }

        $validator = new UID();

        if (!$validator->isValid($resource->getId())) {
            throw new Exception(
                resourceName: $resource->getName(),
                resourceGroup: $resource->getGroup(),
                resourceId: $resource->getId(),
                message: $validator->getDescription(),
            );
        }

        // Check if document has already been created
        $exists = \array_key_exists(
            $resource->getId(),
            $this->cache->get($resource->getName())
        );

        if ($exists) {
            $resource->setStatus(
                Resource::STATUS_SKIPPED,
                'Row has already been created'
            );
            return false;
        }

        $data = $resource->getData();

        $hasCreatedAt = !empty($data['$createdAt']);
        $hasUpdatedAt = !empty($data['$updatedAt']);

        if (! $hasCreatedAt) {
            $createdAt = $resource->getCreatedAt();
            if (empty($createdAt)) {
                $createdAt = $data['created_at'] ?? $data['createdAt'] ?? null;
            }

            $data['$createdAt'] = $this->normalizeDateTime($createdAt);
        }

        if (! $hasUpdatedAt) {
            $updatedAt = $resource->getUpdatedAt();
            if (empty($updatedAt)) {
                $updatedAt = $data['updated_at'] ?? $data['updatedAt'] ?? null;
            }

            if (empty($updatedAt)) {
                $data['$updatedAt'] = (string) $data['$createdAt'];
            } else {
                $data['$updatedAt'] = $this->normalizeDateTime($updatedAt, $data['$createdAt']);
            }
        }

        $this->rowBuffer[] = new UtopiaDocument(\array_merge([
            '$id' => $resource->getId(),
            '$permissions' => $resource->getPermissions(),
        ], $data));

        if ($isLast) {
            try {
                $database = $this->dbForProject->getDocument(
                    'databases',
                    $resource->getTable()->getDatabase()->getId(),
                );

                $table = $this->dbForProject->getDocument(
                    'database_' . $database->getSequence(),
                    $resource->getTable()->getId(),
                );

                $databaseInternalId = $database->getSequence();
                $tableInternalId = $table->getSequence();
                $dbForDatabases = ($this->getDatabasesDB)($database);
                /**
                 * This is in case an attribute was deleted from Appwrite attributes collection but was not deleted from the table
                 * When creating an archive we select * which will include orphan attribute from the schema
                 */
                if ($dbForDatabases->getAdapter()->getSupportForAttributes()) {
                    foreach ($this->rowBuffer as $row) {
                        foreach ($row as $key => $value) {
                            if (\str_starts_with($key, '$')) {
                                continue;
                            }

                            /** @var \Utopia\Database\Document $attribute */
                            $found = false;
                            foreach ($table->getAttribute('attributes', []) as $attribute) {
                                if ($attribute->getAttribute('key') == $key) {
                                    $found = true;
                                    break;
                                }
                            }

                            if (! $found) {
                                $row->removeAttribute($key);
                            }
                        }
                    }
                }
                $dbForDatabases->skipRelationshipsExistCheck(fn () => $dbForDatabases->createDocuments(
                    'database_' . $databaseInternalId . '_collection_' . $tableInternalId,
                    $this->rowBuffer
                ));

            } finally {
                $this->rowBuffer = [];
            }
        }


        return true;
    }

    /**
     * @throws \Exception
     */
    private function normalizeDateTime(mixed $value, mixed $fallback = null): string
    {
        $resolved = $this->stringifyDateValue($value)
            ?? $this->stringifyDateValue($fallback);

        if (empty($resolved)) {
            return DateTime::format(new \DateTime());
        }

        if (\is_numeric($resolved) && \strlen($resolved) === 10 && (int) $resolved > 0) { // Unix timestamp
            $resolved = '@' . $resolved;
        }

        return DateTime::format(new \DateTime($resolved));
    }

    private function stringifyDateValue(mixed $value): ?string
    {
        if (\is_string($value)) {
            return $value;
        }
        if (\is_int($value) || \is_float($value)) {
            return (string) $value;
        }

        return null;
    }

    /**
     * @throws AppwriteException
     */
    public function importFileResource(Resource $resource): Resource
    {
        switch ($resource->getName()) {
            case Resource::TYPE_FILE:
                /** @var File $resource */
                return $this->importFile($resource);
            case Resource::TYPE_BUCKET:
                /** @var Bucket $resource */

                $compression = match ($resource->getCompression()) {
                    'none' => Compression::NONE(),
                    'gzip' => Compression::GZIP(),
                    'zstd' => Compression::ZSTD(),
                    default => throw new \Exception('Invalid Compression: ' . $resource->getCompression(), Exception::CODE_VALIDATION),
                };

                $response = $this->storage->createBucket(
                    $resource->getId(),
                    $resource->getBucketName(),
                    $resource->getPermissions(),
                    $resource->getFileSecurity(),
                    $resource->getEnabled(),
                    $resource->getMaxFileSize(),
                    $resource->getAllowedFileExtensions(),
                    $compression,
                    $resource->getEncryption(),
                    $resource->getAntiVirus(),
                    $resource->getTransformations()
                );

                $resource->setId($response['$id']);
        }

        $resource->setStatus(Resource::STATUS_SUCCESS);

        return $resource;
    }

    /**
     * Import File Data
     *
     * @returns File
     * @throws AppwriteException
     */
    public function importFile(File $file): File
    {
        $bucketId = $file->getBucket()->getId();

        $response = null;

        if ($file->getSize() <= Transfer::STORAGE_MAX_CHUNK_SIZE) {
            $response = $this->client->call(
                'POST',
                "/storage/buckets/{$bucketId}/files",
                [
                    'content-type' => 'multipart/form-data',
                ],
                [
                    'bucketId' => $bucketId,
                    'fileId' => $file->getId(),
                    'file' => new \CURLFile('data://' . $file->getMimeType() . ';base64,' . base64_encode($file->getData()), $file->getMimeType(), $file->getFileName()),
                    'permissions' => $file->getPermissions(),
                ]
            );

            $file->setStatus(Resource::STATUS_SUCCESS);
            $file->setData('');

            return $file;
        }

        $response = $this->client->call(
            'POST',
            "/storage/buckets/{$bucketId}/files",
            [
                'content-type' => 'multipart/form-data',
                'content-range' => 'bytes ' . ($file->getStart()) . '-' . ($file->getEnd() == ($file->getSize() - 1) ? $file->getSize() : $file->getEnd()) . '/' . $file->getSize(),
            ],
            [
                'bucketId' => $bucketId,
                'fileId' => $file->getId(),
                'file' => new \CURLFile('data://' . $file->getMimeType() . ';base64,' . base64_encode($file->getData()), $file->getMimeType(), $file->getFileName()),
                'permissions' => $file->getPermissions(),
            ]
        );

        if ($file->getEnd() == ($file->getSize() - 1)) {
            $file->setStatus(Resource::STATUS_SUCCESS);

            // Signatures for encrypted files are invalid, so we skip the check
            if (!$file->getBucket()->getEncryption() || $file->getSize() > (20 * 1024 * 1024)) {
                if (\is_array($response) && $response['signature'] !== $file->getSignature()) {
                    $file->setStatus(Resource::STATUS_WARNING, 'File signature mismatch, Possibly corrupted.');
                }
            }
        }

        $file->setData('');

        return $file;
    }

    /**
     * @throws AppwriteException
     */
    public function importAuthResource(Resource $resource): Resource
    {
        switch ($resource->getName()) {
            case Resource::TYPE_USER:
                /** @var User $resource */
                if (!empty($resource->getPasswordHash())) {
                    $this->importPasswordUser($resource);
                } else {
                    $this->users->create(
                        $resource->getId(),
                        $resource->getEmail(),
                        null,
                        null,
                        null
                    );
                }

                if (!empty($resource->getUsername())) {
                    $this->users->updateName($resource->getId(), $resource->getUsername());
                }

                if (!empty($resource->getPhone())) {
                    $this->users->updatePhone($resource->getId(), $resource->getPhone());
                }

                if ($resource->getEmailVerified()) {
                    $this->users->updateEmailVerification($resource->getId(), true);
                }

                if ($resource->getPhoneVerified()) {
                    $this->users->updatePhoneVerification($resource->getId(), true);
                }

                if ($resource->getDisabled()) {
                    $this->users->updateStatus($resource->getId(), false);
                }

                if (!empty($resource->getPreferences())) {
                    $this->users->updatePrefs($resource->getId(), $resource->getPreferences());
                }

                if (!empty($resource->getLabels())) {
                    $this->users->updateLabels($resource->getId(), $resource->getLabels());
                }

                if (!empty($resource->getTargets())) {
                    $this->importUserTargets($resource->getId(), $resource->getTargets());
                }

                break;
            case Resource::TYPE_TEAM:
                /** @var Team $resource */
                $this->teams->create($resource->getId(), $resource->getTeamName());

                if (!empty($resource->getPreferences())) {
                    $this->teams->updatePrefs($resource->getId(), $resource->getPreferences());
                }
                break;
            case Resource::TYPE_MEMBERSHIP:
                /** @var Membership $resource */
                $user = $resource->getUser();

                $this->teams->createMembership(
                    $resource->getTeam()->getId(),
                    $resource->getRoles(),
                    userId: $user->getId(),
                );
                break;
        }

        $resource->setStatus(Resource::STATUS_SUCCESS);

        return $resource;
    }

    /**
     * @param User $user
     * @return array<string, mixed>|null
     * @throws AppwriteException
     * @throws \Exception
     */
    public function importPasswordUser(User $user): ?array
    {
        $hash = $user->getPasswordHash();
        $result = null;

        if (!$hash) {
            throw new \Exception('Password hash is missing', Exception::CODE_VALIDATION);
        }

        switch ($hash->getAlgorithm()) {
            case Hash::ALGORITHM_SCRYPT_MODIFIED:
                $result = $this->users->createScryptModifiedUser(
                    $user->getId(),
                    $user->getEmail(),
                    $hash->getHash(),
                    $hash->getSalt(),
                    $hash->getSeparator(),
                    $hash->getSigningKey(),
                    empty($user->getUsername()) ? null : $user->getUsername()
                );
                break;
            case Hash::ALGORITHM_BCRYPT:
                $result = $this->users->createBcryptUser(
                    $user->getId(),
                    $user->getEmail(),
                    $hash->getHash(),
                    empty($user->getUsername()) ? null : $user->getUsername()
                );
                break;
            case Hash::ALGORITHM_ARGON2:
                $result = $this->users->createArgon2User(
                    $user->getId(),
                    $user->getEmail(),
                    $hash->getHash(),
                    empty($user->getUsername()) ? null : $user->getUsername()
                );
                break;
            case Hash::ALGORITHM_SHA256:
                $result = $this->users->createSHAUser(
                    $user->getId(),
                    $user->getEmail(),
                    $hash->getHash(),
                    PasswordHash::SHA256(),
                    empty($user->getUsername()) ? null : $user->getUsername()
                );
                break;
            case Hash::ALGORITHM_PHPASS:
                $result = $this->users->createPHPassUser(
                    $user->getId(),
                    $user->getEmail(),
                    $hash->getHash(),
                    empty($user->getUsername()) ? null : $user->getUsername()
                );
                break;
            case Hash::ALGORITHM_SCRYPT:
                $result = $this->users->createScryptUser(
                    $user->getId(),
                    $user->getEmail(),
                    $hash->getHash(),
                    $hash->getSalt(),
                    $hash->getPasswordCpu(),
                    $hash->getPasswordMemory(),
                    $hash->getPasswordParallel(),
                    $hash->getPasswordLength(),
                    empty($user->getUsername()) ? null : $user->getUsername()
                );
                break;
            case Hash::ALGORITHM_PLAINTEXT:
                $result = $this->users->create(
                    $user->getId(),
                    $user->getEmail(),
                    $user->getPhone(),
                    $hash->getHash(),
                    empty($user->getUsername()) ? null : $user->getUsername()
                );
                break;
        }

        return $result;
    }

    /**
     * @throws AppwriteException
     */
    public function importFunctionResource(Resource $resource): Resource
    {
        switch ($resource->getName()) {
            case Resource::TYPE_FUNCTION:
                /** @var Func $resource */

                $runtime = match ($resource->getRuntime()) {
                    'node-14.5' => Runtime::NODE145(),
                    'node-16.0' => Runtime::NODE160(),
                    'node-18.0' => Runtime::NODE180(),
                    'node-19.0' => Runtime::NODE190(),
                    'node-20.0' => Runtime::NODE200(),
                    'node-21.0' => Runtime::NODE210(),
                    'node-22' => Runtime::NODE22(),
                    'php-8.0' => Runtime::PHP80(),
                    'php-8.1' => Runtime::PHP81(),
                    'php-8.2' => Runtime::PHP82(),
                    'php-8.3' => Runtime::PHP83(),
                    'ruby-3.0' => Runtime::RUBY30(),
                    'ruby-3.1' => Runtime::RUBY31(),
                    'ruby-3.2' => Runtime::RUBY32(),
                    'ruby-3.3' => Runtime::RUBY33(),
                    'python-3.8' => Runtime::PYTHON38(),
                    'python-3.9' => Runtime::PYTHON39(),
                    'python-3.10' => Runtime::PYTHON310(),
                    'python-3.11' => Runtime::PYTHON311(),
                    'python-3.12' => Runtime::PYTHON312(),
                    'python-ml-3.11' => Runtime::PYTHONML311(),
                    'python-ml-3.12' => Runtime::PYTHONML312(),
                    'dart-3.0' => Runtime::DART30(),
                    'dart-3.1' => Runtime::DART31(),
                    'dart-3.3' => Runtime::DART33(),
                    'dart-3.5' => Runtime::DART35(),
                    'dart-2.15' => Runtime::DART215(),
                    'dart-2.16' => Runtime::DART216(),
                    'dart-2.17' => Runtime::DART217(),
                    'dart-2.18' => Runtime::DART218(),
                    'dart-2.19' => Runtime::DART219(),
                    'deno-1.21' => Runtime::DENO121(),
                    'deno-1.24' => Runtime::DENO124(),
                    'deno-1.35' => Runtime::DENO135(),
                    'deno-1.40' => Runtime::DENO140(),
                    'deno-1.46' => Runtime::DENO146(),
                    'deno-2.0' => Runtime::DENO20(),
                    'dotnet-6.0' => Runtime::DOTNET60(),
                    'dotnet-7.0' => Runtime::DOTNET70(),
                    'dotnet-8.0' => Runtime::DOTNET80(),
                    'java-8.0' => Runtime::JAVA80(),
                    'java-11.0' => Runtime::JAVA110(),
                    'java-17.0' => Runtime::JAVA170(),
                    'java-18.0' => Runtime::JAVA180(),
                    'java-21.0' => Runtime::JAVA210(),
                    'java-22' => Runtime::JAVA22(),
                    'swift-5.5' => Runtime::SWIFT55(),
                    'swift-5.8' => Runtime::SWIFT58(),
                    'swift-5.9' => Runtime::SWIFT59(),
                    'swift-5.10' => Runtime::SWIFT510(),
                    'kotlin-1.6' => Runtime::KOTLIN16(),
                    'kotlin-1.8' => Runtime::KOTLIN18(),
                    'kotlin-1.9' => Runtime::KOTLIN19(),
                    'kotlin-2.0' => Runtime::KOTLIN20(),
                    'cpp-17' => Runtime::CPP17(),
                    'cpp-20' => Runtime::CPP20(),
                    'bun-1.0' => Runtime::BUN10(),
                    'bun-1.1' => Runtime::BUN11(),
                    'go-1.23' => Runtime::GO123(),
                    default => throw new \Exception('Invalid Runtime: ' . $resource->getRuntime(), Exception::CODE_VALIDATION),
                };

                $this->functions->create(
                    $resource->getId(),
                    $resource->getFunctionName(),
                    $runtime,
                    $resource->getExecute(),
                    $resource->getEvents(),
                    $resource->getSchedule(),
                    $resource->getTimeout(),
                    $resource->getEnabled(),
                    $resource->getLogging(),
                    $resource->getEntrypoint(),
                    $resource->getCommands(),
                    $resource->getScopes(),
                    specification: $resource->getSpecification() ?: null,
                );
                break;
            case Resource::TYPE_ENVIRONMENT_VARIABLE:
                /** @var EnvVar $resource */
                $this->functions->createVariable(
                    $resource->getFunc()->getId(),
                    $resource->getKey(),
                    $resource->getValue()
                );
                break;
            case Resource::TYPE_DEPLOYMENT:
                /** @var Deployment $resource */
                return $this->importDeployment($resource);
        }

        $resource->setStatus(Resource::STATUS_SUCCESS);

        return $resource;
    }

    /**
     * @throws AppwriteException
     * @throws \Exception
     */
    private function importDeployment(Deployment $deployment): Resource
    {
        $function = $deployment->getFunction();

        // Deployment API always creates a new deployment, so unlike other resources
        // there's no duplicate detection. Skip if the parent function wasn't imported successfully.
        if ($function->getStatus() !== Resource::STATUS_SUCCESS) {
            $deployment->setStatus(Resource::STATUS_SKIPPED, 'Parent function "' . $function->getId() . '" failed to import');

            return $deployment;
        }

        $functionId = $function->getId();

        $response = null;

        if ($deployment->getSize() <= Transfer::STORAGE_MAX_CHUNK_SIZE) {
            $response = $this->client->call(
                'POST',
                "/functions/{$functionId}/deployments",
                [
                    'content-type' => 'multipart/form-data',
                ],
                [
                    'functionId' => $functionId,
                    'code' => new \CURLFile('data://application/gzip;base64,' . base64_encode($deployment->getData()), 'application/gzip', 'deployment.tar.gz'),
                    'activate' => $deployment->getActivated() ? 'true' : 'false',
                    'entrypoint' => $deployment->getEntrypoint(),
                ]
            );

            $deployment->setStatus(Resource::STATUS_SUCCESS);

            return $deployment;
        }

        $response = $this->client->call(
            'POST',
            "/v1/functions/{$functionId}/deployments",
            [
                'content-type' => 'multipart/form-data',
                'content-range' => 'bytes ' . ($deployment->getStart()) . '-' . ($deployment->getEnd() == ($deployment->getSize() - 1) ? $deployment->getSize() : $deployment->getEnd()) . '/' . $deployment->getSize(),
                'x-appwrite-id' => $deployment->getId(),
            ],
            [
                'functionId' => $functionId,
                'code' => new \CURLFile('data://application/gzip;base64,' . base64_encode($deployment->getData()), 'application/gzip', 'deployment.tar.gz'),
                'activate' => $deployment->getActivated() ? 'true' : 'false',
                'entrypoint' => $deployment->getEntrypoint(),
            ]
        );

        if (!\is_array($response) || !isset($response['$id'])) {
            throw new \Exception('Deployment creation failed', Exception::CODE_INTERNAL);
        }

        if ($deployment->getStart() === 0) {
            $deployment->setId($response['$id']);
        }

        if ($deployment->getEnd() == ($deployment->getSize() - 1)) {
            $deployment->setStatus(Resource::STATUS_SUCCESS);
        } else {
            $deployment->setStatus(Resource::STATUS_PENDING);
        }

        return $deployment;
    }

    /**
     * @throws AppwriteException
     * @throws \Exception
     */
    public function importMessagingResource(Resource $resource): Resource
    {
        switch ($resource->getName()) {
            case Resource::TYPE_PROVIDER:
                /** @var Provider $resource */
                $this->createProvider($resource);
                break;
            case Resource::TYPE_TOPIC:
                /** @var Topic $resource */
                $this->createTopic($resource);
                break;
            case Resource::TYPE_SUBSCRIBER:
                /** @var Subscriber $resource */
                $this->createSubscriber($resource);
                break;
            case Resource::TYPE_MESSAGE:
                /** @var Message $resource */
                $this->createMessage($resource);
                break;
            default:
                throw new \Exception('Unknown messaging resource type: ' . $resource->getName());
        }

        $resource->setStatus(Resource::STATUS_SUCCESS);

        return $resource;
    }

    /**
     * @throws AppwriteException
     */
    public function importSiteResource(Resource $resource): Resource
    {
        switch ($resource->getName()) {
            case Resource::TYPE_SITE:
                /** @var Site $resource */

                $buildRuntime = match ($resource->getBuildRuntime()) {
                    'node-14.5' => BuildRuntime::NODE145(),
                    'node-16.0' => BuildRuntime::NODE160(),
                    'node-18.0' => BuildRuntime::NODE180(),
                    'node-19.0' => BuildRuntime::NODE190(),
                    'node-20.0' => BuildRuntime::NODE200(),
                    'node-21.0' => BuildRuntime::NODE210(),
                    'node-22' => BuildRuntime::NODE22(),
                    'php-8.0' => BuildRuntime::PHP80(),
                    'php-8.1' => BuildRuntime::PHP81(),
                    'php-8.2' => BuildRuntime::PHP82(),
                    'php-8.3' => BuildRuntime::PHP83(),
                    'ruby-3.0' => BuildRuntime::RUBY30(),
                    'ruby-3.1' => BuildRuntime::RUBY31(),
                    'ruby-3.2' => BuildRuntime::RUBY32(),
                    'ruby-3.3' => BuildRuntime::RUBY33(),
                    'python-3.8' => BuildRuntime::PYTHON38(),
                    'python-3.9' => BuildRuntime::PYTHON39(),
                    'python-3.10' => BuildRuntime::PYTHON310(),
                    'python-3.11' => BuildRuntime::PYTHON311(),
                    'python-3.12' => BuildRuntime::PYTHON312(),
                    'python-ml-3.11' => BuildRuntime::PYTHONML311(),
                    'python-ml-3.12' => BuildRuntime::PYTHONML312(),
                    'dart-3.0' => BuildRuntime::DART30(),
                    'dart-3.1' => BuildRuntime::DART31(),
                    'dart-3.3' => BuildRuntime::DART33(),
                    'dart-3.5' => BuildRuntime::DART35(),
                    'dart-3.8' => BuildRuntime::DART38(),
                    'dart-3.9' => BuildRuntime::DART39(),
                    'dart-2.15' => BuildRuntime::DART215(),
                    'dart-2.16' => BuildRuntime::DART216(),
                    'dart-2.17' => BuildRuntime::DART217(),
                    'dart-2.18' => BuildRuntime::DART218(),
                    'dart-2.19' => BuildRuntime::DART219(),
                    'deno-1.21' => BuildRuntime::DENO121(),
                    'deno-1.24' => BuildRuntime::DENO124(),
                    'deno-1.35' => BuildRuntime::DENO135(),
                    'deno-1.40' => BuildRuntime::DENO140(),
                    'deno-1.46' => BuildRuntime::DENO146(),
                    'deno-2.0' => BuildRuntime::DENO20(),
                    'dotnet-6.0' => BuildRuntime::DOTNET60(),
                    'dotnet-7.0' => BuildRuntime::DOTNET70(),
                    'dotnet-8.0' => BuildRuntime::DOTNET80(),
                    'java-8.0' => BuildRuntime::JAVA80(),
                    'java-11.0' => BuildRuntime::JAVA110(),
                    'java-17.0' => BuildRuntime::JAVA170(),
                    'java-18.0' => BuildRuntime::JAVA180(),
                    'java-21.0' => BuildRuntime::JAVA210(),
                    'java-22' => BuildRuntime::JAVA22(),
                    'swift-5.5' => BuildRuntime::SWIFT55(),
                    'swift-5.8' => BuildRuntime::SWIFT58(),
                    'swift-5.9' => BuildRuntime::SWIFT59(),
                    'swift-5.10' => BuildRuntime::SWIFT510(),
                    'kotlin-1.6' => BuildRuntime::KOTLIN16(),
                    'kotlin-1.8' => BuildRuntime::KOTLIN18(),
                    'kotlin-1.9' => BuildRuntime::KOTLIN19(),
                    'kotlin-2.0' => BuildRuntime::KOTLIN20(),
                    'cpp-17' => BuildRuntime::CPP17(),
                    'cpp-20' => BuildRuntime::CPP20(),
                    'bun-1.0' => BuildRuntime::BUN10(),
                    'bun-1.1' => BuildRuntime::BUN11(),
                    'go-1.23' => BuildRuntime::GO123(),
                    'static-1' => BuildRuntime::STATIC1(),
                    'flutter-3.24' => BuildRuntime::FLUTTER324(),
                    'flutter-3.27' => BuildRuntime::FLUTTER327(),
                    'flutter-3.29' => BuildRuntime::FLUTTER329(),
                    'flutter-3.32' => BuildRuntime::FLUTTER332(),
                    'flutter-3.35' => BuildRuntime::FLUTTER335(),
                    default => throw new \Exception('Invalid Build Runtime: ' . $resource->getBuildRuntime(), Exception::CODE_VALIDATION),
                };

                $framework = match ($resource->getFramework()) {
                    'analog' => Framework::ANALOG(),
                    'angular' => Framework::ANGULAR(),
                    'astro' => Framework::ASTRO(),
                    'flutter', 'flutter-web' => Framework::FLUTTER(),
                    'lynx' => Framework::LYNX(),
                    'nextjs' => Framework::NEXTJS(),
                    'nuxt' => Framework::NUXT(),
                    'react' => Framework::REACT(),
                    'react-native' => Framework::REACTNATIVE(),
                    'remix' => Framework::REMIX(),
                    'svelte-kit' => Framework::SVELTEKIT(),
                    'tanstack-start' => Framework::TANSTACKSTART(),
                    'vite' => Framework::VITE(),
                    'vue' => Framework::VUE(),
                    default => Framework::OTHER(),
                };

                $adapter = match ($resource->getAdapter()) {
                    'static' => Adapter::STATIC(),
                    'ssr' => Adapter::SSR(),
                    default => null,
                };

                $this->sites->create(
                    $resource->getId(),
                    $resource->getSiteName(),
                    $framework,
                    $buildRuntime,
                    $resource->getEnabled(),
                    $resource->getLogging(),
                    $resource->getTimeout(),
                    $resource->getInstallCommand(),
                    $resource->getBuildCommand(),
                    $resource->getOutputDirectory(),
                    $adapter,
                    fallbackFile: $resource->getFallbackFile(),
                    specification: $resource->getSpecification(),
                );
                break;
            case Resource::TYPE_SITE_VARIABLE:
                /** @var SiteEnvVar $resource */
                $this->sites->createVariable(
                    $resource->getSite()->getId(),
                    $resource->getKey(),
                    $resource->getValue()
                );
                break;
            case Resource::TYPE_SITE_DEPLOYMENT:
                /** @var SiteDeployment $resource */
                return $this->importSiteDeployment($resource);
        }

        $resource->setStatus(Resource::STATUS_SUCCESS);

        return $resource;
    }

    /**
     * Import user targets not auto-created by the server (e.g. push).
     * providerInternalId is resolved later in createProvider().
     *
     * @param array<array<string, mixed>> $targets
     */
    protected function importUserTargets(string $userId, array $targets): void
    {
        $userDoc = null;

        foreach ($targets as $target) {
            switch ($target['providerType'] ?? '') {
                case 'email':
                case 'sms':
                    // Auto-created by the server when a user is created with an email/phone
                    break;
                case 'push':
                    $userDoc ??= $this->dbForProject->getDocument('users', $userId);

                    $createdAt = $this->normalizeDateTime($target['$createdAt'] ?? null);
                    $updatedAt = $this->normalizeDateTime($target['$updatedAt'] ?? null, $createdAt);

                    $this->dbForProject->createDocument('targets', new UtopiaDocument([
                        '$id' => $target['$id'],
                        '$createdAt' => $createdAt,
                        '$updatedAt' => $updatedAt,
                        '$permissions' => [
                            Permission::read(Role::user($userId)),
                            Permission::update(Role::user($userId)),
                            Permission::delete(Role::user($userId)),
                        ],
                        'userId' => $userId,
                        'userInternalId' => $userDoc->getSequence(),
                        'providerType' => $target['providerType'],
                        'providerId' => $target['providerId'] ?? null,
                        'identifier' => $target['identifier'],
                        'name' => $target['name'] ?? null,
                        'expired' => $target['expired'] ?? false,
                    ]));
                    break;
            }
        }

        if ($userDoc !== null) {
            $this->dbForProject->purgeCachedDocument('users', $userId);
        }
    }

    /**
     * @throws AppwriteException
     * @throws \Exception
     */
    protected function createProvider(Provider $resource): void
    {
        $credentials = $resource->getCredentials();
        $options = $resource->getOptions();
        $id = $resource->getId();
        $name = $resource->getProviderName();
        $enabled = $resource->getEnabled();

        match ($resource->getProvider()) {
            'mailgun' => $this->messaging->createMailgunProvider(
                $id,
                $name,
                $credentials['apiKey'] ?? null,
                $credentials['domain'] ?? null,
                $credentials['isEuRegion'] ?? null,
                ($options['fromName'] ?? '') ?: null,
                ($options['fromEmail'] ?? '') ?: null,
                ($options['replyToName'] ?? '') ?: null,
                ($options['replyToEmail'] ?? '') ?: null,
                $enabled,
            ),
            'sendgrid' => $this->messaging->createSendgridProvider(
                $id,
                $name,
                $credentials['apiKey'] ?? null,
                ($options['fromName'] ?? '') ?: null,
                ($options['fromEmail'] ?? '') ?: null,
                ($options['replyToName'] ?? '') ?: null,
                ($options['replyToEmail'] ?? '') ?: null,
                $enabled,
            ),
            'resend' => $this->messaging->createResendProvider(
                $id,
                $name,
                $credentials['apiKey'] ?? null,
                ($options['fromName'] ?? '') ?: null,
                ($options['fromEmail'] ?? '') ?: null,
                ($options['replyToName'] ?? '') ?: null,
                ($options['replyToEmail'] ?? '') ?: null,
                $enabled,
            ),
            'smtp' => $this->messaging->createSMTPProvider(
                $id,
                $name,
                $credentials['host'] ?? '',
                $credentials['port'] ?? null,
                ($credentials['username'] ?? '') ?: null,
                ($credentials['password'] ?? '') ?: null,
                match ($options['encryption'] ?? '') {
                    'ssl' => SmtpEncryption::SSL(),
                    'tls' => SmtpEncryption::TLS(),
                    default => SmtpEncryption::NONE(),
                },
                $options['autoTLS'] ?? null,
                ($options['mailer'] ?? '') ?: null,
                ($options['fromName'] ?? '') ?: null,
                ($options['fromEmail'] ?? '') ?: null,
                ($options['replyToName'] ?? '') ?: null,
                ($options['replyToEmail'] ?? '') ?: null,
                $enabled,
            ),
            'msg91' => $this->messaging->createMsg91Provider(
                $id,
                $name,
                $credentials['templateId'] ?? null,
                $credentials['senderId'] ?? null,
                $credentials['authKey'] ?? null,
                $enabled,
            ),
            'telesign' => $this->messaging->createTelesignProvider(
                $id,
                $name,
                ($options['from'] ?? '') ?: null,
                $credentials['customerId'] ?? null,
                $credentials['apiKey'] ?? null,
                $enabled,
            ),
            'textmagic' => $this->messaging->createTextmagicProvider(
                $id,
                $name,
                ($options['from'] ?? '') ?: null,
                $credentials['username'] ?? null,
                $credentials['apiKey'] ?? null,
                $enabled,
            ),
            'twilio' => $this->messaging->createTwilioProvider(
                $id,
                $name,
                ($options['from'] ?? '') ?: null,
                $credentials['accountSid'] ?? null,
                $credentials['authToken'] ?? null,
                $enabled,
            ),
            'vonage' => $this->messaging->createVonageProvider(
                $id,
                $name,
                ($options['from'] ?? '') ?: null,
                $credentials['apiKey'] ?? null,
                $credentials['apiSecret'] ?? null,
                $enabled,
            ),
            'fcm' => $this->messaging->createFCMProvider(
                $id,
                $name,
                $credentials['serviceAccountJSON'] ?? null,
                $enabled,
            ),
            'apns' => $this->messaging->createAPNSProvider(
                $id,
                $name,
                $credentials['authKey'] ?? null,
                $credentials['authKeyId'] ?? null,
                $credentials['teamId'] ?? null,
                $credentials['bundleId'] ?? null,
                $options['sandbox'] ?? null,
                $enabled,
            ),
            default => throw new \Exception('Unknown provider: ' . $resource->getProvider()),
        };

        // Resolve providerInternalId for push targets that were written during GROUP_AUTH
        // before the provider existed on the destination.
        $provider = $this->dbForProject->getDocument('providers', $id);
        $targets = $this->dbForProject->find('targets', [
            Query::equal('providerId', [$id]),
            Query::isNull('providerInternalId'),
        ]);

        $userIds = [];

        foreach ($targets as $target) {
            $target->setAttribute('providerInternalId', $provider->getSequence());
            $this->dbForProject->updateDocument('targets', $target->getId(), $target);
            $userIds[$target->getAttribute('userId')] = true;
        }

        foreach (array_keys($userIds) as $userId) {
            $this->dbForProject->purgeCachedDocument('users', $userId);
        }
    }

    /**
     * @throws AppwriteException
     */
    protected function createTopic(Topic $resource): void
    {
        $this->messaging->createTopic(
            $resource->getId(),
            $resource->getTopicName(),
            $resource->getSubscribe(),
        );
    }

    /**
     * @throws AuthorizationException
     * @throws StructureException
     * @throws DatabaseException|\Exception
     */
    protected function createSubscriber(Subscriber $resource): void
    {
        $target = match ($resource->getProviderType()) {
            'push' => $this->dbForProject->getDocument('targets', $resource->getTargetId()),
            'email', 'sms' => $this->dbForProject->findOne('targets', [
                Query::equal('userId', [$resource->getUserId()]),
                Query::equal('providerType', [$resource->getProviderType()]),
            ]),
            default => throw new \Exception('Unknown provider type: ' . $resource->getProviderType()),
        };

        if (!$target || $target->isEmpty()) {
            throw new \Exception('Target not found for subscriber: ' . $resource->getId());
        }

        $topic = $this->dbForProject->getDocument('topics', $resource->getTopicId());
        if ($topic->isEmpty()) {
            throw new \Exception('Topic not found: ' . $resource->getTopicId());
        }

        $user = $this->dbForProject->getDocument('users', $resource->getUserId());
        if ($user->isEmpty()) {
            throw new \Exception('User not found: ' . $resource->getUserId());
        }

        $createdAt = $this->normalizeDateTime($resource->getCreatedAt());
        $updatedAt = $this->normalizeDateTime($resource->getUpdatedAt(), $createdAt);

        $this->dbForProject->createDocument('subscribers', new UtopiaDocument([
            '$id' => $resource->getId(),
            '$createdAt' => $createdAt,
            '$updatedAt' => $updatedAt,
            '$permissions' => [
                Permission::read(Role::user($resource->getUserId())),
                Permission::delete(Role::user($resource->getUserId())),
            ],
            'topicId' => $topic->getId(),
            'topicInternalId' => $topic->getSequence(),
            'targetId' => $target->getId(),
            'targetInternalId' => $target->getSequence(),
            'userId' => $user->getId(),
            'userInternalId' => $user->getSequence(),
            'providerType' => $resource->getProviderType(),
            'search' => implode(' ', [
                $resource->getId(),
                $target->getId(),
                $user->getId(),
                $resource->getProviderType(),
            ]),
        ]));

        $totalAttribute = match ($resource->getProviderType()) {
            'email' => 'emailTotal',
            'sms' => 'smsTotal',
            'push' => 'pushTotal',
            default => throw new \Exception('Unknown provider type: ' . $resource->getProviderType()),
        };

        $this->dbForProject->increaseDocumentAttribute('topics', $resource->getTopicId(), $totalAttribute);
    }

    /**
     * @throws AppwriteException
     * @throws \Exception
     */
    protected function createMessage(Message $resource): void
    {
        $resolvedTargets = $resource->getTargets();
        $status = $resource->getMessageStatus();

        if ($status === 'scheduled') {
            $scheduledAt = $resource->getScheduledAt();

            if (!empty($scheduledAt) && new \DateTime($scheduledAt) > new \DateTime()) {
                $this->createScheduledMessage($resource, $resolvedTargets);

                return;
            }

            $status = 'draft';
        }

        if ($status === 'processing') {
            $status = 'draft';
        }

        $createdAt = $this->normalizeDateTime($resource->getCreatedAt());
        $updatedAt = $this->normalizeDateTime($resource->getUpdatedAt(), $createdAt);

        $data = $resource->getData();
        $searchContent = match ($resource->getProviderType()) {
            'email' => $data['subject'] ?? '',
            'sms' => $data['content'] ?? '',
            'push' => $data['title'] ?? '',
            default => '',
        };

        $this->dbForProject->createDocument('messages', new UtopiaDocument([
            '$id' => $resource->getId(),
            '$createdAt' => $createdAt,
            '$updatedAt' => $updatedAt,
            '$permissions' => [],
            'providerType' => $resource->getProviderType(),
            'topics' => $resource->getTopics(),
            'users' => $resource->getUsers(),
            'targets' => $resolvedTargets,
            'scheduledAt' => null,
            'deliveredAt' => $resource->getDeliveredAt() ?: null,
            'deliveryErrors' => $resource->getDeliveryErrors(),
            'deliveredTotal' => $resource->getDeliveredTotal(),
            'data' => $data,
            'status' => $status,
            'search' => implode(' ', array_filter([
                $resource->getId(),
                $data['description'] ?? '',
                $status,
                $searchContent,
                $resource->getProviderType(),
            ])),
        ]));
    }

    /**
     * @param array<string> $resolvedTargets
     * @throws AppwriteException
     * @throws \Exception
     */
    protected function createScheduledMessage(Message $resource, array $resolvedTargets): void
    {
        $data = $resource->getData();
        $topics = $resource->getTopics() ?: null;
        $users = $resource->getUsers() ?: null;
        $targets = $resolvedTargets ?: null;
        $scheduledAt = $resource->getScheduledAt();

        match ($resource->getProviderType()) {
            'email' => $this->messaging->createEmail(
                $resource->getId(),
                $data['subject'] ?? '',
                $data['content'] ?? '',
                $topics,
                $users,
                $targets,
                $data['cc'] ?? null,
                $data['bcc'] ?? null,
                null,
                false,
                $data['html'] ?? null,
                $scheduledAt,
            ),
            'sms' => $this->messaging->createSMS(
                $resource->getId(),
                $data['content'] ?? '',
                $topics,
                $users,
                $targets,
                false,
                $scheduledAt,
            ),
            'push' => $this->messaging->createPush(
                $resource->getId(),
                $data['title'] ?? null,
                $data['body'] ?? null,
                $topics,
                $users,
                $targets,
                $data['data'] ?? null,
                $data['action'] ?? null,
                $data['image'] ?? null,
                $data['icon'] ?? null,
                $data['sound'] ?? null,
                $data['color'] ?? null,
                $data['tag'] ?? null,
                $data['badge'] ?? null,
                false,
                $scheduledAt,
                $data['contentAvailable'] ?? null,
                $data['critical'] ?? null,
                null,
            ),
            default => throw new \Exception('Unknown provider type: ' . $resource->getProviderType()),
        };
    }

    private function importSiteDeployment(SiteDeployment $deployment): Resource
    {
        $site = $deployment->getSite();

        // Deployment API always creates a new deployment, so unlike other resources
        // there's no duplicate detection. Skip if the parent site wasn't imported successfully.
        if ($site->getStatus() !== Resource::STATUS_SUCCESS) {
            $deployment->setStatus(Resource::STATUS_SKIPPED, 'Parent site "' . $site->getId() . '" failed to import');

            return $deployment;
        }

        $siteId = $site->getId();

        if ($deployment->getSize() <= Transfer::STORAGE_MAX_CHUNK_SIZE) {
            $response = $this->client->call(
                'POST',
                "/sites/{$siteId}/deployments",
                [
                    'content-type' => 'multipart/form-data',
                ],
                [
                    'siteId' => $siteId,
                    'code' => new \CURLFile('data://application/gzip;base64,' . base64_encode($deployment->getData()), 'application/gzip', 'deployment.tar.gz'),
                    'activate' => $deployment->getActivated() ? 'true' : 'false',
                ]
            );

            if (!\is_array($response) || !isset($response['$id'])) {
                throw new \Exception('Site deployment creation failed', Exception::CODE_INTERNAL);
            }

            $deployment->setStatus(Resource::STATUS_SUCCESS);

            return $deployment;
        }

        $response = $this->client->call(
            'POST',
            "/sites/{$siteId}/deployments",
            [
                'content-type' => 'multipart/form-data',
                'content-range' => 'bytes ' . ($deployment->getStart()) . '-' . ($deployment->getEnd() == ($deployment->getSize() - 1) ? $deployment->getSize() : $deployment->getEnd()) . '/' . $deployment->getSize(),
                'x-appwrite-id' => $deployment->getId(),
            ],
            [
                'siteId' => $siteId,
                'code' => new \CURLFile('data://application/gzip;base64,' . base64_encode($deployment->getData()), 'application/gzip', 'deployment.tar.gz'),
                'activate' => $deployment->getActivated() ? 'true' : 'false',
            ]
        );

        if (!\is_array($response) || !isset($response['$id'])) {
            throw new \Exception('Site deployment creation failed', Exception::CODE_INTERNAL);
        }

        if ($deployment->getStart() === 0) {
            $deployment->setId($response['$id']);
        }

        if ($deployment->getEnd() == ($deployment->getSize() - 1)) {
            $deployment->setStatus(Resource::STATUS_SUCCESS);
        } else {
            $deployment->setStatus(Resource::STATUS_PENDING);
        }

        return $deployment;
    }

    private function validateFieldsForIndexes(Index $resource, UtopiaDocument $table, array &$lengths)
    {
        /**
         * @var array<UtopiaDocument> $tableColumns
         */
        $tableColumns = $table->getAttribute('attributes', []);

        $oldColumns = \array_map(
            fn ($attr) => $attr->getArrayCopy(),
            $tableColumns
        );

        $oldColumns[] = [
            'key' => '$id',
            'type' => UtopiaDatabase::VAR_STRING,
            'status' => 'available',
            'required' => true,
            'array' => false,
            'default' => null,
            'size' => UtopiaDatabase::LENGTH_KEY
        ];

        $oldColumns[] = [
            'key' => '$createdAt',
            'type' => UtopiaDatabase::VAR_DATETIME,
            'status' => 'available',
            'signed' => false,
            'required' => false,
            'array' => false,
            'default' => null,
            'size' => 0
        ];

        $oldColumns[] = [
            'key' => '$updatedAt',
            'type' => UtopiaDatabase::VAR_DATETIME,
            'status' => 'available',
            'signed' => false,
            'required' => false,
            'array' => false,
            'default' => null,
            'size' => 0
        ];

        foreach ($resource->getColumns() as $i => $column) {
            // find attribute metadata in collection document
            $columnIndex = \array_search(
                $column,
                \array_column($oldColumns, 'key')
            );

            if ($columnIndex === false) {
                throw new Exception(
                    resourceName: $resource->getName(),
                    resourceGroup: $resource->getGroup(),
                    resourceId: $resource->getId(),
                    message: 'Column not found in table: ' . $column,
                );
            }

            $columnStatus = $oldColumns[$columnIndex]['status'];
            $columnType = $oldColumns[$columnIndex]['type'];
            $columnArray = $oldColumns[$columnIndex]['array'] ?? false;

            if ($columnType === UtopiaDatabase::VAR_RELATIONSHIP) {
                throw new Exception(
                    resourceName: $resource->getName(),
                    resourceGroup: $resource->getGroup(),
                    resourceId: $resource->getId(),
                    message: 'Relationship columns are not supported in indexes',
                );
            }

            // Ensure attribute is available
            if ($columnStatus !== 'available') {
                throw new Exception(
                    resourceName: $resource->getName(),
                    resourceGroup: $resource->getGroup(),
                    resourceId: $resource->getId(),
                    message: 'Column not available: ' . $column,
                );
            }

            $lengths[$i] = null;

            if ($columnArray === true) {
                $lengths[$i] = UtopiaDatabase::MAX_ARRAY_INDEX_LENGTH;
            }
        }
    }
}