fix(integration-tests-kotlin): the AllTypes oracle was missing intEnumVal

`persistence-conformance` has no skip valve — every port runs every fixture — so
adding `intEnumVal` to the shared corpus obliged all five ports to carry it. Four
did: Java and Python drive their columns from metadata, and C# regenerates its
AppDbContext. Kotlin's oracle is a HAND-WRITTEN Exposed table, and nobody added
the column, so QueryScenarioConformanceTest[20] and [27] died with

    IllegalStateException: No column 'intEnumVal' on table 'all_types'

The lane that catches this runs on release tags and manual dispatch only, so the
branch would have merged with a standing red nothing on a PR would have shown.

Fixed by supplying the missing piece, not by narrowing the corpus. The new
IntBackedEnumColumnType is the harness analogue of the customEnumeration the
Kotlin generator emits: a Column<String> carrying the member SYMBOL over an
INTEGER column, translating through @intValueMap in both directions, and THROWING
on a stored int that maps to no member — the same ruling every port now
implements. It is String-typed rather than enum-typed for the reason already
documented for the jsonb columns beside it: this generic runner moves plain YAML
scalars and has no generated enum class to bind.

Both coercion paths need an explicit guard ahead of the sqlType dispatch, whose
`int` branch would otherwise try "PUBLISHED".toInt() — the column is physically
INTEGER while its authoring value is a symbol, which is the one shape that
dispatch cannot infer.

QueryScenarioConformanceTest: 27/27.

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

Author: dmealing

server/java/integration-tests-kotlin/src/test/kotlin/com/metaobjects/integration/kotlin/QueryScenarioRunner.kt

@@ -33,6 +33,7 @@ import org.jetbrains.exposed.sql.update
 import org.jetbrains.exposed.sql.statements.InsertStatement
 import org.jetbrains.exposed.sql.transactions.transaction
 import com.metaobjects.integration.kotlin.tables.AllTypesTable
+import com.metaobjects.integration.kotlin.tables.IntBackedEnumColumnType
 import java.math.BigDecimal
 import java.net.URI
 import java.sql.DriverManager
