@amritk/generate-validators 0.4.1 → 0.5.0

package/dist/generators/build-schema.d.ts

@@ -7,8 +7,9 @@ export type GeneratedFile = {
     content: string;
 };
 /**
- * Builds all TypeScript validator files from a JSON Schema by traversing
- * all $ref references recursively, mirroring the generate-parsers pipeline.
+ * Builds all TypeScript validator files from a JSON Schema by traversing all
+ * `$ref` / `$dynamicRef` references recursively (via the shared
+ * `@amritk/helpers/walk-ref-graph` walker).
  *
  * Each generated file exports:
  * - A TypeScript type definition
@@ -28,3 +29,4 @@ export type GeneratedFile = {
  * ```
  */
 export declare const buildValidatorSchema: (rootSchema: JSONSchema, rootTypeName: string, typeSuffix?: string) => Promise<GeneratedFile[]>;
+//# sourceMappingURL=build-schema.d.ts.map

package/dist/generators/build-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-schema.d.ts","sourceRoot":"","sources":["../../src/generators/build-schema.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAIjE;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAmBD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,oBAAoB,eACnB,UAAU,gBACR,MAAM,0BAEnB,OAAO,CAAC,aAAa,EAAE,CAuBzB,CAAA"}

package/dist/generators/build-schema.js

@@ -0,0 +1,61 @@
+import { generateIndexBarrel } from '@amritk/helpers/generate-index-barrel';
+import { walkRefGraph } from '@amritk/helpers/walk-ref-graph';
+import { generateValidatorFile } from './generate-files.js';
+const VALIDATION_RESULT_CONTENT = `/**
+ * A single validation error with a human-readable message and a JSON Pointer
+ * path indicating where in the document the error occurred.
+ */
+export type ValidationError = {
+  message: string
+  path: string
+}
+
+/**
+ * The result of a generated validator function.
+ * Returns \`true\` when the input is valid, or an object with \`valid: false\`
+ * and a list of errors when it is not.
+ */
+export type ValidationResult = true | { valid: false; errors: ValidationError[] }
+`;
+/**
+ * Builds all TypeScript validator files from a JSON Schema by traversing all
+ * `$ref` / `$dynamicRef` references recursively (via the shared
+ * `@amritk/helpers/walk-ref-graph` walker).
+ *
+ * Each generated file exports:
+ * - A TypeScript type definition
+ * - A `validateFoo(input: unknown, _path?: string): ValidationResult` function
+ *
+ * A `validation-result.ts` file containing the `ValidationResult` and `ValidationError`
+ * runtime contract is always emitted. An `index.ts` re-exports everything.
+ *
+ * @param rootSchema - The root JSON Schema to build from
+ * @param rootTypeName - The name for the root type (e.g. "Document")
+ * @returns An array of generated TypeScript files
+ *
+ * @example
+ * ```typescript
+ * const files = await buildValidatorSchema(schema, 'Document')
+ * // files → [{ filename: 'document.ts', content: '...' }, { filename: 'info.ts', ... }, ...]
+ * ```
+ */
+export const buildValidatorSchema = async (rootSchema, rootTypeName, typeSuffix = '') => {
+    const files = [];
+    walkRefGraph(rootSchema, rootTypeName, { typeSuffix }, (node) => {
+        // `validation-result` and `index` are reserved output filenames, so never
+        // let a definition of either name overwrite them.
+        if (node.filename === 'validation-result' || node.filename === 'index')
+            return;
+        const content = generateValidatorFile(node.schema, node.typeName, {
+            rootSchema: node.rootSchema,
+            typeSuffix,
+            ...(node.ref !== undefined ? { selfRef: node.ref } : {}),
+        });
+        files.push({ filename: `${node.filename}.ts`, content });
+    });
+    // Emit the runtime contract for validators. ValidationResult is mjst-defined
+    // (not derived from the input schema), so its content is fixed.
+    files.push({ filename: 'validation-result.ts', content: VALIDATION_RESULT_CONTENT });
+    files.push({ filename: 'index.ts', content: generateIndexBarrel(files) });
+    return files;
+};

