do not support ApplyDefaults on structs (#57)

We cannot reliably apply schema defaults to structs.

We do not know if a struct field was missing in the JSON, or was present
with its zero value. In the latter case, we could overwrite a legitimate
value with a non-zero default.

Author: jba

jsonschema/validate.go

@@ -676,15 +676,16 @@ func (st *state) resolveDynamicRef(schema *Schema) (*Schema, error) {
 }
 
 // ApplyDefaults modifies an instance by applying the schema's defaults to it. If
-// a schema or sub-schema has a default, then a corresponding zero instance value
+// a schema or sub-schema has a default, then a corresponding missing instance value
 // is set to the default.
 //
 // The JSON Schema specification does not describe how defaults should be interpreted.
 // This method honors defaults only on properties, and only those that are not required.
 // If the instance is a map and the property is missing, the property is added to
 // the map with the default.
-// If the instance is a struct, the field corresponding to the property exists, and
-// its value is zero, the field is set to the default.
+// ApplyDefaults does not support structs, because it cannot know whether a field
+// is missing in the JSON, or was explicitly set to its zero value.
+//
 // ApplyDefaults can panic if a default cannot be assigned to a field.
 //
 // The argument must be a pointer to the instance.
@@ -770,57 +771,7 @@ func (st *state) applyDefaults(instancep reflect.Value, schema *Schema) (err err
 					}
 				}
 			case reflect.Struct:
-				// If there is a default for this property, and the field exists but is zero,
-				// set the field to the default.
-				if subschema.Default != nil && val.IsValid() && val.IsZero() {
-					if err := json.Unmarshal(subschema.Default, val.Addr().Interface()); err != nil {
-						return err
-					}
-					// Recurse into newly set object to apply deeper defaults.
-					if val.Kind() == reflect.Map {
-						if val.IsNil() {
-							val.Set(reflect.MakeMap(val.Type()))
-						}
-						if err := st.applyDefaults(val.Addr(), subschema); err != nil {
-							return err
-						}
-					} else if val.Kind() == reflect.Struct {
-						if err := st.applyDefaults(val.Addr(), subschema); err != nil {
-							return err
-						}
-					}
-				} else if val.IsValid() {
-					// Recurse into existing sub-instance when object-like.
-					switch val.Kind() {
-					case reflect.Map:
-						if val.IsNil() && schemaHasDefaultsInProperties(subschema) {
-							val.Set(reflect.MakeMap(val.Type()))
-						}
-						if !val.IsNil() {
-							if err := st.applyDefaults(val.Addr(), subschema); err != nil {
-								return err
-							}
-						}
-					case reflect.Struct:
-						if err := st.applyDefaults(val.Addr(), subschema); err != nil {
-							return err
-						}
-					case reflect.Pointer:
-						et := val.Type().Elem()
-						if (et.Kind() == reflect.Map || et.Kind() == reflect.Struct) && val.IsNil() && schemaHasDefaultsInProperties(subschema) {
-							nv := reflect.New(et)
-							if et.Kind() == reflect.Map {
-								nv.Elem().Set(reflect.MakeMap(et))
-							}
-							val.Set(nv)
-						}
-						if !val.IsNil() && (et.Kind() == reflect.Map || et.Kind() == reflect.Struct) {
-							if err := st.applyDefaults(val, subschema); err != nil {
-								return err
-							}
-						}
-					}
-				}
+				return errors.New("cannot apply defaults to a struct")
 			default:
 				panic(fmt.Sprintf("applyDefaults: property %s: bad value %s of kind %s",
 					prop, instance, instance.Kind()))

jsonschema/validate_test.go

