jsonschema: handle embedding of custom schemas (#32)

When a type with a custom schema is embedded, honor its customization by taking (a clone of) its custom properties.

For now, disallow any keyword on the embedded struct other than "type" and "properties". It's unclear how other keywords should be treated.

Fixes #17.

Author: jba

jsonschema/infer.go

@@ -221,11 +221,63 @@ func forType(t reflect.Type, seen map[reflect.Type]bool, ignore bool, schemas ma
 		s.Type = "object"
 		// no additional properties are allowed
 		s.AdditionalProperties = falseSchema()
+
+		// If skipPath is non-nil, it is path to an anonymous field whose
+		// schema has been replaced by a known schema.
+		var skipPath []int
 		for _, field := range reflect.VisibleFields(t) {
 			if field.Anonymous {
+				override := schemas[field.Type]
+				if override != nil {
+					// Type must be object, and only properties can be set.
+					if override.Type != "object" {
+						return nil, fmt.Errorf(`custom schema for embedded struct must have type "object", got %q`,
+							override.Type)
+					}
+					// Check that all keywords relevant for objects are absent, except properties.
+					ov := reflect.ValueOf(override).Elem()
+					for _, sfi := range schemaFieldInfos {
+						if sfi.sf.Name == "Type" || sfi.sf.Name == "Properties" {
+							continue
+						}
+						fv := ov.FieldByIndex(sfi.sf.Index)
+						if !fv.IsZero() {
+							return nil, fmt.Errorf(`overrides for embedded fields can have only "Type" and "Properties"; this has %q`, sfi.sf.Name)
+						}
+					}
+
+					skipPath = field.Index
+					for name, prop := range override.Properties {
+						s.Properties[name] = prop.CloneSchemas()
+					}
+				}
 				continue
 			}
 
+			// Check to see if this field has been promoted from a replaced anonymous
+			// type.
+			if skipPath != nil {
+				skip := false
+				if len(field.Index) >= len(skipPath) {
+					skip = true
+					for i, index := range skipPath {
+						if field.Index[i] != index {
+							// If we're no longer in a subfield.
+							skip = false
+							break
+						}
+					}
+				}
+				if skip {
+					continue
+				} else {
+					// Anonymous fields are followed immediately by their promoted fields.
+					// Once we encounter a field that *isn't* promoted, we can stop
+					// checking.
+					skipPath = nil
+				}
+			}
+
 			info := fieldJSONInfo(field)
 			if info.omit {
 				continue

jsonschema/infer_test.go

@@ -212,20 +212,34 @@ func TestFor(t *testing.T) {
 }
 
 func TestForType(t *testing.T) {
+	// This tests embedded structs with a custom schema in addition to ForType.
 	type schema = jsonschema.Schema
 
-	// ForType is virtually identical to For. Just test that options are handled properly.
-	opts := &jsonschema.ForOptions{
-		IgnoreInvalidTypes: true,
-		TypeSchemas: map[reflect.Type]*jsonschema.Schema{
-			reflect.TypeFor[custom](): {Type: "custom"},
-		},
+	type E struct {
+		G float64 // promoted into S
+		B int     // hidden by S.B
 	}
 
 	type S struct {
 		I int
 		F func()
 		C custom
+		E
+		B bool
+	}
+
+	opts := &jsonschema.ForOptions{
+		IgnoreInvalidTypes: true,
+		TypeSchemas: map[reflect.Type]*schema{
+			reflect.TypeFor[custom](): {Type: "custom"},
+			reflect.TypeFor[E](): {
+				Type: "object",
+				Properties: map[string]*schema{
+					"G": {Type: "integer"},
+					"B": {Type: "integer"},
+				},
+			},
+		},
 	}
 	got, err := jsonschema.ForType(reflect.TypeOf(S{}), opts)
 	if err != nil {
@@ -236,15 +250,80 @@ func TestForType(t *testing.T) {
 		Properties: map[string]*schema{
 			"I": {Type: "integer"},
 			"C": {Type: "custom"},
+			"G": {Type: "integer"},
+			"B": {Type: "boolean"},
 		},
-		Required:             []string{"I", "C"},
+		Required:             []string{"I", "C", "B"},
 		AdditionalProperties: falseSchema(),
 	}
 	if diff := cmp.Diff(want, got, cmpopts.IgnoreUnexported(schema{})); diff != "" {
 		t.Fatalf("ForType mismatch (-want +got):\n%s", diff)
 	}
 }
 
+func TestCustomEmbeddedError(t *testing.T) {
+	// Disallow anything but "type" and "properties".
+	type schema = jsonschema.Schema
+
+	type (
+		E struct{ G int }
+		S struct{ E }
+	)
+
+	for _, tt := range []struct {
+		name     string
+		override *schema
+	}{
+		{
+			"missing type",
+			&schema{},
+		},
+		{
+			"wrong type",
+			&schema{Type: "number"},
+		},
+		{
+			"extra string field",
+			&schema{
+				Type:  "object",
+				Title: "t",
+			},
+		},
+		{
+			"extra pointer field",
+			&schema{
+				Type:          "object",
+				MinProperties: jsonschema.Ptr(1),
+			},
+		},
+		{
+			"extra array field",
+			&schema{
+				Type:     "object",
+				Required: []string{"G"},
+			},
+		},
+		{
+			"extra schema field",
+			&schema{
+				Type:                 "object",
+				AdditionalProperties: falseSchema(),
+			},
+		},
+	} {
+		t.Run(tt.name, func(t *testing.T) {
+			opts := &jsonschema.ForOptions{
+				TypeSchemas: map[reflect.Type]*schema{
+					reflect.TypeFor[E](): tt.override,
+				},
+			}
+			if _, err := jsonschema.ForType(reflect.TypeOf(S{}), opts); err == nil {
+				t.Error("got nil, want error")
+			}
+		})
+	}
+}
+
 func forErr[T any]() error {
 	_, err := jsonschema.For[T](nil)
 	return err