jet-validator

The Fastest JSON Schema Validator in JavaScript

  

---

🚀 Why jet-validator?

5-44x faster compilation | 26KB gzipped | Zero dependencies | JSON Schema Draft 06-2020-12

jet-validator compiles JSON Schemas into highly optimized validation functions in sub-millisecond time. Unlike traditional validators that interpret schemas at runtime, jet-validator generates specialized code tailored to your exact schema structure.

Built with simplicity in mind.

Just one import for all supported drafts, check full documentation for how to specify draft for $ref keyword for schema 07 and earlier.

$3

- ⚡ Lightning Fast - 5-44x faster compilation than AJV (sub-millisecond compilation)
- ✅ Highly Compliant - 99.5%+ compliance on JSON Schema Test Suite across all supported drafts
- 📦 Smaller Bundle - <26KB with built-in format validators and custom error messages(no external packages needed)
- 📝 Built-in Formats - email, uri, date-time, uuid, and more included (no extra packages!)
- ⚠️ Custom Error Messages - Flexible error customization with errorMessage keyword
- 🎯 Zero Dependencies - Pure TypeScript implementation
- 💪 TypeScript-First - Full type safety out of the box
- 🔧 Enhanced Features - elseIf conditionals, advanced $data references, custom keywords, custom formats
- 🔄 Partial AJV Compatibility - Similar API, minimal code changes needed
- 📊 Multiple Error Modes - Fail-fast or collect all errors
- 🌐 Async Schema Loading - Load schemas from HTTP, databases, or file systems
- 🚫 No Infinite Recursion - Smart resolution process prevents stack overflow errors

🛠️ Schema Builder

Want a fluent, type-safe API for building schemas? Check out @jetio/schema-builder:
``typescript
import { SchemaBuilder, JetValidator } from "@jetio/schema-builder";

const schema = new SchemaBuilder()
.object()
.properties({
name: s => s.string().minLength(2),
email: s => s.string().format("email"),
age: s => s.integer().minimum(18)
})
.required(["name", "email"])
.build();

const validator = new JetValidator();
const validate = validator.compile(schema);
`

The schema-builder package includes this validator, so you get both in one install.

$3

Because compilation is fast (1-5ms for complex schemas), you can:

✅ Compile schemas on-the-fly - No caching required if performance isn't critical
✅ Hot-reload validation rules - Update schemas without restarting
✅ Dynamic schema generation - Build schemas based on user input or config
✅ Per-request validators - Create custom validators for each request context
✅ Faster Startup - Faster cold starts when compiling large numbers of schemas in serverless environments

---

📦 Installation

`bash
npm install @jetio/validator
`

`bash
pnpm add @jetio/validator
`

`bash
yarn add @jetio/validator
`

---

🚀 Quick Start

`typescript
import { JetValidator } from "@jetio/validator";

const jetValidator = new JetValidator();

const schema = {
type: "object",
properties: {
name: { type: "string", minLength: 2 },
age: { type: "number", minimum: 0, maximum: 120 },
email: { type: "string", format: "email" },
},
required: ["name", "age"],
};

const validate = jetValidator.compile(schema);

// Valid data
console.log(
validate({
name: "Alice",
age: 25,
email: "alice@example.com",
})
);
// Output: true

// Invalid data
console.log(
validate({
name: "A",
age: 150,
})
);
// Output: false