package/dist/generators/collect-validator-imports.d.ts

@@ -32,3 +32,4 @@ type CollectValidatorImportsOptions = {
  */
 export declare const collectValidatorImports: (schema: JSONSchema, options?: CollectValidatorImportsOptions) => string[];
 export {};
+//# sourceMappingURL=collect-validator-imports.d.ts.map

package/dist/generators/collect-validator-imports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collect-validator-imports.d.ts","sourceRoot":"","sources":["../../src/generators/collect-validator-imports.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAEjE;;GAEG;AACH,KAAK,8BAA8B,GAAG;IACpC;;;OAGG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACrC;;;OAGG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAA;IACzD;;;OAGG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAC7B,CAAA;AAoED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,uBAAuB,WAAY,UAAU,YAAY,8BAA8B,KAAG,MAAM,EA6B5G,CAAA"}

package/dist/generators/collect-validator-imports.js

@@ -0,0 +1,99 @@
+import { refToFilename } from '@amritk/helpers/ref-to-filename';
+import { refToName } from '@amritk/helpers/ref-to-name';
+import { resolveRef } from '@amritk/helpers/resolve-ref';
+import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasItems, hasOneOf, hasRef } from '@amritk/helpers/schema-guards';
+/**
+ * Generates an import statement for a single $ref, importing both the type
+ * and the validator function from the ref's generated file.
+ */
+const buildImport = (ref, suffix) => {
+    const filename = refToFilename(ref);
+    const typeName = refToName(ref, suffix);
+    const validatorName = `validate${typeName}`;
+    return `import { type ${typeName}, ${validatorName} } from './${filename}'`;
+};
+/**
+ * Resolves the canonical filename for a ref, stripping `-or-reference` suffixes
+ * so that `#/$defs/parameter-or-reference` maps to `parameter`.
+ */
+const canonicalFilename = (ref) => {
+    const base = ref.endsWith('-or-reference') ? ref.replace('-or-reference', '') : ref;
+    return refToFilename(base);
+};
+/**
+ * Walks one level of the schema and yields all direct $ref strings that should
+ * become imports: properties, additionalProperties, items, and union branches.
+ */
+const collectDirectRefs = (schema) => {
+    if (typeof schema === 'boolean' || schema === null)
+        return [];
+    const refs = [];
+    if (hasRef(schema)) {
+        refs.push(schema.$ref);
+        return refs;
+    }
+    const propSchemas = 'properties' in schema && typeof schema.properties === 'object' && schema.properties !== null
+        ? Object.values(schema.properties)
+        : [];
+    for (const prop of propSchemas) {
+        if (hasRef(prop))
+            refs.push(prop.$ref);
+        if (hasItems(prop) && hasRef(prop.items))
+            refs.push(prop.items.$ref);
+        if (hasAdditionalProperties(prop) && hasRef(prop.additionalProperties)) {
+            refs.push(prop.additionalProperties.$ref);
+        }
+    }
+    if (hasItems(schema) && hasRef(schema.items)) {
+        refs.push(schema.items.$ref);
+    }
+    if (hasAdditionalProperties(schema) && hasRef(schema.additionalProperties)) {
+        refs.push(schema.additionalProperties.$ref);
+    }
+    for (const branch of [
+        ...(hasOneOf(schema) ? schema.oneOf : []),
+        ...(hasAnyOf(schema) ? schema.anyOf : []),
+        ...(hasAllOf(schema) ? schema.allOf : []),
+    ]) {
+        if (hasRef(branch))
+            refs.push(branch.$ref);
+    }
+    return refs;
+};
+/**
+ * Collects import statements for all $ref dependencies of a schema.
+ * Each import brings in both the generated TypeScript type and validator function.
+ *
+ * @example
+ * ```typescript
+ * const schema = { properties: { contact: { $ref: '#/$defs/contact' } } }
+ * collectValidatorImports(schema)
+ * // ["import { type Contact, validateContact } from './contact'"]
+ * ```
+ */
+export const collectValidatorImports = (schema, options) => {
+    const selfFilename = options?.selfRef ? refToFilename(options.selfRef) : null;
+    const rootSchema = options?.rootSchema;
+    const typeSuffix = options?.typeSuffix ?? '';
+    const refs = collectDirectRefs(schema);
+    const seen = new Set();
+    const imports = [];
+    for (const ref of refs) {
+        const filename = canonicalFilename(ref);
+        if (seen.has(filename))
+            continue;
+        if (selfFilename && filename === selfFilename)
+            continue;
+        // Skip refs that don't resolve in this schema (external / never generated)
+        if (rootSchema) {
+            const resolved = resolveRef(ref, rootSchema);
+            if (!resolved)
+                continue;
+        }
+        seen.add(filename);
+        // -or-reference unions import the base type's validator
+        const importRef = ref.endsWith('-or-reference') ? ref.replace('-or-reference', '') : ref;
+        imports.push(buildImport(importRef, typeSuffix));
+    }
+    return imports;
+};

