fix(codegen-kotlin): emit imports for non-default Exposed column functions

KotlinExposedTableGenerator was emitting only `import org.jetbrains.exposed.sql.Table`,
so generated Tables that use column functions from non-default Exposed packages
(`date`, `time`, `datetime`, `timestamp`, `timestampWithTimeZone`, `duration` —
extension functions on Table that live in `org.jetbrains.exposed.sql.javatime.*`)
compile-fail with "unresolved reference" errors. Functions inherited from Table
(`varchar`, `integer`, `long`, `double`, `bool`, `text`, `uuid`, `enumerationByName`)
were unaffected; the bug only surfaces on tables with date/timestamp fields, which
is why the existing snapshot fixtures shipped with the bug latent.

Snapshot tests check text equality, not compilation — so the missing imports
silently rode along inside the fixtures. Downstream adopters that try to compile
the generated Tables hit the failure immediately.

The fix:
- New `KotlinTypeMapper.exposedColumnImport(field)` returns the FQN to import for
  each field subtype that needs a non-default Exposed package (currently DateField
  and TimestampField), or null when the column function is a Table member.
- `KotlinExposedTableGenerator.emit` walks the entity's MetaFields (including
  flattened object sub-fields) and collects the required imports into a sorted set,
  then emits them in the file header after the `Table` import.
- Snapshot fixture `single-entity-primitives/acme/demo/AuthorTable.kt` updated to
  carry the now-correct javatime imports.
- Added three regression tests in `KotlinExposedTableGeneratorTest`:
  `dateAndTimestampFieldsEmitJavatimeImports`,
  `primitiveOnlyTableEmitsNoExtraImports` (no spurious imports), and
  `flattenedSubFieldDateContributesImport` (sub-field imports propagate).

All 81 tests pass.

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/KotlinExposedTableGenerator.kt

