Validate byte length for string attributes stored as TEXT

src/Database/Adapter/Limits.php

@@ -3,6 +3,7 @@
 namespace Utopia\Database\Adapter;
 
 use DateTime;
+use Utopia\Database\Database;
 use Utopia\Query\Schema\ColumnType;
 
 /**
@@ -34,6 +35,32 @@ public function __construct(
         public ColumnType $idType,
         public array $keywords,
         public array $internalIndexKeys,
+        public bool $escalatedStringByteCap = true,
     ) {
     }
+
+    /**
+     * Byte capacity for a {@see ColumnType::String} attribute stored outside VARCHAR, matching {@see SQL::getSqlType()}.
+     * Null when the declared size fits in VARCHAR or when escalated TEXT types have no byte cap (PostgreSQL).
+     */
+    public function stringEscalatedStorageByteLimit(int $size): ?int
+    {
+        if ($size <= $this->varchar) {
+            return null;
+        }
+
+        if (! $this->escalatedStringByteCap) {
+            return null;
+        }
+
+        if ($size > 16777215) {
+            return Database::MAX_LONGTEXT_BYTES;
+        }
+
+        if ($size > 65535) {
+            return Database::MAX_MEDIUMTEXT_BYTES;
+        }
+
+        return Database::MAX_TEXT_BYTES;
+    }
 }

src/Database/Adapter/Postgres.php

@@ -1774,6 +1774,12 @@ public function schema(): PostgresSchema
         return new PostgresSchema();
     }
 
+    #[\Override]
+    protected function limitsEscalatedStringByteCap(): bool
+    {
+        return false;
+    }
+
     #[\Override]
     protected function getSqlType(ColumnType $type, int $size, bool $signed = true, bool $array = false, bool $required = false): string
     {

src/Database/Adapter/Redis.php

@@ -1673,6 +1673,7 @@ public function limits(): Limits
             idType: ColumnType::Integer,
             keywords: [],
             internalIndexKeys: [],
+            escalatedStringByteCap: false,
         );
     }
 

src/Database/Adapter/SQL.php

@@ -2610,9 +2610,15 @@ public function limits(): Limits
             idType: ColumnType::Integer,
             keywords: $this->getKeywords(),
             internalIndexKeys: [Storage::INDEX_PRIMARY, Storage::INDEX_CREATED_AT, Storage::INDEX_UPDATED_AT, Storage::INDEX_TENANT_ID],
+            escalatedStringByteCap: $this->limitsEscalatedStringByteCap(),
         );
     }
 
+    protected function limitsEscalatedStringByteCap(): bool
+    {
+        return true;
+    }
+
     #[\Override]
     public function getCountOfAttributes(Document $collection): int
     {

src/Database/Adapter/SQLite.php

@@ -136,6 +136,12 @@ public function __construct(object $pdo)
         $this->registerUserFunctions();
     }
 
+    #[\Override]
+    protected function limitsEscalatedStringByteCap(): bool
+    {
+        return $this->emulateMySQL;
+    }
+
     #[Override]
     public function reconnect(): void
     {

src/Database/Validator/Structure.php

@@ -325,8 +325,17 @@ protected function checkForInvalidAttributeValues(Document $document, array $str
                     break;
 
                 case ColumnType::Varchar:
+                    $validators[] = new Text($size, min: 0);
+                    break;
+
                 case ColumnType::String:
                     $validators[] = new Text($size, min: 0);
+                    if (! $attribute->array) {
+                        $byteCap = $this->profile->limits->stringEscalatedStorageByteLimit($size);
+                        if ($byteCap !== null) {
+                            $validators[] = new ByteLength($byteCap);
+                        }
+                    }
                     break;
 
                 case ColumnType::Integer:

tests/e2e/Adapter/Scopes/DocumentTests.php

@@ -1384,6 +1384,98 @@ public function testTextByteTruncationUpdate(): void
         }
     }
 
