feat(schema): SchemaParser handles objects (with additionalProperties) and arrays

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: thced

src/main/java/com/retailsvc/http/spec/schema/SchemaParser.java

@@ -1,6 +1,7 @@
 package com.retailsvc.http.spec.schema;
 
 import java.util.EnumSet;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -26,8 +27,8 @@ public static Schema parse(Map<String, Object> raw) {
       case NUMBER -> parseNumber(raw, types);
       case BOOLEAN -> new BooleanSchema(types);
       case NULL -> new NullSchema();
-      case OBJECT, ARRAY ->
-          throw new UnsupportedOperationException("object/array parsing comes in C2");
+      case OBJECT -> parseObject(raw, types);
+      case ARRAY -> parseArray(raw, types);
     };
   }
 
@@ -80,6 +81,47 @@ private static NumberSchema parseNumber(Map<String, Object> raw, Set<TypeName> t
         (String) raw.get("format"));
   }
 
+  @SuppressWarnings("unchecked")
+  private static ObjectSchema parseObject(Map<String, Object> raw, Set<TypeName> types) {
+    Map<String, Object> rawProps = (Map<String, Object>) raw.getOrDefault("properties", Map.of());
+    Map<String, Schema> properties = new LinkedHashMap<>();
+    for (var e : rawProps.entrySet()) {
+      properties.put(e.getKey(), parse((Map<String, Object>) e.getValue()));
+    }
+    List<String> required = (List<String>) raw.getOrDefault("required", List.of());
+    AdditionalProperties ap = parseAdditionalProperties(raw.get("additionalProperties"));
+    return new ObjectSchema(
+        types,
+        Map.copyOf(properties),
+        List.copyOf(required),
+        ap,
+        toIntOrNull(raw.get("minProperties")),
+        toIntOrNull(raw.get("maxProperties")));
+  }
+
+  @SuppressWarnings("unchecked")
+  private static AdditionalProperties parseAdditionalProperties(Object value) {
+    if (value == null || Boolean.TRUE.equals(value)) {
+      return new AdditionalProperties.Allowed();
+    }
+    if (Boolean.FALSE.equals(value)) {
+      return new AdditionalProperties.Forbidden();
+    }
+    return new AdditionalProperties.SchemaConstraint(parse((Map<String, Object>) value));
+  }
+
+  @SuppressWarnings("unchecked")
+  private static ArraySchema parseArray(Map<String, Object> raw, Set<TypeName> types) {
+    Map<String, Object> items = (Map<String, Object>) raw.getOrDefault("items", Map.of());
+    Schema itemSchema = items.isEmpty() ? new NullSchema() : parse(items);
+    return new ArraySchema(
+        types,
+        itemSchema,
+        toIntOrNull(raw.get("minItems")),
+        toIntOrNull(raw.get("maxItems")),
+        Boolean.TRUE.equals(raw.get("uniqueItems")));
+  }
+
   private static Integer toIntOrNull(Object v) {
     return v == null ? null : ((Number) v).intValue();
   }

src/test/java/com/retailsvc/http/spec/schema/SchemaParserTest.java

@@ -60,4 +60,51 @@ void parsesLegacyNullableTrueAsTypeUnion() {
     Schema s = SchemaParser.parse(Map.of("type", "string", "nullable", true));
     assertThat(s.types()).containsExactlyInAnyOrder(TypeName.STRING, TypeName.NULL);
   }
+
+  @Test
+  void parsesObjectWithRequiredAndProperties() {
+    Map<String, Object> raw =
+        Map.of(
+            "type", "object",
+            "required", List.of("name"),
+            "properties", Map.of("name", Map.of("type", "string")));
+    ObjectSchema o = (ObjectSchema) SchemaParser.parse(raw);
+    assertThat(o.required()).containsExactly("name");
+    assertThat(o.properties()).containsKey("name");
+    assertThat(o.properties().get("name")).isInstanceOf(StringSchema.class);
+    assertThat(o.additionalProperties()).isInstanceOf(AdditionalProperties.Allowed.class);
+  }
+
+  @Test
+  void parsesObjectWithAdditionalPropertiesFalse() {
+    Map<String, Object> raw = Map.of("type", "object", "additionalProperties", false);
+    ObjectSchema o = (ObjectSchema) SchemaParser.parse(raw);
+    assertThat(o.additionalProperties()).isInstanceOf(AdditionalProperties.Forbidden.class);
+  }
+
+  @Test
+  void parsesObjectWithAdditionalPropertiesSchema() {
+    Map<String, Object> raw =
+        Map.of("type", "object", "additionalProperties", Map.of("type", "string"));
+    ObjectSchema o = (ObjectSchema) SchemaParser.parse(raw);
+    assertThat(o.additionalProperties()).isInstanceOf(AdditionalProperties.SchemaConstraint.class);
+  }
+
+  @Test
+  void parsesArrayWithItems() {
+    Map<String, Object> raw =
+        Map.of(
+            "type",
+            "array",
+            "items",
+            Map.of("type", "integer"),
+            "minItems",
+            1,
+            "uniqueItems",
+            true);
+    ArraySchema a = (ArraySchema) SchemaParser.parse(raw);
+    assertThat(a.items()).isInstanceOf(IntegerSchema.class);
+    assertThat(a.minItems()).isEqualTo(1);
+    assertThat(a.uniqueItems()).isTrue();
+  }
 }