@@ -160,7 +160,6 @@ func TestApplyDefaults(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	type S struct{ A, B, C int }
 	for _, tt := range []struct {
 		instancep any // pointer to instance value
 		want      any // desired value (not a pointer)
@@ -173,14 +172,6 @@ func TestApplyDefaults(t *testing.T) {
 				// "C" not added: it is required (Validate will catch that)
 			},
 		},
-		{
-			&S{B: 1},
-			S{
-				A: 1, // filled from default
-				B: 1, // untouched: non-zero
-				C: 0, // untouched: required
-			},
-		},
 	} {
 		if err := rs.ApplyDefaults(tt.instancep); err != nil {
 			t.Fatal(err)
@@ -218,14 +209,6 @@ func TestApplyNestedDefaults(t *testing.T) {
 		},
 	}
 
-	type Nested struct{ B string }
-	type Root struct{ A Nested }
-	type RootPtr struct{ A *Nested }
-	type RootMap struct{ A map[string]any }
-	type RootPtrMap struct{ A *map[string]any }
-
-	mapPtr := func(m map[string]any) *map[string]any { return &m }
-
 	for _, tc := range []struct {
 		name      string
 		schema    *Schema
@@ -264,83 +247,6 @@ func TestApplyNestedDefaults(t *testing.T) {
 			instancep: &map[string]map[string]any{},
 			want:      map[string]map[string]any{"A": {"B": "foo"}},
 		},
-		{
-			name:      "MapValueStructMissingParentTyped",
-			schema:    base,
-			instancep: &map[string]Nested{},
-			want:      map[string]Nested{"A": {B: "foo"}},
-		},
-		{
-			name:      "StructZeroValueParent",
-			schema:    base,
-			instancep: &Root{},
-			want:      Root{A: Nested{B: "foo"}},
-		},
-		{
-			name:      "StructZeroValueParentWithParentDefault",
-			schema:    withParentDefault,
-			instancep: &Root{},
-			want:      Root{A: Nested{B: "foo"}},
-		},
-		{
-			name:      "StructPointerNilParent",
-			schema:    base,
-			instancep: &RootPtr{},
-			want:      RootPtr{A: &Nested{B: "foo"}},
-		},
-		{
-			name:      "StructPresentNonzeroChildPreserved",
-			schema:    base,
-			instancep: &Root{A: Nested{B: "bar"}},
-			want:      Root{A: Nested{B: "bar"}},
-		},
-		{
-			name:      "StructPointerNonNilChildPreserved",
-			schema:    base,
-			instancep: &RootPtr{A: &Nested{B: "bar"}},
-			want:      RootPtr{A: &Nested{B: "bar"}},
-		},
-		{
-			name:      "StructMapNilParent",
-			schema:    base,
-			instancep: &RootMap{},
-			want:      RootMap{A: map[string]any{"B": "foo"}},
-		},
-		{
-			name:      "StructMapParentDefaultObjectMissing",
-			schema:    withParentDefault,
-			instancep: &RootMap{},
-			want:      RootMap{A: map[string]any{"X": float64(1), "B": "foo"}},
-		},
-		{
-			name:      "StructMapParentDefaultObjectPresent",
-			schema:    withParentDefault,
-			instancep: &RootMap{A: map[string]any{}},
-			want:      RootMap{A: map[string]any{"B": "foo"}},
-		},
-		{
-			name:      "StructPtrMapNilParent",
-			schema:    base,
-			instancep: &RootPtrMap{},
-			want:      RootPtrMap{A: mapPtr(map[string]any{"B": "foo"})},
-		},
-		{
-			name: "StructMapNilParentWithNullParentDefault",
-			schema: &Schema{
-				Type: "object",
-				Properties: map[string]*Schema{
-					"A": {
-						// Default null exercises map allocation in struct subschemas
-						Default: mustMarshal(nil),
-						Properties: map[string]*Schema{
-							"B": {Type: "string", Default: mustMarshal("foo")},
-						},
-					},
-				},
-			},
-			instancep: &RootMap{},
-			want:      RootMap{A: map[string]any{"B": "foo"}},
-		},
 	} {
 		t.Run(tc.name, func(t *testing.T) {
 			rs, err := tc.schema.Resolve(&ResolveOptions{ValidateDefaults: true})
@@ -522,7 +428,8 @@ func TestStructEmbedding(t *testing.T) {
 					},
 					Required:             []string{"id", "name", "extra"},
 					AdditionalProperties: falseSchema(),
-				}},
+				},
+			},
 			validInstance: []Banana{
 				{Apple: &Apple{ID: "foo1", Name: "Test Foo 2"}, Extra: "additional data 1"},
 				{Apple: &Apple{ID: "foo2", Name: "Test Foo 2"}, Extra: "additional data 2"},
@@ -544,7 +451,8 @@ func TestStructEmbedding(t *testing.T) {
 					},
 					Required:             []string{"id", "name", "extra"},
 					AdditionalProperties: falseSchema(),
-				}},
+				},
+			},
 			validInstance: [2]Banana{
 				{Apple: &Apple{ID: "foo1", Name: "Test Foo 2"}, Extra: "additional data 1"},
 				{Apple: &Apple{ID: "foo2", Name: "Test Foo 2"}, Extra: "additional data 2"},
@@ -564,7 +472,8 @@ func TestStructEmbedding(t *testing.T) {
 					},
 					Required:             []string{"id", "name", "extra"},
 					AdditionalProperties: falseSchema(),
-				}},
+				},
+			},
 			validInstance: []Durian{
 				{cranberry: &cranberry{ID: "foo1", Name: "Test Foo 2"}, Extra: "additional data 1"},
 				{cranberry: &cranberry{ID: "foo2", Name: "Test Foo 2"}, Extra: "additional data 2"},
@@ -584,7 +493,8 @@ func TestStructEmbedding(t *testing.T) {
 					},
 					Required:             []string{"id", "name", "extra"},
 					AdditionalProperties: falseSchema(),
-				}},
+				},
+			},
 			validInstance: []Fig{
 				{Elderberry: Elderberry{ID: "foo1", Name: "Test Foo 2"}, Extra: "additional data 1"},
 				{Elderberry: Elderberry{ID: "foo2", Name: "Test Foo 2"}, Extra: "additional data 2"},
@@ -604,7 +514,8 @@ func TestStructEmbedding(t *testing.T) {
 					},
 					Required:             []string{"id", "name", "extra"},
 					AdditionalProperties: falseSchema(),
-				}},
+				},
+			},
 			validInstance: []Honeyberry{
 				{grape: grape{ID: "foo1", Name: "Test Foo 2"}, Extra: "additional data 1"},
 				{grape: grape{ID: "foo2", Name: "Test Foo 2"}, Extra: "additional data 2"},