console.log(validate.errors);
// Output:
// [{
// dataPath: '/name',
// schemaPath: '/properties/name',
// keyword: 'minLength',
// message: 'must NOT have fewer than 2 characters'
// },
// {
// dataPath: '/age',
// schemaPath: '/properties/age',
// keyword: 'maximum',
// message: 'must be <= 120'
// }]
`

→ See Getting Started Guide

---

📊 JSON Schema Compliance

jet-validator supports JSON Schema Draft 06 through 2020-12 with exceptional compliance rates across all drafts.

$3

All results are from the official JSON Schema Test Suite. Optional tests were skipped. You can view the test code in the test folder of our repository.

#### Draft 2020-12

jet-validator:

`
Total tests: 1261
Passed: 1251 (99.2%)
Failed: 10 (0.8%)
`

AJV (for comparison):

`
Total tests: 1261
Passed: 1208 (95.8%)
Failed: 53 (4.2%)
`

📋 View jet-validator failures (10 tests)

dynamicRef.json (4 failures):

- Multiple dynamic paths edge cases
- Dynamic scope leaving edge cases

properties.json (1 failure):

- __proto__ property edge case

required.json (4 failures) - JavaScript object property names __proto__ property edge case

vocabulary.json (1 failure):

- Custom metaschema with no validation vocabulary

📋 View AJV failures (53 tests)

dynamicRef.json (23 failures) - Dynamic reference resolution issues
ref.json (8 failures) - Stack overflow errors with relative URIs (RangeError: Maximum call stack size exceeded)
required.json (4 failures) - JavaScript object property names __proto__ property edge case
unevaluatedItems.json (12 failures) - Nested items evaluation
unevaluatedProperties.json (4 failures) - Dynamic reference with unevaluated properties
properties.json (1 failure) - JavaScript object property names
vocabulary.json (1 failure) - Custom metaschema validation

---

#### Draft 2019-09

jet-validator:

`
Total tests: 1227
Passed: 1206 (98.3%)
Failed: 21 (1.7%)
`

AJV (for comparison):

`
Total tests: 1227
Passed: 1206 (98.3%)
Failed: 23 (1.7%)
`

📋 View jet-validator failures (23 tests)

recursiveRef.json (13 failures):

- $recursiveRef and $recursiveAnchor are intentionally not supported
- These keywords are confusing and serve little practical purpose
- Users should upgrade to Draft 2020-12 and use $dynamicRef/$dynamicAnchor instead (much better design)

Other failures:

- defs.json (1) - Metaschema validation edge case recursiveAnchor
- properties.json (1) - __proto__ property edge case
required.json (4 failures) - JavaScript object property names __proto__ property edge case
- ref.json (1) - Recursive anchor interaction
- unevaluatedItems.json (1) - Recursive reference evaluation
- unevaluatedProperties.json (1) - Recursive reference evaluation
- vocabulary.json (1) - Custom metaschema (not supported)

📋 View AJV failures (21 tests)

ref.json (8 failures) - Stack overflow errors (RangeError: Maximum call stack size exceeded)
required.json (4 failures) - JavaScript object property names
unevaluatedItems.json (3 failures) - Nested items and conditional evaluation
recursiveRef.json (2 failures) - Recursive reference resolution
unevaluatedProperties.json (2 failures) - Conditional evaluation
properties.json (1 failure) - JavaScript object property names
vocabulary.json (1 failure) - Custom metaschema validation

---

#### Draft 07

jet-validator:

`
Total tests: 913
Passed: 908 (99.5%)
Failed: 5 (0.5%)
`

AJV (for comparison):

`
Total tests: 913
Passed: 905 (99.1%)
Failed: 8 (0.9%)
`

📋 View jet-validator failures (5 test)

properties.json (5 failure):

- __proto__ property edge case
required.json (4 failures) - JavaScript object property names __proto__ property edge case

📋 View AJV failures (8 tests)

required.json (4 failures) - JavaScript object property names __proto__ property edge case
ref.json (3 failures) - Reference resolution and sibling keywords
properties.json (1 failure) - JavaScript object property names

---

#### Draft 06

jet-validator:

`
Total tests: 829
Passed: 824 (99.4%)
Failed: 5 (0.6%)
`

AJV: _Specific version does not support Draft 06_

📋 View jet-validator failures (5 test)

properties.json (1 failure):
required.json (4 failures) - JavaScript object property names __proto__ property edge case

- __proto__ property edge case

---

$3

Unlike other validators that struggle with certain schema patterns, jet-validator never encounters infinite recursion problems.

`
Due to our advanced resolution process, jet-validator never has infinite recursion problems.
Unlike other validators which exceed maximum call stack size on certain schemas,
jet-validator's recursion only goes as deep as the data being validated.

