json-accelerator

In controlled environments like RESTful APIs, most fields are known to be safe. You can improve performance by setting the global unsafe option to 'manual' and explicitly marking only uncontrolled user-submitted fields for sanitization in the schema using { sanitize: true }.

When a field is marked with sanitize: true, the encoder will sanitize that specific string and continue encoding regardless of the global unsafe configuration.

import { Type as t } from '@sinclair/typebox'
import { createAccelerator } from 'json-accelerator'

const shape = t.Object({
	name: t.String(),
	id: t.Number(),
	unknown: t.String({ sanitize: true }) // Explicitly mark as needing sanitization
})

const value = {
	id: 0,
	name: 'saltyaom',
	unknown: `hello\nworld`
} satisfies typeof shape.static

// Set to 'manual' to skip automatic sanitization on all other fields
const encode = createAccelerator(shape, {
	sanitize: 'manual'
})

console.log(encode(value)) // {"id":0,"name":"saltyaom","unknown":"hello\\nworld"}

The createAccelerator function generates a high-performance serialization function based on a provided TypeBox or OpenAPI schema. This is significantly faster than standard JSON.stringify because the serialization logic is pre-generated for the specific shape of your data.

Important Caveat: The library does not perform type validation. It assumes the input data strictly adheres to the schema. To ensure safety, you should validate your data using a TypeBox compiler (like TypeCompiler.Compile) before passing it to the accelerator.

import { Type as t } from '@sinclair/typebox'
import { createAccelerator } from 'json-accelerator'

const shape = t.Object({
	name: t.String(),
	id: t.Number()
})

const value = {
	id: 0,
	name: 'saltyaom'
} satisfies typeof shape.static

const encode = createAccelerator(shape)

console.log(encode(value)) // {"id":0,"name":"saltyaom"}

Use createAccelerator to generate a highly optimized function that converts data matching a TypeBox schema into a JSON string. Instead of using the standard JSON.stringify, this function generates a specialized, high-performance string template specifically tailored to your schema's structure.

Usage

1. Define your schema using @sinclair/typebox.
2. Pass the schema to createAccelerator.
3. Use the returned function to encode your data.

Configuration Options

When calling createAccelerator, you can provide an options object:

• sanitize: Determines how to handle unsafe characters in strings. Defaults to 'auto'.
  • 'auto': Automatically detects if sanitization is needed and uses JSON.stringify logic to escape characters.
  • 'manual': Assumes the input is already safe; no extra processing is performed.
  • 'throw': Throws an error if invalid characters are detected.
• definitions: A record of TAnySchema objects used to resolve $ref pointers within your schema.

Note: If you use sanitize: 'auto', the encoder may use JSON.stringify internally for specific string fields to ensure safety, but it optimizes the rest of the structure.

import { Type } from '@sinclair/typebox'
import { createAccelerator } from 'json-accelerator'

const UserSchema = Type.Object({
  id: Type.Number(),
  name: Type.String(),
  email: Type.Optional(Type.String())
})

// Create the optimized encoder
const encode = createAccelerator(UserSchema)

// Use it to transform data to a JSON string
const jsonString = encode({
  id: 1,
  name: 'John Doe'
})

console.log(jsonString) // '{"id":1,"name":"John Doe"}'