fix(metadata): DATE-array null-element read + pin scalar-on-array-field widening (#275)

Review fix round 1 on the #275 DATE-array storage gap fix.

Important #1: MetaObjectDeserializer's readDateElement fell through to
el.getAsString() for a JsonNull element (JsonNull is not a JsonPrimitive),
which throws UnsupportedOperationException naming no field -- the same
bare-throw shape C1 eliminated on the write side. Reachable by design:
MetaObjectSerializer deliberately emits JsonNull.INSTANCE at a null
element position (pinned by an existing test), so the serializer's own
output could not be read back by its sibling deserializer. Fixed with an
isJsonNull() guard as the first line of readDateElement, matching what
write already emits; added a full-pipeline null-element round-trip test;
corrected the readFieldValue DATE-case comment that (falsely) claimed the
branch already round-tripped end to end.

Important #2: the report's blast-radius argument conflated "no-op for a
non-array field" with "no-op for every setObject call site" --
getEffectiveDataType() == getDataType() is a property of the field, not
the value. An array-typed field receiving a scalar JSON value (live in
MetaObjectDeserializer's own else-arms) genuinely changed from a loud
InvalidValueException to a silent single-element wrap (or, for STRING, a
comma-split) -- verified both directions by temporarily reverting the E2
fix and confirming the old exception. Not a new rule: it converges with
DataObjectBase._setObjectAttribute's pre-existing effective-type
conversion, which is what produced this task's own E1 RED evidence in the
first place. Added six pinning tests and corrected the report's claim in
place.

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/io/object/gson/MetaObjectDeserializer.java

@@ -130,8 +130,10 @@ protected void readFieldValue(MetaObject mo, MetaField mf, Object vo,
                     // 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).
+                    // round-trips a date array end to end today, INCLUDING a null element (see
+                    // readDateElement's isJsonNull() guard -- required because the write side,
+                    // MetaObjectSerializer, deliberately emits JsonNull.INSTANCE at a null element
+                    // position; see GsonArrayWriteRoundTripTest's Step 3b/A6 coverage).
                     if (mf.isArrayType() && el.isJsonArray()) {
                         List<Date> dates = new ArrayList<>();
                         for (JsonElement item : el.getAsJsonArray()) {
@@ -201,8 +203,15 @@ protected void readFieldValue(MetaObject mo, MetaField mf, Object vo,
         }
     }
 
-    /** Single JSON array element of a DATE-array field: number -> epoch millis, string -> tolerant ISO parse. */
+    /** Single JSON array element of a DATE-array field: null -> null (JsonNull.getAsString()
+     * throws UnsupportedOperationException, so this must be checked before isJsonPrimitive --
+     * JsonNull is not a JsonPrimitive), number -> epoch millis, string -> tolerant ISO parse.
+     * Mirrors what MetaObjectSerializer.writeField's DATE-array branch emits at a null element
+     * position (JsonNull.INSTANCE), so a null element round-trips instead of throwing. */
     private Date readDateElement(MetaField mf, JsonElement el) {
+        if (el.isJsonNull()) {
+            return null;
+        }
         if (el.isJsonPrimitive() && el.getAsJsonPrimitive().isNumber()) {
             return new Date(el.getAsLong());
         }

server/java/metadata/src/test/java/com/metaobjects/io/object/gson/GsonArrayWriteRoundTripTest.java

@@ -346,6 +346,28 @@ public void dateArray_roundTripsThroughFullGsonPipeline() {
         Assert.assertEquals(dates, result.get("dates"));
     }
 
+    @Test
+    public void dateArray_withNullElement_roundTripsThroughFullGsonPipeline() {
+        // Review fix round 1, Important #1: the write side (MetaObjectSerializer, pinned by
+        // dateArray_withNullElement_writesJsonNullAtThatPosition above) deliberately emits
+        // JsonNull.INSTANCE at a null element position. The read side must accept what the write
+        // side produces -- readDateElement checks isJsonNull() first (JsonNull is not a
+        // JsonPrimitive, so el.getAsString() would otherwise throw
+        // UnsupportedOperationException, naming no field).
+        Gson gson = MetaObjectGsonInitializer.getBuilderWithAdapters(arrayLoader).create();
+
+        ValueObject vo = newArrayThing();
+        List<Date> dates = Arrays.asList(utc(2026, 6, 3, 0, 0, 0, 0), null);
+        vo.put("dates", dates);
+
+        String json = gson.toJson(vo);
+        Assert.assertTrue("expected a null element in the wire array, was: " + json,
+                json.contains("\"2026-06-03\"") && json.contains("null"));
+
+        ValueObject result = (ValueObject) gson.fromJson(json, ValueObject.class);
+        Assert.assertEquals(dates, result.get("dates"));
+    }
+
     @Test
     public void timestampArray_roundTripsThroughFullGsonPipeline() {
         Gson gson = MetaObjectGsonInitializer.getBuilderWithAdapters(arrayLoader).create();
@@ -454,4 +476,76 @@ public void scalarFields_serializeUnaffectedByArraySupport() {
         Assert.assertEquals("2026-06-03", obj.get("day").getAsString());
         Assert.assertEquals(new java.math.BigDecimal("19.99"), obj.get("price").getAsBigDecimal());
     }
+
+    // -----------------------------------------------------------------------
+    // Step 7 — review fix round 1, Important #2: a SCALAR JSON value (not wrapped in an array)
+    // read onto an array-typed field. Before E2, MetaField.setObject converted via the field's
+    // scalar getDataType() -- e.g. toType(STRING, "a,b") -> "a,b" identity -- and
+    // setObjectAttribute's effective-class check (List required for an isArray field) rejected
+    // it with InvalidValueException: a loud failure. After E2, setObject converts via
+    // getEffectiveDataType() (the *_ARRAY variant), so the value is coerced into a single- (or,
+    // for STRING specifically, comma-split multi-) element List and stored WITHOUT error. This is
+    // not a new behavior invented by this task: DataObjectBase._setObjectAttribute (the
+    // vo.put()/ValueObject.Map path exercised throughout this file) already converted against the
+    // effective type before this task, and is exactly what made the RED evidence in this task's
+    // report (`vo.put("dates", list)` throwing before DataConverter.toDateArray existed) possible
+    // in the first place. E2 converges MetaObjectDeserializer's setObject-based read path with
+    // that pre-existing behavior rather than introducing a new rule. Pinned here per line, not
+    // asserted in prose only, since a live JSON read path (a scalar value where an array is
+    // expected -- e.g. a legacy or hand-written payload) can reach every one of these.
+    // -----------------------------------------------------------------------
+
+    private ValueObject deserializeArrayThing(String json) {
+        Gson gson = MetaObjectGsonInitializer.getBuilderWithAdapters(arrayLoader).create();
+        return (ValueObject) gson.fromJson(json, ValueObject.class);
+    }
+
+    @Test
+    public void stringArray_scalarJsonValue_commaSplitsIntoMultiElementList() {
+        // The headline case: a bare JSON string containing a comma is not merely wrapped, it is
+        // SPLIT -- DataConverter.toStringArray's String branch treats a comma-containing string
+        // as delimited. Silent, and worth a name of its own.
+        ValueObject result = deserializeArrayThing(
+                "{\"@type\":\"test::arrays::ArrayThing\",\"tags\":\"a,b\"}");
+        Assert.assertEquals(Arrays.asList("a", "b"), result.get("tags"));
+    }
+
+    @Test
+    public void booleanArray_scalarJsonValue_wrapsAsSingleElementList() {
+        ValueObject result = deserializeArrayThing(
+                "{\"@type\":\"test::arrays::ArrayThing\",\"flags\":true}");
+        Assert.assertEquals(Arrays.asList(true), result.get("flags"));
+    }
+
+    @Test
+    public void intArray_scalarJsonValue_wrapsAsSingleElementList() {
+        ValueObject result = deserializeArrayThing(
+                "{\"@type\":\"test::arrays::ArrayThing\",\"counts\":5}");
+        Assert.assertEquals(Arrays.asList(5), result.get("counts"));
+    }
+
+    @Test
+    public void longArray_scalarJsonValue_wrapsAsSingleElementList() {
+        ValueObject result = deserializeArrayThing(
+                "{\"@type\":\"test::arrays::ArrayThing\",\"bigCounts\":10}");
+        Assert.assertEquals(Arrays.asList(10L), result.get("bigCounts"));
+    }
+
+    @Test
+    public void doubleArray_scalarJsonValue_wrapsAsSingleElementList() {
+        ValueObject result = deserializeArrayThing(
+                "{\"@type\":\"test::arrays::ArrayThing\",\"amounts\":3.5}");
+        Assert.assertEquals(Arrays.asList(3.5), result.get("amounts"));
+    }
+
+    @Test
+    public void dateArray_scalarJsonNumber_wrapsAsSingleElementList() {
+        // DATE's "scalar value on an array field" branch is reached independently of the
+        // isArrayType() check that guards BOOLEAN/INT/LONG/DOUBLE/STRING above -- the DATE case's
+        // number/string arms run whenever the element isn't a JSON array, array-typed field or
+        // not (MetaObjectDeserializer.java's DATE case, the `else if isNumber` arm).
+        ValueObject result = deserializeArrayThing(
+                "{\"@type\":\"test::arrays::ArrayThing\",\"dates\":1749000000000}");
+        Assert.assertEquals(Arrays.asList(new Date(1749000000000L)), result.get("dates"));
+    }
 }