+    public function testStringByteTruncationCreate(): void
+    {
+        /** @var Database $database */
+        $database = $this->getDatabase();
+
+        if (!$database->getAdapter()->supports(Capability::DefinedAttributes)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $attributeSize = 20000;
+        $byteCap = $database->profile()->limits->stringEscalatedStorageByteLimit($attributeSize);
+
+        $database->createCollection(Collection::create(id: __FUNCTION__));
+        $database->createAttribute(__FUNCTION__, Attribute::string(key: 'cursorJson', size: $attributeSize));
+
+        $value = \str_repeat('📝', 20000);
+        $this->assertGreaterThan(65535, \strlen($value));
+
+        $document = new Document([
+            '$id' => 'first',
+            'cursorJson' => $value,
+            '$permissions' => [
+                Permission::read(Role::any()),
+                Permission::create(Role::any()),
+                Permission::update(Role::any()),
+                Permission::delete(Role::any()),
+            ],
+        ]);
+
+        if ($byteCap !== null) {
+            try {
+                $database->createDocument(__FUNCTION__, $document);
+                $this->fail('Expected StructureException for over-capacity string value');
+            } catch (StructureException $e) {
+                $this->assertStringContainsString((string) $byteCap.' bytes', $e->getMessage());
+            }
+
+            return;
+        }
+
+        $created = $database->createDocument(__FUNCTION__, $document);
+        $this->assertSame($value, $created->getAttribute('cursorJson'));
+    }
+
+    public function testStringByteTruncationUpdate(): void
+    {
+        /** @var Database $database */
+        $database = $this->getDatabase();
+
+        if (!$database->getAdapter()->supports(Capability::DefinedAttributes)) {
+            $this->expectNotToPerformAssertions();
+            return;
+        }
+
+        $attributeSize = 20000;
+        $byteCap = $database->profile()->limits->stringEscalatedStorageByteLimit($attributeSize);
+
+        $database->createCollection(Collection::create(id: __FUNCTION__));
+        $database->createAttribute(__FUNCTION__, Attribute::string(key: 'cursorJson', size: $attributeSize));
+
+        $document = new Document([
+            '$id' => 'first',
+            'cursorJson' => \str_repeat('a', 16383),
+            '$permissions' => [
+                Permission::read(Role::any()),
+                Permission::create(Role::any()),
+                Permission::update(Role::any()),
+                Permission::delete(Role::any()),
+            ],
+        ]);
+
+        $created = $database->createDocument(__FUNCTION__, $document);
+
+        $value = \str_repeat('📝', 20000);
+        $this->assertGreaterThan(65535, \strlen($value));
+
+        if ($byteCap !== null) {
+            try {
+                $database->updateDocument(__FUNCTION__, $created->getId(), $created->setAttribute('cursorJson', $value));
+                $this->fail('Expected StructureException for over-capacity string value on update');
+            } catch (StructureException $e) {
+                $this->assertStringContainsString((string) $byteCap.' bytes', $e->getMessage());
+            }
+
+            return;
+        }
+
+        $updated = $database->updateDocument(__FUNCTION__, $created->getId(), $created->setAttribute('cursorJson', $value));
+        $this->assertSame($value, $updated->getAttribute('cursorJson'));
+    }
+
     public function testUpsertDocumentsInc(): void
     {
         /** @var Database $database */

tests/unit/Adapter/LimitsStringEscalationTest.php

@@ -0,0 +1,66 @@
+<?php
+
+namespace Tests\Unit\Adapter;
+
+use PHPUnit\Framework\TestCase;
+use Utopia\Database\Adapter\Limits;
+use Utopia\Database\Database;
+use Utopia\Query\Schema\ColumnType;
+
+class LimitsStringEscalationTest extends TestCase
+{
+    public function testStringEscalatedStorageByteLimit(): void
+    {
+        $limits = new Limits(
+            string: 4294967295,
+            varchar: 16381,
+            integer: 0,
+            bigInteger: 0,
+            attributes: 0,
+            indexes: 0,
+            defaultAttributes: 0,
+            defaultIndexes: 0,
+            indexLength: 0,
+            uidLength: 36,
+            documentSize: 0,
+            minDateTime: new \DateTime('0000-01-01'),
+            maxDateTime: new \DateTime('9999-12-31'),
+            idType: ColumnType::Integer,
+            keywords: [],
+            internalIndexKeys: [],
+        );
+
+        $this->assertNull($limits->stringEscalatedStorageByteLimit(100));
+        $this->assertSame(Database::MAX_TEXT_BYTES, $limits->stringEscalatedStorageByteLimit(16382));
+        $this->assertSame(Database::MAX_TEXT_BYTES, $limits->stringEscalatedStorageByteLimit(65535));
+        $this->assertSame(Database::MAX_MEDIUMTEXT_BYTES, $limits->stringEscalatedStorageByteLimit(65536));
+        $this->assertSame(Database::MAX_TEXT_BYTES, $limits->stringEscalatedStorageByteLimit(20000));
+        $this->assertSame(Database::MAX_MEDIUMTEXT_BYTES, $limits->stringEscalatedStorageByteLimit(100000));
+        $this->assertSame(Database::MAX_LONGTEXT_BYTES, $limits->stringEscalatedStorageByteLimit(20000000));
+    }
+
+    public function testStringEscalatedStorageByteLimitDisabled(): void
+    {
+        $limits = new Limits(
+            string: 4294967295,
+            varchar: 16381,
+            integer: 0,
+            bigInteger: 0,
+            attributes: 0,
+            indexes: 0,
+            defaultAttributes: 0,
+            defaultIndexes: 0,
+            indexLength: 0,
+            uidLength: 36,
+            documentSize: 0,
+            minDateTime: new \DateTime('0000-01-01'),
+            maxDateTime: new \DateTime('9999-12-31'),
+            idType: ColumnType::Integer,
+            keywords: [],
+            internalIndexKeys: [],
+            escalatedStringByteCap: false,
+        );
+
+        $this->assertNull($limits->stringEscalatedStorageByteLimit(20000));
+    }
+}

tests/unit/Support/Profiles.php

@@ -35,6 +35,7 @@ public static function of(
         ?DateTime $minDateTime = null,
         ?DateTime $maxDateTime = null,
         array $internalIndexKeys = [],
+        bool $escalatedStringByteCap = true,
     ): Profile {
         return new Profile(
             new Limits(
@@ -54,6 +55,7 @@ public static function of(
                 idType: $idType,
                 keywords: [],
                 internalIndexKeys: $internalIndexKeys,
+                escalatedStringByteCap: $escalatedStringByteCap,
             ),
             $capabilities,
             $features,