@@ -122,6 +122,36 @@ class KotlinExposedTableGenerator : MultiFileDirectGeneratorBase<MetaObject>() {
         val needsJsonbImport = objectColumns.any { it.kind == ObjectColumnKind.JSONB }
         val needsRefOptForDecor = refDecorations.values.any { it.hasReferenceOption }
 
+        // Walk every field that will actually become a Table column and collect the
+        // imports its column function requires. Member functions on Table (varchar,
+        // integer, long, etc.) return null and are skipped; extension functions from
+        // org.jetbrains.exposed.sql.javatime (date / timestampWithTimeZone / ...)
+        // return their FQN so the generated file imports them. Without this the
+        // generated tables compile-fail with unresolved-reference errors. Flattened
+        // object sub-fields are walked too — they emit columns of their own.
+        val columnFunctionImports = sortedSetOf<String>()
+        for (field in entity.metaFields) {
+            if (field is ObjectField) continue
+            // EnumField uses enumerationByName (a Table member) when generated, regardless
+            // of what the type-mapper would return for a bare column emission — skip it
+            // here so it doesn't accidentally drag in a non-applicable import.
+            if (field is EnumField) continue
+            KotlinTypeMapper.exposedColumnImport(field)?.let { columnFunctionImports += it }
+        }
+        // Flattened object sub-columns also contribute column functions (and thus
+        // potentially imports). Walk the field.object children's referenced object.value
+        // sub-fields the same way buildObjectColumns does.
+        for (field in entity.metaFields) {
+            if (field !is ObjectField) continue
+            if (readStorage(field) != STORAGE_FLATTENED) continue
+            val ref = readObjectRef(field) ?: continue
+            val target = KotlinGenUtil.resolveObjectByShortOrFqn(loader, ref) ?: continue
+            for (subField in target.metaFields) {
+                if (subField is EnumField) continue
+                KotlinTypeMapper.exposedColumnImport(subField)?.let { columnFunctionImports += it }
+            }
+        }
+
         val source = buildString {
             if (pkg.isNotEmpty()) {
                 append("package $pkg\n\n")
@@ -130,6 +160,9 @@ class KotlinExposedTableGenerator : MultiFileDirectGeneratorBase<MetaObject>() {
             if (fkColumns.any { it.hasReferenceOption } || needsRefOptForDecor) {
                 append("import org.jetbrains.exposed.sql.ReferenceOption\n")
             }
+            for (imp in columnFunctionImports) {
+                append("import $imp\n")
+            }
             if (needsJsonbImport) {
                 append("import org.jetbrains.exposed.sql.json.jsonb\n")
                 append("import kotlinx.serialization.json.Json\n")

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

@@ -113,6 +113,30 @@ object KotlinTypeMapper {
     /** Map a MetaField to the Exposed `Table` column statement (e.g., `varchar("name", 100)`). */
     fun exposedColumnSpec(field: MetaField<*>): String = exposedColumnSpec(field, field.name)
 
+    /**
+     * Return the fully-qualified import required for the Exposed column function this
+     * field maps to, or `null` when the column function is a member of [org.jetbrains.exposed.sql.Table]
+     * (no import beyond `Table` itself needed).
+     *
+     * Used by [KotlinExposedTableGenerator] to assemble the per-file import block — without
+     * this, generated tables that use `date(...)`, `timestampWithTimeZone(...)`, etc.
+     * compile-fail with unresolved-reference errors. Extension functions from the
+     * `org.jetbrains.exposed.sql.javatime` package must be imported explicitly.
+     *
+     * Returns `null` for column functions that are members of `Table` itself
+     * (`varchar`, `integer`, `long`, `double`, `bool`, `text`, `uuid`, `enumerationByName`,
+     * `binary`) — those are inherited by the `object FooTable : Table(...)` declaration
+     * and don't need their own import line.
+     */
+    fun exposedColumnImport(field: MetaField<*>): String? = when (field) {
+        is DateField      -> "org.jetbrains.exposed.sql.javatime.date"
+        is TimestampField -> "org.jetbrains.exposed.sql.javatime.timestampWithTimeZone"
+        // StringField, IntegerField, LongField, DoubleField, BooleanField, CurrencyField,
+        // EnumField, and UUID-subtype fields all map to member functions on Table.
+        // No additional import required.
+        else -> null
+    }
+
     /**
      * Same as [exposedColumnSpec], but with an explicit physical column name. Used by the
      * `@storage: "flattened"` codepath to emit prefixed columns (e.g., `address_street`)

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

@@ -656,6 +656,127 @@ class KotlinExposedTableGeneratorTest {
         }
     }
 
+    // === non-default Exposed column-function imports ========================
+
+    /**
+     * Regression: date / timestamp fields emit column functions that live in
+     * `org.jetbrains.exposed.sql.javatime.*` (extension functions on Table — NOT
+     * Table member methods like varchar/integer/long). Without the matching imports
+     * the generated file compile-fails with "unresolved reference: date /
+     * timestampWithTimeZone". See also the comment on
+     * [KotlinTypeMapper.exposedColumnImport].
+     */
+    @Test fun dateAndTimestampFieldsEmitJavatimeImports() {
+        val withDateAndTs = """{
+          "metadata.root": { "package": "x", "children": [
+            { "object.entity": { "name": "Event", "children": [
+                { "field.long":      { "name": "id" } },
+                { "field.date":      { "name": "occursOn" } },
+                { "field.timestamp": { "name": "loggedAt" } },
+                { "source.rdb":      { "@table": "events" } },
+                { "identity.primary": { "@fields": "id", "@generation": "increment" } }
+            ] } }
+          ] }
+        }""".trimIndent()
+        val outDir = Files.createTempDirectory("ktbl-jt-")
+        try {
+            val gen = KotlinExposedTableGenerator()
+            gen.setArgs(mapOf("outputDir" to outDir.toString()))
+            gen.execute(loadString("jt", withDateAndTs))
+
+            val table = outDir.resolve("x/EventTable.kt")
+            assertTrue(Files.exists(table),
+                "expected $table; files=${Files.walk(outDir).toList()}")
+            val src = Files.readString(table)
+            assertTrue("import org.jetbrains.exposed.sql.javatime.date" in src,
+                "expected javatime.date import for field.date; saw:\n$src")
+            assertTrue("import org.jetbrains.exposed.sql.javatime.timestampWithTimeZone" in src,
+                "expected javatime.timestampWithTimeZone import for field.timestamp; saw:\n$src")
+            // And the column functions are still emitted in the body.
+            assertTrue("val occursOn = date(\"occursOn\")" in src, src)
+            assertTrue("val loggedAt = timestampWithTimeZone(\"loggedAt\")" in src, src)
+        } finally {
+            outDir.toFile().deleteRecursively()
+        }
+    }
+
+    /**
+     * Tables with only primitive columns (varchar / integer / long / bool / double /
+     * uuid / text / enumerationByName) emit ONLY the `Table` import — no spurious
+     * javatime / json imports. The header should stay minimal when no extension-function
+     * column functions are used.
+     */
+    @Test fun primitiveOnlyTableEmitsNoExtraImports() {
+        val primitivesOnly = """{
+          "metadata.root": { "package": "x", "children": [
+            { "object.entity": { "name": "Plain", "children": [
+                { "field.long":    { "name": "id" } },
+                { "field.string":  { "name": "name", "@required": true } },
+                { "field.int":     { "name": "count" } },
+                { "field.boolean": { "name": "active" } },
+                { "source.rdb":    { "@table": "plain" } },
+                { "identity.primary": { "@fields": "id", "@generation": "increment" } }
+            ] } }
+          ] }
+        }""".trimIndent()
+        val outDir = Files.createTempDirectory("ktbl-prim-")
+        try {
+            val gen = KotlinExposedTableGenerator()
+            gen.setArgs(mapOf("outputDir" to outDir.toString()))
+            gen.execute(loadString("prim", primitivesOnly))
+
+            val table = outDir.resolve("x/PlainTable.kt")
+            assertTrue(Files.exists(table))
+            val src = Files.readString(table)
+            assertTrue("import org.jetbrains.exposed.sql.Table" in src, src)
+            assertTrue("import org.jetbrains.exposed.sql.javatime" !in src,
+                "should NOT emit javatime imports for a primitives-only table; saw:\n$src")
+            assertTrue("import org.jetbrains.exposed.sql.json" !in src,
+                "should NOT emit json imports for a primitives-only table; saw:\n$src")
+        } finally {
+            outDir.toFile().deleteRecursively()
+        }
+    }
+
+    /**
+     * Flattened object sub-columns also feed the import collector — if a value-object
+     * has a date sub-field, the flattened column emits `date(...)` and therefore
+     * needs the matching javatime import on the owning entity's Table file.
+     */
+    @Test fun flattenedSubFieldDateContributesImport() {
+        val flatWithDate = """{
+          "metadata.root": { "package": "x", "children": [
+            { "object.value": { "name": "Window", "children": [
+                { "field.date": { "name": "openOn", "@required": true } },
+                { "field.date": { "name": "closeOn", "@required": true } }
+            ] } },
+            { "object.entity": { "name": "Booking", "children": [
+                { "field.long":   { "name": "id" } },
+                { "field.object": { "name": "window", "@objectRef": "Window", "@storage": "flattened", "@required": true } },
+                { "source.rdb":   { "@table": "bookings" } },
+                { "identity.primary": { "@fields": "id", "@generation": "increment" } }
+            ] } }
+          ] }
+        }""".trimIndent()
+        val outDir = Files.createTempDirectory("ktbl-flatdate-")
+        try {
+            val gen = KotlinExposedTableGenerator()
+            gen.setArgs(mapOf("outputDir" to outDir.toString()))
+            gen.execute(loadString("flatdate", flatWithDate))
+
+            val table = outDir.resolve("x/BookingTable.kt")
+            assertTrue(Files.exists(table),
+                "expected $table; files=${Files.walk(outDir).toList()}")
+            val src = Files.readString(table)
+            assertTrue("import org.jetbrains.exposed.sql.javatime.date" in src,
+                "flattened sub-field date should contribute the javatime.date import; saw:\n$src")
+            assertTrue("val windowOpenOn = date(\"window_openOn\")" in src, src)
+            assertTrue("val windowCloseOn = date(\"window_closeOn\")" in src, src)
+        } finally {
+            outDir.toFile().deleteRecursively()
+        }
+    }
+
     @Test fun manyToOneInverseRespectsOnDelete() {
         val withCascadeOnMany = """{
           "metadata.root": { "package": "acme::demo", "children": [

server/java/codegen-kotlin/src/test/resources/snapshots/single-entity-primitives/acme/demo/AuthorTable.kt

@@ -1,6 +1,8 @@
 package acme.demo
 
 import org.jetbrains.exposed.sql.Table
+import org.jetbrains.exposed.sql.javatime.date
+import org.jetbrains.exposed.sql.javatime.timestampWithTimeZone
 
 /** GENERATED — do not hand-edit. Regenerated from metadata. */
 object AuthorTable : Table("authors") {