@@ -418,6 +419,9 @@ object QueryScenarioRunner {
      */
     private fun coerceForWrite(raw: Any?, col: Column<*>): Any? {
         if (raw == null) return null
+        // Int-backed field.enum: bind the member SYMBOL and let the column's codec encode it to
+        // the stored int (see the same guard in `coerce`).
+        if (col.columnType is IntBackedEnumColumnType) return raw.toString()
         val type = col.columnType.sqlType().lowercase()
         return when {
             type == "uuid" -> if (raw is UUID) raw else UUID.fromString(raw.toString().lowercase())
@@ -607,6 +611,10 @@ object QueryScenarioRunner {
      */
     private fun coerce(raw: Any?, col: Column<*>): Any? {
         if (raw == null) return null
+        // An int-backed field.enum is a Column<String> over INTEGER: the authoring value is the
+        // member SYMBOL and the column's own codec maps it to the stored int. Checked BEFORE the
+        // sqlType dispatch, whose `int` branch would try "PUBLISHED".toInt().
+        if (col.columnType is IntBackedEnumColumnType) return raw.toString()
         val type = col.columnType.sqlType().lowercase()
         return when {
             // uuid columns compare against java.util.UUID — the YAML supplies a string

server/java/integration-tests-kotlin/src/test/kotlin/com/metaobjects/integration/kotlin/tables/AllTypesTable.kt

@@ -29,6 +29,7 @@ import org.jetbrains.exposed.sql.json.jsonb
  *   - default `field.timestamp` (instant/TZ-aware, ADR-0036 Wave 2) → `instantWithTimeZone("tsTzVal")` (TIMESTAMPTZ)
  *   - `field.currency` (@currency USD)                  → `long("moneyVal")` (BIGINT minor units)
  *   - `field.enum` (@values LOW/MEDIUM/HIGH)            → `varchar("enumVal", 64)` (text + CHECK in DDL)
+ *   - `field.enum` + `@intValueMap` (int-backed)        → `intBackedEnum("intEnumVal", …)` (INTEGER + int CHECK)
  *   - `field.uuid` (non-key, @required)                 → `uuid("uuidVal")` (Postgres native uuid)
  *   - `field.object` (@objectRef Settings, @storage jsonb) → `jsonb("settings", …)` (real Postgres JSONB)
  *   - `field.object` (@objectRef Label, @storage jsonb, isArray) → `jsonb("labels", …)` (JSONB array)
@@ -64,6 +65,13 @@ object AllTypesTable : Table("all_types") {
     val tsTzVal = instantWithTimeZone("tsTzVal")
     val moneyVal = long("moneyVal")
     val enumVal = varchar("enumVal", 64)
+    // INT-BACKED `field.enum` (@intValueMap): physically INTEGER (+ the canonical DDL's
+    // CHECK (… IN (0, 5, 9))), carrying the member SYMBOL in and out — storage changes, the
+    // wire format does not. Nullable to match the canonical DDL (`"intEnumVal" INTEGER`, no
+    // NOT NULL). See [IntBackedEnumColumnType] for why this is a Column<String> here while the
+    // GENERATED form binds a real enum through customEnumeration.
+    val intEnumVal =
+        intBackedEnum("intEnumVal", mapOf("DRAFT" to 0, "PUBLISHED" to 5, "ARCHIVED" to 9)).nullable()
     val uuidVal = uuid("uuidVal")
     // `field.uri` → plain `text` column carrying the verbatim URI string (Postgres has no uri
     // type). See [MetaUriColumnType] — round-trips the URI unchanged.

server/java/integration-tests-kotlin/src/test/kotlin/com/metaobjects/integration/kotlin/tables/IntBackedEnumColumnType.kt

@@ -0,0 +1,60 @@
+package com.metaobjects.integration.kotlin.tables
+
+import org.jetbrains.exposed.sql.Column
+import org.jetbrains.exposed.sql.ColumnType
+import org.jetbrains.exposed.sql.Table
+
+/**
+ * Hand-written reference Exposed column type for an INT-BACKED `field.enum` (`@intValueMap`) —
+ * the test-harness analogue of the `customEnumeration(...)` call
+ * [com.metaobjects.generator.kotlin.KotlinExposedTableGenerator] emits for such a field.
+ *
+ * The column is physically `INTEGER` (plus the canonical DDL's `CHECK (… IN (0, 5, 9))`) while
+ * the value carried in and out is the member SYMBOL — which is the whole contract of int-backing:
+ * storage changes, the wire format does not.
+ *
+ * It is a `Column<String>` rather than a `Column<SomeEnum>` because this cross-port oracle has no
+ * generated enum class to bind — the generic [com.metaobjects.integration.kotlin.QueryScenarioRunner]
+ * moves plain YAML scalars. The GENERATED form binds a real Kotlin enum through
+ * `customEnumeration`, and is covered separately by the codegen tests; the divergence is the same
+ * one already documented for the jsonb columns in [AllTypesTable].
+ *
+ * **A stored int that maps to no member THROWS** rather than surfacing the raw value or nulling
+ * it, matching the generated `customEnumeration`'s `else ->` branch and every sibling port: the
+ * row holds data the model says is impossible, and both alternatives hand the caller something
+ * untrue. The write side is exhaustive by construction upstream (`@intValueMap`'s keys are
+ * loader-validated to equal `@values`), so an unmapped SYMBOL here can only be a harness bug —
+ * it fails loudly for the same reason.
+ */
+internal class IntBackedEnumColumnType(
+    private val intByMember: Map<String, Int>,
+) : ColumnType<String>() {
+
+    private val memberByInt: Map<Int, String> =
+        intByMember.entries.associate { (member, stored) -> stored to member }
+
+    override fun sqlType(): String = "INTEGER"
+
+    override fun valueFromDB(value: Any): String {
+        val stored = (value as? Number)?.toInt()
+            ?: error("int-backed field.enum column read a non-numeric value: $value")
+        return memberByInt[stored]
+            ?: error(
+                "field.enum read stored value $stored with no member in @intValueMap " +
+                    "(declared: $intByMember) — the database holds a value the model does not describe."
+            )
+    }
+
+    override fun notNullValueToDB(value: String): Any =
+        intByMember[value]
+            ?: error("field.enum has no @intValueMap entry for member '$value' (declared: $intByMember).")
+
+    override fun nonNullValueToString(value: String): String = notNullValueToDB(value).toString()
+}
+
+/**
+ * Column builder for an int-backed `field.enum`: a `Column<String>` carrying the member symbol
+ * over an `INTEGER` column, translating through [intByMember] (`@intValueMap`) in both directions.
+ */
+internal fun Table.intBackedEnum(name: String, intByMember: Map<String, Int>): Column<String> =
+    registerColumn(name, IntBackedEnumColumnType(intByMember))