Ajv JSON Schema Validator

Ajv is a high-performance JSON schema validator used in Node.js, browsers, Electron, and other JavaScript environments. Key features include:

• Write less code: Implement complex validation logic via declarative schemas instead of manual code.
• Super fast & secure: Compiles schemas into optimized JavaScript code for high performance.
• Multi-standard: Supports both JSON Schema (various drafts) and JSON Type Definition (JTD).

Ajv v7 introduced several significant improvements:

• JSON Schema draft-2019-09 support: Includes keywords like unevaluatedProperties, unevaluatedItems, and dynamic recursive references.
• Strict Mode: A new mode that prohibits ignored or ambiguous JSON Schema elements to reduce mistakes and unexpected validation results.
• Improved Code Generation: Re-written to be safer against code injection from untrusted schemas and optimized to reduce compiled schema code size by over 10%.
• ES6 Compilation: Schemas are compiled to ES6 code by default, though ES5 support is available via an option.
• New Keyword API: A simplified API for defining user-defined keywords, making it easier to work with subschemas. The ajv-keywords package (v4.0.0+) uses this new API.

Ajv version 8 introduced several key improvements and support for newer standards:

• JSON Schema draft-2020-12 support: Includes the prefixItems keyword, updated semantics for the items keyword, and support for dynamic recursive references.
• OpenAPI support: Support for the discriminator keyword.
• Improved JSON Type Definition (JTD) support:
  • Errors are now consistent with the JTD specification.
  • Error objects include additional properties to simplify error handling.
  • Internationalized error messages are available via the ajv-i18n package.
• TypeScript enhancements: Support for type unions in the JSONSchemaType type.

Standalone validation allows you to generate validation functions from JSON Schemas at compile/build time. These functions can be used at runtime without initializing the full Ajv instance.

Benefits:

• Reduced bundle size: Ajv itself does not need to be included in the client-side bundle.
• Faster startup: Schema compilation happens during the build process rather than at runtime.
• CSP Compatibility: Avoids the use of the Function constructor, which is often prohibited by strict Content Security Policies (CSP).

The Type form defines a single primitive value. It requires a type member and supports optional nullable and metadata members.

Supported type values:

• "string"
• "boolean"
• "timestamp" (accepts RFC3339 strings or Date objects; configurable via the timestamp Ajv option)
• Integers: "int8", "uint8", "int16", "uint16", "int32", "uint32"
• Floats: "float32", "float64"

Note: Unlike JSON Schema, JTD does not support multi-type definitions (e.g., string | number); use nullable: true if a value can be null.

{
  type: "string"
}

Ajv provides several specialized classes depending on the JSON Schema specification or format you are using. All classes inherit from the core Ajv class, which contains the methods for managing schemas and extensions.

• Ajv (core): The base class without any pre-defined keywords. Use this if you want to build a custom validator from scratch.
• Ajv (subclass from lib/ajv.ts): Includes JSON Schema draft-07 keywords. This is a common choice for standard JSON Schema validation.
• Ajv (subclass from lib/2019.ts): Includes JSON Schema draft-2019-09 keywords.
• Ajv (subclass from lib/jtd.ts): Includes support for JSON Type Definition (JTD).

The Ref form allows you to reference a schema defined in the root definitions member of the schema. This is used to avoid duplication and enable recursion.

Key Members:

• ref: The name of the key in the definitions object.
• nullable and metadata: Optional.

Constraints:

• You can only reference schemas located in the root-level definitions member.
• You cannot reference the root of the schema directly (use a named definition instead).
• You cannot reference schemas in other files (though you can combine files using JavaScript).

{
  properties: {
    propFoo: {ref: "foo", nullable: true}
  },
  definitions: {
    foo: {type: "string"}
  }
}

When working with JTD schemas in TypeScript, Ajv provides two utility types to ensure type safety between your schemas and your data:

1. JTDSchemaType: Converts your data type into the type of a JTD schema.
2. JTDDataType: Converts the type of a JTD schema into the type of the data it validates.