@amritk/generate-parsers 0.16.1 → 0.16.2

package/README.md

@@ -173,10 +173,10 @@ x64), parsing valid input at steady state:
 
 | case | mode | mjst (generated) | zod | typebox |
 |:--|:--|--:|--:|--:|
-| user (4 fields) | parseSafe | **~11M** ops/s | ~2.5M ops/s | ~1.0M ops/s |
-| order (nested + array) | parseSafe | **~3.9M** ops/s | ~0.46M ops/s | ~0.13M ops/s |
-| user (4 fields) | parseStrict | **~9M** ops/s | ~1.4M ops/s | ~1.3M ops/s |
-| order (nested + array) | parseStrict | **~5.4M** ops/s | ~0.27M ops/s | ~0.20M ops/s |
+| user (4 fields) | parseSafe | **~16M** ops/s | ~3.3M ops/s | ~1.3M ops/s |
+| order (nested + array) | parseSafe | **~5.8M** ops/s | ~0.6M ops/s | ~0.18M ops/s |
+| user (4 fields) | parseStrict | **~13M** ops/s | ~1.8M ops/s | ~1.85M ops/s |
+| order (nested + array) | parseStrict | **~7.5M** ops/s | ~0.36M ops/s | ~0.28M ops/s |
 
 The upstream `assert` case (seven scalar roots plus a nested object) runs faster
 still — tens of millions of ops/s — but at that size the numbers swing enough

package/dist/generators/generate-enum-check.js

@@ -37,18 +37,27 @@ export const generateEnumCheck = (accessor, enumValues) => {
  * keeps its plain fallback and emits no extra code.
  */
 export const generateEnumCaseInsensitiveCoercion = (accessor, enumValues, fallback) => {
-    const byLower = {};
+    const entries = [];
+    const seen = new Set();
     for (const value of enumValues) {
         if (typeof value !== 'string')
             continue;
         const lower = value.toLowerCase();
         // First writer wins, so declaration order breaks ties between members that
-        // fold to the same key (e.g. `"on"` and `"ON"`).
-        if (!(lower in byLower))
-            byLower[lower] = value;
+        // fold to the same key (e.g. `"on"` and `"ON"`). `Set` membership is used
+        // instead of `lower in obj` so a member folding to an inherited name like
+        // `constructor` or `toString` is not wrongly treated as already-present.
+        if (seen.has(lower))
+            continue;
+        seen.add(lower);
+        entries.push([lower, value]);
     }
-    if (Object.keys(byLower).length === 0)
+    if (entries.length === 0)
         return null;
-    const map = JSON.stringify(byLower);
-    return `(typeof ${accessor} === "string" ? ((${map} as Record<string, string>)[(${accessor} as string).toLowerCase()] ?? ${fallback}) : ${fallback})`;
+    // A `Map` — not a plain object — so a folded key that collides with an
+    // inherited member (`constructor`, `toString`, `__proto__`, …) resolves to
+    // `undefined` (→ `fallback`) rather than an `Object.prototype` value. A
+    // plain-object lookup would return the inherited function/object for such a key.
+    const map = `new Map(${JSON.stringify(entries)})`;
+    return `(typeof ${accessor} === "string" ? (${map}.get((${accessor} as string).toLowerCase()) ?? ${fallback}) : ${fallback})`;
 };

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

@@ -454,6 +454,18 @@ const generateNonObjectParser = (typeName, schema, strict, unionCtx) => {
             return `export const ${functionName} = (input: unknown): ${typeName} => input as ${typeName};`;
         }
     }
+    // Strict counterpart of the block above for a *type-less* `const`/`enum` root
+    // (`{ enum: [...] }` / `{ const: ... }` with no `type`): the no-`type` bail
+    // below would otherwise return a bare cast, so strict mode has to assert
+    // membership here. A typed `const`/`enum` (`{ type: 'string', enum: [...] }`)
+    // keeps flowing to the strict scalar path, which asserts it via
+    // generateScalarStrictAssertion.
+    if (strict && isSchemaObject(schema) && !hasType(schema) && (hasConst(schema) || hasEnum(schema))) {
+        const assertion = generateScalarStrictAssertion(schema, typeName, unionCtx?.rootSchema);
+        if (assertion !== null) {
+            return `export const ${functionName} = (input: unknown): ${typeName} => {\n${assertion}\n  return input as ${typeName};\n};`;
+        }
+    }
     // Root-level arrays with rich item schemas delegate every element to a real
     // parser, so nested enums and $refs inside array items are validated instead
     // of spread through unchecked. $ref items call the imported parser; inline