THERE IS NO INFINITE RECURSION IN jet-validator.
`

While AJV encounters stack overflow errors (RangeError: Maximum call stack size exceeded) on schemas with complex relative URI references, jet-validator handles these schemas without issue. Our three-phase resolution process (Collection → Assignment → Resolution) eliminates circular reference problems at compile time.

→ Learn more about our Resolution Process

---

$3

For transparency, here are the keywords jet-validator intentionally does not support:

Draft 2019-09:

- $recursiveRef / $recursiveAnchor - Confusing design, replaced by better $dynamicRef/$dynamicAnchor in Draft 2020-12
- $vocabulary - Custom vocabulary system (edge case feature)

Draft 2020-12:

- $vocabulary - Custom vocabulary system (edge case feature)

Why not support these?

- $recursiveRef/$recursiveAnchor serve little practical purpose and are confusing. The Draft 2020-12 $dynamicRef/$dynamicAnchor keywords are much better designed.
- $vocabulary is an edge case feature that adds complexity without significant benefit for most users.

---

⚡ Performance Benchmarks

Environment: Ubuntu 1.6GHz laptop under realistic load (browser, IDE, system services)

Why under load? Production servers are never idle. These results reflect real-world conditions.

$3

🚀 Compilation: 19x faster (1.47ms vs 28.29ms)
✅ Valid Data: 58% win rate (36/62)
🛡️ Invalid Data: 73% win rate (45/62)
🏆 Overall: 72% win rate (89/124)

📊 Full Benchmark Report | 📈 Detailed Results

_Tested against AJV v8.17.1 using official benchmarks with 65 schemas, 1000 warmups, 10000 iterations, 30 runs per test_

---

$3

Caching becomes optional instead of mandatory:

`typescript
// ❌ Other validators: Must cache to avoid compilation overhead
const validateUser = ajv.compile(userSchema); // Cache this!

// ✅ jet-validator: Fast enough to compile on-demand
app.post("/validate", (req, res) => {
const schema = req.body.schema;
const validate = jetValidator.compile(schema); // < 2ms
res.json(validate(req.body.data));
});
`

---

🎯 Core Features

$3

Simple validation with comprehensive error reporting:

`typescript
const jetValidator = new JetValidator();

const schema = {
type: "object",
properties: {
username: { type: "string", minLength: 3, maxLength: 20 },
email: { type: "string", format: "email" },
age: { type: "number", minimum: 18 },
},
required: ["username", "email"],
};

const validate = jetValidator.compile(schema);
const result = validate({ username: "jo", email: "invalid" });

console.log(result); // false
console.log(validate.errors); // Detailed error information
`

→ See Basic Validation Examples

---

$3

Compile once, validate many times with blazing speed:

`typescript
// Synchronous compilation
const validate = jetValidator.compile(schema);

// Async compilation (for remote schemas)
const validate = await jetValidator.compileAsync(schema);

// Add schemas to registry for reuse
jetValidator.addSchema(schema, "user-schema");
const validate = jetValidator.getSchema("user-schema");
`

→ See Schema Management & Compilation

---

$3

Customize validation behavior to match your needs:

`typescript
const jetValidator = new JetValidator({
// Error handling
allErrors: true, // Collect all errors, not just first
errorMessage: true, // Enable custom error messages

// Validation strictness
strict: true, // Strict mode for schema validation
strictNumbers: true, // Reject NaN and Infinity
strictRequired: true, // Fail on undefined required properties

// Data modification
coerceTypes: true, // Auto-convert types (string → number)
useDefaults: true, // Apply default values
removeAdditional: true, // Remove extra properties

// Format validation
validateFormats: true, // Enable format validation

// Performance
async: true, // Enable async validation
});
`

→ See All Configuration Options

---

$3

Rich, detailed error information with customizable messages:

`typescript
const jetValidator = new JetValidator({
allErrors: true,
errorMessage: true,
});

const schema = {
type: "object",
properties: {
password: {
type: "string",
minLength: 8,
errorMessage: "Password must be at least 8 characters long",
},
confirmPassword: {
type: "string",
const: { $data: "1/password" },
errorMessage: "Passwords must match",
},
},
};

const validate = jetValidator.compile(schema);
const result = validate({
password: "short",
confirmPassword: "different",
});

