feat(schema): SchemaParser handles combinators, const, top-level enum

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

Author: thced

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

@@ -1,5 +1,6 @@
 package com.retailsvc.http.spec.schema;
 
+import java.util.ArrayList;
 import java.util.EnumSet;
 import java.util.LinkedHashMap;
 import java.util.List;
@@ -15,6 +16,15 @@ public static Schema parse(Map<String, Object> raw) {
       return new RefSchema((String) raw.get("$ref"));
     }
 
+    if (raw.containsKey("oneOf")) return new OneOfSchema(parseList(raw, "oneOf"));
+    if (raw.containsKey("anyOf")) return new AnyOfSchema(parseList(raw, "anyOf"));
+    if (raw.containsKey("allOf")) return new AllOfSchema(parseList(raw, "allOf"));
+    if (raw.containsKey("not")) return new NotSchema(parse((Map<String, Object>) raw.get("not")));
+    if (raw.containsKey("const")) return new ConstSchema(raw.get("const"));
+    if (raw.containsKey("enum") && !raw.containsKey("type")) {
+      return new EnumSchema(List.copyOf((List<Object>) raw.get("enum")));
+    }
+
     Set<TypeName> types = parseTypes(raw);
 
     // Pick primary (non-null) type for record dispatch.
@@ -122,6 +132,14 @@ private static ArraySchema parseArray(Map<String, Object> raw, Set<TypeName> typ
         Boolean.TRUE.equals(raw.get("uniqueItems")));
   }
 
+  @SuppressWarnings("unchecked")
+  private static List<Schema> parseList(Map<String, Object> raw, String key) {
+    List<Map<String, Object>> raws = (List<Map<String, Object>>) raw.get(key);
+    List<Schema> out = new ArrayList<>(raws.size());
+    for (Map<String, Object> r : raws) out.add(parse(r));
+    return List.copyOf(out);
+  }
+
   private static Integer toIntOrNull(Object v) {
     return v == null ? null : ((Number) v).intValue();
   }

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

@@ -107,4 +107,43 @@ void parsesArrayWithItems() {
     assertThat(a.minItems()).isEqualTo(1);
     assertThat(a.uniqueItems()).isTrue();
   }
+
+  @Test
+  void parsesOneOf() {
+    Map<String, Object> raw =
+        Map.of("oneOf", List.of(Map.of("type", "string"), Map.of("type", "integer")));
+    OneOfSchema o = (OneOfSchema) SchemaParser.parse(raw);
+    assertThat(o.options()).hasSize(2);
+    assertThat(o.options().get(0)).isInstanceOf(StringSchema.class);
+  }
+
+  @Test
+  void parsesAnyOfAllOfNot() {
+    assertThat(SchemaParser.parse(Map.of("anyOf", List.of(Map.of("type", "string")))))
+        .isInstanceOf(AnyOfSchema.class);
+    assertThat(SchemaParser.parse(Map.of("allOf", List.of(Map.of("type", "string")))))
+        .isInstanceOf(AllOfSchema.class);
+    assertThat(SchemaParser.parse(Map.of("not", Map.of("type", "null"))))
+        .isInstanceOf(NotSchema.class);
+  }
+
+  @Test
+  void parsesConst() {
+    assertThat(SchemaParser.parse(Map.of("const", 42))).isInstanceOf(ConstSchema.class);
+    assertThat(((ConstSchema) SchemaParser.parse(Map.of("const", "a"))).value()).isEqualTo("a");
+  }
+
+  @Test
+  void parsesTopLevelEnumWithoutType() {
+    Schema s = SchemaParser.parse(Map.of("enum", List.of(1, 2, 3)));
+    assertThat(s).isInstanceOf(EnumSchema.class);
+    assertThat(((EnumSchema) s).values()).containsExactly(1, 2, 3);
+  }
+
+  @Test
+  void enumOnStringStaysAsStringSchema() {
+    Schema s = SchemaParser.parse(Map.of("type", "string", "enum", List.of("a", "b")));
+    assertThat(s).isInstanceOf(StringSchema.class);
+    assertThat(((StringSchema) s).enumValues()).containsExactly("a", "b");
+  }
 }