fix(codegen-kotlin): expose field.string @dbColumnType:jsonb as a parsed JSON value in REST payloads (#98)

[dmealing]

Part of #98 — the Kotlin port.

The two-layer nuance

field.string @dbColumnType=jsonb is the sanctioned "open JSON bag": the physical column is JSONB, but the logical subtype stays string. Kotlin has both a persistence layer and a REST layer, and they are treated differently:

• Persistence — String stays (unchanged). KotlinExposedTableGenerator keeps emitting the identity-codec jsonb("col", { it }, { it }), and the entity data-class property stays String — the JDBC driver returns jsonb as raw text, so String is correct. KotlinTypeMapper.kotlinTypeName / exposedColumnSpec are untouched. The entity-CRUD controller reuses the entity data class as its @RequestBody/response DTO and rowTo<Entity> maps the String-typed column into it, so it correctly stays String too.
• REST payload — becomes a parsed JSON value (the fix). A jsonb bag is now exposed at the serialization/payload boundary as kotlinx JsonElement (the @Serializable substrate this port already uses for field.map jsonb columns), so a client sends/receives a real JSON object instead of a double-encoded string. Matches TS z.unknown() (fix(codegen-ts): emit z.unknown() (not z.string()) for field.string @dbColumnType:jsonb #97) and Python Any (fix(codegen-python): emit Any (not str) for field.string @dbColumnType:jsonb (#98) #99).

Layering found (is the type mapper shared? how differentiated?)

KotlinTypeMapper.kotlinTypeName is shared by the persistence path (entity data class, Exposed table, entity-CRUD controller DTO) and the payload path (KotlinPayloadGenerator). To split them without disturbing persistence, I added a dedicated payloadTypeName method keyed on a new isJsonbOpenBag predicate (the single source of truth). It is identical to kotlinTypeName for every subtype except the jsonb open bag, which maps to JsonElement.

• KotlinPayloadGenerator resolves field types through payloadTypeName.
• The lenient→strict extract mapper (KotlinExtractorGenerator) bridges String → JsonElement via Json.parseToJsonElement so generated extractors compile.
• api-docs (KotlinApiModelBuilder) documents the payload field as the parsed value it actually emits; the entity model field still documents String.

JSON-value type chosen — why JsonElement

KotlinPayloadGenerator emits @Serializable data classes (kotlinx.serialization). kotlinx.serialization.json.JsonElement is the idiomatic "any JSON value" type there (natively serializable; the same Json already used by the jsonb(...) column codec for field.map). Any? / Map<String, Any?> are not directly @serializable, and Jackson JsonNode is the wrong substrate for this port.

Test evidence (TDD, RED→GREEN)

cd server/java && mvn -pl codegen-kotlin -am test → BUILD SUCCESS, 254 tests, 0 failures. New tests:

• KotlinTypeMapperTest — payloadTypeName(jsonb) == JsonElement while kotlinTypeName(jsonb) == String and exposedColumnSpec(jsonb) == jsonb("...", { it }, { it }) (persistence unchanged); plain field.string payload stays String.
• KotlinPayloadGeneratorTest — emitted payload data class has val config: JsonElement (+ import kotlinx.serialization.json.JsonElement) for the jsonb field while a sibling plain string stays val label: String.
• Existing KotlinTypeMapperTest persistence assertions (incl. kotlinTypeName == String) stay green; api-docs accuracy gate + cross-port conformance green.

Deferrals / findings

• The entity-CRUD REST contract for a jsonb field stays String: the Spring controller reuses the entity data class as its DTO, and that class is the persistence row-holder bound to the String-typed identity-codec jsonb column. Exposing it as a parsed value there would require either changing the column codec (out of scope — persistence must stay raw text) or introducing a separate REST DTO + rowTo/insert conversion (a new generator surface). This PR fixes the cleanly-separable typed-payload surface; the entity-CRUD double-encoding is the same deliberate raw-text contract C# also has (per the cross-port: verify+fix field.string @dbColumnType:jsonb → validator/DTO typing in C#/Python/Java/Kotlin (TS fixed in #97) #98 maintainer table).
• Docker/Testcontainers integration (integration-tests-kotlin) was not run; unit/codegen tests cover the change.

🤖 Generated with Claude Code

[dmealing]

Follow-up commit a0247c4b: the jsonb open-bag is now a parsed JsonElement at every Kotlin layer, not just the REST payload.

The derived entity-CRUD controller reuses the Exposed entity data class as its DTO, and that property was still String (the Exposed column used an identity codec jsonb(col, { it }, { it }) keeping raw JSON text) — so the entity-CRUD contract still exposed a jsonb bag as a double-encoded String. Per the maintainer decision (uniform parsed value at the API boundary, all ports), this does the Kotlin analogue of the C# jsonb <-> JsonDocument change:

• KotlinTypeMapper.kotlinTypeName → JsonElement for the jsonb open bag (keyed on the existing isJsonbOpenBag predicate), so the entity data class / reused CRUD DTO is a parsed JSON value.
• KotlinTypeMapper.exposedColumnSpec → real JsonElement codec: encode { it.toString() }, decode { Json.parseToJsonElement(it) } (the concrete decode anchors the column generic to Column<JsonElement>). Still a real jsonb(...) column — only the codec/type changes.
• KotlinExposedTableGenerator emits the kotlinx.serialization.json.Json import for tables carrying a jsonb open bag.

Net: column / entity data class (CRUD DTO) / payload all expose JsonElement for a jsonb bag — full parity with TS (z.unknown()), Python (Any), Java, and C# (JsonDocument). A plain field.string stays String; @dbColumnType:uuid stays String. The wire/serialized form is byte-identical ({...}); only the in-process Kotlin type changes String -> JsonElement.

Tests (TDD): KotlinTypeMapperTest flips the jsonb persistence assertions to JsonElement (still asserting a real jsonb(...) column); new KotlinEntityGeneratorTest proves the entity data class types the jsonb field as JsonElement; the integration-tests-kotlin reference AssetTable.payload + QueryScenarioRunner read/write coercion + RuntimeReturnTypeTest updated to the parsed read-back. codegen-kotlin module green; integration-tests-kotlin green 90/90 against Testcontainers Postgres.