console.log(validate.errors); // Custom error messages included
`

Error Object Structure:

`typescript
{
dataPath: string; // Path to invalid data: "/properties/user"
schemaPath: string; // Path to schema location: "/properties/user"
keyword: string; // Keyword that failed: "minLength"
fullSchemaPath: string; // Complete path: "/properties/user/minLength"
message: string; // Error message
params?: object; // Additional context
}
`

→ See Error Handling Guide

---

$3

jet-validator provides production-grade error handling out of the box:

#### Error Utility Methods

Built-in utilities for working with errors:

`typescript
// Pretty-print errors with hierarchy
jetValidator.logErrors(validate.errors);

// Group errors by field (perfect for forms)
const fieldErrors = jetValidator.getFieldErrors(validate.errors);
// { '/email': ['Invalid format', 'Too short'], '/age': ['Must be positive'] }

// Format as readable string
jetValidator.errorsText(validate.errors, { separator: "\n" });
`

#### Custom Error Messages

Schema-level or parent-level customization:

`typescript
const schema = {
type: "object",
properties: {
email: {
type: "string",
format: "email",
minLength: 5,
},
},
errorMessage: {
properties: {
email: {
type: "Email must be text",
format: "Invalid email format",
minLength: "Email too short",
},
},
},
};
`

→ See Complete Error Handling Guide

---

$3

Build modular, reusable schemas with $ref, $dynamicRef, and schema composition:

`typescript
const schema = {
$id: "https://example.com/schemas/user.json",
type: "object",
properties: {
profile: { $ref: "#/$defs/profile" },
address: { $ref: "https://example.com/schemas/address.json" },
},
$defs: {
profile: {
type: "object",
properties: {
name: { type: "string" },
bio: { type: "string" },
},
},
},
};

// Load remote schemas automatically
const jetValidator = new JetValidator({
loadSchema: async (uri) => {
const response = await fetch(uri);
return response.json();
},
});

const validate = await jetValidator.compileAsync(schema);
`

→ See Schema References & Composition

---

$3

Validate your schemas before using them (supports JSON Schema Draft 06-2020-12):

`typescript
const jetValidator = new JetValidator({
validateSchema: true,
meta: true,
});

// Your schema is automatically validated against the meta-schema
const validate = jetValidator.compile(schema);
// Throws error if schema is invalid

// Or validate explicitly
const isValid = jetValidator.validateSchema(schema);
`

→ See Meta-Schema System

---

🔥 Advanced Features

$3

Built-in formats plus easy custom format registration:

`typescript
// Built-in formats (no extra packages needed!)
const schema = {
type: "object",
properties: {
email: { type: "string", format: "email" },
url: { type: "string", format: "uri" },
date: { type: "string", format: "date-time" },
ipv4: { type: "string", format: "ipv4" },
},
};

// Add custom formats
jetValidator.addFormat("phone", /^\+?[1-9]\d{1,14}$/);

// Or with validation function
jetValidator.addFormat("even-number", {
type: "number",
validate: (value) => value % 2 === 0,
});

// Async format validation
jetValidator.addFormat("unique-email", {
type: "string",
async: true,
validate: async (email) => {
return !(await database.emailExists(email));
},
});
`

→ See Format Validation Guide

---

$3

Compare and validate against other values in your data:

`typescript
const schema = {
type: "object",
properties: {
startDate: { type: "string", format: "date" },
endDate: {
type: "string",
format: "date",
// endDate must be after startDate
formatMinimum: { $data: "1/startDate" },
},
minPrice: { type: "number" },
maxPrice: { type: "number" },
currentPrice: {
type: "number",
minimum: { $data: "1/minPrice" },
maximum: { $data: "1/maxPrice" },
},
},
};

const jetValidator = new JetValidator({ $data: true });
const validate = jetValidator.compile(schema);
`

→ See $data References Guide

---

$3

Enhanced conditional validation without deep nesting:

`typescript
// Standard JSON Schema (deeply nested)
{
if: { properties: { type: { const: 'A' } } },
then: { / ... / },
else: {
if: { properties: { type: { const: 'B' } } },
then: { / ... / },
else: { / ... / }
}
}

