feat(codegen-kotlin): KotlinTypeMapper emits text() column for long strings (kind=text OR maxLength>4000)

StringField.exposedColumnSpec now dispatches to Exposed text(name) when
either @kind=text is set or @maxlength exceeds the VARCHAR/TEXT cutoff
(4000, the Postgres TOAST boundary). Otherwise behavior is unchanged:
varchar(name, N) with N defaulting to 255.

- new private constants: VARCHAR_TEXT_THRESHOLD=4000, KIND_TEXT, ATTR_KIND
- new helper: stringAttr(field, name) reads an own-only string attribute
  for dispatch keys outside the registered StringField schema
- three new tests on KotlinTypeMapperTest (kind=text -> text, large
  maxLength -> text, small maxLength -> varchar)

53 prior + 3 new = 56 tests green. Snapshot fixtures unaffected (no
existing fixture uses maxLength > 4000).

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: dmealing

server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinTypeMapper.kt

@@ -45,6 +45,20 @@ object KotlinTypeMapper {
     /** Default VARCHAR width for string-backed `field.enum` storage (v1). */
     const val ENUM_VARCHAR_LEN = 64
 
+    /**
+     * Threshold beyond which a [StringField]'s `@maxLength` is treated as unbounded text and
+     * emitted as Exposed `text(name)` rather than `varchar(name, N)`. Chosen at 4000 — the
+     * customary Postgres inline-VARCHAR cutoff (TOAST boundary); larger values are better
+     * served by `TEXT`, which Exposed maps to `text(name)`.
+     */
+    private const val VARCHAR_TEXT_THRESHOLD = 4000
+
+    /** Sentinel `@kind` value on a [StringField] that forces `text(name)` emission. */
+    private const val KIND_TEXT = "text"
+
+    /** Attribute name read off a [StringField] to dispatch to `text(name)` (kind=text). */
+    private const val ATTR_KIND = "kind"
+
     /**
      * Compute the generated Kotlin enum-class name for an [EnumField] hung off [entity].
      *
@@ -105,7 +119,16 @@ object KotlinTypeMapper {
      * for nested object.value fields without mutating the underlying MetaField.
      */
     fun exposedColumnSpec(field: MetaField<*>, colName: String): String = when (field) {
-        is StringField    -> "varchar(\"$colName\", ${stringMaxLength(field)})"
+        is StringField    -> {
+            // Dispatch to Exposed `text(name)` when the field is declared as unbounded text:
+            //   (1) explicit `@kind: "text"` opt-in, OR
+            //   (2) `@maxLength` exceeds the VARCHAR/TEXT cutoff (Postgres TOAST boundary).
+            // Otherwise emit `varchar(name, N)` with N defaulting to 255.
+            val kind = stringAttr(field, ATTR_KIND)
+            val maxLen = stringMaxLength(field)
+            if (kind == KIND_TEXT || maxLen > VARCHAR_TEXT_THRESHOLD) "text(\"$colName\")"
+            else "varchar(\"$colName\", $maxLen)"
+        }
         is IntegerField   -> "integer(\"$colName\")"
         is LongField      -> "long(\"$colName\")"
         is DoubleField    -> "double(\"$colName\")"
@@ -127,6 +150,20 @@ object KotlinTypeMapper {
         )
     }
 
+    /**
+     * Best-effort read of a named string attribute (own-only) on [field]. Returns null when
+     * the attribute is absent, throws during lookup, or isn't a [com.metaobjects.attr.MetaAttribute].
+     * Used for non-typed dispatch keys (e.g. `@kind`) that aren't part of the registered
+     * StringField attribute schema.
+     */
+    private fun stringAttr(field: MetaField<*>, name: String): String? {
+        if (!field.hasMetaAttr(name, false)) return null
+        val attr = runCatching {
+            field.getMetaAttr(name, false)
+        }.getOrNull() as? com.metaobjects.attr.MetaAttribute<*> ?: return null
+        return attr.valueAsString
+    }
+
     /** Resolve @maxLength on a StringField; default 255. */
     private fun stringMaxLength(field: StringField): Int {
         if (!field.hasMetaAttr(StringField.ATTR_MAX_LENGTH, false)) return 255

server/java/codegen-kotlin/src/test/kotlin/com/metaobjects/generator/kotlin/KotlinTypeMapperTest.kt

@@ -1,6 +1,8 @@
 package com.metaobjects.generator.kotlin
 
 import com.metaobjects.DataTypes
+import com.metaobjects.attr.IntAttribute
+import com.metaobjects.attr.StringAttribute
 import com.metaobjects.field.BooleanField
 import com.metaobjects.field.CurrencyField
 import com.metaobjects.field.DateField
@@ -151,6 +153,27 @@ class KotlinTypeMapperTest {
         assertNull(KotlinTypeMapper.enumTypeName(idField, entity))
     }
 
+    // === Long-text dispatch (varchar vs text) ===
+
+    @Test fun `string with kind text maps to text column`() {
+        val f = StringField("body")
+        f.addMetaAttr(StringAttribute.create("kind", "text"))
+        assertEquals("text(\"body\")", KotlinTypeMapper.exposedColumnSpec(f))
+    }
+
+    @Test fun `string with maxLength over threshold maps to text column`() {
+        val f = StringField("description")
+        f.addMetaAttr(IntAttribute.create(StringField.ATTR_MAX_LENGTH, 10000))
+        assertEquals("text(\"description\")", KotlinTypeMapper.exposedColumnSpec(f))
+    }
+
+    @Test fun `string with no kind and small maxLength maps to varchar`() {
+        val f = StringField("name")
+        f.addMetaAttr(IntAttribute.create(StringField.ATTR_MAX_LENGTH, 100))
+        val spec = KotlinTypeMapper.exposedColumnSpec(f)
+        assertTrue(spec.contains("varchar") && spec.contains("100"), "got: $spec")
+    }
+
     @Test fun `uuid field (matched by subtype) maps to java util UUID and uuid exposed column`() {
         // `field.uuid` has no dedicated Java class today — mapper matches by subtype name.
         // Use a minimal anonymous PrimitiveField with subType="uuid" to drive the path.