@amritk/generate-parsers 0.8.0 → 0.9.0

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

@@ -2,6 +2,7 @@ import { escapeRegexPattern } from '@amritk/helpers/escape-regex-pattern';
 import { refToName } from '@amritk/helpers/ref-to-name';
 import { safeAccessor, safeKey } from '@amritk/helpers/safe-accessor';
 import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasConst, hasDefault, hasEnum, hasExamples, hasExclusiveMaximum, hasExclusiveMinimum, hasItems, hasMaxItems, hasMaximum, hasMaxLength, hasMinItems, hasMinimum, hasMinLength, hasMultipleOf, hasOneOf, hasPattern, hasProperties, hasRef, hasType, hasUniqueItems, isObjectSchema, isSchemaObject, } from '@amritk/helpers/schema-guards';
+import { unknownKeyCheck } from '@amritk/helpers/unknown-key-check';
 import { getDefaultValue } from '../helpers/get-default-value.js';
 import { generateObjectStrictAssertion, generateScalarStrictAssertion } from './generate-strict-assertion.js';
 import { generateValidationExpression } from './generate-validation-expression.js';
@@ -551,13 +552,17 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
         preamble.push(generateShapeValidator(propSchema, subName, useRefImports, suffix, false));
         preamble.push(generateObjectParser(propSchema, subName, useRefImports, suffix, logWarnings, strict, false));
     }
-    // additionalProperties: false — hoist the declared-keys Set so the per-call
-    // sweep is one Set lookup per key. The predicate form is shared by the fast
-    // path and the shape validator; strict mode throws with the offending key.
+    // additionalProperties: false — the per-key "is this undeclared" test inlines
+    // `!==` comparisons for a short key list and hoists a Set only for a long one
+    // (see unknownKeyCheck). The predicate form is shared by the fast path and the
+    // shape validator; strict mode throws with the offending key.
     const strictKeys = hasStrictKeys(schema);
+    const strictKeyCheck = unknownKeyCheck(properties.map(([key]) => key), `_knownKeys${typeName}`);
     if (strictKeys) {
-        preamble.push(`const _knownKeys${typeName} = new Set(${JSON.stringify(properties.map(([key]) => key))});`);
-        preamble.push(`const _hasOnlyKnownKeys${typeName} = (input: Record<string, unknown>): boolean => {\n  for (const _k in input) if (!_knownKeys${typeName}.has(_k)) return false;\n  return true;\n};`);
+        for (const declaration of strictKeyCheck.declarations) {
+            preamble.push(`${declaration};`);
+        }
+        preamble.push(`const _hasOnlyKnownKeys${typeName} = (input: Record<string, unknown>): boolean => {\n  for (const _k in input) if (${strictKeyCheck.isUnknown('_k')}) return false;\n  return true;\n};`);
     }
     const fallbackObject = generateFallbackObject(schema, useRefImports, typeName, suffix, subTypeNames);
     const lines = [];
@@ -568,7 +573,7 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
         }
         if (strictKeys) {
             lines.push(`  for (const _k in input) {`);
-            lines.push(`    if (!_knownKeys${typeName}.has(_k)) throw new Error(\`[${typeName}] unknown property "\${_k}"\`);`);
+            lines.push(`    if (${strictKeyCheck.isUnknown('_k')}) throw new Error(\`[${typeName}] unknown property "\${_k}"\`);`);
             lines.push(`  }`);
         }
     }
@@ -631,10 +636,12 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
     }
     // Emit a warning for any input key not declared in the schema's properties
     if (logWarnings && propInfo.length > 0) {
-        const keysList = propInfo.map(({ key }) => JSON.stringify(key)).join(', ');
-        lines.push(`  const _knownKeys = new Set([${keysList}]);`);
+        const warnKeyCheck = unknownKeyCheck(propInfo.map(({ key }) => key), '_knownKeys');
+        for (const declaration of warnKeyCheck.declarations) {
+            lines.push(`  ${declaration};`);
+        }
         lines.push(`  for (const _k in input) {`);
-        lines.push(`    if (!_knownKeys.has(_k)) {`);
+        lines.push(`    if (${warnKeyCheck.isUnknown('_k')}) {`);
         lines.push(`      console.warn(\`[${typeName}] Unknown property "\${_k}"\`);`);
         lines.push(`    }`);
         lines.push(`  }`);
@@ -747,6 +754,59 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
         return fn;
     return `${preamble.join('\n\n')}\n\n${fn}`;
 };
