feat(schema): SchemaParser handles primitives, refs, nullable forms

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

Author: thced

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

@@ -0,0 +1,90 @@
+package com.retailsvc.http.spec.schema;
+
+import java.util.EnumSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+public final class SchemaParser {
+  private SchemaParser() {}
+
+  @SuppressWarnings("unchecked")
+  public static Schema parse(Map<String, Object> raw) {
+    if (raw.containsKey("$ref")) {
+      return new RefSchema((String) raw.get("$ref"));
+    }
+
+    Set<TypeName> types = parseTypes(raw);
+
+    // Pick primary (non-null) type for record dispatch.
+    TypeName primary =
+        types.stream().filter(t -> t != TypeName.NULL).findFirst().orElse(TypeName.NULL);
+
+    return switch (primary) {
+      case STRING -> parseString(raw, types);
+      case INTEGER -> parseInteger(raw, types);
+      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");
+    };
+  }
+
+  private static Set<TypeName> parseTypes(Map<String, Object> raw) {
+    Object t = raw.get("type");
+    EnumSet<TypeName> out = EnumSet.noneOf(TypeName.class);
+    if (t instanceof String s) {
+      out.add(TypeName.fromJsonSchema(s));
+    } else if (t instanceof List<?> list) {
+      for (Object name : list) {
+        out.add(TypeName.fromJsonSchema((String) name));
+      }
+    }
+    if (Boolean.TRUE.equals(raw.get("nullable"))) {
+      out.add(TypeName.NULL);
+    }
+    return out;
+  }
+
+  @SuppressWarnings("unchecked")
+  private static StringSchema parseString(Map<String, Object> raw, Set<TypeName> types) {
+    return new StringSchema(
+        types,
+        (String) raw.get("pattern"),
+        toIntOrNull(raw.get("minLength")),
+        toIntOrNull(raw.get("maxLength")),
+        (String) raw.get("format"),
+        (List<String>) raw.get("enum"));
+  }
+
+  private static IntegerSchema parseInteger(Map<String, Object> raw, Set<TypeName> types) {
+    return new IntegerSchema(
+        types,
+        toLongOrNull(raw.get("minimum")),
+        toLongOrNull(raw.get("maximum")),
+        toLongOrNull(raw.get("exclusiveMinimum")),
+        toLongOrNull(raw.get("exclusiveMaximum")),
+        toLongOrNull(raw.get("multipleOf")),
+        (String) raw.get("format"));
+  }
+
+  private static NumberSchema parseNumber(Map<String, Object> raw, Set<TypeName> types) {
+    return new NumberSchema(
+        types,
+        (Number) raw.get("minimum"),
+        (Number) raw.get("maximum"),
+        (Number) raw.get("exclusiveMinimum"),
+        (Number) raw.get("exclusiveMaximum"),
+        (Number) raw.get("multipleOf"),
+        (String) raw.get("format"));
+  }
+
+  private static Integer toIntOrNull(Object v) {
+    return v == null ? null : ((Number) v).intValue();
+  }
+
+  private static Long toLongOrNull(Object v) {
+    return v == null ? null : ((Number) v).longValue();
+  }
+}

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

@@ -0,0 +1,63 @@
+package com.retailsvc.http.spec.schema;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.List;
+import java.util.Map;
+import org.junit.jupiter.api.Test;
+
+class SchemaParserTest {
+  @Test
+  void parsesString() {
+    Schema s = SchemaParser.parse(Map.of("type", "string", "minLength", 1, "maxLength", 64));
+    assertThat(s).isInstanceOf(StringSchema.class);
+    StringSchema str = (StringSchema) s;
+    assertThat(str.minLength()).isEqualTo(1);
+    assertThat(str.maxLength()).isEqualTo(64);
+  }
+
+  @Test
+  void parsesIntegerWithFormat() {
+    Schema s = SchemaParser.parse(Map.of("type", "integer", "format", "int64", "minimum", 0));
+    assertThat(s).isInstanceOf(IntegerSchema.class);
+    assertThat(((IntegerSchema) s).format()).isEqualTo("int64");
+    assertThat(((IntegerSchema) s).minimum()).isEqualTo(0L);
+  }
+
+  @Test
+  void parsesNumber() {
+    Schema s = SchemaParser.parse(Map.of("type", "number", "multipleOf", 0.5));
+    assertThat(s).isInstanceOf(NumberSchema.class);
+    assertThat(((NumberSchema) s).multipleOf()).isEqualTo(0.5);
+  }
+
+  @Test
+  void parsesBoolean() {
+    assertThat(SchemaParser.parse(Map.of("type", "boolean"))).isInstanceOf(BooleanSchema.class);
+  }
+
+  @Test
+  void parsesNull() {
+    assertThat(SchemaParser.parse(Map.of("type", "null"))).isInstanceOf(NullSchema.class);
+  }
+
+  @Test
+  void parsesRef() {
+    Schema s = SchemaParser.parse(Map.of("$ref", "#/components/schemas/User"));
+    assertThat(s).isInstanceOf(RefSchema.class);
+    assertThat(((RefSchema) s).pointer()).isEqualTo("#/components/schemas/User");
+  }
+
+  @Test
+  void parsesTypeArrayWithNullForNullable() {
+    Schema s = SchemaParser.parse(Map.of("type", List.of("string", "null")));
+    assertThat(s).isInstanceOf(StringSchema.class);
+    assertThat(s.types()).containsExactlyInAnyOrder(TypeName.STRING, TypeName.NULL);
+  }
+
+  @Test
+  void parsesLegacyNullableTrueAsTypeUnion() {
+    Schema s = SchemaParser.parse(Map.of("type", "string", "nullable", true));
+    assertThat(s.types()).containsExactlyInAnyOrder(TypeName.STRING, TypeName.NULL);
+  }
+}