Merge omdb-remediation Tier 2 (dead-code purge) + migration-removal plan

Purge: ~720 lines of dead/commented code removed across 6 OMDB runtime
files (ExpressionParser, ManagedObject, QueryOptions, GenericSQLDriver,
ObjectManagerDB, DirtyWriteException) — deletion-only, suites identical
(om+omdb 68/0/0), no migration-subsystem files touched, reviewed safe.
Plus the OMDB schema-migration subsystem removal plan (Option A, decisions
resolved).

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

Author: dmealing

docs/superpowers/plans/2026-05-30-omdb-migration-subsystem-removal.md

@@ -0,0 +1,94 @@
+# OMDB Schema-Migration Subsystem Removal — Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax.
+
+**Goal:** Remove OMDB's diff-and-converge **schema-migration engine** from the Java port. Schema migrations move to a **TS-only** approach ([[ts-only-schema-migrations-pivot]]); OMDB keeps its **runtime persistence** role only.
+
+**Status:** PLAN (not yet executed). Carries one **load-bearing scope decision** (Option A vs B below) that must be confirmed before implementation.
+
+---
+
+## The scope decision (CONFIRM FIRST)
+
+OMDB has TWO schema-touching capabilities. They are independent:
+
+1. **Diff-and-converge MIGRATION engine** — `migrate/*` (16 files), the `MigrationSqlRenderer` interface, the drivers' `render(Change)` methods, the `meta:migrate` Maven goal, and the Java migration-conformance scenarios. **This is what the TS-only pivot replaces.**
+2. **Runtime auto-create DDL** — `MetaClassDBValidatorService` calling the drivers' *legacy* `createTable`/`createIndex`/`createForeignKey`. This bootstraps a schema at runtime/startup and is what the OMDB **test harness** (`AbstractOMDBTest`, ~10 tests) uses to create its tables. It does NOT use the `Change`/`render` engine.
+
+- **Option A (RECOMMENDED — remove the engine only):** delete capability #1; **keep** capability #2 (validator + legacy `createTable` DDL). Rationale: low blast radius; the test harness keeps working; runtime auto-create is a legitimate dev/test convenience orthogonal to *migrations* (schema evolution), which is the thing going TS-only. The shared `defs/` model stays (it's also the runtime mapping model).
+- **Option B (purist — remove all schema/DDL generation):** also delete the validator + the legacy `createTable`/`createIndex`/`createForeignKey` DDL, making OMDB a pure data-access runtime. **Much larger:** ~10 omdb tests + the integration-tests harness lose their schema setup and must be re-tooled to create tables via raw SQL fixtures. Only do this if the intent is "OMDB never emits DDL at all."
+
+**This plan implements Option A.** If B is chosen, add a Phase 0 that replaces `AbstractOMDBTest`'s validator-based setup with raw-SQL fixtures, then also delete the validator + legacy DDL methods.
+
+---
+
+## What gets removed (Option A)
+
+**Delete (whole files):**
+- `omdb/.../manager/db/migrate/` — all 16: `AllowOptions`, `BlockedChangesError`, `Change`, `ChangeStatusRules`, `DiffResult`, `EmitResult`, `ExpectedSchemaBuilder`, `JdbcSqlTypes`, `MigrationEmitter`, `RenameHints`, `SchemaDiffer`, `SchemaIntrospector`, `SchemaMigrationEngine`, `SchemaSnapshot`, `SqlType`, `ViewBodyBuilder`.
+- `omdb/.../manager/db/MigrationSqlRenderer.java` (the interface drivers implement).
+- `maven-plugin/.../mojo/MetaDataMigrateMojo.java` (the `meta:migrate` goal).
+- omdb migration tests: `SchemaMigrationEngineTest`, `ExpectedSchemaBuilderTest`, `ViewMigrationTest` (+ any migrate-specific fixtures).
+- `integration-tests/.../MigrationScenarioRunner.java` + the migration-scenario invocations.
+
+**Edit (remove migration bits, keep the rest):**
+- `GenericSQLDriver.java`, `PostgresDriver.java`, `DerbyDriver.java` — remove `implements MigrationSqlRenderer`, the `render(Change)` methods, and migration-only helpers (e.g. `pgType`/`derbyType` `SqlType` mappers used only by `render`). KEEP the legacy `createTable`/`createIndex`/`createForeignKey`/`createSequence` DDL (used by the validator) and ALL CRUD/query/codec/paging.
+- `DatabaseDriver.java` — drop any migration-only abstract methods/signatures if present.
+- `integration-tests` migration scenario wiring + any `meta:migrate` usage in test/build configs.
+- `omdb/.../driver/DriverFloatTypeTest.java` — remove its `migrate.*` references (keep the float-type assertions, re-pointed off `SqlType` if needed).
+
+**KEEP (do not touch):**
+- `manager/db/defs/*` (TableDef/ColumnDef/IndexDef/etc.) — shared runtime mapping model.
+- `MetaClassDBValidatorService` + the legacy `createTable`/`createIndex`/`createForeignKey` driver DDL.
+- All CRUD/query/codec/transaction/paging/UUID code; the Spring Boot starter; `om`.
+
+---
+
+## Cross-cutting impact (handle as part of the plan)
+
+- **Maven plugin:** `meta:gen`, `meta:verify`, `meta:editor` stay; `meta:migrate` goes. Update the plugin README/docs to drop `migrate`. Check the plugin POM/`@Mojo` registration and any shared base (`AbstractMetaDataMojo`) for migrate-only plumbing.
+- **Persistence-conformance:** Java currently runs "3 migration + 9 query" (per [[java-persistence-conformance-status]]). After removal Java runs **query only**; the corpus's migration scenarios remain for TS (and whichever ports still own migration). Update the `integration-tests` runner + the conformance memory/docs to reflect that Java no longer executes migration scenarios. **Decision:** confirm the corpus migration scenarios are NOT expected from Java anymore (vs. temporarily skipped).
+- **`spec/` + docs:** `meta migrate` references in CLAUDE.md ("Useful commands" mentions `meta migrate` — that's the TS CLI, leave), the Java maven-plugin docs, FR-003 docs, and `spec/roadmap.md` open-questions/migration notes. Update Java-migration claims; note migrations are TS-only. Reconcile [[fr003-migrate-cross-lang-divergences]].
+- **Memories to update after:** [[java-persistence-conformance-status]], [[ts-only-schema-migrations-pivot]], [[omdb-remediation-status]].
+
+---
+
+## Sequencing (Option A)
+
+**Pre-flight verification (Task 0):**
+- [ ] Confirm `SqlType`/`JdbcSqlTypes` have NO runtime (non-migration) consumers: `grep -rn "SqlType\|JdbcSqlTypes" server/java --include=*.java | grep -v /target/ | grep -v /migrate/` → expect only `migrate/` + the drivers' `render` path. If a runtime consumer exists, STOP and re-scope.
+- [ ] Confirm `defs/` has runtime consumers (it does: SimpleMappingHandlerDB/ObjectMapping/validator/CRUD) → KEEP.
+- [ ] Snapshot baseline: `mvn -q -pl om,omdb,maven-plugin,core-spring,omdb-ktx test` green; `integration-tests` green (Docker).
+
+**Unit 1 — drivers shed the renderer.**
+- [ ] Remove `implements MigrationSqlRenderer` + `render(Change)` + migration-only `SqlType` mappers from `GenericSQLDriver`/`PostgresDriver`/`DerbyDriver`; delete `MigrationSqlRenderer.java`. Keep legacy DDL + CRUD.
+- [ ] `mvn -q -pl omdb test` — fix any compile breakage (the validator/CRUD must still compile against the kept DDL). Commit.
+
+**Unit 2 — delete the `migrate/` package + its tests.**
+- [ ] Delete `migrate/*` (16 files) + `SchemaMigrationEngineTest`/`ExpectedSchemaBuilderTest`/`ViewMigrationTest` + migrate fixtures. Fix `DriverFloatTypeTest` references.
+- [ ] `mvn -q -pl omdb test` green. Commit.
+
+**Unit 3 — remove the Maven `meta:migrate` goal.**
+- [ ] Delete `MetaDataMigrateMojo`; remove migrate-only plumbing from `AbstractMetaDataMojo`/plugin config; update plugin README (drop `migrate`, keep gen/verify/editor).
+- [ ] `mvn -q -pl maven-plugin test` (or `install`) green. Commit.
+
+**Unit 4 — integration-tests: drop Java migration scenarios.**
+- [ ] Remove `MigrationScenarioRunner` + migration-scenario invocations; keep query + api-contract scenarios. Adjust the conformance count (Java = query-only).
+- [ ] `mvn -f integration-tests/pom.xml test` (Docker) green. Commit.
+
+**Unit 5 — docs + memories.**
+- [ ] Update maven-plugin docs, FR-003/spec/roadmap Java-migration claims, and the conformance memories. Commit.
+
+**Final:** full reactor `mvn -q test` green; cross-cutting review + simplify; finish branch (merge forward + push).
+
+---
+
+## Decisions — RESOLVED 2026-05-30
+1. **Option A** — remove the migration ENGINE only; **keep** runtime auto-create DDL (validator + legacy `createTable`/`createIndex`/`createForeignKey`) and the shared `defs/` model. ✓
+2. **Persistence-conformance** — Java **permanently** stops running migration scenarios (not skipped); the corpus migration scenarios remain for TS (and other ports that own migration). ✓
+3. **Maven `meta:migrate`** — **fully removed; do NOT proxy the TS CLI.** Rationale: the TS `meta migrate` runs against a TS project shape (`metaobjects.config.ts`/`.metaobjects/`/TS CLI), would force Node+npm into every Maven build, and re-entangles the TS-owns-migrations boundary. Add a one-line plugin-README pointer ("schema migrations are managed by the TS toolchain"). **Flag (non-blocking):** a pure-Java shop is then left with runtime auto-create (dev) + externally-managed schema (prod), or adopting the TS CLI — revisit only if pure-Java adopters are a target.
+4. **`defs/`** — stays (runtime mapping model). ✓
+
+## Risks / notes
+- The drivers are the trickiest edit — `render(Change)` and legacy `createTable` coexist in the same files; delete only the `Change`/render surface. The Tier-1 paging/codec work and Tier-0 fixes are all in CRUD/query paths and are unaffected.
+- This is **forward-only** removal — no rollback path (consistent with the TS-only direction). The deleted engine remains in git history if ever needed.

server/java/om/src/main/java/com/metaobjects/manager/QueryOptions.java

@@ -24,7 +24,6 @@ public class QueryOptions
   private Expression mExp        = null;
   private SortOrder mOrder       = null;
   private Range mRange           = null;
-  //private boolean mWriteableOnly = false;
   private Collection<MetaField> mFields      = null;
   private boolean mWithLock		 = false;
 
@@ -40,39 +39,15 @@ public QueryOptions( Expression exp )
   public QueryOptions( Expression exp, SortOrder order )
   {
     this( exp, order, null );
-    //mExp = exp;
-    //mOrder = order;
   }
 
-  //public QueryOptions( SortOrder order )
-  //{
-  //  mOrder = order;
-  //}
-
   public QueryOptions( Expression exp, SortOrder order, Range range )
   {
     setExpression( exp );
     setSortOrder( order );
     setRange( range );
   }
 
-  //public QueryOptions( SortOrder order, Range range )
-  //{
-  //  mOrder = order;
-  //  mRange = range;
-  //}
-
-  //public QueryOptions( Range range )
-  //{
-  //  mRange = range;
-  //}
-
-  //public QueryOptions( Expression exp, Range range )
-  //{
-  //  mExp = exp;
-  //  mRange = range;
-  //}
-
   public void setExpression( Expression exp )
   {
     mExp = exp;
@@ -128,14 +103,6 @@ public Collection<MetaField> getFields()
     return mFields;
   }
 
-  //public void setWriteableOnly( boolean writeableOnly ) {
-  //  mWriteableOnly = writeableOnly;
-  //}
-
-  //public boolean getWriteableOnly() {
-  //  return mWriteableOnly;
-  //}
-
   public String toString()
   {
     return "Options{ EXP: " + getExpression() + "; ORDER: " + getSortOrder() + "; RANGE: " + getRange() + " }";

server/java/om/src/main/java/com/metaobjects/manager/exp/parser/ExpressionParser.java

@@ -2,13 +2,8 @@
 
 import java.text.DateFormat;
 
-import com.metaobjects.object.EntityMetaObject;
 import com.metaobjects.object.MetaObject;
 import com.metaobjects.field.MetaField;
-import com.metaobjects.field.DateField;
-import com.metaobjects.field.IntegerField;
-import com.metaobjects.field.LongField;
-import com.metaobjects.field.StringField;
 import com.metaobjects.manager.exp.Expression;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -264,20 +259,4 @@ protected boolean isOr( String str, int x ) {
             str.charAt( x+2 ) == '(' )) return true;
     return false;
   }
