@amritk/generate-validators 0.11.6 → 0.11.7

package/README.md

@@ -129,20 +129,21 @@ Measured on Bun 1.3 (Linux x64), validating valid input at steady state:
 
 | schema | mjst (generated) | typia (transformed) | ajv (compiled) | typebox (compiled) | zod |
 |:--|--:|--:|--:|--:|--:|
-| small (4 fields) | **~22M** ops/s | ~4.2M ops/s | ~7.0M ops/s | ~4.0M ops/s | ~1.8M ops/s |
-| order (nested + array) | **~6.9M** ops/s | ~1.7M ops/s | ~2.5M ops/s | ~1.7M ops/s | ~0.4M ops/s |
-| assert-loose | **~110M** ops/s | ~100M ops/s | ~31M ops/s | ~41M ops/s | ~3.2M ops/s |
-| assert-strict | **~98M** ops/s | ~82M ops/s | ~13M ops/s | ~28M ops/s | ~1.1M ops/s |
+| small (4 fields) | **~48M** ops/s | ~5M ops/s | ~10.5M ops/s | ~5.3M ops/s | ~2M ops/s |
+| order (nested + array) | **~7.8M** ops/s | ~2.2M ops/s | ~3.5M ops/s | ~2.1M ops/s | ~0.5M ops/s |
+| assert-loose | **~184M** ops/s | ~183M ops/s | ~45M ops/s | ~63M ops/s | ~3.8M ops/s |
+| assert-strict | **~162M** ops/s | ~148M ops/s | ~22M ops/s | ~38M ops/s | ~1.3M ops/s |
 
 The `assert-loose` / `assert-strict` rows are the exact shape used by
 [`moltar/typescript-runtime-type-benchmarks`](https://github.com/moltar/typescript-runtime-type-benchmarks)
-(seven scalar roots plus a nested object); the boolean guard lets mjst edge past
-typia on both, with and without `additionalProperties: false`. (typia and
-TypeBox still win the *invalid* path, where they bail on the first error rather
-than collecting a full error list.)
-
-Preparing a validator costs ~0.1 ms for mjst codegen and ~0.05–0.12 ms for a
-TypeBox `TypeCompiler` compile, versus ~8–10 ms for an Ajv compile. Every library
+(seven scalar roots plus a nested object): the boolean guard puts mjst clearly
+ahead of typia on `assert-strict` (with `additionalProperties: false`) and
+neck-and-neck with it on `assert-loose` — the two trade the lead run-to-run
+within noise. (typia and TypeBox still win the *invalid* path, where they bail on
+the first error rather than collecting a full error list.)
+
+Preparing a validator costs ~0.3–0.6 ms for mjst codegen and ~0.05–0.2 ms for a
+TypeBox `TypeCompiler` compile, versus ~9–12 ms for an Ajv compile. Every library
 agrees on every verdict; parity is asserted before timing (TypeBox is given
 uuid/email format checkers so every library does the same work). Each library is
 timed in an isolated process over a pool of distinct inputs, reporting the median

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

@@ -54,7 +54,11 @@ const collectDirectRefs = (value, refs = []) => {
     // generated files, not inlined by this validator. `collectDirectRefs`
     // self-guards on non-objects, so a keyword that is a boolean or missing is a
     // harmless no-op.
-    const subSchemaMaps = ['properties', 'patternProperties', 'dependentSchemas'];
+    // `dependencies` (draft-07) is dual-form: a string array (dependentRequired) or
+    // a subschema (dependentSchemas). The emitter delegates the schema form via
+    // `validateX`, so a `$ref` inside it must be imported; the string-array form is
+    // a harmless no-op here (its values are strings, not schemas).
+    const subSchemaMaps = ['properties', 'patternProperties', 'dependentSchemas', 'dependencies'];
     for (const mapKey of subSchemaMaps) {
         const map = schema[mapKey];
         if (typeof map === 'object' && map !== null && !Array.isArray(map)) {

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

@@ -105,6 +105,21 @@ const getTypeArray = (schema) => {
     return schema.type;
 };
 const createRootContext = () => ({ objVar: 'obj', pathPrefix: '${_path}', depth: 0, hoisted: [] });
+/**
+ * Renders a schema-controlled property name as a static error-path segment.
+ *
+ * The name is appended to a backtick template-literal path (`` `${_path}/…` ``),
+ * so two independent escapings apply. First the JSON Pointer escape (`~`→`~0`,
+ * `/`→`~1`, `~` first) so a key containing `/` or `~` reads back unambiguously —
+ * matching the paths the runtime-validators interpreter emits. Then a
+ * template-literal escape of `` ` ``, `\`, and `$`, so a key like `` a`b `` or
+ * `${x}` cannot terminate the literal (a build failure) or inject an
+ * interpolation (a runtime `ReferenceError` / arbitrary expression).
+ */
+const pointerSegment = (key) => key
+    .replace(/~/g, '~0')
+    .replace(/\//g, '~1')
+    .replace(/[\\`$]/g, '\\$&');
 /**
  * Returns the `patternProperties` regex sources, or an empty array when the
  * schema declares none. The keys of `patternProperties` are the patterns.
@@ -183,31 +198,54 @@ const generateMissingRequiredChecks = (schema, ctx) => {
  * and recursion into inline nested objects.
  */
 const generatePropertyChecks = (key, propSchema, isRequired, suffix, ctx) => {
-    if (!isSchemaObject(propSchema))
+    if (!isSchemaObject(propSchema)) {
+        // A boolean `true` (accept-anything) schema carries no shape checks, but a
+        // required key must still be present. `false` never validates a present value,
+        // which the strict-key / additionalProperties path handles; here we only need
+        // to enforce presence for `true`.
+        if (isRequired && propSchema === true) {
+            const parentPath = ctx.depth === 0 ? '_path' : `\`${ctx.pathPrefix}\``;
+            return [
+                `  if (!(${JSON.stringify(key)} in ${ctx.objVar})) {`,
+                `    errors.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath} })`,
+                `  }`,
+            ];
+        }
         return [];
+    }
     const raw = `${ctx.objVar}[${JSON.stringify(key)}]`;
-    const path = `\`${ctx.pathPrefix}/${key}\``;
+    const path = `\`${ctx.pathPrefix}/${pointerSegment(key)}\``;
     // Missing-property errors report at the parent object's path. At the root
     // that is the `_path` parameter itself; inside nested objects it is the
     // parent's accumulated static path.
     const parentPath = ctx.depth === 0 ? '_path' : `\`${ctx.pathPrefix}\``;
     const lines = [];
-    // $ref — delegate to the imported validator
+    // $ref — delegate to the imported validator. Per 2020-12, sibling keywords
+    // alongside `$ref` still apply to the same value, so any constraint/combinator
+    // siblings (e.g. `{ $ref, minLength: 5 }`) run after the delegation. A bare
+    // `{ $ref }` produces no siblings, leaving the output unchanged.
     if (hasRef(propSchema)) {
         const ref = propSchema.$ref;
         const vName = validatorName(refToName(ref, suffix));
+        const siblings = [
+            ...generateConstraintChecks(key, raw, path, propSchema, suffix, ctx),
+            ...generateCombinatorChecks(key, raw, path, propSchema, suffix, ctx),
+        ];
+        const delegate = [
+            `    const _r = ${vName}(${raw}, ${path})`,
+            `    if (_r !== true) errors.push(..._r.errors)`,
+            ...siblings,
+        ];
         if (isRequired) {
             lines.push(`  if (!(${JSON.stringify(key)} in ${ctx.objVar})) {`);
             lines.push(`    errors.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath} })`);
             lines.push(`  } else {`);
-            lines.push(`    const _r = ${vName}(${raw}, ${path})`);
-            lines.push(`    if (_r !== true) errors.push(..._r.errors)`);
+            lines.push(...delegate);
             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(...delegate);
             lines.push(`  }`);
         }
         return lines;
@@ -347,20 +385,32 @@ const generatePropertyChecks = (key, propSchema, isRequired, suffix, ctx) => {
             ...generateConstraintChecks(key, raw, path, propSchema, suffix, ctx),
             ...generateCombinatorChecks(key, raw, path, propSchema, suffix, ctx),
         ];
-    if (extraLines.length > 0) {
-        if (!hasType(propSchema) && isRequired) {
-            // No `type` to anchor a missing-property check, so enforce presence here.
-            lines.push(`  if (!(${JSON.stringify(key)} in ${ctx.objVar})) {`);
-            lines.push(`    errors.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath} })`);
-            lines.push(`  } else {`);
+    if (hasType(propSchema)) {
+        // Presence was already enforced in the `hasType` branch; only wrap the
+        // combinator siblings so they run when the value is present.
+        if (extraLines.length > 0) {
+            lines.push(`  if (${raw} !== undefined) {`);
             lines.push(...extraLines);
             lines.push(`  }`);
         }
-        else {
-            lines.push(`  if (${raw} !== undefined) {`);
+    }
+    else if (isRequired) {
+        // Type-less required property. Presence must be enforced even when the schema
+        // contributes no other checks (e.g. `{}` — an accept-anything schema), so a
+        // missing required key is still an error. Any extra checks run in the `else`.
+        lines.push(`  if (!(${JSON.stringify(key)} in ${ctx.objVar})) {`);
+        lines.push(`    errors.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath} })`);
+        if (extraLines.length > 0) {
+            lines.push(`  } else {`);
             lines.push(...extraLines);
-            lines.push(`  }`);
         }
+        lines.push(`  }`);
+    }
+    else if (extraLines.length > 0) {
+        // Type-less optional property: run any checks only when the value is present.
+        lines.push(`  if (${raw} !== undefined) {`);
+        lines.push(...extraLines);
+        lines.push(`  }`);
     }
     return lines;
 };
@@ -485,7 +535,16 @@ const generateConstraintChecks = (key, raw, path, propSchema, suffix, ctx) => {
         hasMaxItems(propSchema) ||
         (hasUniqueItems(propSchema) && propSchema.uniqueItems === true) ||
         isSchemaObject(sp['contains']) ||
-        Array.isArray(sp['prefixItems'])) {
+        Array.isArray(sp['prefixItems']) ||
+        (sp['items'] === false && !Array.isArray(sp['prefixItems']))) {
+        // `items: false` with no `prefixItems` forbids every element, so the array
+        // must be empty. (With `prefixItems`, the tuple block below caps the length
+        // instead.) Without this the constraint was silently ignored.
+        if (sp['items'] === false && !Array.isArray(sp['prefixItems'])) {
+            lines.push(`  if (Array.isArray(${raw}) && ${raw}.length > 0) {`);
+            lines.push(`    errors.push({ message: 'must NOT have more than 0 items', path: ${path} })`);
+            lines.push(`  }`);
+        }
         if (hasMinItems(propSchema)) {
             lines.push(`  if (Array.isArray(${raw}) && ${raw}.length < ${propSchema.minItems}) {`);
             lines.push(`    errors.push({ message: 'must have at least ${propSchema.minItems} items', path: ${path} })`);
@@ -778,7 +837,7 @@ const generateInlineObjectChecks = (key, propSchema, raw, suffix, ctx) => {
         // When `key` is empty the value is located AT `ctx.pathPrefix` already (e.g. an
         // inline object reached through a combinator branch or a dynamic-key value), so
         // appending `/${key}` would emit a spurious `//` or trailing `/` in error paths.
-        pathPrefix: key === '' ? ctx.pathPrefix : `${ctx.pathPrefix}/${key}`,
+        pathPrefix: key === '' ? ctx.pathPrefix : `${ctx.pathPrefix}/${pointerSegment(key)}`,
         depth: ctx.depth + 1,
         hoisted: ctx.hoisted,
     };
@@ -1566,10 +1625,44 @@ const generateScalarValidator = (schema, typeName, suffix) => {
     // (exactly one) and inline branches included, not just `$ref` branches.
     if (hasAllOf(schema) || hasAnyOf(schema) || hasOneOf(schema) || 'not' in schema || 'if' in schema) {
         const ctx = createRootContext();
-        const checks = generateCombinatorChecks('', 'input', '`${_path}`', schema, suffix, ctx);
+        const checks = [];
+        // The root path expression the shared emitters use, as a template literal body.
+        const rootPath = '`${_path}`';
+        // A `type` (and its sibling value constraints) alongside a combinator still
+        // applies — the value must satisfy BOTH. Emit the type/constraint checks first,
+        // then the combinator checks, so a schema like `{ type: 'string', not: {…} }`
+        // or `{ type: 'number', minimum: 10, allOf: [{ maximum: 100 }] }` no longer
+        // drops the `type` check and its siblings.
+        const rootTypeArray = getTypeArray(schema);
+        if (rootTypeArray) {
+            const allWrong = rootTypeArray
+                .map((t) => wrongTypeCondition('input', t))
+                .filter((c) => c !== '')
+                .map((c) => `(${c})`)
+                .join(' && ');
+            if (allWrong) {
+                const label = rootTypeArray.map((t) => typeofString(t)).join(' or ');
+                checks.push(`  if (${allWrong}) {`);
+                checks.push(`    errors.push({ message: ${JSON.stringify(`must be ${label}`)}, path: ${rootPath} })`);
+                checks.push(`  }`);
+            }
+            checks.push(...generateConstraintChecks('', 'input', rootPath, schema, suffix, ctx));
+        }
+        else if (hasType(schema)) {
+            const t = schema.type;
+            const wrongType = wrongTypeCondition('input', t);
+            if (wrongType) {
+                checks.push(`  if (${wrongType}) {`);
+                checks.push(`    errors.push({ message: 'must be ${typeofString(t)}', path: ${rootPath} })`);
+                checks.push(`  }`);
+            }
+            checks.push(...generateConstraintChecks('', 'input', rootPath, schema, suffix, ctx));
+        }
+        checks.push(...generateCombinatorChecks('', 'input', rootPath, schema, suffix, ctx));
         const body = checks.join('\n').replaceAll('errors.push(', '(errors ??= []).push(');
+        const hoistedBlock = ctx.hoisted.length > 0 ? `${ctx.hoisted.join('\n')}\n\n` : '';
         return [
-            `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+            `${hoistedBlock}export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
             `  let errors: ValidationError[] | undefined`,
             body,
             `  return errors !== undefined ? { valid: false, errors } : true`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/generate-validators",
-  "version": "0.11.6",
+  "version": "0.11.7",
   "description": "Generate TypeScript validation functions from JSON Schemas.",
   "module": "./dist/index.js",
   "type": "module",
@@ -46,10 +46,10 @@
   },
   "dependencies": {
     "json-schema-typed": "^8.0.1",
-    "@amritk/helpers": "0.13.0"
+    "@amritk/helpers": "0.13.1"
   },
   "devDependencies": {
-    "@amritk/runtime-validators": "0.7.0",
+    "@amritk/runtime-validators": "0.7.1",
     "@ryoppippi/unplugin-typia": "^2.6.5",
     "@scalar/openapi-parser": "^0.26.1",
     "@sinclair/typebox": "^0.34.49",