Merge omdb-final-cleanup: TimeField round-trip + validator propagation

Two final OMDB-remediation fixes:
- DataConverter passes DataTypes.CUSTOM values through (return val) instead of
  throwing — unblocks TimeField (LocalTime). Completes the round-trip: + Types.TIME
  in SimpleMappingHandlerDB.getSQLType/getSQLLength and Derby/Postgres createTable DDL.
- MetaClassDBValidatorService.verifyMapping no longer swallows exceptions (restored
  the MetaDataException rethrow) so TableDoesNotExistException surfaces when a table
  is missing and autoCreate=false.

metadata + omdb suites green (omdb 35/35). Reviewed (spec ✅ / quality Approved) +
simplified. Follow-up note: the TimeField SQL-type hook is instanceof-specific; a
unified codec-registry SQL-type extension point would also cover ClassField (the only
other CUSTOM field, not used in OMDB DDL today) — deferred, non-blocking.

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

Author: dmealing

server/java/metadata/src/main/java/com/metaobjects/util/DataConverter.java

@@ -51,7 +51,9 @@ public static Object toType( DataTypes dataType, Object val ) {
 			case STRING_ARRAY: return toStringArray( val );
 			case OBJECT_ARRAY: return toObjectArray( val );
 
-			case CUSTOM: throw new IllegalStateException( "Cannot convert to a custom type, value passed: [" + val + "]" );
+			// Custom types are opaque to the generic converter; their JDBC binding is
+			// handled by the per-type codec (e.g. TimeCodec for TimeField/LocalTime).
+			case CUSTOM: return val;
 
 			default: throw new IllegalStateException( "Unknown type (" + dataType + "), cannot convert object [" + val + "]" );
 		}

server/java/metadata/src/test/java/com/metaobjects/util/DataConverterTests.java

@@ -1,8 +1,10 @@
 package com.metaobjects.util;
 
+import com.metaobjects.DataTypes;
 import com.metaobjects.loader.LoaderOptions;
 import org.junit.Test;
 
+import java.time.LocalTime;
 import java.util.ArrayList;
 import java.util.Date;
 import java.util.List;
@@ -329,6 +331,24 @@ public void testToStringArray() {
         assertEquals("42", numberResult.get(0));
     }
 
