feat(codegen-kotlin): emit text() for field.string with dbColumnType=jsonb

The Kotlin Exposed table generator was treating `@dbColumnType=jsonb`
on a `field.string` as a no-op — same fall-through as any other unknown
override — so the column emitted as `varchar(name, 255)` even when the
adopter clearly wanted Postgres JSONB on the DB side. The 255-char
default cap then silently truncates any non-trivial JSON payload
(rubric weights, feature flags, config blobs) that exceeds it.

Add a `DB_COLUMN_TYPE_JSONB` constant and a `when (dbColumnType(field))`
branch in the `StringField` arm of `KotlinTypeMapper.exposedColumnSpec`
that emits `text("col")` instead. Rationale:

* The DB column is `JSONB`. Postgres accepts text I/O against JSONB,
  so a `text` column on the Exposed side reads + writes without
  conversion.
* `text` is unbounded — no accidental truncation on JSON payloads
  larger than the varchar default.
* The Kotlin data class property stays `String` (raw JSON text). The
  application is responsible for ensuring well-formed JSON; Postgres
  validates at write time.

This is the **raw-string** JSONB path for `field.string`. The
typed-object JSONB path on `field.object` (`@storage=jsonb`) is
unchanged and continues to emit `jsonb(name, encoder, decoder)` with
kotlinx.serialization.

Tests cover the three failure shapes of the old behaviour:
1. plain `dbColumnType=jsonb` now emits `text(...)` not `varchar(...)`.
2. lookup is case-folded (`"JSONB"` and `"jsonb"` both route to text).
3. an explicit `maxLength` doesn't override — JSONB wins, the column
   is unbounded regardless.

Adopters with existing `varchar(255)` JSONB columns in their schema
need no migration: the DB column shape doesn't change, only the
Exposed-side mapping.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: dmealing

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

@@ -78,6 +78,22 @@ object KotlinTypeMapper {
     /** `@dbColumnType` value on [StringField] that selects Exposed `uuid("col")`. */
     private const val DB_COLUMN_TYPE_UUID = "uuid"
 
+    /**
+     * `@dbColumnType` value on [StringField] that emits a `text("col")` column
+     * intended for a Postgres `JSONB`-typed column on the DB side. The Kotlin
+     * property stays `String` (raw JSON text); the application is responsible
+     * for ensuring well-formed JSON and Postgres validates at write time.
+     * Using `text` (rather than `varchar(255)` default) removes the
+     * accidental length cap on serialised payloads — JSON blobs routinely
+     * exceed 255 chars (e.g. rubric weights, feature flags, configuration).
+     *
+     * Note: this is the **raw-string** JSONB path for `field.string`. The
+     * typed-object JSONB path on `field.object` (`@storage=jsonb`) lives in
+     * [KotlinExposedTableGenerator]'s object-column emission and uses
+     * `jsonb("col", encoder, decoder)` with kotlinx.serialization.
+     */
+    private const val DB_COLUMN_TYPE_JSONB = "jsonb"
+
     /** `@dbColumnType` value on [TimestampField] that opts in to Exposed `timestampWithTimeZone("col")`. */
     private const val DB_COLUMN_TYPE_TIMESTAMP_WITH_TZ = "timestamp_with_tz"
 
@@ -186,17 +202,25 @@ object KotlinTypeMapper {
             // data class property stays `String` for now (Exposed coerces String ↔ uuid at
             // the SQL boundary), so adopters can convert a string-shaped FK column to the
             // native Postgres uuid type without changing their data class shape.
-            if (dbColumnType(field) == DB_COLUMN_TYPE_UUID) {
-                "uuid(\"$colName\")"
-            } else {
-                // 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)"
+            //
+            // `@dbColumnType=jsonb` opt-in: emit `text("col")` instead of varchar. The DB
+            // column is `JSONB` (Postgres accepts text I/O against JSONB), and the Exposed
+            // `text` column has no length cap so JSON payloads larger than 255 chars
+            // (rubric weights, feature flags, configuration blobs) don't trip the
+            // varchar-default limit. The Kotlin property stays `String` (raw JSON text).
+            when (dbColumnType(field)) {
+                DB_COLUMN_TYPE_UUID  -> "uuid(\"$colName\")"
+                DB_COLUMN_TYPE_JSONB -> "text(\"$colName\")"
+                else -> {
+                    // 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\")"

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

@@ -144,6 +144,35 @@ class KotlinTypeMapperTest {
         assertEquals(STRING, KotlinTypeMapper.kotlinTypeName(f))
     }
 
+    @Test fun `string field with dbColumnType=jsonb emits text column not capped varchar`() {
+        // `@dbColumnType=jsonb` on a `field.string` opts the column to Postgres JSONB on
+        // the DB side. The Exposed column is `text(...)` (unbounded) rather than the
+        // default `varchar(name, 255)` — JSON payloads routinely exceed 255 chars and
+        // Postgres accepts text I/O against a JSONB column. Kotlin property stays String
+        // (raw JSON text); the application is responsible for validity.
+        val f = StringField("rubricWeights")
+        f.addMetaAttr(StringAttribute.create("dbColumnType", "jsonb"))
+        assertEquals("text(\"rubric_weights\")", KotlinTypeMapper.exposedColumnSpec(f))
+        assertEquals(STRING, KotlinTypeMapper.kotlinTypeName(f))
+    }
+
+    @Test fun `string field with dbColumnType=jsonb is case-insensitive`() {
+        // `@dbColumnType` lookup case-folds (see `KotlinTypeMapper.dbColumnType`); both
+        // `"JSONB"` and `"jsonb"` route to the JSONB branch.
+        val f = StringField("featureFlags")
+        f.addMetaAttr(StringAttribute.create("dbColumnType", "JSONB"))
+        assertEquals("text(\"feature_flags\")", KotlinTypeMapper.exposedColumnSpec(f))
+    }
+
+    @Test fun `string field with dbColumnType=jsonb ignores maxLength`() {
+        // A short `@maxLength` would normally select varchar; the JSONB override wins
+        // regardless so a YAML with both attributes still gets the unbounded text column.
+        val f = StringField("blob")
+        f.addMetaAttr(StringAttribute.create("dbColumnType", "jsonb"))
+        f.addMetaAttr(IntAttribute.create("maxLength", 64))
+        assertEquals("text(\"blob\")", KotlinTypeMapper.exposedColumnSpec(f))
+    }
+
     // === Currency / Enum / UUID coverage ===
 
     @Test fun `currency field maps to Long and long exposed column with snake_case name`() {