Merge codegen-kotlin Phase E — simplification pass

Net -36 lines across the Phase A–D additions (+213/-249, 6 files).

- KotlinGenUtil (NEW) consolidates resolveObjectByShortOrFqn / splitDottedRef /
  isRequiredField helpers that were copy-pasted across Entity / ExposedTable /
  Payload generators.
- KotlinTypeMapper: restored when (field) typed arms; lifted magic 64 (enum
  varchar width) to a named const.
- KotlinEntityGenerator: collapsed two-arm subtype gate via EMITTED_SUBTYPES set.
- KotlinExposedTableGenerator: switched string literals to MetaObject /
  CompositionRelationship / MetaIdentity / RdbSource typed constants;
  joinToString-based FK reference-option assembly.
- KotlinPayloadGenerator: shared-resolver one-liners; fallbackType lambda
  collapses 8 identical fall-throughs.
- KotlinSpringConfigGenerator: companion-object constants + buildValidatorFn
  helper.

45 module tests still green.

Author: dmealing

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

@@ -45,12 +45,11 @@ class KotlinEntityGenerator : MultiFileDirectGeneratorBase<MetaObject>() {
     override fun execute(loader: MetaDataLoader) {
         parseArgs()
         val outRoot = Paths.get(outDir.absolutePath)
+        // Emit a data class for entities AND value objects. Value objects (object.value) are
+        // referenced by field.object on entities; the value class must exist for the entity's
+        // typed property to resolve.
         for (obj in loader.metaObjects) {
-            // Emit a data class for both entities AND value objects. Value objects (object.value)
-            // are referenced by field.object on entities; the value class must exist for the
-            // entity's typed property to resolve.
-            if (obj.subType != MetaObject.SUBTYPE_ENTITY && obj.subType != MetaObject.SUBTYPE_VALUE) continue
-            emit(obj, outRoot, loader)
+            if (obj.subType in EMITTED_SUBTYPES) emit(obj, outRoot, loader)
         }
     }
 
@@ -66,7 +65,7 @@ class KotlinEntityGenerator : MultiFileDirectGeneratorBase<MetaObject>() {
         val ctorBuilder = FunSpec.constructorBuilder()
         for (field in obj.metaFields) {
             val baseType = resolvePropertyType(field, loader)
-            val nullable = !isRequired(field)
+            val nullable = !KotlinGenUtil.isRequiredField(field)
             val propType = if (nullable) baseType.copy(nullable = true) else baseType
             val propName = field.name
             val param = ParameterSpec.builder(propName, propType)
@@ -95,12 +94,10 @@ class KotlinEntityGenerator : MultiFileDirectGeneratorBase<MetaObject>() {
     private fun resolvePropertyType(field: MetaField<*>, loader: MetaDataLoader): TypeName {
         if (field is ObjectField) {
             val ref = readObjectRef(field)
-            if (ref != null) {
-                val target = resolveObjectByShortOrFqn(loader, ref)
-                if (target != null) {
-                    val (targetPkg, targetShort) = PackageMapping.splitFqn(target.name)
-                    return ClassName(targetPkg, targetShort)
-                }
+            val target = ref?.let { KotlinGenUtil.resolveObjectByShortOrFqn(loader, it) }
+            if (target != null) {
+                val (targetPkg, targetShort) = PackageMapping.splitFqn(target.name)
+                return ClassName(targetPkg, targetShort)
             }
         }
         return KotlinTypeMapper.kotlinTypeName(field)
@@ -113,27 +110,9 @@ class KotlinEntityGenerator : MultiFileDirectGeneratorBase<MetaObject>() {
             .getOrNull()
     }
 
-    /** Resolve a MetaObject (entity OR value) by FQN match or short-name match. */
-    private fun resolveObjectByShortOrFqn(loader: MetaDataLoader, ref: String): MetaObject? {
-        for (child in loader.metaObjects) {
-            val short = child.name.substringAfterLast("::")
-            if (child.name == ref || short == ref) return child
-        }
-        return null
-    }
-
-    /**
-     * Required iff explicit `@required: true` attribute is set on the field; otherwise nullable.
-     * MVP heuristic — refined when richer required-detection lands (see fr-003 spec).
-     */
-    private fun isRequired(field: MetaField<*>): Boolean {
-        if (!field.hasMetaAttr(MetaField.ATTR_REQUIRED, true)) return false
-        val raw = runCatching { field.getMetaAttr(MetaField.ATTR_REQUIRED, true).value }.getOrNull()
-        return when (raw) {
-            is Boolean -> raw
-            is String -> raw.equals("true", ignoreCase = true)
-            else -> false
-        }
+    private companion object {
+        /** MetaObject subtypes this generator emits a Kotlin data class for. */
+        val EMITTED_SUBTYPES = setOf(MetaObject.SUBTYPE_ENTITY, MetaObject.SUBTYPE_VALUE)
     }
 
     // === MultiFileDirectGeneratorBase abstract-method stubs ====================

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

@@ -1,14 +1,14 @@
 package com.metaobjects.generator.kotlin
 
-import com.metaobjects.field.MetaField
+import com.metaobjects.database.CoreDBMetaDataProvider
 import com.metaobjects.field.ObjectField
 import com.metaobjects.generator.GeneratorIOWriter
 import com.metaobjects.generator.direct.MultiFileDirectGeneratorBase
 import com.metaobjects.identity.MetaIdentity
 import com.metaobjects.loader.MetaDataLoader
 import com.metaobjects.`object`.MetaObject
+import com.metaobjects.relationship.CompositionRelationship
 import com.metaobjects.relationship.MetaRelationship
-import com.metaobjects.source.MetaSource
 import com.metaobjects.source.RdbSource
 import java.io.OutputStream
 import java.io.PrintWriter
@@ -39,20 +39,22 @@ class KotlinExposedTableGenerator : MultiFileDirectGeneratorBase<MetaObject>() {
         parseArgs()
         val outRoot = Paths.get(outDir.absolutePath)
         for (entity in loader.metaObjects) {
-            if (entity.subType != "entity") continue
-            val sourceRdb = findRdbSource(entity) ?: continue
+            if (entity.subType != MetaObject.SUBTYPE_ENTITY) continue
+            val sourceRdb = entity.children.filterIsInstance<RdbSource>().firstOrNull() ?: continue
             emit(entity, sourceRdb, outRoot, loader)
         }
     }
 
-    private fun emit(entity: MetaObject, sourceRdb: MetaSource, outRoot: Path, loader: MetaDataLoader) {
+    private fun emit(entity: MetaObject, sourceRdb: RdbSource, outRoot: Path, loader: MetaDataLoader) {
         val (pkg, shortName) = PackageMapping.splitFqn(entity.name)
         val tableObjectName = shortName + "Table"
         val tableName = sourceRdb.tableName ?: (shortName.lowercase() + "s")
 
-        val primary = findPrimaryIdentity(entity)
+        val primary = entity.children
+            .filterIsInstance<MetaIdentity>()
+            .firstOrNull { it.isPrimary }
         val primaryFieldName = primary?.fields?.firstOrNull()
-        val incrementPk = primary?.generation == MetaIdentity.GENERATION_INCREMENT
+        val incrementPk = primary?.isIncrement == true
 
         val fkColumns = buildFkColumns(entity, loader)
         val objectColumns = buildObjectColumns(entity, primaryFieldName, loader)
@@ -74,13 +76,11 @@ class KotlinExposedTableGenerator : MultiFileDirectGeneratorBase<MetaObject>() {
             append("/** GENERATED — do not hand-edit. Regenerated from metadata. */\n")
             append("object $tableObjectName : Table(\"$tableName\") {\n")
             for (field in entity.metaFields) {
-                if (field is ObjectField) {
-                    // ObjectField columns are produced by buildObjectColumns() so we can
-                    // emit @storage flattened (N columns) or jsonb (1 column) uniformly.
-                    continue
-                }
+                // ObjectField columns are produced by buildObjectColumns() so we can emit
+                // @storage flattened (N columns) or jsonb (1 column) uniformly.
+                if (field is ObjectField) continue
                 val isPk = field.name == primaryFieldName
-                val nullable = !isPk && !isRequired(field)
+                val nullable = !isPk && !KotlinGenUtil.isRequiredField(field)
                 val baseSpec = KotlinTypeMapper.exposedColumnSpec(field)
                 val withAuto = if (isPk && incrementPk) "$baseSpec.autoIncrement()" else baseSpec
                 val full = if (nullable) "$withAuto.nullable()" else withAuto
@@ -138,25 +138,23 @@ class KotlinExposedTableGenerator : MultiFileDirectGeneratorBase<MetaObject>() {
         for (field in entity.metaFields) {
             if (field !is ObjectField) continue
             val parentName = field.name
+            val parentNullable = parentName != primaryFieldName && !KotlinGenUtil.isRequiredField(field)
             val storage = readStorage(field)        // null → default to jsonb
             if (storage == STORAGE_FLATTENED) {
                 val ref = readObjectRef(field) ?: continue
-                val target = resolveObjectByShortOrFqn(loader, ref) ?: continue
-                val parentNullable = parentName != primaryFieldName && !isRequired(field)
+                val target = KotlinGenUtil.resolveObjectByShortOrFqn(loader, ref) ?: continue
                 for (subField in target.metaFields) {
                     val propertyName = parentName + subField.name.replaceFirstChar { it.uppercase() }
                     val colName = parentName + "_" + subField.name
                     val baseSpec = KotlinTypeMapper.exposedColumnSpec(subField, colName)
                     // Sub-column is nullable iff the parent is nullable OR the sub-field itself is.
-                    val nullable = parentNullable || !isRequired(subField)
+                    val nullable = parentNullable || !KotlinGenUtil.isRequiredField(subField)
                     val full = if (nullable) "$baseSpec.nullable()" else baseSpec
                     result.add(ObjectColumnSpec(propertyName, full, ObjectColumnKind.FLATTENED))
                 }
             } else {
                 // jsonb (explicit) OR absent (default per CLAUDE.md back-compat rule).
-                val colName = parentName
-                val expr = "jsonb(\"$colName\", { Json.encodeToString(it) }, { Json.decodeFromString(it) })"
-                val parentNullable = parentName != primaryFieldName && !isRequired(field)
+                val expr = "jsonb(\"$parentName\", { Json.encodeToString(it) }, { Json.decodeFromString(it) })"
                 val full = if (parentNullable) "$expr.nullable()" else expr
                 result.add(ObjectColumnSpec(parentName, full, ObjectColumnKind.JSONB))
             }
@@ -177,15 +175,6 @@ class KotlinExposedTableGenerator : MultiFileDirectGeneratorBase<MetaObject>() {
             .getOrNull()
     }
 
-    /** Resolve a MetaObject (entity OR value) by FQN match or short-name match. */
-    private fun resolveObjectByShortOrFqn(loader: MetaDataLoader, ref: String): MetaObject? {
-        for (child in loader.metaObjects) {
-            val short = child.name.substringAfterLast("::")
-            if (child.name == ref || short == ref) return child
-        }
-        return null
-    }
-
     private companion object {
         /** Cross-language @storage attr on field.object — values: flattened | jsonb (default). */
         const val ATTR_STORAGE = "storage"
@@ -223,53 +212,39 @@ class KotlinExposedTableGenerator : MultiFileDirectGeneratorBase<MetaObject>() {
         val result = mutableListOf<FkColumnSpec>()
         for (child in entity.children) {
             if (child !is MetaRelationship) continue
-            if (child.subType != "composition") continue
+            if (child.subType != CompositionRelationship.SUBTYPE_COMPOSITION) continue
             // Skip the "many" side — FK lives on the other entity.
             if (child.cardinality == MetaRelationship.CARDINALITY_MANY) continue
 
             val objectRef = child.objectRef ?: continue
-            val targetShortName = resolveTargetShortName(objectRef, loader) ?: continue
-            val targetTable = targetShortName + "Table"
+            val target = KotlinGenUtil.resolveObjectByShortOrFqn(loader, objectRef) ?: continue
+            val targetTable = PackageMapping.splitFqn(target.name).second + "Table"
 
-            // Use shortName: relationship.name is fully-qualified after loading
-            // (e.g., "acme::demo::author"), which would produce an illegal Kotlin
-            // identifier with "::" embedded. shortName is the leaf authored token.
+            // Use shortName: relationship.name is fully-qualified after loading (e.g.
+            // "acme::demo::author"), which would produce an illegal Kotlin identifier with
+            // "::" embedded. shortName is the leaf authored token.
             val relShortName = child.shortName ?: child.name
-            val propertyName = if (child.hasMetaAttr(com.metaobjects.database.CoreDBMetaDataProvider.COLUMN, true)) {
-                runCatching { child.getMetaAttr(com.metaobjects.database.CoreDBMetaDataProvider.COLUMN, true).valueAsString }
-                    .getOrNull() ?: (relShortName + "Id")
-            } else {
-                relShortName + "Id"
-            }
+            val propertyName = readColumnAttr(child) ?: (relShortName + "Id")
 
             // Default Exposed FK is `long(...)`; refine later if other PK types appear.
-            val parts = StringBuilder("long(\"$propertyName\").references($targetTable.id")
-            var hasOption = false
+            val refParts = mutableListOf<String>()
             val onDelete = child.onDeleteRaw?.let { mapReferentialAction(it) }
             val onUpdate = child.onUpdateRaw?.let { mapReferentialAction(it) }
-            if (onDelete != null) {
-                parts.append(", onDelete = ReferenceOption.$onDelete")
-                hasOption = true
-            }
-            if (onUpdate != null) {
-                parts.append(", onUpdate = ReferenceOption.$onUpdate")
-                hasOption = true
-            }
-            parts.append(')')
-            result.add(FkColumnSpec(propertyName, parts.toString(), hasOption))
+            if (onDelete != null) refParts += "onDelete = ReferenceOption.$onDelete"
+            if (onUpdate != null) refParts += "onUpdate = ReferenceOption.$onUpdate"
+
+            val refArgs = if (refParts.isEmpty()) "" else ", " + refParts.joinToString(", ")
+            val expr = "long(\"$propertyName\").references($targetTable.id$refArgs)"
+            result.add(FkColumnSpec(propertyName, expr, hasReferenceOption = refParts.isNotEmpty()))
         }
         return result
     }
 
-    /** Resolve `@objectRef` (short name OR fully-qualified) to the target entity's short name. */
-    private fun resolveTargetShortName(objectRef: String, loader: MetaDataLoader): String? {
-        // Try exact match first (FQN), then by short name across all entities.
-        val direct = loader.metaObjects.firstOrNull { it.name == objectRef }
-        if (direct != null) return PackageMapping.splitFqn(direct.name).second
-        val byShortName = loader.metaObjects.firstOrNull {
-            PackageMapping.splitFqn(it.name).second == objectRef
-        }
-        return byShortName?.let { PackageMapping.splitFqn(it.name).second }
+    /** Read the `@column` attr on a relationship (inheritance allowed); null when absent. */
+    private fun readColumnAttr(rel: MetaRelationship): String? {
+        if (!rel.hasMetaAttr(CoreDBMetaDataProvider.COLUMN, true)) return null
+        return runCatching { rel.getMetaAttr(CoreDBMetaDataProvider.COLUMN, true).valueAsString }
+            .getOrNull()
     }
 
     /**
@@ -287,26 +262,6 @@ class KotlinExposedTableGenerator : MultiFileDirectGeneratorBase<MetaObject>() {
         else -> null
     }
 
-    private fun findRdbSource(entity: MetaObject): MetaSource? =
-        entity.children.firstOrNull { it is RdbSource } as? MetaSource
-
-    private fun findPrimaryIdentity(entity: MetaObject): MetaIdentity? {
-        for (child in entity.children) {
-            if (child is MetaIdentity && child.subType == "primary") return child
-        }
-        return null
-    }
-
-    private fun isRequired(field: MetaField<*>): Boolean {
-        if (!field.hasMetaAttr(MetaField.ATTR_REQUIRED, true)) return false
-        val raw = runCatching { field.getMetaAttr(MetaField.ATTR_REQUIRED, true).value }.getOrNull()
-        return when (raw) {
-            is Boolean -> raw
-            is String -> raw.equals("true", ignoreCase = true)
-            else -> false
-        }
-    }
-
     // === MultiFileDirectGeneratorBase abstract-method stubs ====================
     override fun writeSingleFile(md: MetaObject, writer: GeneratorIOWriter<*>?) { /* unused */ }
     override fun <T : GeneratorIOWriter<*>?> getSingleWriter(

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

@@ -0,0 +1,49 @@
+package com.metaobjects.generator.kotlin
+
+import com.metaobjects.field.MetaField
+import com.metaobjects.loader.MetaDataLoader
+import com.metaobjects.`object`.MetaObject
+
+/**
+ * Internal helpers shared by the codegen-kotlin generators. Extracted to keep
+ * the three generators (entity / exposed-table / payload) from carrying near-identical
+ * private copies of the same lookups.
+ */
+internal object KotlinGenUtil {
+
+    /**
+     * Resolve a MetaObject (entity OR value) by exact FQN match or by short-name match
+     * (the trailing segment after the last `::`). Returns null when neither matches.
+     */
+    fun resolveObjectByShortOrFqn(loader: MetaDataLoader, ref: String): MetaObject? {
+        for (child in loader.metaObjects) {
+            if (child.name == ref || child.name.substringAfterLast("::") == ref) return child
+        }
+        return null
+    }
+
+    /**
+     * Split `"A.b"` into `("A","b")`; null if the ref isn't a single-dot ref
+     * (no dot, leading dot, or trailing dot).
+     */
+    fun splitDottedRef(ref: String): Pair<String, String>? {
+        val dot = ref.indexOf('.')
+        if (dot <= 0 || dot >= ref.length - 1) return null
+        return ref.substring(0, dot) to ref.substring(dot + 1)
+    }
+
+    /**
+     * Required iff explicit `@required: true` attribute is set on the field (inheritance
+     * allowed); otherwise nullable. MVP heuristic — refined when richer required-detection
+     * lands (see fr-003 spec).
+     */
+    fun isRequiredField(field: MetaField<*>): Boolean {
+        if (!field.hasMetaAttr(MetaField.ATTR_REQUIRED, true)) return false
+        val raw = runCatching { field.getMetaAttr(MetaField.ATTR_REQUIRED, true).value }.getOrNull()
+        return when (raw) {
+            is Boolean -> raw
+            is String -> raw.equals("true", ignoreCase = true)
+            else -> false
+        }
+    }
+}