// jet-validator elseIf (clean and readable)
{
if: { properties: { type: { const: 'A' } } },
then: { / ... / },
elseIf: [
{
if: { properties: { type: { const: 'B' } } },
then: { / ... / }
},
{
if: { properties: { type: { const: 'C' } } },
then: { / ... / }
}
],
else: { / default case / }
}
`

→ See elseIf Keyword Guide

---

$3

Extend jet-validator with your own validation logic:

`typescript
// Add custom keyword
jetValidator.addKeyword({
keyword: "isEven",
type: "number",
validate: (schema, data) => {
return data % 2 === 0;
},
error: {
message: "Number must be even",
},
});

const schema = {
type: "number",
isEven: true,
};

const validate = jetValidator.compile(schema);
console.log(validate(4)); // true
console.log(validate(5)); // false
`

→ See Custom Keywords Guide

---

🛠️ Utility Functions

jet-validator exports utility functions that can be used for schema manipulation and debugging:

`typescript
import {
getSchemaAtPath,
getJSONType,
deepEqual,
canonicalStringify,
len_of,
} from "@jetio/validator/utilities";
`

$3

Retrieve a sub-schema at a specific JSON Pointer path.

`typescript
const schema = {
properties: {
user: {
type: "object",
properties: {
name: { type: "string", minLength: 2 },
},
},
},
};

const subSchema = getSchemaAtPath(schema, "#/properties/user/properties/name");
// Returns: { type: 'string', minLength: 2 }
`

Use case: Debugging validation errors - retrieve the exact schema that caused an error.

---

$3

Get the JSON Schema type of any value (matches JSON Schema type semantics).

`typescript
getJSONType(42); // 'integer'
getJSONType(3.14); // 'number'
getJSONType([1, 2, 3]); // 'array'
getJSONType(null); // 'null'
getJSONType({}); // 'object'
`

Use case: Type checking in custom keywords or validation logic.

---

$3

Deep equality comparison (used internally for const keyword).

`typescript
deepEqual({ a: 1, b: [2, 3] }, { a: 1, b: [2, 3] }); // true
deepEqual({ a: 1 }, { a: 1, b: 2 }); // false
`

Use case: Comparing complex data structures in tests or custom validators.

---

$3

Deterministic JSON stringification (sorted keys for consistent hashing).

`typescript
const obj1 = { b: 2, a: 1 };
const obj2 = { a: 1, b: 2 };

canonicalStringify(obj1) === canonicalStringify(obj2); // true
JSON.stringify(obj1) === JSON.stringify(obj2); // false
`

Use case: Caching, deduplication, or comparing schemas.

---

$3

Get the true Unicode character count (handles surrogate pairs correctly).

`typescript
len_of("hello"); // 5
len_of("👋🏽"); // 2 (not 4)
len_of("café"); // 4
`

Use case: Validating minLength/maxLength for strings with emoji or special Unicode characters.


---

🔄 Migration from AJV

jet-validator has a very similar API to AJV:

`typescript
// Before (AJV)
import Ajv from "ajv";
const ajv = new Ajv();
const validate = ajv.compile(schema);

