fix: Address code review for SchemaParser composition

Reordered `parseBaseIfPresent` so that `primary` (the dominant
non-null TypeName) is only computed after the two implicit-shape
early-return branches (object/array keyword detection), ensuring
it is never evaluated unnecessarily.

Pinned the empty-schema → permissive ObjectSchema behaviour with a
new `parsesEmptySchemaAsPermissiveObject` test, which documents the
intentional deviation from the old NullSchema return.

Added a `parsesEmptyAllOfAsPermissiveObject` regression test to
confirm that `allOf: []` (zero assertions) falls through to the
permissive-object fallback.

Strengthened `allOfBranchesFlattenIntoOuterAllOf` with per-part
instanceof assertions and concrete minLength/maxLength constraint
checks on the flattened StringSchema parts.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: thced

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

@@ -58,17 +58,15 @@ private static Schema parseBaseIfPresent(Map<String, Object> raw) {
     if (types.isEmpty() && !hasObjectShapeKeywords(raw) && !hasArrayShapeKeywords(raw)) {
       return null;
     }
-
-    TypeName primary =
-        types.stream().filter(t -> t != TypeName.NULL).findFirst().orElse(TypeName.NULL);
-
     if (types.isEmpty() && hasObjectShapeKeywords(raw)) {
       return parseObject(raw, types);
     }
     if (types.isEmpty() && hasArrayShapeKeywords(raw)) {
       return parseArray(raw, types);
     }
 
+    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);

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

@@ -235,6 +235,27 @@ void multipleCombinatorsInOneSchemaWrapInAllOf() {
     assertThat(all.parts().get(1)).isInstanceOf(NotSchema.class);
   }
 
+  @Test
+  void parsesEmptySchemaAsPermissiveObject() {
+    // {} accepts anything that's an object; this is the JSON Schema 3.1 default
+    // and a behaviour change from the previous parser, which returned NullSchema.
+    Schema s = SchemaParser.parse(Map.of());
+    assertThat(s).isInstanceOf(ObjectSchema.class);
+    ObjectSchema obj = (ObjectSchema) s;
+    assertThat(obj.types()).isEmpty();
+    assertThat(obj.properties()).isEmpty();
+    assertThat(obj.required()).isEmpty();
+    assertThat(obj.additionalProperties()).isInstanceOf(AdditionalProperties.Allowed.class);
+  }
+
+  @Test
+  void parsesEmptyAllOfAsPermissiveObject() {
+    // allOf: [] contributes zero assertions; with no base assertion, the parser
+    // falls back to permissive object.
+    Schema s = SchemaParser.parse(Map.of("allOf", List.of()));
+    assertThat(s).isInstanceOf(ObjectSchema.class);
+  }
+
   @Test
   void allOfBranchesFlattenIntoOuterAllOf() {
     Schema s =
@@ -250,6 +271,11 @@ void allOfBranchesFlattenIntoOuterAllOf() {
     AllOfSchema all = (AllOfSchema) s;
     // Base + the two allOf branches flattened.
     assertThat(all.parts()).hasSize(3);
+    assertThat(all.parts().get(0)).isInstanceOf(StringSchema.class);
+    assertThat(all.parts().get(1)).isInstanceOf(StringSchema.class);
+    assertThat(all.parts().get(2)).isInstanceOf(StringSchema.class);
+    assertThat(((StringSchema) all.parts().get(1)).minLength()).isEqualTo(1);
+    assertThat(((StringSchema) all.parts().get(2)).maxLength()).isEqualTo(10);
   }
 
   @Test