fix: infer - missing nullable type for non Go types (#42)

When providing a struct containing an attribute where the type is a pointer to a
non-native type, the infer analysis wouldn't set the output schema type as
nullable for this attribute.

Example:

```go
type example struct {
	Value *time.Time `json:"value"`
}

func main() {
	schema, err := jsonschema.For[example](nil)
	if err != nil {
		fmt.Fprintf(os.Stderr, "failed to generate JSON schema: %v", err)
		os.Exit(1)
	}
	encoded, err := json.Marshal(schema)
	if err != nil {
		fmt.Fprintf(os.Stderr, "failed to encode JSON schema: %v", err)
		os.Exit(1)
	}
	fmt.Println(string(encoded))
}
```

This would generate:
```json
{"type":"object","required":["value"],"properties":{"value":{"type":"string"}},"additionalProperties":false}
```

Using the `TypeSchemas` option will have the same result, since only the
element is analysed [1]:

```go
schema, err := jsonschema.For[example](&jsonschema.ForOptions{
	TypeSchemas: map[reflect.Type]*jsonschema.Schema{
		reflect.TypeFor[*time.Time](): {
			Types: []string{"null", "string"},
		},
	},
})
```

With this patch the null flag will be checked even when there's a match with
pre-registered types, resulting on the following output:

```json
{"type":"object","required":["value"],"properties":{"value":{"type":["null","string"]}},"additionalProperties":false}
```

Resolves #41

[1] https://github.com/google/jsonschema-go/blob/3ba200528d086ef03a2d8e8d4f7d7146400e342f/jsonschema/infer.go#L114

Author: rafaeljusto

jsonschema/infer.go

@@ -12,11 +12,15 @@ import (
 	"maps"
 	"math"
 	"math/big"
+	"os"
 	"reflect"
 	"regexp"
+	"slices"
 	"time"
 )
 
+const debugEnv = "JSONSCHEMAGODEBUG"
+
 // ForOptions are options for the [For] and [ForType] functions.
 type ForOptions struct {
 	// If IgnoreInvalidTypes is true, fields that can't be represented as a JSON
@@ -128,7 +132,16 @@ func forType(t reflect.Type, seen map[reflect.Type]bool, ignore bool, schemas ma
 	}
 
 	if s := schemas[t]; s != nil {
-		return s.CloneSchemas(), nil
+		cloned := s.CloneSchemas()
+		if os.Getenv(debugEnv) != "typeschemasnull=1" && allowNull {
+			if cloned.Type != "" {
+				cloned.Types = []string{"null", cloned.Type}
+				cloned.Type = ""
+			} else if !slices.Contains(cloned.Types, "null") {
+				cloned.Types = append([]string{"null"}, cloned.Types...)
+			}
+		}
+		return cloned, nil
 	}
 
 	var (
@@ -332,7 +345,11 @@ func init() {
 	ss := &Schema{Type: "string"}
 	initialSchemaMap[reflect.TypeFor[time.Time]()] = ss
 	initialSchemaMap[reflect.TypeFor[slog.Level]()] = ss
-	initialSchemaMap[reflect.TypeFor[big.Int]()] = &Schema{Types: []string{"null", "string"}}
+	if os.Getenv(debugEnv) == "typeschemasnull=1" {
+		initialSchemaMap[reflect.TypeFor[big.Int]()] = &Schema{Types: []string{"null", "string"}}
+	} else {
+		initialSchemaMap[reflect.TypeFor[big.Int]()] = ss
+	}
 	initialSchemaMap[reflect.TypeFor[big.Rat]()] = ss
 	initialSchemaMap[reflect.TypeFor[big.Float]()] = ss
 }

jsonschema/infer_test.go

@@ -94,7 +94,8 @@ func TestFor(t *testing.T) {
 			{"bool", forType[bool](ignore), &schema{Type: "boolean"}},
 			{"time", forType[time.Time](ignore), &schema{Type: "string"}},
 			{"level", forType[slog.Level](ignore), &schema{Type: "string"}},
-			{"bigint", forType[big.Int](ignore), &schema{Types: []string{"null", "string"}}},
+			{"bigint", forType[big.Int](ignore), &schema{Type: "string"}},
+			{"bigint", forType[*big.Int](ignore), &schema{Types: []string{"null", "string"}}},
 			{"custom", forType[custom](ignore), &schema{Type: "custom"}},
 			{"intmap", forType[map[string]int](ignore), &schema{
 				Type:                 "object",
@@ -113,7 +114,8 @@ func TestFor(t *testing.T) {
 				forType[struct {
 					F           int `json:"f" jsonschema:"fdesc"`
 					G           []float64
-					P           *bool  `jsonschema:"pdesc"`
+					P           *bool `jsonschema:"pdesc"`
+					PT          *time.Time
 					Skip        string `json:"-"`
 					NoSkip      string `json:",omitempty"`
 					unexported  float64
@@ -125,9 +127,10 @@ func TestFor(t *testing.T) {
 						"f":      {Type: "integer", Description: "fdesc"},
 						"G":      {Type: "array", Items: &schema{Type: "number"}},
 						"P":      {Types: []string{"null", "boolean"}, Description: "pdesc"},
+						"PT":     {Types: []string{"null", "string"}},
 						"NoSkip": {Type: "string"},
 					},
-					Required:             []string{"f", "G", "P"},
+					Required:             []string{"f", "G", "P", "PT"},
 					AdditionalProperties: falseSchema(),
 				},
 			},
@@ -220,12 +223,21 @@ func TestForType(t *testing.T) {
 		B int     // hidden by S.B
 	}
 
+	type M1 int
+	type M2 int
+
 	type S struct {
-		I int
-		F func()
-		C custom
+		I  int
+		F  func()
+		C  custom
+		P  *custom
+		PP **custom
 		E
-		B bool
+		B   bool
+		M1  M1
+		PM1 *M1
+		M2  M2
+		PM2 *M2
 	}
 
 	opts := &jsonschema.ForOptions{
@@ -239,6 +251,8 @@ func TestForType(t *testing.T) {
 					"B": {Type: "integer"},
 				},
 			},
+			reflect.TypeFor[M1](): {Types: []string{"custom1", "custom2"}},
+			reflect.TypeFor[M2](): {Types: []string{"null", "custom3", "custom4"}},
 		},
 	}
 	got, err := jsonschema.ForType(reflect.TypeOf(S{}), opts)
@@ -248,12 +262,18 @@ func TestForType(t *testing.T) {
 	want := &schema{
 		Type: "object",
 		Properties: map[string]*schema{
-			"I": {Type: "integer"},
-			"C": {Type: "custom"},
-			"G": {Type: "integer"},
-			"B": {Type: "boolean"},
+			"I":   {Type: "integer"},
+			"C":   {Type: "custom"},
+			"P":   {Types: []string{"null", "custom"}},
+			"PP":  {Types: []string{"null", "custom"}},
+			"G":   {Type: "integer"},
+			"B":   {Type: "boolean"},
+			"M1":  {Types: []string{"custom1", "custom2"}},
+			"PM1": {Types: []string{"null", "custom1", "custom2"}},
+			"M2":  {Types: []string{"null", "custom3", "custom4"}},
+			"PM2": {Types: []string{"null", "custom3", "custom4"}},
 		},
-		Required:             []string{"I", "C", "B"},
+		Required:             []string{"I", "C", "P", "PP", "B", "M1", "PM1", "M2", "PM2"},
 		AdditionalProperties: falseSchema(),
 	}
 	if diff := cmp.Diff(want, got, cmpopts.IgnoreUnexported(schema{})); diff != "" {