feat(metadata): SP-G Java recon Unit7 — converge physical db* onto cross-port logical attrs + drop dead DDL/migration vestiges

Removes Java's residual physical db* attr vocabulary so the metadata-module
registry manifest byte-matches the cross-port canonical (residual EMPTY).

Converged logical-equivalent db* → cross-port logical names (already on
field.base via MetaField since Unit 4):
- dbType="jsonb" (typed owned-object storage) → field.object @storage="jsonb";
  migrated OMDB consumers (SimpleMappingHandlerDB.isJsonbField,
  GenericSQLDriver.isJsonbField).
- dbNullable → @required (inverted), dbLength → @maxlength,
  dbPrecision → @precision, dbScale → @scale; migrated codegen-mustache
  HelperRegistry.
- dbColumnType / column kept (already registered on field.base; the
  @dbColumnType value vocabulary remains in CoreDBMetaDataProvider as the
  single cross-port home consumed by OMDB + codegen-spring + codegen-kotlin).

Dropped as dead DDL/migration vestiges (no live runtime consumer; schema is
TS-owned per ADR-0015, OMDB is pure data-access):
- field/object: dbForeignKey, dbIndex, dbUnique, previousName
- identity: dbIndexName, dbSequenceName, dbTablespace
- removed PreviousNameAttrTest + meta.rename.json (migration-rename only).

CoreDBMetaDataProvider.registerTypes now registers no field/object/identity
attrs — all cross-port logical attrs live on field.base.

Gate stays @Ignore/@disabled (Unit 8 flips it); confirmed locally the
metadata-module runner passes (residual EMPTY). Verified: metadata 925,
codegen-base 31, codegen-mustache 35, omdb 37, codegen-spring/codegen-kotlin
green, integration-tests 68 (Testcontainers persistence-conformance + api-contract).

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

Author: dmealing

fixtures/registry-conformance/README.md

@@ -259,6 +259,16 @@ Detail per port:
   through the loader's validation, OMDB, `codegen-spring`, and `codegen-kotlin`
   (all consume the current Java attrs). It is tracked as a dedicated follow-on,
   NOT a silent omission, and the canonical is **not** edited (it is correct).
+  **Update (Phase 2 complete):** every divergence above has since been reconciled
+  unit-by-unit — the final piece, the physical `db*` vocabulary, was converged in
+  SP-G Unit 7 (the logical-equivalent attrs `dbType`/`dbIndex`/`dbLength`/
+  `dbNullable`/`dbPrecision`/`dbScale`/`dbUnique` mapped onto the cross-port
+  `dbColumnType`/`db.indexed`/`maxLength`/required-ness/`precision`/`scale`/`unique`
+  + owned-object `@storage="jsonb"`, with consumers in `omdb` + `codegen-mustache`
+  migrated; the DDL/migration-only remnants `dbForeignKey`/`previousName`/
+  `dbIndexName`/`dbSequenceName`/`dbTablespace` dropped as dead under ADR-0015).
+  The Java manifest now byte-matches the canonical (residual EMPTY); the gate stays
+  `@Ignore`/`@Disabled` only until SP-G Unit 8 flips it atomically with CI wiring.
 
 ## Regenerating the canonical
 

server/java/codegen-base/src/test/resources/schema-validation/valid-inline-attributes.json

@@ -19,7 +19,7 @@
                 "name": "productId",
                 "subType": "long",
                 "@column": "product_id",