// After (jet-validator)
import { JetValidator } from "@jetio/validator";
const jetValidator = new JetValidator();
const validate = jetValidator.compile(schema);
`

Benefits of switching:

- ⚡ 19x faster compilation
- 📦 Smaller bundle size
- 🎯 Built-in formats and error messages (no separate packages)
- ✨ Enhanced features (elseIf, better $data)

What's different:

- Error object structure
- Custom keywords use different API
- Meta-schema setup with cli

---

🎓 When to Use jet-validator

$3

✅ High-throughput APIs - Validate thousands of requests per second
✅ Dynamic schemas - Generate and compile schemas on-the-fly
✅ Serverless functions - Fast cold starts with quick compilation
✅ Real-time validation - Hot-reload schemas without restart
✅ Complex validation logic - Advanced $data and conditional validation
✅ Bundle size matters - <100KB with all features included

$3

⚠️ You need 100% JSON Schema spec compliance (we're at 99.5%)
⚠️ You're already heavily invested in AJV ecosystem with custom plugins (we offer the same custom keywords but contexts are simpler and different, although much more easy to use)
⚠️ You need streaming validation for extremely large documents

---

🌟 What Makes jet-validator Different?

$3

jet-validator eliminates infinite recursion through a unique resolution approach. Unlike other validators that resolve references during traversal (causing stack overflow), jet-validator:

1. Collects all references and identifiers
2. Assigns unique function names to each location when inlining is impossible
3. Resolves references by replacing them with function calls

This architecture enables both lightning-fast compilation and bulletproof circular reference handling.

→ Learn more about the resolution process

---

$3

Traditional validators:

`typescript
// Slow: 10-20ms per compilation
const validate = ajv.compile(schema); // Must cache!
`

jet-validator:

`typescript
// Fast: 0.7ms per compilation
const validate = jetValidator.compile(schema); // Can recompile!
`

---

$3

Avoid deeply nested if/else chains with clean, readable elseIf syntax.

---

$3

Reference and compare values within your data during validation.

---

$3

No need for separate packages - formats, error messages, and advanced features are all included.

---

💡 Common Use Cases

$3

`typescript
app.post("/api/users", (req, res) => {
const validate = jetValidator.compile(userSchema);
const result = validate(req.body);

if (!result) {
return res.status(400).json({ errors: validate.errors });
}

// Process valid data
});
`

---

$3

`typescript
const jetValidator = new JetValidator({ coerceTypes: true });

const formSchema = {
type: "object",
properties: {
age: { type: "number", minimum: 18 },
agree: { type: "boolean" },
},
};

const validate = jetValidator.compile(formSchema);

// Automatically converts strings to correct types
const data = { age: "25", agree: "true" };
validate(data);
console.log(data); // { age: '25', agree: 'true' }
// Note: JetValidator does not modify original data objects
`

---

$3

`typescript
const configSchema = {
type: "object",
properties: {
port: { type: "number", default: 3000 },
host: { type: "string", default: "localhost" },
ssl: { type: "boolean", default: false },
},
};

const jetValidator = new JetValidator({ useDefaults: true });
const validate = jetValidator.compile(configSchema);

const config = {};
validate(config);
console.log(config); // {}
// Note: JetValidator does not modify original data objects
`

---

$3

`typescript
function createValidatorForUser(userType) {
const schema = {
type: "object",
properties: {
name: { type: "string" },
role: { const: userType },
},
};

// Fast enough to compile per request
return jetValidator.compile(schema);
}

const validateAdmin = createValidatorForUser("admin");
const validateUser = createValidatorForUser("user");
`

---

📚 Documentation

$3

Getting Started:

- Installation & Setup
- Quick Start Guide
- Choosing Schema Language

Core Concepts:

- Configuration Options
- Schema Compilation
- Validation Methods
- Schema Management
- Error Handling

Advanced Features:

- Schema References & Composition
- Meta-Schema System
- $data References
- elseIf Conditionals
- Format Validation
- Custom Keywords
- Utilities API

Complete Documentation:

- 📖 Full Documentation (20k+ lines) - Everything in one searchable file

---

Acknowledgments

- Format validation patterns follow RFC and ISO specifications
- Inspired by the performance goals of AJV

🤝 Contributing

We welcome contributions! jet-validator is a community project and we appreciate all help.

$3

- 🐛 Report bugs - Found an issue? Open a bug report
- 💡 Suggest features - Have an idea? Open a feature request
- 📖 Improve docs - Fix typos, add examples, clarify explanations
- 🧪 Add test cases - Contribute to JSON Schema compliance
- ⚡ Performance improvements - Make it even faster
- 🎨 Code contributions - Fix bugs or implement features

$3

`bash


Clone the repo

git clone https://github.com/official-jetio/validator
cd validator

Install dependencies

npm install

Build the project

npm run build

Run JSON Schema Test Suite

npm run test:draft2020-12
npm run test:draft2019-09
npm run test:draft7
npm run test:draft6

Run all tests

npm run test

Run benchmarks

