fix(metadata): close the DATE-array storage gap left by #275

Two root defects in the JSON array-write storage path, deliberately left
unfixed by the #275 batch as out-of-scope scope-creep triggers:

- MetaField.setObject(Object,Object) converted via the field's SCALAR
  getDataType() instead of the array-aware getEffectiveDataType(), so an
  isArray field's List value was corrupted (comma-joined / bracketed
  toString()) before setObjectAttribute's own instanceof check rejected it.
  Broke setBoolean/setInt/setLong/setDouble/setStringArray, and every
  MetaObjectDeserializer array-read branch that routes through it.
- DataConverter had no DATE_ARRAY case (the commented-out
  `//toDateArray(val)` fragment), so no entry point could store a
  List<Date> on an isArray field.date/field.timestamp field.

Fix: getEffectiveDataType() in MetaField.setObject (a strict no-op for
every non-array field); a new DataConverter.toDateArray mirroring the
sibling toLongArray/toBooleanArray shape, wired into case DATE_ARRAY.
BYTE_ARRAY/SHORT_ARRAY stay on the unsupported arm (field.byte/field.short
are non-functional stubs).

Also closes the deferred findings this unblocked: MetaObjectSerializer's
DATE-array element loop now converts via DataConverter.toDate(o) instead
of a hard cast; field.timestamp (incl. @localTime) array coverage; a
full-Gson-pipeline round trip for the previously-untestable DATE-array
read path in MetaObjectDeserializer; null-array-itself pins extended to
every touched type; and a stale MetaObjectDeserializer comment describing
the DATE-array branch as blocked, now rewritten to match reality.

Blast-radius checked: every MetaField.setObject caller either passes a
scalar value (no-op under the fix) or already routed around the array bug
via setObjectArray/setValue; no caller depended on the corrupting
conversion succeeding.

Refs #275

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015TqsuDye2SfXGf43vuoD3n

Author: dmealing

server/java/metadata/src/main/java/com/metaobjects/field/MetaField.java

@@ -1089,7 +1089,11 @@ public void setDate(Object obj, Date value) {
     }
 
     public void setObject(Object obj, Object value) {
-        setObjectAttribute(obj, DataConverter.toType(getDataType(), value ));
+        // ADR-0039: use the RESOLVING, array-aware getEffectiveDataType() -- the field's SCALAR
+        // getDataType() corrupted a List for an isArray field (e.g. comma-joining a STRING array
+        // into a single string) before setObjectAttribute's own instanceof check rejected it.
+        // getEffectiveDataType() is a strict no-op for every non-array field (#275 carry-forward).
+        setObjectAttribute(obj, DataConverter.toType(getEffectiveDataType(), value ));
     }
 
     public void setObjectArray(Object obj, List<?> value) {

server/java/metadata/src/main/java/com/metaobjects/io/object/gson/MetaObjectDeserializer.java

@@ -126,14 +126,12 @@ protected void readFieldValue(MetaObject mo, MetaField mf, Object vo,
                     // nothing that parsed before stops parsing). String -> tolerant ISO parse
                     // (TemporalWireFormat). Array: element-wise into a List<Date> via
                     // setObjectArray, skipping context.deserialize(el, List.class), which yields a
-                    // type-losing List<Double>. setObjectArray only bypasses MetaField's OWN
-                    // DataConverter.toType call; setObjectAttribute still routes through
-                    // AbstractObjectRepresentation.setValue, which unconditionally applies
-                    // DataConverter.toType(effectiveDataType, value) -- and DataConverter's
-                    // DATE_ARRAY case is unimplemented (unsupported()). So today this branch
-                    // throws UnsupportedOperationException for a non-empty date array on the
-                    // default (non-proxy) representation path; it becomes correct once
-                    // DataConverter grows a DATE_ARRAY conversion.
+                    // type-losing List<Double>. setObjectArray routes through
+                    // AbstractObjectRepresentation.setValue, which applies
+                    // DataConverter.toType(effectiveDataType, value) -- backed, since the #275
+                    // carry-forward unit, by DataConverter.toDateArray. This branch genuinely
+                    // round-trips a date array end to end today (see
+                    // GsonArrayWriteRoundTripTest's Step 3b/A6 coverage).
                     if (mf.isArrayType() && el.isJsonArray()) {
                         List<Date> dates = new ArrayList<>();
                         for (JsonElement item : el.getAsJsonArray()) {

server/java/metadata/src/main/java/com/metaobjects/io/object/gson/MetaObjectSerializer.java

@@ -8,6 +8,7 @@
 import com.metaobjects.loader.MetaDataLoader;
 import com.metaobjects.object.MetaObject;
 import com.metaobjects.object.MetaObjectAware;
+import com.metaobjects.util.DataConverter;
 import com.google.gson.*;
 
 import static com.metaobjects.io.json.JsonIOUtil.*;
@@ -94,7 +95,13 @@ protected void writeField(MetaObject mo, MetaField mf, Object vo,
                     } else {
                         JsonArray arr = new JsonArray();
                         for (Object o : dates) {
-                            java.util.Date d = (java.util.Date) o;
+                            // C1: route through the shared DataConverter.toDate(Object) rather
+                            // than a hard (Date) cast -- matches the non-array DATE branch below
+                            // (mf.getDate(vo) is itself backed by DataConverter.toDate), and
+                            // accepts the same scalar inputs that converter always has, instead
+                            // of throwing a bare ClassCastException for anything not already a
+                            // java.util.Date.
+                            java.util.Date d = DataConverter.toDate(o);
                             if (d == null) arr.add(JsonNull.INSTANCE);
                             else arr.add(TemporalWireFormat.format(mf, d));
                         }

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

@@ -47,9 +47,9 @@ public static Object toType( DataTypes dataType, Object val ) {
 
 			case BYTE_ARRAY://return toByteArray( val );
 			case SHORT_ARRAY: //return toShortArray( val );
-			case DATE_ARRAY: //toDateArray( val );
 				return unsupported(dataType,val);
 
+			case DATE_ARRAY: return toDateArray( val );
 			case STRING_ARRAY: return toStringArray( val );
 			case OBJECT_ARRAY: return toObjectArray( val );
 
@@ -755,6 +755,33 @@ public static List<Boolean> toBooleanArray(Object val) {
 		}
 	}
 
+	/**
+	 * Convert value to Date array (List&lt;Date&gt;)
+	 */
+	public static List<Date> toDateArray(Object val) {
+		if (val == null) return null;
+
+		if (val instanceof List<?>) {
+			List<?> list = (List<?>) val;
+			return list.stream()
+				.map(DataConverter::toDate)
+				.collect(java.util.stream.Collectors.toList());
+		} else if (val instanceof String) {
+			String s = (String) val;
+			if (s.trim().isEmpty()) return new java.util.ArrayList<>();
+
+			if (s.contains(",")) {
+				return java.util.Arrays.stream(s.split(","))
+					.map(item -> toDate(item.trim()))
+					.collect(java.util.stream.Collectors.toList());
+			} else {
+				return java.util.Arrays.asList(toDate(s.trim()));
+			}
+		} else {
+			return java.util.Arrays.asList(toDate(val));
+		}
+	}
+
 	/**
 	 * Convert value to Double array (List&lt;Double&gt;)
 	 */