Reflector 's Mapper callback

[tpoxa]

Hey. I am really want to migrate to your library cause it has so much perks but I think I am missing some kind of a Reflector's callback which will allow to generate Schema depends on a reflect.Type of a variable.

I saw map of types associations but unfortunately it is not an option, cause I do custom types based on a type any which I check using .Kind in the callback. So reflector does not know about exact name of a type.

CollectionDefinitions could be option but it gets definition name and schema.

What other thing I can try with?

Here is the program based on invopop's library which I am trying to migrate from.

package main

import (
    "encoding/json"
    "fmt"
    "github.com/invopop/jsonschema"
    "reflect"
)

type CustomParameter any

// User is used as a base to provide tests for comments.
type User struct {
    Param interface{} `json:"param"`

    // Unique sequential identifier.
    // Name of the user
    Dynamic CustomParameter `json:"dynamic" jsonschema:"title=Test"`
    //Some interface{} `json:"some,omitempty" jsonschema_extras:"requiredWhen=[1,2,3]"`
}

func main() {

    definitions := jsonschema.Definitions{}

    r := jsonschema.Reflector{
        Anonymous: true,
        Mapper: func(r reflect.Type) *jsonschema.Schema {
            if r.Name() == "" {
                return nil
            }
            if r.Kind() == reflect.Interface {
                definitions[r.Name()] = &jsonschema.Schema{
                    Type: "object",
                    Extras: map[string]interface{}{
                        "configurable": true,
                    },
                }
                return &jsonschema.Schema{
                    Ref: fmt.Sprintf("#/$defs/%s", r.Name()),
                }
            }
            return nil
        },
        AllowAdditionalProperties: true,
    }

    sh := r.Reflect(&User{})

    for k, v := range definitions {
        sh.Definitions[k] = v
    }
    j, _ := json.MarshalIndent(sh, "", " ")
    fmt.Println(string(j))

}

The result. I highlighted important points for me

{
 "$schema": "https://json-schema.org/draft/2020-12/schema",
 "$ref": "#/$defs/User",
 "$defs": {
  "CustomParameter": { <-- definition based on a custom type name 
   "type": "object",
   "configurable": true <- I need to have this custom prop based on a kind,  using json tags might also work...
  },
  "User": {
   "properties": {
    "param": true,
    "dynamic": {
     "$ref": "#/$defs/CustomParameter",
     "title": "Test" <-- would be good to have ability add this to override for ad-hoc overrides of definition's title
    }
   },
   "type": "object",
   "required": [
    "param",
    "dynamic"
   ]
  }
 }
}

Thank you.

[vearutop]

There is an InterceptType option that allows schema customization based on its reflect.Value. (All available options are listed at https://pkg.go.dev/github.com/swaggest/jsonschema-go#Reflector.Reflect)

https://go.dev/play/p/hZgF5vsks1R

package main

import (
    "encoding/json"
    "fmt"
    "reflect"

    "github.com/swaggest/jsonschema-go"
)

func main() {
    type CustomParameter interface{}

    // User is used as a base to provide tests for comments.
    type User struct {
        Param interface{} `json:"param" title:"Param"`

        // Unique sequential identifier.
        // Name of the user
        Dynamic CustomParameter `json:"dynamic" title:"Test"`
        //Some interface{} `json:"some,omitempty" jsonschema_extras:"requiredWhen=[1,2,3]"`
    }

    r := jsonschema.Reflector{}

    defs := map[string]jsonschema.Schema{}

    r.DefaultOptions = append(r.DefaultOptions,
        jsonschema.DefinitionsPrefix("#/$defs/"),
        jsonschema.CollectDefinitions(func(name string, schema jsonschema.Schema) {
            defs[name] = schema
        }),
        jsonschema.InterceptType(func(value reflect.Value, schema *jsonschema.Schema) (bool, error) {
            r := value.Type()

            // Nil interfaces arrive as pointer wraps.
            if r.Kind() == reflect.Ptr {
                r = r.Elem()
            }

            if r.Name() == "" {
                return false, nil
            }

            if r.Kind() == reflect.Interface {
                // Making new definition.
                s := jsonschema.Schema{}
                s.AddType(jsonschema.Object)
                s.WithExtraPropertiesItem("configurable", true)
                defs[r.Name()] = s

                // Replacing current schema with reference.
                rs := jsonschema.Schema{}
                rs.WithRef(fmt.Sprintf("#/$defs/%s", r.Name()))
                *schema = rs

                // Alternatively, in this case schema can be updated instead of replacing,
                // because it would be empty for an interface.
                //
                //schema.WithRef(fmt.Sprintf("#/$defs/%s", r.Name()))

                // True return disables further schema processing.
                return true, nil
            }

            return false, nil
        }))

    sh, _ := r.Reflect(User{})
    sh.WithExtraPropertiesItem("$defs", defs)

    j, _ := json.MarshalIndent(sh, "", " ")
    fmt.Println(string(j))
}

{
 "properties": {
  "dynamic": {
   "$ref": "#/$defs/CustomParameter",
   "title": "Test"
  },
  "param": {
   "title": "Param"
  }
 },
 "type": "object",
 "$defs": {
  "CustomParameter": {
   "type": "object",
   "configurable": true
  }
 }
}

[tpoxa]

That's awesome. Thanks @vearutop