gojsonschema

To implement business-specific logic that goes beyond standard JSON Schema drafts, you can manually add errors to a gojsonschema.Result using the AddError method. This allows you to maintain a consistent error format within your application's result set.

To do this, you typically create a custom error type that embeds gojsonschema.ResultErrorFields and use gojsonschema.NewJsonContext to define the location of the error.

type AnswerInvalidError struct {
    gojsonschema.ResultErrorFields
}

func newAnswerInvalidError(context *gojsonschema.JsonContext, value interface{}, details gojsonschema.ErrorDetails) *AnswerInvalidError {
    err := AnswerInvalidError{}
    err.SetContext(context)
    err.SetType("custom_invalid_error")
    // it is important to use SetDescriptionFormat() as this is used to call SetDescription() after it has been parsed
    // using the description of err will be overridden by this.
    err.SetDescriptionFormat("Answer to the Ultimate Question of Life, the Universe, and Everything is {{.answer}}")
    err.SetValue(value)
    err.SetDetails(details)

    return &err
}

func main() {
    // ...
    schema, err := gojsonschema.NewSchema(schemaLoader)
    result, err := gojsonschema.Validate(schemaLoader, documentLoader)

    if true { // some validation
        jsonContext := gojsonschema.NewJsonContext("question", nil)
        errDetail := gojsonschema.ErrorDetails{
            "answer": 42,
        }
        result.AddError(
            newAnswerInvalidError(
                gojsonschema.NewJsonContext("answer", jsonContext),
                52,
                errDetail,
            ),
            errDetail,
        )
    }

    return result, err
}

You can manually manage external schemas (referenced via $ref) by using a SchemaLoader. This allows you to pre-load schemas into memory so they don't need to be fetched via HTTP/File during compilation.

1. Create a SchemaLoader with gojsonschema.NewSchemaLoader().
2. Add individual schemas using sl.AddSchema(uri, loader).
3. Add multiple schemas using sl.AddSchemas(loader) (useful if the loader contains a schema with an $id).
4. Compile the main schema using sl.Compile(mainSchemaLoader). The compiled schema can now resolve its $ref pointers using the schemas previously added to the SchemaLoader.

sl := gojsonschema.NewSchemaLoader()
loader1 := gojsonschema.NewStringLoader(`{ "type" : "string" }`)
err := sl.AddSchema("http://some_host.com/string.json", loader1)

// Or if the loader has an $id:
loader2 := gojsonschema.NewStringLoader(`{
    "$id" : "http://some_host.com/maxlength.json",
    "maxLength" : 5
}`)
err = sl.AddSchemas(loader2)

// Compile the main schema which references the above
loader3 := gojsonschema.NewStringLoader(`{
    "$id" : "http://some_host.com/main.json",
    "allOf" : [
        { "$ref" : "http://some_host.com/string.json" },
        { "$ref" : "http://some_host.com/maxlength.json" }
    ]
}`)
schema, err := sl.Compile(loader3)

You can extend gojsonschema by creating custom format checkers for repetitive or complex validation logic (e.g., checking a database or a specific string prefix).

To implement a custom checker:

1. Define a type that implements the gojsonschema.FormatChecker interface.
2. Implement the IsFormat(input interface{}) bool method.
3. Register the checker using gojsonschema.FormatCheckers.Add("format_name", checker).

Important: When validating numbers, the input to IsFormat will be of type float64.

// Define the format checker
type RoleFormatChecker struct {}

// Ensure it meets the gojsonschema.FormatChecker interface
func (f RoleFormatChecker) IsFormat(input interface{}) bool {
    asString, ok := input.(string)
    if ok == false {
        return false
    }

    return strings.HasPrefix("ROLE_", asString)
}

// Add it to the library
gojsonschema.FormatCheckers.Add("role", RoleFormatChecker{})