+/**
+ * Combined-parser variant for `properties` + `patternProperties` schemas that
+ * set `additionalProperties: false`. Declared properties are coerced as usual,
+ * keys matching any pattern are kept (the first `$ref` pattern is coerced via
+ * its imported parser when ref imports are on), and every other key is rejected
+ * in strict mode or stripped in coerce mode — matching the interpreter.
+ */
+const generateStrictCombinedParser = (schema, typeName, functionName, propertyLines, patterns, useRefImports, suffix, strict) => {
+    const declaredKeys = hasProperties(schema) ? Object.keys(schema.properties) : [];
+    // Below the inline threshold a key === "a" || key === "b" chain skips declared
+    // keys without the per-call Set allocation; a wider list hoists the Set.
+    const knownKeyCheck = unknownKeyCheck(declaredKeys, '_knownKeys');
+    // The first $ref pattern (when ref imports are on) coerces its matching values
+    // through the imported parser; the remaining patterns keep the raw value.
+    const refPattern = useRefImports ? patterns.find(([, ps]) => isSchemaObject(ps) && hasRef(ps)) : undefined;
+    const loopLines = [`    if (${knownKeyCheck.isKnown('key')}) continue;`];
+    if (refPattern) {
+        const parserName = generateParserName(refToName(refPattern[1].$ref, suffix));
+        loopLines.push(`    if (/${escapeRegexPattern(refPattern[0])}/.test(key)) {`);
+        loopLines.push(`      (result as Record<string, unknown>)[key] = ${parserName}(input[key]);`);
+        loopLines.push(`      continue;`);
+        loopLines.push(`    }`);
+    }
+    const keepConditions = patterns
+        .filter(([p]) => !(refPattern && p === refPattern[0]))
+        .map(([p]) => `/${escapeRegexPattern(p)}/.test(key)`);
+    if (keepConditions.length > 0) {
+        loopLines.push(`    if (${keepConditions.join(' || ')}) {`);
+        loopLines.push(`      (result as Record<string, unknown>)[key] = input[key];`);
+        loopLines.push(`      continue;`);
+        loopLines.push(`    }`);
+    }
+    // Unknown key: throw in strict mode, otherwise let it fall through (dropped,
+    // since it was never copied into `result`).
+    if (strict)
+        loopLines.push(`    throw new Error(\`[${typeName}] unknown property "\${key}"\`);`);
+    const notObjectBranch = strict
+        ? `    throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);`
+        : `    return {} as unknown as ${typeName};`;
+    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('');
+    return `export const ${functionName} = (input: unknown): ${typeName} => {
+  if (!isObject(input)) {
+${notObjectBranch}
+  }
+${knownKeysDeclaration}  const result = ${resultBody} as unknown as ${typeName};
+  for (const key in input) {
+${loopLines.join('\n')}
+  }
+  return result;
+};`;
+};
 /**
  * Generates a parser for schemas that have both properties AND patternProperties.
  * Parses the known properties first, then iterates remaining keys to match patterns.
@@ -768,6 +828,14 @@ const generateCombinedObjectParser = (schema, typeName, useRefImports, suffix, l
     const patternProps = schema.patternProperties;
     const patterns = Object.entries(patternProps);
     const refPattern = patterns.find(([, ps]) => isSchemaObject(ps) && hasRef(ps));
+    const strictKeys = hasAdditionalProperties(schema) && schema.additionalProperties === false;
+    // With `additionalProperties: false`, keys matching neither a declared
+    // property nor any pattern must be rejected (strict) or stripped (coerce).
+    // The blanket `...input` spread used below cannot do that, so build a
+    // selective copy that mirrors the interpreter's undeclared-key handling.
+    if (strictKeys) {
+        return generateStrictCombinedParser(schema, typeName, functionName, propertyLines, patterns, useRefImports, suffix, strict);
+    }
     if (!refPattern || !useRefImports) {
         return generateObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict);
     }
@@ -894,6 +962,38 @@ const generatePatternPropertiesParser = (schema, typeName, useRefImports, suffix
     const notObjectBranch = strict
         ? `    throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);`
         : `    return {} as unknown as ${typeName};`;
+    // With `additionalProperties: false`, only keys matching a pattern survive:
+    // others are rejected (strict) or stripped (coerce). Start from an empty
+    // object rather than spreading every input key.
+    const strictKeys = hasAdditionalProperties(schema) && schema.additionalProperties === false;
+    if (strictKeys) {
+        const loopLines = [`    if (/${escapedPattern}/.test(key)) {`];
+        if (patternAssignment) {
+            loopLines.push(`      const value = input[key];`);
+            loopLines.push(`      ${patternAssignment}`);
+        }
+        loopLines.push(`      continue;`);
+        loopLines.push(`    }`);
+        const keepConditions = patterns.slice(1).map(([p]) => `/${escapeRegexPattern(p)}/.test(key)`);
+        if (keepConditions.length > 0) {
+            loopLines.push(`    if (${keepConditions.join(' || ')}) {`);
+            loopLines.push(`      (result as Record<string, unknown>)[key] = input[key];`);
+            loopLines.push(`      continue;`);
+            loopLines.push(`    }`);
+        }
+        if (strict)
+            loopLines.push(`    throw new Error(\`[${typeName}] unknown property "\${key}"\`);`);
+        return `export const ${functionName} = (input: unknown): ${typeName} => {
+  if (!isObject(input)) {
+${notObjectBranch}
+  }
+  const result = {} as unknown as ${typeName};
+  for (const key in input) {
+${loopLines.join('\n')}
+  }
+  return result;
+};`;
+    }
     // Generate a parser that handles both pattern matching and x- extensions
     return `export const ${functionName} = (input: unknown): ${typeName} => {
   if (!isObject(input)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/generate-parsers",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Generate TypeScript parsers and type definitions from JSON Schemas.",
   "module": "./dist/index.js",
   "type": "module",
@@ -47,7 +47,7 @@
   },
   "dependencies": {
     "json-schema-typed": "^8.0.1",
-    "@amritk/helpers": "0.9.0",
+    "@amritk/helpers": "0.10.0",
     "@amritk/generate-markdown": "0.2.4"
   }
 }