fromJsonSchema

SUPPORT · function · Runtime value

Build an adapter from a caller-owned typed JSON Schema compiler.

The schema is cloned and frozen before it reaches the compiler, so later mutation of the input cannot change validation. Compilation and validation must both be synchronous.

Import

TypeScript

import { fromJsonSchema } from '@jangts/agent-core/support';

JavaScript

import { fromJsonSchema } from '@jangts/agent-core/support';

Other public entry points:@jangts/agent-core/support.

Definition

Type parameters

Type parameter	Constraint	Default type
Value	—	unknown

Call

fromJsonSchema<Value = unknown>(schema: JsonSchema, options: JsonSchemaOptions<Value>): SchemaAdapter<Value>

Build an adapter from a caller-owned typed JSON Schema compiler.

The schema is cloned and frozen before it reaches the compiler, so later mutation of the input cannot change validation. Compilation and validation must both be synchronous.

Type parameter	Constraint	Default type
Value	—	unknown

Parameter	Type	Passing	Description
schema	Readonly<Record<string, unknown>>	Required	—
options	JsonSchemaOptions<Value>	Required	—

Fields of options

Field	Type	Required	Description
compile	(schema: Record<string, unknown>) => JsonSchemaValidator<Value>	Required	Compiles a frozen schema copy into a validator; must return synchronously.
error	((value: unknown, errors: unknown) => Error) | undefined	Optional	Builds the thrown error for an invalid value; defaults to a TypeError.

Returns: SchemaAdapter<Value>.

Return value structure

Field	Type	Required	Description
jsonSchema	Readonly<Record<string, unknown>>	Required	Read-only. Schema advertised to the model and used for documentation.
parse	(input: unknown) => Value	Required	Validates or coerces untrusted input into Value; throws when the input is invalid.

Examples

• Schema: keep the JSON declaration and actual parsing on the same contract: Support generates a canonical SchemaAdapter; Core only requires the jsonSchema and synchronous parse contract.

A string object with real validation

Beginner · Node.js

TypeScript

import { Support } from '@jangts/agent-core';
const nameSchema = Support.defineSchema({
  jsonSchema: { type: 'object', properties: { name: { type: 'string' } }, required: ['name'], additionalProperties: false },
  parse(value: unknown) {
    if (!value || typeof value !== 'object' || Array.isArray(value) || Object.keys(value).length !== 1 || !('name' in value) || typeof value.name !== 'string') throw new TypeError('需要 name 字符串');
    return { name: value.name };
  },
});
console.log(nameSchema.parse({ name: 'Ivan' }));

JavaScript

import { Support } from '@jangts/agent-core';
const nameSchema = Support.defineSchema({
    jsonSchema: { type: 'object', properties: { name: { type: 'string' } }, required: ['name'], additionalProperties: false },
    parse(value) {
        if (!value || typeof value !== 'object' || Array.isArray(value) || Object.keys(value).length !== 1 || !('name' in value) || typeof value.name !== 'string')
            throw new TypeError('需要 name 字符串');
        return { name: value.name };
    },
});
console.log(nameSchema.parse({ name: 'Ivan' }));

Reuse a parsing object you already own

Configuration · Node.js

When integrating a real parsing library, toJsonSchema must accurately express that parser; the library name does not determine trustworthiness.

TypeScript

import { Support } from '@jangts/agent-core';
class NameParser {
  parse(value: unknown) { if (typeof value !== 'string' || !value.trim()) throw new TypeError('需要非空姓名'); return value.trim(); }
}
const schema = Support.fromParserSchema(new NameParser(), {
  toJsonSchema: () => ({ type: 'string', minLength: 1 }),
});
console.log(schema.parse(' Ivan '));

JavaScript

import { Support } from '@jangts/agent-core';
class NameParser {
    parse(value) { if (typeof value !== 'string' || !value.trim())
        throw new TypeError('需要非空姓名'); return value.trim(); }
}
const schema = Support.fromParserSchema(new NameParser(), {
    toJsonSchema: () => ({ type: 'string', minLength: 1 }),
});
console.log(schema.parse(' Ivan '));

Use an existing JSON Schema compile port

Extension · Node.js

This demonstrates an explicit compile port, not a general JSON Schema compiler; production can plug in a mature compiler the App already has.

TypeScript

import { Support } from '@jangts/agent-core';
const schema = Support.fromJsonSchema<number>({ type: 'integer', minimum: 0 }, {
  compile(jsonSchema) {
    if (jsonSchema.type !== 'integer' || jsonSchema.minimum !== 0) throw new Error('本例编译器只处理该规则');
    return (value: unknown): value is number => typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
  },
});
console.log(schema.parse(3));

JavaScript

import { Support } from '@jangts/agent-core';
const schema = Support.fromJsonSchema({ type: 'integer', minimum: 0 }, {
    compile(jsonSchema) {
        if (jsonSchema.type !== 'integer' || jsonSchema.minimum !== 0)
            throw new Error('本例编译器只处理该规则');
        return (value) => typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
    },
});
console.log(schema.parse(3));

Related policy source

• Schema snapshots and synchronous validation rules

Related definitions

• JsonSchema
• JsonSchemaOptions
• SchemaAdapter