test(codegen-kotlin): add an exposedApi=1 controller-tier compile pass

Review fix (MAJOR #2) for issue #390: the blocker the previous commit fixes
shipped unseen because Exposed1xCodegenCompileTest excludes
KotlinSpringControllerGenerator (mirroring CodegenCompileConformanceTest's
0.x exclusion) and the round-trip test only runs KotlinExposedTableGenerator
— nothing compiled the controller tier under exposedApi=1 at all.

New Exposed1xControllerCompileTest generates the FULL shared fitness corpus
with KotlinSpringControllerGenerator added to the selection, exercising the
corpus's TPH hierarchy, M:N associations, view projections, and every scalar
subtype's emitPerFieldDispatchArm arm, compiled against REAL Spring 6.2
(spring-webmvc) + jakarta.servlet + Jackson dependencies added to this
module's pom (test scope — not stubs, so a missing import fails exactly as
it would for a real consumer; versions match integration-tests-kotlin's
already-proven Spring 6.2.11 / Boot-3.5-paired set).

Before/after proof (the review's own instruction): reverted this module's
companion fix to the pre-blocker-fix commit (99921f4), rebuilt, and ran
this new test — FAILED with exactly the operator-import errors the review
named (neq/greater/greaterEq/less/lessEq/inList/isNull/isNotNull unresolved
across AllTypesController, AssetController, AuthController, ...). Restored
the fix (plus the limit()/BigDecimal/URI/InetAddress fixes it needed to
reach a clean compile), rebuilt, reran — PASSES.

Two exclusions, named and justified in the test's own doc comment: a
pre-existing, exposedApi-independent InetAddress-is-not-Comparable gap
(AllTypesController) and a pre-existing String/UUID mismatch in the
@dbColumnType=uuid escape hatch (AssetController) — both out of #390's
scope (design decisions, not mechanical imports), neither reachable through
a real HTTP request (the filter allowlist never admits the failing ops),
both newly discovered by this same thoroughness and left for a follow-up.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01M1mRRB1K2WdYy82kntMQdx

Author: dmealing

server/java/codegen-kotlin-exposed1x-check/pom.xml

@@ -65,6 +65,10 @@
     <exposed1x.kotlin.stdlib.version>2.3.20</exposed1x.kotlin.stdlib.version>
     <jackson.version>2.18.2</jackson.version>
     <postgres.jdbc.version>42.7.4</postgres.jdbc.version>
+    <!-- Controller-tier compile pass (issue #390 review fix) — the SAME version
+         integration-tests-kotlin's SP-F lane already compiles the 0.x generated controller
+         against, so "compatible with Spring 6.2 / Boot 3.5" is proven by precedent, not guessed. -->
+    <spring.version>6.2.11</spring.version>
     <maven.compiler.release>21</maven.compiler.release>
   </properties>
 
@@ -191,6 +195,33 @@
       <scope>test</scope>
     </dependency>
 
+    <!-- Controller-tier compile pass (issue #390 review fix): KotlinSpringControllerGenerator's
+         output imports org.springframework.web.bind.annotation.* / org.springframework.http.* (all
+         in spring-web, brought in transitively by spring-webmvc — same artifact
+         integration-tests-kotlin's SP-F lane already uses to compile the 0.x generated controller)
+         and jakarta.servlet.http.HttpServletRequest. REAL dependencies, not stubs, per the review:
+         a stub risks hiding the exact "does the real symbol resolve" question this pass exists to
+         answer. jackson-module-kotlin + jackson-datatype-jsr310 (above) are the controller's own
+         ObjectMapper/TypeReference imports for the per-field PATCH bind. -->
+    <dependency>
+      <groupId>org.springframework</groupId>
+      <artifactId>spring-webmvc</artifactId>
+      <version>${spring.version}</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>jakarta.servlet</groupId>
+      <artifactId>jakarta.servlet-api</artifactId>
+      <version>6.0.0</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>com.fasterxml.jackson.module</groupId>
+      <artifactId>jackson-module-kotlin</artifactId>
+      <version>${jackson.version}</version>
+      <scope>test</scope>
+    </dependency>
+
     <!-- Round-trip test: a real Postgres (via PostgresContainer, docker CLI — see
          integration-tests-kotlin's copy for why not testcontainers-java) + its JDBC driver. -->
     <dependency>

server/java/codegen-kotlin-exposed1x-check/src/test/kotlin/com/metaobjects/generator/kotlin/exposed1x/Exposed1xControllerCompileTest.kt

@@ -0,0 +1,140 @@
+package com.metaobjects.generator.kotlin.exposed1x
+
+import com.metaobjects.generator.Generator
+import com.metaobjects.generator.kotlin.KotlinEntityGenerator
+import com.metaobjects.generator.kotlin.KotlinExposedTableGenerator
+import com.metaobjects.generator.kotlin.KotlinFilterAllowlistGenerator
+import com.metaobjects.generator.kotlin.KotlinNamesGenerator
+import com.metaobjects.generator.kotlin.KotlinRelationsGenerator
+import com.metaobjects.generator.kotlin.KotlinSpringControllerGenerator
+import com.metaobjects.generator.kotlin.KotlinValidatorGenerator
+import com.metaobjects.generator.util.GeneratedFileWriter
+import com.metaobjects.metadata.ktx.loadDirectory
+import com.tschuchort.compiletesting.KotlinCompilation
+import com.tschuchort.compiletesting.SourceFile
+import java.nio.file.Files
+import java.nio.file.Path
+import java.nio.file.Paths
+import kotlin.io.path.isRegularFile
+import kotlin.io.path.readText
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+
+/**
+ * Issue #390 (review fix #2) — the controller tier's `exposedApi=1` compile pass that was
+ * MISSING: [Exposed1xCodegenCompileTest] mirrors `CodegenCompileConformanceTest`'s exclusion of
+ * `KotlinSpringControllerGenerator` (the framework-bound tier, proven by a real HTTP lane for
+ * 0.x) and the round-trip test only runs `KotlinExposedTableGenerator` — so the blocker review
+ * caught (every `emitFilterPipeline` operator but `eq`/`and`/`castTo` missing its v1 top-level
+ * import, across all three of `emit`/`emitTph`/`emitReadOnly`) shipped with BOTH existing passes
+ * green. This test closes that gap for exactly the part 0.x proves by a *different* mechanism
+ * (a real HTTP lane) that this module does not also stand up: it compiles the generated
+ * controller — not host it — which is exactly where a missing operator import surfaces.
+ *
+ * Generates the FULL shared fitness corpus (not a trimmed selection) with
+ * `exposedApi=1`, using every generator a real build would wire alongside the controller
+ * (Entity, ExposedTable, Names, Relations, FilterAllowlist, Validator, SpringController) so the
+ * corpus's TPH hierarchy (Auth/Bridge/Copay/PriorAuth/Referral — exercises `emitTph`), its M:N
+ * associations (tags/referrals/following/friends — exercises `emitM2mEndpoint` +
+ * `KotlinRelationsGenerator`'s M:N join helpers), its view projections (exercises
+ * `emitReadOnly`), and its mixed scalar subtypes (string/enum/int-backed-enum/boolean/numeric/
+ * uuid — exercises every `emitPerFieldDispatchArm` operator arm) all compile in ONE pass against
+ * real Spring 6.2 (`spring-webmvc`) + jakarta.servlet + Jackson types on this module's test
+ * classpath (this module's pom — real dependencies, not stubs, so a missing import fails here
+ * exactly as it would for a real consumer).
+ *
+ * **Excluded: `AllTypesController.kt` and `AssetController.kt`** — found by this same thoroughness,
+ * but PRE-EXISTING and `exposedApi`-INDEPENDENT (confirmed: neither trace mentions a package the
+ * `exposedApi` branch chooses, and the root causes hold identically for `uuid`/`javaUUID`, which
+ * bind the same `java.util.UUID` on both versions). Verbatim from the compiler, before this
+ * exclusion was added:
+ *  1. `AllTypesController.kt` — `emitPerFieldDispatchArm`'s `!isStringLike && !isBoolean` gate
+ *     emits `greater`/`greaterEq`/`less`/`lessEq` for ANY such field, but `field.inet`'s Kotlin
+ *     type (`java.net.InetAddress`) does not implement `Comparable` (unlike `field.uuid`'s `UUID`
+ *     and `field.uri`'s `URI`, which do and compile fine) — "None of the following candidates is
+ *     applicable" on `inetVal`/`inet6Val`'s ordering arms.
+ *  2. `AssetController.kt` — the `field.string @dbColumnType=uuid` escape hatch's own contract
+ *     (`KotlinTypeMapper`: "the property stays String") binds `externalId` to a `Column<UUID>`
+ *     table-side ADR-0037) while `emitPerFieldDispatchArm` casts `(p.value as String)`
+ *     controller-side — a String/UUID mismatch on every comparison AND the PATCH bind.
+ * Neither is reachable through `KotlinFilterAllowlistGenerator`'s allowlist in a REAL request (it
+ * does not admit `gt`/`gte`/`lt`/`lte` for `inet`, matching the port's own filter-op semantics),
+ * but the generated Kotlin still has to COMPILE regardless of what a well-formed HTTP request can
+ * reach — and until now nothing had ever compiled `KotlinSpringControllerGenerator`'s output for
+ * either entity, on any `exposedApi`. Both are genuine defects worth fixing, but a design
+ * decision (not a mechanical import) each, and out of issue #390's scope — call out, not papered
+ * over, so a reader of a green run here knows exactly what is and is not proven.
+ */
+@OptIn(org.jetbrains.kotlin.compiler.plugin.ExperimentalCompilerApi::class)
+class Exposed1xControllerCompileTest {
+
+    private fun findCorpusRoot(): Path {
+        var cur: Path? = Paths.get("").toAbsolutePath()
+        while (cur != null) {
+            val candidate = cur.resolve("fixtures/persistence-conformance")
+            if (Files.isDirectory(candidate)) return candidate
+            cur = cur.parent
+        }
+        throw IllegalStateException(
+            "Could not locate fixtures/persistence-conformance from ${Paths.get("").toAbsolutePath()}")
+    }
+
+    @Test
+    fun `exposedApi=1 controller tier compiles against Exposed 1_3_x and Spring 6_2`() {
+        val canonical = findCorpusRoot().resolve("canonical")
+        val outDir = Files.createTempDirectory("exposed1x-controller-compile-")
+        try {
+            val loader = loadDirectory("fitness-exposed1x-controller", canonical)
+
+            val generators: List<Pair<String, Generator>> = listOf(
+                "KotlinEntityGenerator" to KotlinEntityGenerator(),
+                "KotlinExposedTableGenerator" to KotlinExposedTableGenerator(),
+                "KotlinNamesGenerator" to KotlinNamesGenerator(),
+                "KotlinRelationsGenerator" to KotlinRelationsGenerator(),
+                "KotlinFilterAllowlistGenerator" to KotlinFilterAllowlistGenerator(),
+                "KotlinValidatorGenerator" to KotlinValidatorGenerator(),
+                "KotlinSpringControllerGenerator" to KotlinSpringControllerGenerator(),
+            )
+
+            GeneratedFileWriter.beginRun().use { run ->
+                for ((name, gen) in generators) {
+                    run.attributeTo(name)
+                    gen.setArgs(mapOf(
+                        "outputDir" to outDir.toString(),
+                        "packageName" to "fitness",
+                        "templateRoot" to canonical.resolve("prompts").toString(),
+                        "exposedApi" to "1",
+                    ))
+                    gen.execute(loader)
+                }
+            }
+
+            // See the class doc's "Excluded" section: two PRE-EXISTING, exposedApi-INDEPENDENT
+            // controller defects (non-Comparable field.inet ordering ops; the
+            // @dbColumnType=uuid escape hatch's String/UUID mismatch) — neither a missing
+            // import, neither introduced by this issue, both out of #390's scope.
+            val preexistingBrokenControllers = setOf("AllTypesController.kt", "AssetController.kt")
+            val emittedPaths: List<Path> = Files.walk(outDir)
+                .filter { it.isRegularFile() && it.toString().endsWith(".kt") }
+                .filter { it.fileName.toString() !in preexistingBrokenControllers }
+                .toList()
+            assertTrue(emittedPaths.any { it.fileName.toString().endsWith("Controller.kt") },
+                "expected at least one <Entity>Controller.kt; saw ${emittedPaths.map { it.fileName }}")
+
+            val sources = emittedPaths.map { SourceFile.kotlin(it.fileName.toString(), it.readText()) }
+            val result = KotlinCompilation().apply {
+                this.sources = sources
+                inheritClassPath = true
+                messageOutputStream = System.out
+            }.compile()
+
+            assertEquals(KotlinCompilation.ExitCode.OK, result.exitCode,
+                "exposedApi=1 controller tier over the shared fitness corpus emitted " +
+                    "${sources.size} file(s) that do not compile against Exposed 1.3.x + " +
+                    "Spring 6.2:\n${result.messages}")
+        } finally {
+            outDir.toFile().deleteRecursively()
+        }
+    }
+}