fix: gogen jsonschema number and nullable handling (#13)

Author: matthewgetz

gogen.go

@@ -52,6 +52,13 @@ func WithGoHeaderComment(text string) GoOption {
 // GoGenerator to render many schemas with the same options; option parsing
 // happens once at construction. It is the inverse of [Generator], which
 // produces a schema from a Go type.
+//
+// Nullability is presence: a scalar whose type union admits null
+// ("type": ["number", "null"]) — or the two-branch anyOf form
+// [WithGenerateNullablePointers] emits for a Go pointer — generates a
+// pointer field (*float64), so an absent or null value is distinguishable
+// from the zero value. Requiredness never strips the pointer (null is a
+// legal value); containers stay bare (nil is already their absent state).
 type GoGenerator struct {
 	opts goOptions
 }
@@ -229,15 +236,22 @@ func (b *goBuilder) goType(sch map[string]any, hint string) (string, bool) {
 		b.defineType(hint, stringOf(sch["description"]), sch)
 		return hint, true
 	}
+	if inner, ok := nullableAnyOf(sch); ok {
+		typ, _ := b.goType(inner, hint)
+		if strings.HasPrefix(typ, "*") || typ == "any" {
+			return typ, false
+		}
+		return "*" + typ, false
+	}
 	switch typeName(sch) {
 	case "string":
-		return "string", false
+		return nullable(sch, "string"), false
 	case "integer":
-		return "int", false
+		return nullable(sch, "int"), false
 	case "number":
-		return "float64", false
+		return nullable(sch, "float64"), false
 	case "boolean":
-		return "bool", false
+		return nullable(sch, "bool"), false
 	case "array":
 		return "[]" + b.elemType(sch, hint), false
 	case "object":
@@ -347,7 +361,8 @@ func definitions(root map[string]any) map[string]any {
 }
 
 // typeName returns the schema's "type" as a single name. A type array such
-// as ["string","null"] resolves to its sole non-null member; a union of
+// as ["string","null"] resolves to its sole non-null member (see nullableType
+// for how that nullability reaches the generated Go type); a union of
 // several concrete types resolves to the empty string (meaning "any").
 func typeName(sch map[string]any) string {
 	switch t := sch["type"].(type) {
@@ -371,6 +386,48 @@ func typeName(sch map[string]any) string {
 	}
 }
 
+// nullableAnyOf detects the two-branch nullable union [WithGenerateNullablePointers]
+// emits for a Go pointer — anyOf: [{"type":"null"}, <inner>] in either order —
+// and returns the non-null branch. It is the round-trip inverse of that
+// option: a schema generated FROM *T regenerates *T.
+func nullableAnyOf(sch map[string]any) (map[string]any, bool) {
+	anyOf, ok := sch["anyOf"].([]any)
+	if !ok || len(anyOf) != 2 {
+		return nil, false
+	}
+	isNull := func(v any) bool {
+		m := mapOf(v)
+		return len(m) == 1 && stringOf(m["type"]) == "null"
+	}
+	switch {
+	case isNull(anyOf[0]):
+		return mapOf(anyOf[1]), true
+	case isNull(anyOf[1]):
+		return mapOf(anyOf[0]), true
+	}
+	return nil, false
+}
+
+// nullable wraps a scalar Go type in a pointer when the schema's type union
+// admits null — `"type": ["number", "null"]` generates *float64, so an absent
+// (or explicitly null) value is distinguishable from the zero value (the
+// anyOf form is nullableAnyOf's job). This is the presence-carrying mapping
+// for keywords whose zero is meaningful (a declared `minimum: 0` versus no
+// minimum at all). Containers are exempt: slices and maps already have an
+// absent state (nil).
+func nullable(sch map[string]any, goType string) string {
+	types, ok := sch["type"].([]any)
+	if !ok {
+		return goType
+	}
+	for _, e := range types {
+		if s, _ := e.(string); s == "null" {
+			return "*" + goType
+		}
+	}
+	return goType
+}
+
 // enumType infers a Go type from an enum or const value when no explicit
 // type keyword is present. It returns the empty string when neither applies.
 func enumType(sch map[string]any) string {

gogen_test.go

@@ -1,6 +1,7 @@
 package jsonschema_test
 
 import (
+	"encoding/json"
 	"fmt"
 	"go/ast"
 	"go/parser"
@@ -234,10 +235,28 @@ func TestGenerateGo_typeMatrix(t *testing.T) {
 		{"const_string", `{"const":"x"}`, "string"},
 		{"const_bool", `{"const":true}`, "bool"},
 
-		// Type unions.
-		{"nullable_string", `{"type":["string","null"]}`, "string"},
+		// Type unions. A scalar + null union is the presence-carrying mapping:
+		// the pointer distinguishes "absent (or null)" from the zero value —
+		// the contract keywords like a spec's `minimum` rely on (0 declared
+		// vs no bound at all). Containers stay bare: nil is already absence.
+		{"nullable_string", `{"type":["string","null"]}`, "*string"},
+		{"nullable_integer", `{"type":["integer","null"]}`, "*int"},
+		{"nullable_number", `{"type":["number","null"]}`, "*float64"},
+		{"nullable_boolean", `{"type":["boolean","null"]}`, "*bool"},
+		{"nullable_array", `{"type":["array","null"],"items":{"type":"string"}}`, "[]string"},
+		{"nullable_items", `{"type":"array","items":{"type":["integer","null"]}}`, "[]*int"},
+		{"nullable_map_value", `{"type":"object","additionalProperties":{"type":["string","null"]}}`, "map[string]*string"},
 		{"union_multi", `{"type":["string","integer"]}`, "any"},
 
+		// The anyOf nullable form — what WithGenerateNullablePointers emits
+		// for a Go pointer — round-trips back to the pointer, either order.
+		{"anyof_null_number", `{"anyOf":[{"type":"null"},{"type":"number"}]}`, "*float64"},
+		{"anyof_number_null", `{"anyOf":[{"type":"integer"},{"type":"null"}]}`, "*int"},
+		{"anyof_null_ref", `{"anyOf":[{"type":"null"},{"$ref":"#/definitions/Ref"}]}`, "*Ref"},
+		{"anyof_null_array", `{"anyOf":[{"type":"null"},{"type":"array","items":{"type":"string"}}]}`, "*[]string"},
+		{"anyof_null_any", `{"anyOf":[{"type":"null"},{}]}`, "any"},
+		{"anyof_three_way", `{"anyOf":[{"type":"null"},{"type":"string"},{"type":"integer"}]}`, "any"},
+
 		// Constructs with no faithful Go mapping: degrade to any.
 		{"oneOf", `{"oneOf":[{"type":"string"},{"type":"integer"}]}`, "any"},
 		{"anyOf", `{"anyOf":[{"type":"string"},{"type":"boolean"}]}`, "any"},
@@ -254,6 +273,61 @@ func TestGenerateGo_typeMatrix(t *testing.T) {
 	}
 }
 
+// TestGenerateGo_nullableScalars pins the presence-carrying contract around
+// requiredness: a nullable scalar is a pointer whether the field is required
+// or not (null is a legal VALUE — requiredness governs the json tag, never
+// strips the pointer), and the optionality rule for objects cannot
+// double-pointer it.
+func TestGenerateGo_nullableScalars(t *testing.T) {
+	schema := []byte(`{
+		"type": "object",
+		"required": ["min"],
+		"properties": {
+			"min": {"type": ["number", "null"]},
+			"max": {"type": ["number", "null"]}
+		}
+	}`)
+	src, err := jsonschema.GenerateGo(schema, jsonschema.WithGoRootType("Root"))
+	if err != nil {
+		t.Fatalf("GenerateGo: %v", err)
+	}
+	if got := structFieldType(t, src, "Root", "Min"); got != "*float64" {
+		t.Errorf("required nullable scalar = %q, want *float64", got)
+	}
+	if got := structFieldType(t, src, "Root", "Max"); got != "*float64" {
+		t.Errorf("optional nullable scalar = %q, want *float64", got)
+	}
+}
+
+// TestGenerateGo_nullableRoundTrip pins the two directions against each
+// other: a Go pointer field, emitted as a schema under
+// WithGenerateNullablePointers (the anyOf:[null, T] shape), regenerates the
+// same pointer field through GenerateGo.
+func TestGenerateGo_nullableRoundTrip(t *testing.T) {
+	type Bounds struct {
+		Minimum *float64 `json:"minimum"`
+		Label   string   `json:"label"`
+	}
+	schema, err := jsonschema.Generate(Bounds{}, jsonschema.WithGenerateNullablePointers(true))
+	if err != nil {
+		t.Fatalf("Generate: %v", err)
+	}
+	raw, err := json.Marshal(schema)
+	if err != nil {
+		t.Fatalf("marshal schema: %v", err)
+	}
+	src, err := jsonschema.GenerateGo(raw, jsonschema.WithGoRootType("Bounds"))
+	if err != nil {
+		t.Fatalf("GenerateGo: %v", err)
+	}
+	if got := structFieldType(t, src, "Bounds", "Minimum"); got != "*float64" {
+		t.Errorf("round-tripped pointer = %q, want *float64", got)
+	}
+	if got := structFieldType(t, src, "Bounds", "Label"); got != "string" {
+		t.Errorf("round-tripped value = %q, want string", got)
+	}
+}
+
 // TestGenerateGo_requiredFields verifies that required scalars are value
 // types without omitempty and that a required object reference is a value
 // (not a pointer).