node --expose-gc --max-old-space-size=4096 --max-semi-space-size=64 benchmarks/jet-validator-benchmark.js
`

$3

jet-validator uses the official JSON Schema Test Suite as its primary test suite. This ensures real-world compliance rather than contrived unit tests.

To test your changes:

1. Make your changes to the codebase
2. Build: npm run build
3. Run the official test suite: npm run test:draft2020-12 (or appropriate draft)
4. Check compliance rate - aim to maintain or improve current 99.5%+ compliance

The test runner (tests/test.ts) validates against:

- 1,261+ tests for Draft 2020-12
- 1,227+ tests for Draft 2019-09
- 913+ tests for Draft 07
- 829+ tests for Draft 06

$3

Before submitting a PR:

1. ✅ Run the test suite and ensure no regressions
2. ✅ Run npm run build successfully
3. ✅ Update documentation if you're adding features
4. ✅ Add benchmark tests if you're optimizing performance
5. ✅ Explain the "why" in your PR description

Areas that need help:

- Further optimization of common validation patterns
- Additional format validators
- Better error messages
- Documentation improvements
- Edge case handling from the test suite

$3

The resolver (src/compiler/resolver.ts) is the heart of jet-validator. It handles:

- Schema resolution and reference tracking
- $ref, $dynamicRef, $anchor resolution
- External schema loading
- Circular reference prevention
- Three-phase resolution process

If you're working on the resolver, please be extra careful - it's complex but battle-tested against 3,000+ official test cases.

$3

- 💬 Discussions: GitHub Discussions
- 🐛 Issues: Issue Tracker

---

All contributions are appreciated! Even small improvements help make jet-validator better for everyone.

---

🐛 Found an Issue?

We track bugs and feature requests using GitHub Issues.

$3

1. Search existing issues - Your issue might already be reported
2. Check the documentation - The answer might be in the 20k+ line docs
3. Try the latest version - npm install @jetio/validator@latest

$3

- 🐛 Bug Report: Something isn't working correctly

- Include: Schema, data, expected vs actual behavior, error messages
- File a bug report →

- 💡 Feature Request: Suggest a new feature or improvement

- Include: Use case, examples, why it's needed
- Request a feature →

- ❓ Question: Need help or clarification

- Use GitHub Discussions for questions
- Issues are for bugs and features only

- 📖 Documentation: Docs are unclear or missing information
- Improve docs →

$3

`markdown
Description: Brief description of the issue

Schema:
\\\json
{
"type": "object",
// your schema here
}
\\\

Data:
\\\json
{
// your data here
}
\\\

Expected: What should happen

Actual: What actually happens

Environment:

- jet-validator version:
- Node.js version:
- OS:
``

---

🔗 Quick Links:

- Report a Bug
- Request a Feature
- Ask a Question

---

⚠️ Benchmark Methodology & Hardware Notes

Performance on Better Hardware:

Results will vary significantly on better hardware. While absolute numbers will improve across the board, jet-validator is expected to maintain its performance advantages, especially in compilation speed.

---

🏆 Conclusion

jet-validator has proven itself as a strong contender for JSON Schema validation in the Node.js ecosystem, offering:

✅ 99.5% JSON Schema compliance - More spec-compliant than AJV in many areas
🚀 Compilation: 19x faster (1.47ms vs 28.29ms) on average - Game-changer for serverless
✅ Valid Data: 58% win rate (36/62)
🛡️ Invalid Data: 73% win rate (45/62)
🏆 Overall: 72% win rate (89/124)

jet-validator is the clear choice for:

- Serverless applications (cold start critical)
- High-volume validation workloads
- Real-world schema validation
- Applications requiring fast compilation
- Security-focused applications (invalid data detection)
- Heavy reliance on complex $ref graphs
- Schemas with complex conditional logic
- Extremely deep composition chains (>10 levels)

---

Whether jet-validator is the "new king" depends on your use case, but the numbers speak for themselves.

---

📄 License

MIT © Great Venerable

---

🔗 Links

- npm Package
- GitHub Repository
- Complete Documentation (20k+ lines)
- Benchmark Results
- Issue Tracker
- GitHub Discussions

---

Built with ❤️ by The Venerable Supreme