package/dist/generators/generate-files.d.ts

@@ -42,3 +42,4 @@ type GenerateValidatorFileOptions = {
  */
 export declare const generateValidatorFile: (schema: JSONSchema, typeName: string, options?: GenerateValidatorFileOptions) => string;
 export {};
+//# sourceMappingURL=generate-files.d.ts.map

package/dist/generators/generate-files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-files.d.ts","sourceRoot":"","sources":["../../src/generators/generate-files.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAKjE;;GAEG;AACH,KAAK,4BAA4B,GAAG;IAClC;;;OAGG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;IACzB;;OAEG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC7C;;;OAGG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAC7B,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,qBAAqB,WACxB,UAAU,YACR,MAAM,YACN,4BAA4B,KACrC,MA0BF,CAAA"}

package/dist/generators/generate-files.js

@@ -0,0 +1,47 @@
+import { generateTypeDefinition } from '@amritk/helpers/generate-type-definition';
+import { collectValidatorImports } from './collect-validator-imports.js';
+import { generateValidatorFunction } from './generate-validator-function.js';
+/**
+ * Generates a complete TypeScript validator file from a JSON Schema.
+ *
+ * The file contains:
+ * - Imports for the ValidationResult/ValidationError types
+ * - Imports for any $ref types and their validator functions
+ * - The exported TypeScript type definition
+ * - The exported validator function
+ *
+ * @example
+ * ```typescript
+ * const schema = {
+ *   type: 'object',
+ *   properties: { title: { type: 'string' } },
+ *   required: ['title'],
+ * }
+ * generateValidatorFile(schema, 'Info')
+ * // import type { ValidationResult, ValidationError } from './validation-result'
+ * // export type Info = { title: string }
+ * // export const validateInfo = (input: unknown, _path = ''): ValidationResult => { ... }
+ * ```
+ */
+export const generateValidatorFile = (schema, typeName, options) => {
+    const typeSuffix = options?.typeSuffix ?? '';
+    const refImports = collectValidatorImports(schema, {
+        selfRef: options?.selfRef,
+        rootSchema: options?.rootSchema,
+        typeSuffix,
+    });
+    const typeDefinition = generateTypeDefinition(schema, typeName, { typeSuffix });
+    const validatorFunction = generateValidatorFunction(schema, typeName, typeSuffix);
+    let result = `import type { ValidationResult, ValidationError } from './validation-result'\n`;
+    for (const imp of refImports) {
+        result += imp + '\n';
+    }
+    if (refImports.length > 0) {
+        result += '\n';
+    }
+    else {
+        result += '\n';
+    }
+    result += typeDefinition + '\n\n' + validatorFunction;
+    return result;
+};

package/dist/generators/generate-validator-function.d.ts

@@ -22,3 +22,4 @@ import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
  * ```
  */
 export declare const generateValidatorFunction: (schema: JSONSchema, typeName: string, suffix?: string) => string;
+//# sourceMappingURL=generate-validator-function.d.ts.map

package/dist/generators/generate-validator-function.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-validator-function.d.ts","sourceRoot":"","sources":["../../src/generators/generate-validator-function.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAqajE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,yBAAyB,WAAY,UAAU,YAAY,MAAM,sBAAgB,MAM7F,CAAA"}

package/dist/generators/generate-validator-function.js

@@ -0,0 +1,405 @@
+import { getMjstInstanceOf, getMjstPrimitive } from '@amritk/helpers/mjst-extension';
+import { refToName } from '@amritk/helpers/ref-to-name';
+import { hasAdditionalProperties, hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasItems, hasMaximum, hasMaxLength, hasMinimum, hasMinLength, hasMultipleOf, hasOneOf, hasPattern, hasProperties, hasRef, hasRequired, hasType, isObjectSchema, isSchemaObject, } from '@amritk/helpers/schema-guards';
+/**
+ * Derives the validator function name from a type name.
+ * e.g. "InfoObject" → "validateInfoObject"
+ */
+const validatorName = (typeName) => `validate${typeName}`;
+/**
+ * Returns the TypeScript typeof string for a JSON Schema primitive type.
+ */
+const typeofString = (type) => {
+    if (type === 'integer')
+        return 'number';
+    return type;
+};
+/**
+ * Generates the inline condition that is TRUE when a value is the wrong type.
+ */
+const wrongTypeCondition = (accessor, type) => {
+    switch (type) {
+        case 'string':
+            return `typeof ${accessor} !== 'string'`;
+        case 'number':
+        case 'integer':
+            return `typeof ${accessor} !== 'number'`;
+        case 'boolean':
+            return `typeof ${accessor} !== 'boolean'`;
+        case 'array':
+            return `!Array.isArray(${accessor})`;
+        case 'object':
+            return `typeof ${accessor} !== 'object' || ${accessor} === null || Array.isArray(${accessor})`;
+        default:
+            return '';
+    }
+};
+/**
+ * Generates validation lines for a single property in an object schema.
+ * Handles $ref delegation, enum checks, type checks, and string/number constraints.
+ */
+const generatePropertyChecks = (key, propSchema, isRequired, suffix) => {
+    if (!isSchemaObject(propSchema))
+        return [];
+    const raw = `obj[${JSON.stringify(key)}]`;
+    const path = `\`\${_path}/${key}\``;
+    const lines = [];
+    // $ref — delegate to the imported validator
+    if (hasRef(propSchema)) {
+        const ref = propSchema.$ref;
+        const vName = validatorName(refToName(ref, suffix));
+        if (isRequired) {
+            lines.push(`  if (!(${JSON.stringify(key)} in obj)) {`);
+            lines.push(`    errors.push({ message: "must have required property '${key}'", path: _path })`);
+            lines.push(`  } else {`);
+            lines.push(`    const _r = ${vName}(${raw}, ${path})`);
+            lines.push(`    if (_r !== true) errors.push(..._r.errors)`);
+            lines.push(`  }`);
+        }
+        else {
+            lines.push(`  if (${raw} !== undefined) {`);
+            lines.push(`    const _r = ${vName}(${raw}, ${path})`);
+            lines.push(`    if (_r !== true) errors.push(..._r.errors)`);
+            lines.push(`  }`);
+        }
+        return lines;
+    }
+    // x-mjst instanceOf (e.g. Date) — value must be an instance of the class
+    const instanceOf = getMjstInstanceOf(propSchema);
+    if (instanceOf) {
+        if (isRequired) {
+            lines.push(`  if (!(${JSON.stringify(key)} in obj)) {`);
+            lines.push(`    errors.push({ message: "must have required property '${key}'", path: _path })`);
+            lines.push(`  } else if (!(${raw} instanceof ${instanceOf})) {`);
+            lines.push(`    errors.push({ message: 'must be ${instanceOf}', path: ${path} })`);
+            lines.push(`  }`);
+        }
+        else {
+            lines.push(`  if (${raw} !== undefined && !(${raw} instanceof ${instanceOf})) {`);
+            lines.push(`    errors.push({ message: 'must be ${instanceOf}', path: ${path} })`);
+            lines.push(`  }`);
+        }
+        return lines;
+    }
+    // x-mjst primitive (e.g. bigint) — value must satisfy a typeof check
+    const primitive = getMjstPrimitive(propSchema);
+    if (primitive) {
+        if (isRequired) {
+            lines.push(`  if (!(${JSON.stringify(key)} in obj)) {`);
+            lines.push(`    errors.push({ message: "must have required property '${key}'", path: _path })`);
+            lines.push(`  } else if (typeof ${raw} !== "${primitive}") {`);
+            lines.push(`    errors.push({ message: 'must be ${primitive}', path: ${path} })`);
+            lines.push(`  }`);
+        }
+        else {
+            lines.push(`  if (${raw} !== undefined && typeof ${raw} !== "${primitive}") {`);
+            lines.push(`    errors.push({ message: 'must be ${primitive}', path: ${path} })`);
+            lines.push(`  }`);
+        }
+        return lines;
+    }
+    // enum
+    if (hasEnum(propSchema)) {
+        const allowed = JSON.stringify(propSchema.enum);
+        const label = propSchema.enum.map((v) => JSON.stringify(v)).join(', ');
+        if (isRequired) {
+            lines.push(`  if (!(${JSON.stringify(key)} in obj)) {`);
+            lines.push(`    errors.push({ message: "must have required property '${key}'", path: _path })`);
+            lines.push(`  } else if (!(${allowed} as unknown[]).includes(${raw})) {`);
+            lines.push(`    errors.push({ message: \`must be one of: ${label}\`, path: ${path} })`);
+            lines.push(`  }`);
+        }
+        else {
+            lines.push(`  if (${raw} !== undefined && !(${allowed} as unknown[]).includes(${raw})) {`);
+            lines.push(`    errors.push({ message: \`must be one of: ${label}\`, path: ${path} })`);
+            lines.push(`  }`);
+        }
+        return lines;
+    }
+    // typed property
+    if (hasType(propSchema)) {
+        const t = propSchema.type;
+        const wrongType = wrongTypeCondition(raw, t);
+        const typLabel = typeofString(t);
+        if (isRequired) {
+            lines.push(`  if (!(${JSON.stringify(key)} in obj)) {`);
+            lines.push(`    errors.push({ message: "must have required property '${key}'", path: _path })`);
+            if (wrongType) {
+                lines.push(`  } else if (${wrongType}) {`);
+                lines.push(`    errors.push({ message: 'must be ${typLabel}', path: ${path} })`);
+            }
+            lines.push(`  }`);
+        }
+        else if (wrongType) {
+            lines.push(`  if (${raw} !== undefined && (${wrongType})) {`);
+            lines.push(`    errors.push({ message: 'must be ${typLabel}', path: ${path} })`);
+            lines.push(`  }`);
+        }
+        // String constraints
+        if (t === 'string') {
+            if (hasPattern(propSchema)) {
+                lines.push(`  if (typeof ${raw} === 'string' && !/${propSchema.pattern}/.test(${raw})) {`);
+                lines.push(`    errors.push({ message: 'must match pattern ${propSchema.pattern}', path: ${path} })`);
+                lines.push(`  }`);
+            }
+            if (hasMinLength(propSchema)) {
+                lines.push(`  if (typeof ${raw} === 'string' && ${raw}.length < ${propSchema.minLength}) {`);
+                lines.push(`    errors.push({ message: 'must have at least ${propSchema.minLength} characters', path: ${path} })`);
+                lines.push(`  }`);
+            }
+            if (hasMaxLength(propSchema)) {
+                lines.push(`  if (typeof ${raw} === 'string' && ${raw}.length > ${propSchema.maxLength}) {`);
+                lines.push(`    errors.push({ message: 'must have at most ${propSchema.maxLength} characters', path: ${path} })`);
+                lines.push(`  }`);
+            }
+        }
+        // Number constraints
+        if (t === 'number' || t === 'integer') {
+            if (hasMinimum(propSchema)) {
+                lines.push(`  if (typeof ${raw} === 'number' && ${raw} < ${propSchema.minimum}) {`);
+                lines.push(`    errors.push({ message: 'must be >= ${propSchema.minimum}', path: ${path} })`);
+                lines.push(`  }`);
+            }
+            if (hasMaximum(propSchema)) {
+                lines.push(`  if (typeof ${raw} === 'number' && ${raw} > ${propSchema.maximum}) {`);
+                lines.push(`    errors.push({ message: 'must be <= ${propSchema.maximum}', path: ${path} })`);
+                lines.push(`  }`);
+            }
+            if (hasExclusiveMinimum(propSchema)) {
+                lines.push(`  if (typeof ${raw} === 'number' && ${raw} <= ${propSchema.exclusiveMinimum}) {`);
+                lines.push(`    errors.push({ message: 'must be > ${propSchema.exclusiveMinimum}', path: ${path} })`);
+                lines.push(`  }`);
+            }
+            if (hasExclusiveMaximum(propSchema)) {
+                lines.push(`  if (typeof ${raw} === 'number' && ${raw} >= ${propSchema.exclusiveMaximum}) {`);
+                lines.push(`    errors.push({ message: 'must be < ${propSchema.exclusiveMaximum}', path: ${path} })`);
+                lines.push(`  }`);
+            }
+            if (hasMultipleOf(propSchema)) {
+                lines.push(`  if (typeof ${raw} === 'number' && ${raw} % ${propSchema.multipleOf} !== 0) {`);
+                lines.push(`    errors.push({ message: 'must be a multiple of ${propSchema.multipleOf}', path: ${path} })`);
+                lines.push(`  }`);
+            }
+        }
+        // Array with typed items
+        if (t === 'array' && hasItems(propSchema)) {
+            const itemSchema = propSchema.items;
+            if (hasRef(itemSchema)) {
+                const vName = validatorName(refToName(itemSchema.$ref, suffix));
+                lines.push(`  if (Array.isArray(${raw})) {`);
+                lines.push(`    for (let _i = 0; _i < ${raw}.length; _i++) {`);
+                lines.push(`      const _ir = ${vName}(${raw}[_i], \`${path.slice(1, -1)}/${key}/\${_i}\`)`);
+                lines.push(`      if (_ir !== true) errors.push(..._ir.errors)`);
+                lines.push(`    }`);
+                lines.push(`  }`);
+            }
+            else if (hasType(itemSchema)) {
+                const itemType = itemSchema.type;
+                const itemWrong = wrongTypeCondition('_item', itemType);
+                const itemLabel = typeofString(itemType);
+                if (itemWrong) {
+                    lines.push(`  if (Array.isArray(${raw})) {`);
+                    lines.push(`    for (let _i = 0; _i < ${raw}.length; _i++) {`);
+                    lines.push(`      const _item = ${raw}[_i]`);
+                    lines.push(`      if (${itemWrong}) errors.push({ message: 'items must be ${itemLabel}', path: \`${path.slice(1, -1)}/${key}/\${_i}\` })`);
+                    lines.push(`    }`);
+                    lines.push(`  }`);
+                }
+            }
+        }
+    }
+    return lines;
+};
+/**
+ * Generates a validator function body for an object schema, checking each
+ * property's presence and type and collecting all errors.
+ */
+const generateObjectValidator = (schema, typeName, suffix) => {
+    const vName = validatorName(typeName);
+    const required = new Set(hasRequired(schema) ? schema.required : []);
+    const properties = hasProperties(schema) ? schema.properties : {};
+    const propertyLines = [];
+    for (const [key, propSchema] of Object.entries(properties)) {
+        const checks = generatePropertyChecks(key, propSchema, required.has(key), suffix);
+        if (checks.length > 0) {
+            propertyLines.push(...checks);
+        }
+    }
+    // additionalProperties with a $ref schema validates all extra keys
+    if (hasAdditionalProperties(schema) &&
+        isSchemaObject(schema.additionalProperties) &&
+        hasRef(schema.additionalProperties)) {
+        const vRefName = validatorName(refToName(schema.additionalProperties.$ref, suffix));
+        propertyLines.push(`  for (const _key of Object.keys(obj)) {`);
+        propertyLines.push(`    if (${JSON.stringify(Object.keys(properties))}.includes(_key)) continue`);
+        propertyLines.push(`    const _r = ${vRefName}(obj[_key as keyof typeof obj], \`\${_path}/\${_key}\`)`);
+        propertyLines.push(`    if (_r !== true) errors.push(..._r.errors)`);
+        propertyLines.push(`  }`);
+    }
+    const body = propertyLines.length > 0 ? '\n' + propertyLines.join('\n') + '\n' : '';
+    return [
+        `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+        `  if (typeof input !== 'object' || input === null || Array.isArray(input)) {`,
+        `    return { valid: false, errors: [{ message: 'must be object', path: _path }] }`,
+        `  }`,
+        ``,
+        `  const errors: ValidationError[] = []`,
+        `  const obj = input as Record<string, unknown>`,
+        body,
+        `  return errors.length > 0 ? { valid: false, errors } : true`,
+        `}`,
+    ].join('\n');
+};
+/**
+ * Generates a validator function for a non-object schema (primitive, array, enum, $ref).
+ */
+const generateScalarValidator = (schema, typeName, suffix) => {
+    const vName = validatorName(typeName);
+    if (!isSchemaObject(schema)) {
+        return [`export const ${vName} = (_input: unknown, _path = ''): ValidationResult => {`, `  return true`, `}`].join('\n');
+    }
+    // Top-level $ref — delegate entirely
+    if (hasRef(schema)) {
+        const delegateName = validatorName(refToName(schema.$ref, suffix));
+        return [
+            `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+            `  return ${delegateName}(input, _path)`,
+            `}`,
+        ].join('\n');
+    }
+    // Top-level x-mjst instanceOf (e.g. a schema that is itself a Date)
+    const instanceOf = getMjstInstanceOf(schema);
+    if (instanceOf) {
+        return [
+            `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+            `  if (!(input instanceof ${instanceOf})) {`,
+            `    return { valid: false, errors: [{ message: 'must be ${instanceOf}', path: _path }] }`,
+            `  }`,
+            `  return true`,
+            `}`,
+        ].join('\n');
+    }
+    // Top-level x-mjst primitive (e.g. a schema that is itself a bigint)
+    const primitive = getMjstPrimitive(schema);
+    if (primitive) {
+        return [
+            `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+            `  if (typeof input !== "${primitive}") {`,
+            `    return { valid: false, errors: [{ message: 'must be ${primitive}', path: _path }] }`,
+            `  }`,
+            `  return true`,
+            `}`,
+        ].join('\n');
+    }
+    // Top-level enum
+    if (hasEnum(schema)) {
+        const allowed = JSON.stringify(schema.enum);
+        const label = schema.enum.map((v) => JSON.stringify(v)).join(', ');
+        return [
+            `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+            `  if (!(${allowed} as unknown[]).includes(input)) {`,
+            `    return { valid: false, errors: [{ message: \`must be one of: ${label}\`, path: _path }] }`,
+            `  }`,
+            `  return true`,
+            `}`,
+        ].join('\n');
+    }
+    // oneOf — try each branch, return errors from all if none match
+    if (hasOneOf(schema)) {
+        const branches = schema.oneOf
+            .map((branch, i) => {
+            if (!hasRef(branch))
+                return null;
+            const bName = validatorName(refToName(branch.$ref, suffix));
+            return `  const _r${i} = ${bName}(input, _path)\n  if (_r${i} === true) return true`;
+        })
+            .filter(Boolean)
+            .join('\n');
+        return [
+            `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+            branches,
+            `  return { valid: false, errors: [{ message: 'must match one of the expected schemas', path: _path }] }`,
+            `}`,
+        ].join('\n');
+    }
+    // Top-level typed schema (string, number, boolean, array)
+    if (hasType(schema)) {
+        const t = schema.type;
+        const wrongType = wrongTypeCondition('input', t);
+        const typLabel = typeofString(t);
+        const constraintLines = [];
+        if (t === 'string') {
+            if (hasPattern(schema)) {
+                constraintLines.push(`  if (typeof input === 'string' && !/${schema.pattern}/.test(input)) {`);
+                constraintLines.push(`    errors.push({ message: 'must match pattern ${schema.pattern}', path: _path })`);
+                constraintLines.push(`  }`);
+            }
+            if (hasMinLength(schema)) {
+                constraintLines.push(`  if (typeof input === 'string' && input.length < ${schema.minLength}) {`);
+                constraintLines.push(`    errors.push({ message: 'must have at least ${schema.minLength} characters', path: _path })`);
+                constraintLines.push(`  }`);
+            }
+            if (hasMaxLength(schema)) {
+                constraintLines.push(`  if (typeof input === 'string' && input.length > ${schema.maxLength}) {`);
+                constraintLines.push(`    errors.push({ message: 'must have at most ${schema.maxLength} characters', path: _path })`);
+                constraintLines.push(`  }`);
+            }
+        }
+        if (!wrongType) {
+            return [
+                `export const ${vName} = (_input: unknown, _path = ''): ValidationResult => {`,
+                `  return true`,
+                `}`,
+            ].join('\n');
+        }
+        if (constraintLines.length === 0) {
+            return [
+                `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+                `  if (${wrongType}) {`,
+                `    return { valid: false, errors: [{ message: 'must be ${typLabel}', path: _path }] }`,
+                `  }`,
+                `  return true`,
+                `}`,
+            ].join('\n');
+        }
+        return [
+            `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+            `  if (${wrongType}) {`,
+            `    return { valid: false, errors: [{ message: 'must be ${typLabel}', path: _path }] }`,
+            `  }`,
+            `  const errors: ValidationError[] = []`,
+            constraintLines.join('\n'),
+            `  return errors.length > 0 ? { valid: false, errors } : true`,
+            `}`,
+        ].join('\n');
+    }
+    return [`export const ${vName} = (_input: unknown, _path = ''): ValidationResult => {`, `  return true`, `}`].join('\n');
+};
+/**
+ * Generates a TypeScript validator function from a JSON Schema.
+ *
+ * The generated function accepts `unknown` input and returns `true` if valid,
+ * or `{ valid: false, errors }` with a list of errors if not.
+ *
+ * Object schemas check that required properties are present and that all
+ * provided properties match their declared types. Non-object schemas (strings,
+ * numbers, enums, $refs) emit an inline type check.
+ *
+ * @example
+ * ```typescript
+ * generateValidatorFunction({ type: 'object', properties: { name: { type: 'string' } }, required: ['name'] }, 'Info')
+ * // export const validateInfo = (input: unknown, _path = ''): ValidationResult => {
+ * //   if (typeof input !== 'object' || ...) return { valid: false, ... }
+ * //   const errors: ValidationError[] = []
+ * //   const obj = input as Record<string, unknown>
+ * //   if (!('name' in obj)) { errors.push(...) } else if (typeof obj['name'] !== 'string') { errors.push(...) }
+ * //   return errors.length > 0 ? { valid: false, errors } : true
+ * // }
+ * ```
+ */
+export const generateValidatorFunction = (schema, typeName, suffix = '') => {
+    if (isObjectSchema(schema)) {
+        return generateObjectValidator(schema, typeName, suffix);
+    }
+    return generateScalarValidator(schema, typeName, suffix);
+};

package/dist/index.d.ts

@@ -1,2 +1,3 @@
-export type { GeneratedFile } from './generators/build-schema';
-export { buildValidatorSchema } from './generators/build-schema';
+export type { GeneratedFile } from './generators/build-schema.js';
+export { buildValidatorSchema } from './generators/build-schema.js';
+//# sourceMappingURL=index.d.ts.map