fix(gen): allOf optional/nullable field boxing

Author: zguydev

gen/schema_gen.go

@@ -111,6 +111,10 @@ func (g *schemaGen) generate(name string, schema *jsonschema.Schema, optional bo
 	}()
 
 	schema = transformSchema(schema)
+	schema, err := flattenAllOfSchema(schema)
+	if err != nil {
+		return nil, errors.Wrap(err, "flatten allOf")
+	}
 
 	t, err := g.generate2(name, schema)
 	if err != nil {

gen/schema_gen_sum.go

@@ -1203,35 +1203,11 @@ func (g *schemaGen) oneOf(name string, schema *jsonschema.Schema, side bool) (*i
 }
 
 func (g *schemaGen) allOf(name string, schema *jsonschema.Schema) (*ir.Type, error) {
-	if err := ensureNoInfiniteRecursion(schema); err != nil {
-		return nil, err
-	}
-
-	// If there is only one schema in allOf, avoid merging to keep the reference.
-	if len(schema.AllOf) == 1 {
-		s := schema.AllOf[0]
-		if s != nil {
-			// Preserve the outer schema's Ref on the inner schema so that the
-			// type is registered under the correct reference key and can be
-			// looked up later (avoiding anonymous type name collisions).
-			if !schema.Ref.IsZero() && s.Ref.IsZero() {
-				cp := *s
-				cp.Ref = schema.Ref
-				s = &cp
-			}
-			return g.generate(name, s, false)
-		}
-	}
-
-	mergedSchema, err := mergeNSchemes(schema.AllOf)
+	mergedSchema, err := flattenAllOfSchema(schema)
 	if err != nil {
 		return nil, err
 	}
-
-	// The reference field must not change
-	mergedSchema.Ref = schema.Ref
-
-	return g.generate(name, mergedSchema, false)
+	return g.generate2(name, mergedSchema)
 }
 
 // shallowSchemaCopy returns a shallow copy of the given schema.
@@ -1247,6 +1223,57 @@ func shallowSchemaCopy(s *jsonschema.Schema) *jsonschema.Schema {
 	return &cpy
 }
 
+func flattenAllOfSchema(schema *jsonschema.Schema) (*jsonschema.Schema, error) {
+	if schema == nil || len(schema.AllOf) == 0 {
+		return schema, nil
+	}
+
+	if err := ensureNoInfiniteRecursion(schema); err != nil {
+		return nil, err
+	}
+
+	parent := shallowSchemaCopy(schema)
+	parent.AllOf = nil
+
+	// If there is only one schema in allOf, avoid merging and keep the inner schema
+	// while still applying wrapper-level metadata from the parent.
+	if len(schema.AllOf) == 1 {
+		child := shallowSchemaCopy(schema.AllOf[0])
+		if child == nil {
+			return parent, nil
+		}
+
+		child.Nullable = child.Nullable || parent.Nullable
+		if child.Type == jsonschema.Empty {
+			child.Type = parent.Type
+		}
+		if child.Ref.IsZero() {
+			child.Ref = parent.Ref
+		}
+		if _, ok := child.Position(); !ok {
+			child.Pointer = parent.Pointer
+		}
+		return child, nil
+	}
+
+	mergedSchema, err := mergeNSchemes(schema.AllOf)
+	if err != nil {
+		return nil, err
+	}
+
+	mergedSchema.Nullable = mergedSchema.Nullable || parent.Nullable
+	if mergedSchema.Type == jsonschema.Empty {
+		mergedSchema.Type = parent.Type
+	}
+	// The reference field must not change.
+	mergedSchema.Ref = parent.Ref
+	if _, ok := mergedSchema.Position(); !ok {
+		mergedSchema.Pointer = parent.Pointer
+	}
+
+	return mergedSchema, nil
+}
+
 func mergeNSchemes(ss []*jsonschema.Schema) (_ *jsonschema.Schema, err error) {
 	switch len(ss) {
 	case 0:

gen/schema_transform_test.go

@@ -355,6 +355,33 @@ func TestNullableOneOf_Optionality(t *testing.T) {
 		assertOptionalNullableGeneric(t, optionalField.Type, ir.KindPrimitive)
 	})
 
+	t.Run("optional nullable allOf field", func(t *testing.T) {
+		a := require.New(t)
+		s := createTestSchemaGen(nil)
+
+		nullableStringAllOf := &jsonschema.Schema{
+			AllOf: []*jsonschema.Schema{
+				createPrimitiveSchema(jsonschema.String),
+				{Nullable: true},
+			},
+		}
+
+		optionalSchema := createObjectSchema(
+			createProperty("optionalNullable", nullableStringAllOf, false),
+		)
+		optionalResult, err := s.generate("WithOptionalAllOf", optionalSchema, false)
+
+		a.NoError(err)
+		a.NotNil(optionalResult)
+		a.Equal(ir.KindStruct, optionalResult.Kind)
+		a.Len(optionalResult.Fields, 1)
+
+		optionalField := optionalResult.Fields[0]
+		a.Equal("OptionalNullable", optionalField.Name)
+		assertOptionalNullableGeneric(t, optionalField.Type, ir.KindPrimitive)
+		a.Equal(ir.String, optionalField.Type.GenericOf.Primitive)
+	})
+
 	t.Run("field in optional object", func(t *testing.T) {
 		a := require.New(t)
 		s := createTestSchemaGen(nil)