-                "@dbNullable": false,
+                "@required": true,
                 "children": [
                   {
                     "validator": {
@@ -59,7 +59,7 @@
                 "name": "price",
                 "subType": "double",
                 "@column": "price",
-                "@dbScale": 2,
+                "@scale": 2,
                 "children": [
                   {
                     "validator": {
@@ -90,7 +90,6 @@
                 "name": "categoryId",
                 "subType": "int",
                 "@column": "category_id",
-                "@dbForeignKey": "categories.id",
                 "@isOptional": true
               }
             },

server/java/codegen-base/src/test/resources/template-test-metadata.json

@@ -22,7 +22,7 @@
               "field.string": {
                 "name": "username",
                 "@column": "username",
-                "@dbNullable": "false",
+                "@required": true,
                 "children": [
                   {
                     "validator.required": {}

server/java/codegen-mustache/src/main/java/com/metaobjects/generator/mustache/HelperRegistry.java

@@ -595,20 +595,21 @@ private String getTableName(MetaObject metaObject) {
     }
 
     /**
-     * Determine if a field should be nullable based on validators.
-     * Returns the explicit dbNullable attribute if present, otherwise analyzes
-     * the field's validators to determine if it's required (not nullable).
+     * Determine if a field should be nullable.
+     * Honors the cross-port logical {@code @required} marker if present (nullable = !required,
+     * SP-G Unit 7 — replaces the legacy {@code @dbNullable} physical attr), otherwise
+     * analyzes the field's validators to determine if it's required (not nullable).
      */
     private boolean isFieldNullable(MetaField metaField) {
-        // Check for explicit dbNullable attribute first
-        if (metaField.hasMetaAttr("dbNullable")) {
+        // Honor the explicit logical @required marker first (cross-port name).
+        if (metaField.hasMetaAttr(MetaField.ATTR_REQUIRED)) {
             try {
-                boolean explicitNullable = Boolean.parseBoolean(
-                    metaField.getMetaAttr("dbNullable").getValueAsString());
-                log.debug("Using explicit dbNullable: {} for field: {}", explicitNullable, metaField.getName());
-                return explicitNullable;
+                boolean required = Boolean.parseBoolean(
+                    metaField.getMetaAttr(MetaField.ATTR_REQUIRED).getValueAsString());
+                log.debug("Using explicit @required: {} for field: {}", required, metaField.getName());
+                return !required;
             } catch (Exception e) {
-                log.warn("Invalid dbNullable value for field {}, falling back to validator analysis",
+                log.warn("Invalid @required value for field {}, falling back to validator analysis",
                     metaField.getName());
             }
         }
@@ -624,19 +625,20 @@ private boolean isFieldNullable(MetaField metaField) {
 
     /**
      * Get the database column length for a field.
-     * Returns the explicit dbLength attribute if present, otherwise analyzes
-     * validators to determine appropriate length constraints.
+     * Returns the explicit logical {@code @maxLength} attribute if present (cross-port name,
+     * SP-G Unit 7 — replaces the legacy {@code @dbLength}), otherwise analyzes validators to
+     * determine appropriate length constraints.
      */
     private Optional<Integer> getFieldColumnLength(MetaField metaField) {
-        // Check for explicit dbLength attribute first
-        if (metaField.hasMetaAttr("dbLength")) {
+        // Check for explicit logical @maxLength attribute first (cross-port name).
+        if (metaField.hasMetaAttr(MetaField.ATTR_MAX_LENGTH)) {
             try {
                 int explicitLength = Integer.parseInt(
-                    metaField.getMetaAttr("dbLength").getValueAsString());
-                log.debug("Using explicit dbLength: {} for field: {}", explicitLength, metaField.getName());
+                    metaField.getMetaAttr(MetaField.ATTR_MAX_LENGTH).getValueAsString());
+                log.debug("Using explicit @maxLength: {} for field: {}", explicitLength, metaField.getName());
                 return Optional.of(explicitLength);
             } catch (NumberFormatException e) {
-                log.warn("Invalid dbLength value for field {}, falling back to validator analysis",
+                log.warn("Invalid @maxLength value for field {}, falling back to validator analysis",
                     metaField.getName());
             }
         }
@@ -649,36 +651,25 @@ private Optional<Integer> getFieldColumnLength(MetaField metaField) {
             return validatorLength;
         }
 
-        // Check for maxLength attribute (common pattern)
-        if (metaField.hasMetaAttr("maxLength")) {
-            try {
-                int maxLength = Integer.parseInt(
-                    metaField.getMetaAttr("maxLength").getValueAsString());
-                log.debug("Using maxLength attribute: {} for field: {}", maxLength, metaField.getName());
-                return Optional.of(maxLength);
-            } catch (NumberFormatException e) {
-                log.warn("Invalid maxLength value for field {}", metaField.getName());
-            }
-        }
-
         log.debug("No length constraint found for field: {}", metaField.getName());
         return Optional.empty();
     }
 
     /**
      * Get the database precision for numeric fields.
-     * Returns the explicit dbPrecision attribute if present, otherwise returns
+     * Returns the explicit logical {@code @precision} attribute if present (cross-port name,
+     * SP-G Unit 7 — replaces the legacy {@code @dbPrecision}), otherwise returns
      * empty Optional as precision is typically database-specific.
      */
     private Optional<Integer> getFieldPrecision(MetaField metaField) {
-        if (metaField.hasMetaAttr("dbPrecision")) {
+        if (metaField.hasMetaAttr(MetaField.ATTR_PRECISION)) {
             try {
                 int precision = Integer.parseInt(
-                    metaField.getMetaAttr("dbPrecision").getValueAsString());
-                log.debug("Using explicit dbPrecision: {} for field: {}", precision, metaField.getName());
+                    metaField.getMetaAttr(MetaField.ATTR_PRECISION).getValueAsString());
+                log.debug("Using explicit @precision: {} for field: {}", precision, metaField.getName());
                 return Optional.of(precision);
             } catch (NumberFormatException e) {
-                log.warn("Invalid dbPrecision value for field {}", metaField.getName());
+                log.warn("Invalid @precision value for field {}", metaField.getName());
             }
         }
 
@@ -687,18 +678,19 @@ private Optional<Integer> getFieldPrecision(MetaField metaField) {
 
     /**
      * Get the database scale for numeric fields.
-     * Returns the explicit dbScale attribute if present, otherwise returns
+     * Returns the explicit logical {@code @scale} attribute if present (cross-port name,
+     * SP-G Unit 7 — replaces the legacy {@code @dbScale}), otherwise returns
      * empty Optional as scale is typically database-specific.
      */
     private Optional<Integer> getFieldScale(MetaField metaField) {
-        if (metaField.hasMetaAttr("dbScale")) {
+        if (metaField.hasMetaAttr(MetaField.ATTR_SCALE)) {
             try {
                 int scale = Integer.parseInt(
-                    metaField.getMetaAttr("dbScale").getValueAsString());
-                log.debug("Using explicit dbScale: {} for field: {}", scale, metaField.getName());
+                    metaField.getMetaAttr(MetaField.ATTR_SCALE).getValueAsString());
+                log.debug("Using explicit @scale: {} for field: {}", scale, metaField.getName());
                 return Optional.of(scale);
             } catch (NumberFormatException e) {
-                log.warn("Invalid dbScale value for field {}", metaField.getName());
+                log.warn("Invalid @scale value for field {}", metaField.getName());
             }
         }