-
-  public static void main( String [] args ) throws ExpressionParseError
-  {
-    MetaObject mc = new EntityMetaObject("test");
-    MetaField a = new LongField("id");
-    MetaField b = new StringField("name");
-    MetaField c = new IntegerField("value");
-    MetaField d = new DateField("time");
-    mc.addMetaField( a );
-    mc.addMetaField( b );
-    mc.addMetaField( c );
-    mc.addMetaField( d );
-
-    Expression exp = ExpressionParser.getInstance().parse( mc, "( time > = '10/12/2006 14:55' and ( ( id = 5 or name = 'test me!' ) and value <> 20))" );
-    log.debug("EXPRESSION: {}", exp);
-  }
 }

server/java/om/src/main/java/com/metaobjects/object/managed/ManagedObject.java

@@ -14,13 +14,10 @@
 import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
 
-//import com.metaobjects.manager.*;
-
 public class ManagedObject implements Map<String, Object>, Serializable, MetaObjectAware {
 
     private static final long serialVersionUID = 6888178049723946186L;
 
-    //private static Log log = LogFactory.getLog( MetaObject.class );
     public class Value implements Serializable {
 
         private static final long serialVersionUID = 746942287755477951L;
@@ -77,21 +74,18 @@ public void setNew(boolean state) {
         }
     }
 
-    //private String mId = null;
     private final Map<String, Value> mAttributes = new ConcurrentHashMap<String, Value>();
-    
+
     private boolean mDeleted = false;
     private boolean mModified = false;
     private boolean mNew = true;
     // The MetaObject is transient, but the loader name, package name, and class name are needed
     private transient MetaObject mMetaObject = null;
     private String mLoaderName = null;
-    //private String mPackageName = null;
     private String mObjectName = null;
     private transient ObjectManager mManager = null;
 
     public ManagedObject() {
-        //mId = "";
         mNew = true;
     }
 
@@ -105,7 +99,6 @@ public ObjectManager getObjectManager() {
 
     public String getObjectRef()
     {
-        //return mId;
         try {
             return getObjectManager().getObjectRef( this ).toString();
         } catch( Exception e ) {
@@ -157,10 +150,6 @@ public String getMetaDataLoaderName() {
         return mLoaderName;
     }
 
-    //public String getMetaPackageName()
-    //{
-    //      return mPackageName;
-    //}
     public String getMetaObjectName() {
         return mObjectName;
     }
@@ -215,18 +204,6 @@ protected Value getObjectAttributeValue(String name) //throws ValueException
         }
     }
 
-    /*public Object getObjectValue( String name )
-     throws MetaException
-     {
-        return getMetaField( name ).getValue( this );
-     }
-
-     public void setObjectValue( String name, Object value )
-     throws MetaException
-     {
-        getMetaField( name ).setValue( this, value );
-     }*/
-    
     //////////////////////////////////////////////////////////////
     // PRIMITIVE SETTER VALUES
     public void setBoolean(String name, boolean value) //throws ValueException
@@ -470,15 +447,7 @@ public String toString() {
             MetaObject mc = getMetaData();
 
             b.append("[");
-            //String ref = getObjectRef();
-            //if ( ref != null )
-            //	b.append( ref );
-            //else
-            //{
-            //b.append( "{NEW}" );
-            //b.append( '@' );
             b.append(mc.getName());
-            //}
             b.append("]");
 
             boolean first = true;