@@ -1243,7 +1255,18 @@ const generateStrictCombinedParser = (schema, typeName, functionName, propertyLi
     const resultBody = propertyLines.length > 0 ? `{\n${propertyLines.join('\n')}\n  }` : '{}';
     // Only the Set form needs a declaration; the inline === chain is stateless.
     const knownKeysDeclaration = knownKeyCheck.declarations.map((decl) => `  ${decl};\n`).join('');
-    const keywordPrelude = strict ? strictObjectKeywordPrelude(schema, typeName) : '';
+    // In strict mode assert the declared properties (type, required, enum,
+    // constraints) — the `result` below is built from the *coercing* property
+    // lines, which silently repair a wrong type and default a missing required key
+    // instead of throwing. `generateObjectStrictAssertion` throws first; the
+    // coercing build then runs only on already-valid input (a no-op there). It also
+    // covers the object-level keyword checks, so it replaces the keyword-only
+    // prelude. `.slice(1)` drops its `isObject` check (emitted just below). Coerce
+    // mode (stripUnknown) keeps its lighter prelude.
+    const assertionPrelude = strict
+        ? generateObjectStrictAssertion(schema, typeName, { useRefImports, suffix }).slice(1)
+        : [];
+    const keywordPrelude = assertionPrelude.length > 0 ? `\n${assertionPrelude.join('\n')}` : '';
     return `export const ${functionName} = (input: unknown): ${typeName} => {
   if (!isObject(input)) {
 ${notObjectBranch}
@@ -1284,6 +1307,14 @@ const generateCombinedObjectParser = (schema, typeName, useRefImports, suffix, l
     if (strictKeys) {
         return generateStrictCombinedParser(schema, typeName, functionName, propertyLines, patterns, useRefImports, suffix, strict);
     }
+    // `stripUnknown` (coerce mode) must keep keys a `patternProperties` regex
+    // declares and drop only the genuinely-undeclared ones. Delegating to
+    // `generateObjectParser` below would strip the pattern-matching keys too — its
+    // strip logic only knows the declared `properties`. The selective combined
+    // copy keeps declared + pattern-matching keys, exactly like the interpreter.
+    if (stripUnknown && !strict) {
+        return generateStrictCombinedParser(schema, typeName, functionName, propertyLines, patterns, useRefImports, suffix, false);
+    }
     if (!refPattern || !useRefImports) {
         return generateObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict, true, stripUnknown, undefined, NO_RESERVED_NAMES, caseInsensitive);
     }
@@ -1341,7 +1372,7 @@ const generateAdditionalPropertiesParser = (schema, typeName, useRefImports, suf
     }
     // Handle additionalProperties with a known type by generating inline validation
     if (isSchemaObject(additionalProps) && hasType(additionalProps)) {
-        const inlineParser = generateInlineValueParser(additionalProps);
+        const inlineParser = generateInlineValueParser(additionalProps, strict, `[${typeName}]`);
         if (inlineParser) {
             if (strict) {
                 return `export const ${functionName} = (input: unknown): ${typeName} => {\n  if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);${keywordPrelude}\n  return validateRecord(input, ${inlineParser}) as ${typeName};\n};`;
@@ -1362,10 +1393,30 @@ const generateAdditionalPropertiesParser = (schema, typeName, useRefImports, suf
  * Used to generate parsers for Record-like types where values have a known
  * primitive or array type (e.g. Record<string, string> or Record<string, string[]>).
  */
-const generateInlineValueParser = (schema) => {
+const generateInlineValueParser = (schema, strict = false, label = '') => {
     if (!isSchemaObject(schema) || !hasType(schema)) {
         return null;
     }
+    // Strict mode must *throw* on a wrong-typed record value, not repair it — the
+    // coercing branch below would silently turn `{ a: 'x' }` into `{ a: 0 }` for a
+    // `Record<string, number>`, which strict mode is documented never to do.
+    if (strict) {
+        const err = (t) => `throw new Error(${JSON.stringify(`${label} record value must be ${t}`)})`;
+        switch (schema.type) {
+            case 'string':
+                return `(value: unknown) => { if (typeof value !== "string") ${err('string')}; return value; }`;
+            case 'number':
+                return `(value: unknown) => { if (typeof value !== "number") ${err('number')}; return value; }`;
+            case 'integer':
+                return `(value: unknown) => { if (typeof value !== "number" || !Number.isInteger(value)) ${err('integer')}; return value; }`;
+            case 'boolean':
+                return `(value: unknown) => { if (typeof value !== "boolean") ${err('boolean')}; return value; }`;
+            case 'array':
+                return `(value: unknown) => { if (!Array.isArray(value)) ${err('array')}; return value; }`;
+            default:
+                return null;
+        }
+    }
     switch (schema.type) {
         case 'string':
             return '(value: unknown) => typeof value === "string" ? value : ""';

package/dist/generators/generate-strict-assertion.js

@@ -4,7 +4,7 @@ import { multipleOfFailExpr } from '@amritk/helpers/multiple-of-check';
 import { quoteJsString } from '@amritk/helpers/quote-js-string';
 import { resolveRef } from '@amritk/helpers/resolve-ref';
 import { safeAccessor } from '@amritk/helpers/safe-accessor';
-import { hasDependentRequired, hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasItems, hasMaxItems, hasMaximum, hasMaxLength, hasMinItems, hasMinimum, hasMinLength, hasMultipleOf, hasPattern, hasProperties, hasPropertyNames, hasRef, hasRequired, hasType, hasUniqueItems, isSchemaObject, } from '@amritk/helpers/schema-guards';
+import { hasConst, hasDependentRequired, hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasItems, hasMaxItems, hasMaximum, hasMaxLength, hasMinItems, hasMinimum, hasMinLength, hasMultipleOf, hasPattern, hasProperties, hasPropertyNames, hasRef, hasRequired, hasType, hasUniqueItems, isSchemaObject, } from '@amritk/helpers/schema-guards';
 import { generateEnumCheck } from './generate-enum-check.js';
 import { canEnforceUnion, generateUnionCheck, getUnionBranches, isInlineObjectProperty } from './generate-type-checks.js';
 import { getPrefixItems, prefixItemsCapsLength, scalarItemTypeCheck } from './generate-validation-expression.js';
@@ -57,12 +57,11 @@ const throwError = (message, suffixExpr) => {
  * Generates strict-mode constraint checks for a typed property
  * (pattern, length, min/max, multipleOf).
  */
-const generateConstraintChecks = (acc, propSchema, typeName, key, context = {}) => {
+const generateConstraintChecks = (acc, propSchema, field, context = {}) => {
     if (!isSchemaObject(propSchema) || !hasType(propSchema))
         return [];
     const t = propSchema.type;
     const lines = [];
-    const field = `[${typeName}] field '${key}'`;
     if (t === 'string') {
         if (hasPattern(propSchema)) {
             const pattern = escapeRegexPattern(propSchema.pattern);
@@ -375,7 +374,7 @@ const generatePropertyAssertion = (key, propSchema, isRequired, typeName, contex
                 lines.push(`  if (${acc} !== undefined && (${wrongType})) ${expected};`);
             }
         }
-        lines.push(...generateConstraintChecks(acc, propSchema, typeName, key, context));
+        lines.push(...generateConstraintChecks(acc, propSchema, field, context));
     }
     // Type-independent constraints, each runtime-gated on the value's shape:
     //   - `contains` asserts on arrays (no-op otherwise),
@@ -444,23 +443,45 @@ export const generateScalarStrictAssertion = (schema, typeName, rootSchema) => {
     if (primitive) {
         return `  if (typeof input !== "${primitive}") ${throwError(`[${typeName}] expected ${primitive}, got `, got)};`;
     }
-    if (!isSchemaObject(schema) || !hasType(schema))
-        return null;
-    const t = schema.type;
-    const wrongType = wrongTypeCondition('input', t);
-    if (!wrongType)
+    if (!isSchemaObject(schema))
         return null;
-    const lines = [`  if (${wrongType}) ${throwError(`[${typeName}] expected ${typeLabel(t)}, got `, got)};`];
-    // Root-level arrays enforce scalar/enum item types too — the same gap the
-    // property path closes in generateConstraintChecks — plus `contains`.
-    if (t === 'array') {
-        const itemCheck = generateItemCheck(schema);
-        if (itemCheck) {
-            lines.push(`  if (!(input as readonly unknown[]).every((_it) => ${itemCheck.check})) ${throwError(`[${typeName}] ${itemCheck.message}`)};`);
+    const label = `[${typeName}]`;
+    const lines = [];
+    // `const` / `enum` apply to a root value regardless of a declared `type` — a
+    // root `{ enum: [...] }` or `{ const: ... }` must reject a non-member, not
+    // silently coerce it. `const` is compared through `JSON.stringify` so it works
+    // for any JSON value; the value must match exactly.
+    if (hasConst(schema)) {
+        const wanted = JSON.stringify(JSON.stringify(schema.const));
+        lines.push(`  if (JSON.stringify(input) !== ${wanted}) ${throwError(`${label} must be ${JSON.stringify(schema.const)}`)};`);
+    }
+    else if (hasEnum(schema)) {
+        const allowed = JSON.stringify(schema.enum);
+        const enumLabel = schema.enum.map((v) => JSON.stringify(v)).join(', ');
+        lines.push(`  if (!(${allowed} as readonly unknown[]).includes(input)) ${throwError(`${label} must be one of: ${enumLabel}`)};`);
+    }
+    if (hasType(schema)) {
+        const t = schema.type;
+        const wrongType = wrongTypeCondition('input', t);
+        if (wrongType) {
+            lines.push(`  if (${wrongType}) ${throwError(`${label} expected ${typeLabel(t)}, got `, got)};`);
         }
-        lines.push(...generateContainsCheck('input', schema, `[${typeName}]`));
-        // Tuple `prefixItems`: assert each position and cap length under items:false.
-        lines.push(...generatePrefixItemsAssertion('input', `[${typeName}]`, schema, rootSchema));
+        // Root-level arrays enforce scalar/enum item types too — the same gap the
+        // property path closes in generateConstraintChecks — plus `contains`.
+        if (t === 'array') {
+            const itemCheck = generateItemCheck(schema);
+            if (itemCheck) {
+                lines.push(`  if (!(input as readonly unknown[]).every((_it) => ${itemCheck.check})) ${throwError(`${label} ${itemCheck.message}`)};`);
+            }
+            lines.push(...generateContainsCheck('input', schema, label));
+            // Tuple `prefixItems`: assert each position and cap length under items:false.
+            lines.push(...generatePrefixItemsAssertion('input', label, schema, rootSchema));
+        }
+        // String (pattern, min/maxLength), number/integer (bounds, multipleOf) and
+        // array (length, uniqueItems) constraints — previously enforced only for
+        // named properties, so a root scalar accepted e.g. `{type:'string',minLength:5}`
+        // violations.
+        lines.push(...generateConstraintChecks('input', schema, label, rootSchema ? { rootSchema } : {}));
     }
-    return lines.join('\n');
+    return lines.length > 0 ? lines.join('\n') : null;
 };

package/dist/generators/generate-validation-expression.js

@@ -132,13 +132,20 @@ const getTypeCoercion = (accessor, schema, defaultValue) => {
     switch (schema.type) {
         case 'string':
             return `String(${accessor})`;
-        case 'number':
-        case 'integer': {
+        case 'number': {
             // Number() of a non-numeric string produces NaN, which silently poisons
             // arithmetic. Guard with Number.isFinite and fall back to the default.
             const n = `Number(${accessor})`;
             return `(Number.isFinite(${n}) ? ${n} : ${defaultValue})`;
         }
+        case 'integer': {
+            // An `integer` must coerce to a whole number, or the "repaired" value still
+            // fails validation (a bare `Number.isFinite` accepts `1.5`). Require
+            // integrality and fall back to the default otherwise — matching the
+            // root-level integer parser, which yields the default for a non-integer.
+            const n = `Number(${accessor})`;
+            return `(Number.isInteger(${n}) ? ${n} : ${defaultValue})`;
+        }
         case 'boolean':
             return `Boolean(${accessor})`;
         case 'array':

package/dist/helpers/get-default-value.js

@@ -50,6 +50,14 @@ export const getDefaultValue = (schema) => {
     if (getMjstPrimitive(schema) === 'bigint') {
         return '0n';
     }
+    // Array-form `type` (e.g. `["string","null"]`): `hasType` is false for it, so
+    // without this a required-but-missing value would default to `undefined` —
+    // violating both `required` and the declared type. Derive the default from the
+    // first listed type so the fallback is a valid member.
+    const rawType = schema['type'];
+    if (Array.isArray(rawType) && rawType.length > 0 && typeof rawType[0] === 'string') {
+        return getDefaultValue({ ...schema, type: rawType[0] });
+    }
     if (!hasType(schema)) {
         return 'undefined';
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/generate-parsers",
-  "version": "0.16.1",
+  "version": "0.16.2",
   "description": "Generate TypeScript parsers and type definitions from JSON Schemas.",
   "module": "./dist/index.js",
   "type": "module",
@@ -48,7 +48,7 @@
   },
   "dependencies": {
     "json-schema-typed": "^8.0.1",
-    "@amritk/helpers": "0.13.0",
+    "@amritk/helpers": "0.13.1",
     "@amritk/generate-markdown": "0.4.1"
   },
   "devDependencies": {