+    /**
+     * CUSTOM type is opaque to the generic converter; values must pass through unchanged.
+     * This allows per-type codecs (e.g. TimeCodec for TimeField) to handle their own
+     * JDBC binding without being blocked by the generic converter.
+     */
+    @Test
+    public void testCustomTypePassesThrough() {
+        LocalTime localTime = LocalTime.of(13, 45, 30);
+        Object result = DataConverter.toType(DataTypes.CUSTOM, localTime);
+        assertSame("CUSTOM type must return the exact same LocalTime instance", localTime, result);
+
+        Object arbitrary = new Object();
+        Object result2 = DataConverter.toType(DataTypes.CUSTOM, arbitrary);
+        assertSame("CUSTOM type must return the exact same Object instance", arbitrary, result2);
+
+        assertNull("CUSTOM type with null input must return null", DataConverter.toType(DataTypes.CUSTOM, null));
+    }
+
     @Test
     public void testToObjectArray() {
         // Test null input

server/java/omdb/src/main/java/com/metaobjects/manager/db/SimpleMappingHandlerDB.java

@@ -13,6 +13,7 @@
 import com.metaobjects.MetaDataException;
 
 import com.metaobjects.field.MetaField;
+import com.metaobjects.field.TimeField;
 import com.metaobjects.identity.MetaIdentity;
 import com.metaobjects.identity.PrimaryIdentity;
 import com.metaobjects.manager.ObjectManager;
@@ -266,6 +267,8 @@ protected boolean isJsonbField(MetaField mf) {
 	protected int getSQLType( MetaField mf ) {
 		// jsonb fields are stored as text (VARCHAR/CLOB) — no native jsonb on Derby
 		if (isJsonbField(mf)) return Types.VARCHAR;
+		// TimeField uses DataTypes.CUSTOM; its SQL column type is TIME.
+		if (mf instanceof TimeField) return Types.TIME;
 		switch( mf.getDataType() )
 		{
 		case BOOLEAN: return Types.BIT;
@@ -285,6 +288,8 @@ protected int getSQLType( MetaField mf ) {
 	protected int getSQLLength( MetaField mf ) {
 		// jsonb: store as CLOB (length > Derby's VARCHAR max of 32672 triggers CLOB in DerbyDriver)
 		if (isJsonbField(mf)) return 65536;
+		// TimeField uses DataTypes.CUSTOM; TIME columns have no meaningful length parameter.
+		if (mf instanceof TimeField) return 0;
 		switch( mf.getDataType() )
 		{
 			case BOOLEAN: return 1;

server/java/omdb/src/main/java/com/metaobjects/manager/db/driver/DerbyDriver.java

@@ -86,6 +86,7 @@ public void createTable(Connection c, TableDef table) throws SQLException {
                     case Types.FLOAT -> query.append("REAL");
                     case Types.DOUBLE -> query.append("DOUBLE");
                     case Types.TIMESTAMP -> query.append("TIMESTAMP");
+                    case Types.TIME -> query.append("TIME");
                     case Types.VARCHAR -> {
                         if (col.getLength() > 32700) {
                             query.append("CLOB");

server/java/omdb/src/main/java/com/metaobjects/manager/db/driver/PostgresDriver.java

@@ -89,6 +89,7 @@ public void createTable(Connection c, TableDef table) throws SQLException {
                     case Types.FLOAT -> query.append("REAL");
                     case Types.DOUBLE -> query.append("DOUBLE PRECISION");
                     case Types.TIMESTAMP -> query.append("TIMESTAMP WITH TIME ZONE");
+                    case Types.TIME -> query.append("TIME");
                     case Types.VARCHAR -> {
                         if (col.getLength() > 10485760) { // 10MB limit for VARCHAR
                             query.append("TEXT");

server/java/omdb/src/main/java/com/metaobjects/manager/db/validator/MetaClassDBValidatorService.java

@@ -180,7 +180,7 @@ private void verifyMapping(Connection c, MetaObject mc, DatabaseDriver dd, Objec
 	      }
 	  }
 	  catch( Exception e ) {
-		  //throw new MetaDataException( "Error validating mapping [" + mapping + "] for MetaClass [" + mc + "]: " + e.getMessage(), e );
+		  throw new MetaDataException( "Error validating mapping [" + mapping + "] for MetaClass [" + mc + "]: " + e.getMessage(), e );
 	  }
   }
 

server/java/omdb/src/test/java/com/metaobjects/manager/db/BulkCreateFallbackTest.java

@@ -21,6 +21,7 @@
 import javax.sql.DataSource;
 import java.io.PrintWriter;
 import java.sql.*;
+import java.time.LocalTime;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
@@ -109,6 +110,7 @@ private ValueObject sample(MetaObject mo, String label) {
         vo.setObject("amount", new java.math.BigDecimal("1.00"));
         vo.setString("label", label);
         vo.setDate("createdAt", new java.util.Date(1_700_000_000_000L));
+        vo.setObject("startTime", LocalTime.of(8, 0, 0));
         return vo;
     }
 

server/java/omdb/src/test/java/com/metaobjects/manager/db/codec/JdbcCodecRoundTripTest.java

@@ -109,6 +109,7 @@ public void primitivesRoundTripThroughCodecs() throws Exception {
             vo.setString("label", "hello-codec");
             Date created = new Date(1_700_000_000_000L);
             vo.setDate("createdAt", created);
+            vo.setObject("startTime", LocalTime.of(8, 0, 0));  // TimeCodec
 
             omdb.createObject(oc, vo);
 
@@ -136,22 +137,54 @@ public void primitivesRoundTripThroughCodecs() throws Exception {
     }
 
     /**
-     * Task 1.5 (remediation) — TimeCodec symmetry at the codec/JDBC boundary.
+     * Full OMDB end-to-end round-trip for {@code field.time} — write a {@link LocalTime}
+     * through {@code omdb.createObject} and read it back through {@code omdb.getObjects}.
      *
-     * <p>A full OMDB round-trip for {@code field.time} is blocked by a
-     * {@code MetaField}/{@code DataConverter} limitation: {@link TimeField}'s
-     * data type is {@code DataTypes.CUSTOM}, and {@code DataConverter.toType(CUSTOM, …)}
-     * throws {@code IllegalStateException}. So {@code MetaField.setObject} (which
-     * {@code TimeCodec.readInto} calls) cannot accept a {@code LocalTime} on a real
-     * TimeField. That is unrelated to the codec's correctness.
-     *
-     * <p>This test therefore drives the codec's real JDBC IO directly against an
-     * embedded-Derby {@code TIME} column: write a {@link LocalTime} via
-     * {@link JdbcCodecs.TimeCodec#write} and read it back via
-     * {@link JdbcCodecs.TimeCodec#readInto}, using a thin {@link TimeField} subclass
-     * whose {@code setObject}/{@code getObject} store the value verbatim (bypassing
-     * the unrelated CUSTOM-type {@code DataConverter} hop). This proves the codec's
-     * {@code LocalTime → java.sql.Time → LocalTime} conversion is symmetric.
+     * <p>This exercises the complete path that was previously blocked:
+     * {@code TimeCodec.readInto} → {@code MetaField.setObject} →
+     * {@code DataConverter.toType(CUSTOM, localTime)}, which now passes through
+     * unchanged instead of throwing {@code IllegalStateException}.
+     */
+    @Test
+    public void timeFieldRoundTripThroughOMDB() throws Exception {
+        MetaObject mo = registry.findMetaObjectByName("codectest::Sample");
+        assertNotNull(mo);
+
+        LocalTime original = LocalTime.of(9, 30, 0);
+
+        ObjectConnection oc = omdb.getConnection();
+        try {
+            ValueObject vo = (ValueObject) mo.newInstance();
+            // Set all NOT-NULL columns required by the CODEC_SAMPLE schema.
+            String label = "time-roundtrip-" + System.currentTimeMillis();
+            vo.setString("label", label);
+            vo.setInt("count", 1);
+            vo.setLong("bignum", 1L);
+            vo.setBoolean("active", false);
+            vo.setDouble("ratio", 0d);
+            vo.setFloat("rate", 0f);
+            vo.setObject("amount", java.math.BigDecimal.ZERO);
+            vo.setDate("createdAt", new Date(0));
+            vo.setObject("startTime", original);
+
+            omdb.createObject(oc, vo);
+
+            Collection<?> rows = omdb.getObjects(oc, mo,
+                    new QueryOptions(new Expression("label", label, Expression.EQUAL)));
+            assertEquals("exactly one row written", 1, rows.size());
+
+            ValueObject read = (ValueObject) rows.iterator().next();
+            assertEquals("TimeField LocalTime must survive full OMDB write+read round-trip",
+                    original, read.getObject("startTime"));
+        } finally {
+            omdb.releaseConnection(oc);
+        }
+    }
+
+    /**
+     * TimeCodec symmetry at the raw codec/JDBC boundary (codec unit test, not OMDB
+     * end-to-end). Uses a verbatim-storing TimeField subclass to isolate ONLY the
+     * codec's {@code LocalTime → java.sql.Time → LocalTime} JDBC conversion.
      */
     @Test
     public void timeCodecIsSymmetricAtTheJdbcBoundary() throws Exception {

server/java/omdb/src/test/java/com/metaobjects/manager/db/validator/MetaClassDBValidatorServiceTest.java

@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2026 Doug Mealing LLC. All Rights Reserved.
+ */
+package com.metaobjects.manager.db.validator;
+
+import com.metaobjects.MetaDataException;
+import com.metaobjects.loader.MetaDataLoader;
+import com.metaobjects.manager.db.ObjectManagerDB;
+import com.metaobjects.manager.db.driver.DerbyDriver;
+import com.metaobjects.manager.db.defs.TableDef;
+import com.metaobjects.registry.MetaDataLoaderRegistry;
+import com.metaobjects.registry.ServiceRegistryFactory;
+import org.junit.Test;
+
+import javax.sql.DataSource;
+import java.io.PrintWriter;
+import java.sql.*;
+import java.util.logging.Logger;
+
+import static org.junit.Assert.*;
+
+/**
+ * Unit tests for MetaClassDBValidatorService exception propagation (Fix B).
+ */
+public class MetaClassDBValidatorServiceTest {
+
+    /**
+     * When autoCreate=false and the underlying driver reports that a table does not
+     * exist, validateDefinition throws TableDoesNotExistException. Before the fix,
+     * verifyMapping silently swallowed this; after the fix it must propagate as a
+     * MetaDataException wrapping the original cause.
+     */
+    @Test
+    public void verifyMappingPropagatesTableDoesNotExistException() throws Exception {
+        MetaDataLoaderRegistry registry = new MetaDataLoaderRegistry(ServiceRegistryFactory.getDefault());
+        MetaDataLoader loader = MetaDataLoader.fromResources(
+            "test-validator", java.util.List.of("meta.fruit.json"));
+        registry.registerLoader(loader);
+
+        // A DerbyDriver subclass whose checkTable always returns false (table absent).
+        DerbyDriver absentDriver = new DerbyDriver() {
+            @Override
+            public boolean checkTable(Connection c, TableDef table) throws SQLException {
+                return false;
+            }
+        };
+
+        String dbFile = "validator-test-" + System.currentTimeMillis();
+        Class.forName("org.apache.derby.jdbc.EmbeddedDriver");
+        // Create the DB so getConnection works; we don't need actual tables.
+        DriverManager.getConnection("jdbc:derby:memory:" + dbFile + ";create=true").close();
+
+        try {
+            DataSource ds = new DataSource() {
+                @Override public Connection getConnection() throws SQLException {
+                    return DriverManager.getConnection("jdbc:derby:memory:" + dbFile + ";create=true");
+                }
+                @Override public Connection getConnection(String u, String p) throws SQLException { return getConnection(); }
+                @Override public PrintWriter getLogWriter() { return new PrintWriter(System.out); }
+                @Override public void setLogWriter(PrintWriter out) {}
+                @Override public void setLoginTimeout(int s) {}
+                @Override public int getLoginTimeout() { return 100; }
+                @Override public Logger getParentLogger() { throw new UnsupportedOperationException(); }
+                @Override public <T> T unwrap(Class<T> iface) { throw new UnsupportedOperationException(); }
+                @Override public boolean isWrapperFor(Class<?> iface) { return false; }
+            };
+
+            ObjectManagerDB omdb = new ObjectManagerDB();
+            omdb.setDatabaseDriver(absentDriver);
+            omdb.setDataSource(ds);
+            omdb.init();
+
+            MetaClassDBValidatorService vs = new MetaClassDBValidatorService();
+            vs.setObjectManager(omdb);
+            vs.setAutoCreate(false);              // must NOT auto-create: triggers the throw path
+            vs.setMetaDataLoaderRegistry(registry);
+
+            try {
+                vs.init();
+                fail("init() must throw when autoCreate=false and the table is absent; "
+                        + "verifyMapping must propagate TableDoesNotExistException, not swallow it");
+            } catch (MetaDataException e) {
+                // Expected: verifyMapping wraps and re-throws as MetaDataException.
+                assertTrue("cause chain must contain TableDoesNotExistException",
+                        isCausedBy(e, TableDoesNotExistException.class));
+            }
+        } finally {
+            // Drop the in-memory DB.
+            try { DriverManager.getConnection("jdbc:derby:memory:" + dbFile + ";drop=true"); }
+            catch (SQLNonTransientConnectionException ignored) {}
+            loader.destroy();
+        }
+    }
+
+    /** Returns true if any cause in the chain is assignable to the given type. */
+    private static boolean isCausedBy(Throwable t, Class<?> type) {
+        while (t != null) {
+            if (type.isInstance(t)) return true;
+            t = t.getCause();
+        }
+        return false;
+    }
+}

server/java/omdb/src/test/resources/meta.codec.json

@@ -68,6 +68,12 @@
                 "@column": "createdAt"
               }
             },
+            {
+              "field.time": {
+                "name": "startTime",
+                "@column": "startTime"
+              }
+            },
             {
               "identity.primary": {
                 "name": "primary",