feat(java omdb): close the 3 port gaps that kept bootstrap-canonical red

Cross-language persistence-conformance Java runner now 3/3 green
(was 2/3 + 1 documented skip).

ExpectedSchemaBuilder rewrite:
- NOT-NULL inferred from `identity.primary` membership OR `@required`
  (matches TS/C#). Legacy `@dbNullable` still honored on top.
- Unique-index emission from `identity.secondary` (uses getShortName() to
  get the bare identifier; getName() would return the FQN like
  `fitness::byTitle`).
- FK emission from `identity.reference`, with @onDelete/@onUpdate paired off
  the matching `MetaRelationship` by @objectref.
- Two-pass walk: tables/entity-map first, view bodies second (need root-level
  resolution for @from/@via cross-entity references).
- Static helpers for clarity (isRequired/readNullable/primaryIdentityFieldNames).

ViewBodyBuilder (new file):
- Walks projection field origins. v1 supports passthrough (no @via) → plain
  base column, and aggregate (@agg/@of/@via) → correlated subquery over a
  to-many. Passthrough-with-via, collection, and multi-base projections return
  null (caller drops the view; cross-port: TS also drops). Port of
  `expected-views.ts` / `PostgresSchema.CreateView`. Identifiers quoted
  throughout for mixed-case round-trip through PG.
- relationshipByShortName + referenceIdentityToward + resolveParentField
  helpers split out for readability.

SchemaDiffer:
- AddIndex + AddFk now emitted alongside CreateTable for new tables
  (matches TS migrate-ts diff()). Gated on the new-table path; rename-table
  branch unaffected (renamed tables keep their existing index/FK shapes).

MigrationScenarioTests:
- EXPECTED_FAILURES emptied. Kept as scaffolding for future deferrals
  matching C# + TS expected-failures pattern.

Gates: Java metadata 634/634, om 30/30, omdb 30/30, integration 3/3.
Other-port gates unchanged.

Phase 2 (query scenarios via ObjectManagerDB + Expression) still pending —
needs a small QuerySpec-DSL → getObjects/getObjectsCount adapter (ObjectManagerDB
is method-based, not LINQ-shaped, so the adapter is bounded). Tracked in
the `java-persistence-conformance-status` memory note.

Author: dmealing

server/java/integration-tests/src/test/java/com/metaobjects/integration/MigrationScenarioTests.java

@@ -31,26 +31,13 @@
 final class MigrationScenarioTests {
 
     /**
-     * Scenarios deferred until the underlying Java port gap is closed. The
-     * harness still loads + parses them; we abort with the documented reason
-     * before running them so {@code BUILD SUCCESS} stays meaningful.
+     * Scenarios deferred until the underlying Java port gap is closed. Empty
+     * today — closing the three previous gaps (index/FK emission, NOT-NULL
+     * inference, projection view-body builder) made all three migration
+     * scenarios green. Kept as a Map so a future expected-fail can be added
+     * with a one-line reason matching the C# and TS expected-failures patterns.
      */
-    private static final Map<String, String> EXPECTED_FAILURES = Map.of(
-        "bootstrap-canonical-from-empty",
-        // Three independent Java gaps surface on the canonical fixture:
-        //   1. ExpectedSchemaBuilder.tableDescriptor returns indexes=[] / foreignKeys=[]
-        //      (`indexes: empty in v1` literal in the source), so unique-index +
-        //      FK CREATE statements never appear in the up SQL.
-        //   2. SimpleMappingHandlerDB doesn't surface @required / identity.primary
-        //      NOT-NULL on columns from the new-metadata layer.
-        //   3. The view-DDL pipeline emits `CREATE OR REPLACE VIEW "v_program" AS null`
-        //      because Java has no port of the TS expected-views.ts / C#
-        //      PostgresSchema.CreateView origin-walker.
-        // Track-and-skip pattern matches `conformance-expected-failures.json`.
-        "deferred: Java omdb migration pipeline needs index/FK emission, "
-        + "NOT-NULL inference from identity.primary + @required, and a "
-        + "projection-view body builder porting passthrough/aggregate origins"
-    );
+    private static final Map<String, String> EXPECTED_FAILURES = Map.of();
 
     private static List<MigrationScenario> SCENARIOS;
 

server/java/omdb/src/main/java/com/metaobjects/manager/db/migrate/ExpectedSchemaBuilder.java

@@ -1,7 +1,12 @@
 package com.metaobjects.manager.db.migrate;
 
+import com.metaobjects.MetaData;
 import com.metaobjects.database.CoreDBMetaDataProvider;
 import com.metaobjects.field.MetaField;
+import com.metaobjects.identity.MetaIdentity;
+import com.metaobjects.identity.PrimaryIdentity;
+import com.metaobjects.identity.ReferenceIdentity;
+import com.metaobjects.identity.SecondaryIdentity;
 import com.metaobjects.loader.MetaDataLoader;
 import com.metaobjects.manager.db.MappingHandler;
 import com.metaobjects.manager.db.ObjectManagerDB;
@@ -10,24 +15,37 @@
 import com.metaobjects.manager.db.defs.BaseDef;
 import com.metaobjects.manager.db.defs.ColumnDef;
 import com.metaobjects.manager.db.defs.TableDef;
-import com.metaobjects.manager.db.defs.ViewDef;
 import com.metaobjects.manager.db.migrate.SchemaSnapshot.ColumnDescriptor;
+import com.metaobjects.manager.db.migrate.SchemaSnapshot.FkDescriptor;
+import com.metaobjects.manager.db.migrate.SchemaSnapshot.IndexDescriptor;
 import com.metaobjects.manager.db.migrate.SchemaSnapshot.TableDescriptor;
 import com.metaobjects.manager.db.migrate.SchemaSnapshot.ViewDescriptor;
 import com.metaobjects.object.MetaObject;
 import com.metaobjects.registry.MetaDataLoaderRegistry;
+import com.metaobjects.relationship.MetaRelationship;
+import com.metaobjects.source.MetaSource;
 
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 /**
- * Builds the EXPECTED {@link SchemaSnapshot} from metadata, reusing the same
- * MappingHandler-derived TableDef/ViewDef the boot-time validator uses (no re-derivation)
- * and the mapped type carried on ColumnDef (converted to canonical SqlType via
- * {@link JdbcSqlTypes}). Also harvests {@code @previousName} into {@link RenameHints}.
+ * Builds the EXPECTED {@link SchemaSnapshot} from metadata.
+ *
+ * <p>Column shapes still come through the legacy {@link MappingHandler}-derived
+ * {@link TableDef} (so existing object-mapping consumers like the Derby
+ * fixture path keep working), but everything new-style enrichment lives here:
+ * NOT-NULL inference from {@code identity.primary} + {@code @required},
+ * unique-index emission from {@code identity.secondary}, FK emission from
+ * {@code identity.reference}, and projection view bodies computed from
+ * {@code origin.passthrough} / {@code origin.aggregate} children.</p>
+ *
+ * <p>Cross-port: mirrors {@code expected-schema.ts} + {@code expected-views.ts}
+ * (TS) and {@code MetaObjects.Codegen.Migrate.ExpectedSchema} +
+ * {@code MetaObjects.Codegen.Schema.PostgresSchema.CreateView} (C#).</p>
  */
 public final class ExpectedSchemaBuilder {
 
@@ -39,95 +57,203 @@ public ExpectedSchemaBuilder(ObjectManagerDB manager, MetaDataLoaderRegistry loa
         this.loaderRegistry = loaderRegistry;
     }
 
-    /**
-     * Build the snapshot; fills {@code hints} as a side-effect.
-     * Pass {@link RenameHints#empty()} if rename tracking is not needed.
-     */
+    /** Build the snapshot; fills {@code hints} as a side-effect. */
     public SchemaSnapshot build(RenameHints hints) {
         MappingHandler mh = manager.getMappingHandler();
         Map<String, TableDescriptor> tables = new LinkedHashMap<>();
         Map<String, ViewDescriptor> views = new LinkedHashMap<>();
 
+        // Pass 1: build tables + collect entities by short-name + harvest renames.
+        // View bodies need the name→entity map to resolve `@from`/`@via` cross-entity refs,
+        // so the view pass runs after this loop completes.
+        Map<String, MetaObject> entityByName = new LinkedHashMap<>();
         for (MetaDataLoader loader : loaders()) {
             for (MetaObject mc : loader.getMetaObjects()) {
-                // Create mapping → TableDef (writable side)
+                entityByName.putIfAbsent(mc.getShortName(), mc);
                 BaseDef createDef = defOf(mh.getCreateMapping(mc));
                 if (createDef instanceof TableDef t) {
                     tables.putIfAbsent(t.getNameDef().getFullname(), tableDescriptor(t, mc));
                 }
-
-                // Read mapping → ViewDef (read side, if any)
-                BaseDef readDef = defOf(mh.getReadMapping(mc));
-                if (readDef instanceof ViewDef v) {
-                    views.putIfAbsent(v.getNameDef().getFullname(),
-                        new ViewDescriptor(v.getNameDef().getName(), v.getNameDef().getSchema(), v.getSQL()));
-                }
-
                 harvestRenameHints(mc, hints);
             }
         }
+
+        // Pass 2: projection view bodies derived from origin children.
+        for (MetaObject mc : entityByName.values()) {
+            String viewName = mc.getPrimaryRdbViewName();
+            if (viewName == null) continue;
+            String body = ViewBodyBuilder.buildSql(mc, entityByName);
+            if (body == null) continue; // unresolvable projection — leave out (cross-port: TS also drops)
+            String viewSchema = mc.findPrimaryReadOnlySource().map(MetaSource::getSchema).orElse(null);
+            String fullName = (viewSchema == null ? "" : viewSchema + ".") + viewName;
+            views.putIfAbsent(fullName, new ViewDescriptor(viewName, viewSchema, body));
+        }
+
         return new SchemaSnapshot(new ArrayList<>(tables.values()), new ArrayList<>(views.values()));
     }
 
     // -------------------------------------------------------------------------
-    // Private helpers
+    // Table descriptor (columns + indexes + FKs + PK)
     // -------------------------------------------------------------------------
 
     private TableDescriptor tableDescriptor(TableDef t, MetaObject mc) {
         List<ColumnDescriptor> cols = new ArrayList<>();
         List<String> pk = new ArrayList<>();
+        Set<String> pkFieldNames = primaryIdentityFieldNames(mc);
 
         for (ColumnDef cd : t.getColumns()) {
             if (cd.getName() == null) continue;
             MetaField<?> mf = fieldForColumn(mc, cd.getName());
             SqlType sqlType = JdbcSqlTypes.fromJdbc(cd.getSQLType(), cd.getLength());
-            boolean nullable = mf == null || readNullable(mf); // default: nullable unless @dbNullable=false
-            // identity is informational in v1; not surfaced here
+            // Unmapped columns default to nullable; mapped columns are nullable unless part of the
+            // primary identity, marked @required, or explicitly @dbNullable=false.
+            boolean isPk = mf != null && pkFieldNames.contains(mf.getName());
+            boolean nullable = mf == null || (!isPk && !isRequired(mf) && readNullable(mf));
             cols.add(new ColumnDescriptor(cd.getName(), sqlType, nullable, null));
-            if (cd.isPrimaryKey()) pk.add(cd.getName());
+            if (cd.isPrimaryKey() || isPk) pk.add(cd.getName());
         }
 
         return new TableDescriptor(
             t.getNameDef().getName(),
             t.getNameDef().getSchema(),
             cols,
-            List.of(),   // indexes: empty in v1 (create-table stays additive)
-            List.of(),   // foreign keys: empty in v1
+            buildIndexes(mc),
+            buildForeignKeys(mc),
             pk);
     }
 
-    private boolean readNullable(MetaField<?> mf) {
-        if (!mf.hasMetaAttr(CoreDBMetaDataProvider.DB_NULLABLE)) return true;
-        return !"false".equals(mf.getMetaAttr(CoreDBMetaDataProvider.DB_NULLABLE).getValueAsString());
+    /** True when {@code @required} is explicitly set to "true". */
+    private static boolean isRequired(MetaField<?> mf) {
+        return mf.hasMetaAttr(MetaField.ATTR_REQUIRED)
+            && "true".equalsIgnoreCase(mf.getMetaAttr(MetaField.ATTR_REQUIRED).getValueAsString());
+    }
+
+    /** True (nullable) unless the legacy {@code @dbNullable} attr explicitly says "false". */
+    private static boolean readNullable(MetaField<?> mf) {
+        return !mf.hasMetaAttr(CoreDBMetaDataProvider.DB_NULLABLE)
+            || !"false".equals(mf.getMetaAttr(CoreDBMetaDataProvider.DB_NULLABLE).getValueAsString());
+    }
+
+    private static Set<String> primaryIdentityFieldNames(MetaObject mc) {
+        PrimaryIdentity pk = mc.getPrimaryIdentity();
+        return pk == null ? Set.of() : Set.copyOf(pk.getFields());
+    }
+
+    // -------------------------------------------------------------------------
+    // Indexes (secondary identities)
+    // -------------------------------------------------------------------------
+
+    private List<IndexDescriptor> buildIndexes(MetaObject mc) {
+        List<IndexDescriptor> indexes = new ArrayList<>();
+        for (SecondaryIdentity sec : mc.getSecondaryIdentities()) {
+            List<String> cols = sec.getFields().stream().map(n -> columnFor(mc, n)).toList();
+            if (cols.isEmpty()) continue;
+            // Secondary identities are unique unless explicitly @unique:false (mirrors TS).
+            boolean unique = !"false".equalsIgnoreCase(attrOrNull(sec, "unique"));
+            // Use the short name (Java's getName() returns the FQN like "fitness::byTitle";
+            // the cross-port assertion vocabulary expects the bare identifier).
+            indexes.add(new IndexDescriptor(sec.getShortName(), cols, unique));
+        }
+        return indexes;
+    }
+
+    // -------------------------------------------------------------------------
+    // Foreign keys (reference identities)
+    // -------------------------------------------------------------------------
+
+    private List<FkDescriptor> buildForeignKeys(MetaObject mc) {
+        String owningTable = mc.getPrimaryRdbTableName();
+        if (owningTable == null) return List.of();
+
+        List<FkDescriptor> fks = new ArrayList<>();
+        for (MetaIdentity id : mc.getIdentities()) {
+            if (!(id instanceof ReferenceIdentity ref) || !ref.isEnforced()) continue;
+            String targetName = ref.getTargetEntity();
+            if (targetName == null || ref.getFields().isEmpty()) continue;
+            MetaObject target = findEntity(targetName);
+            if (target == null) continue;
+            String refTable = target.getPrimaryRdbTableName();
+            if (refTable == null) continue;
+
+            List<String> cols = ref.getFields().stream().map(n -> columnFor(mc, n)).toList();
+            List<String> refTargetFields = ref.getTargetFields();
+            List<String> refCols = refTargetFields.size() > 1
+                ? refTargetFields.stream().map(n -> columnFor(target, n)).toList()
+                : List.of(columnFor(target, resolvedTargetPkField(target, ref)));
+
+            String onDelete = matchingRelationshipAction(mc, targetName, true);
+            String onUpdate = matchingRelationshipAction(mc, targetName, false);
+
+            String name = owningTable + "_" + cols.get(0) + "_fk";
+            fks.add(new FkDescriptor(name, cols, refTable, refCols, onDelete, onUpdate));
+        }
+        return fks;
+    }
+
+    private String resolvedTargetPkField(MetaObject target, ReferenceIdentity fk) {
+        if (fk.getTargetFields().size() == 1) return fk.getTargetFields().get(0);
+        PrimaryIdentity pk = target.getPrimaryIdentity();
+        if (pk != null && !pk.getFields().isEmpty()) return pk.getFields().get(0);
+        return "id";
+    }
+
+    /** Pair a reference identity to its matching relationship by @objectRef, read its @onDelete/@onUpdate. */
+    private static String matchingRelationshipAction(MetaObject owner, String targetEntity, boolean delete) {
+        // Strip package qualifier once (handles both "Target" and "pkg::Target" forms).
+        String bareTarget = stripPkg(targetEntity);
+        for (MetaRelationship rel : owner.getRelationships()) {
+            String objectRef = rel.getObjectRef();
+            if (objectRef == null || !stripPkg(objectRef).equals(bareTarget)) continue;
+            return delete ? rel.getOnDeleteRaw() : rel.getOnUpdateRaw();
+        }
+        return null;
     }
 
+    // -------------------------------------------------------------------------
+    // Field-name / column-name helpers
+    // -------------------------------------------------------------------------
+
     private MetaField<?> fieldForColumn(MetaObject mc, String column) {
         for (MetaField<?> mf : mc.getMetaFields()) {
             if (column.equalsIgnoreCase(columnNameOf(mf))) return mf;
         }
         return null;
     }
 
+    private static String columnFor(MetaObject mc, String fieldName) {
+        for (MetaField<?> mf : mc.getMetaFields()) {
+            if (mf.getName().equals(fieldName)) return columnNameOf(mf);
+        }
+        return fieldName; // fallback to bare name (matches cross-port stale-FK behavior)
+    }
+
     /** The field's column name: {@code @column} when present, otherwise the field name. */
     private static String columnNameOf(MetaField<?> mf) {
         return mf.hasMetaAttr(CoreDBMetaDataProvider.COLUMN)
             ? mf.getMetaAttr(CoreDBMetaDataProvider.COLUMN).getValueAsString()
             : mf.getName();
     }
 
+    private static String stripPkg(String name) {
+        int i = name.lastIndexOf("::");
+        return i < 0 ? name : name.substring(i + 2);
+    }
+
+    private static String attrOrNull(MetaData md, String attr) {
+        return md.hasMetaAttr(attr) ? md.getMetaAttr(attr).getValueAsString() : null;
+    }
+
+    // -------------------------------------------------------------------------
+    // Rename hints
+    // -------------------------------------------------------------------------
+
     private void harvestRenameHints(MetaObject mc, RenameHints hints) {
-        // Determine the table name for this object (source-v2 ADR-0007:
-        // primary writable source.rdb @table; nothing if no such source).
         String table = mc.getPrimaryRdbTableName();
         if (table == null) return;
-
-        // Table-level rename
         if (mc.hasMetaAttr(CoreDBMetaDataProvider.PREVIOUS_NAME)) {
             hints.addTableRename(table,
                 mc.getMetaAttr(CoreDBMetaDataProvider.PREVIOUS_NAME).getValueAsString());
         }
-
-        // Column-level renames
         for (MetaField<?> mf : mc.getMetaFields()) {
             if (mf.hasMetaAttr(CoreDBMetaDataProvider.PREVIOUS_NAME)) {
                 hints.addColumnRename(table, columnNameOf(mf),
@@ -136,6 +262,10 @@ private void harvestRenameHints(MetaObject mc, RenameHints hints) {
         }
     }
 
+    // -------------------------------------------------------------------------
+    // Misc
+    // -------------------------------------------------------------------------
+
     private static BaseDef defOf(ObjectMapping m) {
         return (m instanceof ObjectMappingDB db) ? db.getDBDef() : null;
     }
@@ -145,4 +275,14 @@ private Collection<MetaDataLoader> loaders() {
             ? loaderRegistry.getDataLoaders()
             : com.metaobjects.util.MetaDataUtil.getAllMetaDataLoaders(this);
     }
+
+    private MetaObject findEntity(String name) {
+        String bare = stripPkg(name);
+        for (MetaDataLoader loader : loaders()) {
+            for (MetaObject mc : loader.getMetaObjects()) {
+                if (mc.getShortName().equals(bare)) return mc;
+            }
+        }
+        return null;
+    }
 }

server/java/omdb/src/main/java/com/metaobjects/manager/db/migrate/SchemaDiffer.java

@@ -27,6 +27,12 @@ public DiffResult diff(SchemaSnapshot expected, SchemaSnapshot actual, AllowOpti
                     diffColumns(e, prevTable, hints, changes);   // then converge columns of the renamed table
                 } else {
                     changes.add(new Change.CreateTable(e));      // new table: columns ride with CREATE TABLE
+                    // Indexes + FKs are separate DDL statements; emit alongside the CREATE TABLE
+                    // so they're applied at the same point in the pipeline (matches TS migrate-ts).
+                    for (IndexDescriptor idx : e.indexes())
+                        changes.add(new Change.AddIndex(e.name(), e.schema(), idx));
+                    for (FkDescriptor fk : e.foreignKeys())
+                        changes.add(new Change.AddFk(e.name(), e.schema(), fk));
                 }
             } else {
                 diffColumns(e, a, hints, changes);