@amritk/generate-parsers 0.18.0 → 0.19.0

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

@@ -1,17 +1,18 @@
-import { escapeRegexPattern } from "@amritk/helpers/escape-regex-pattern";
+import { regexLiteral } from "@amritk/helpers/escape-regex-pattern";
 import { quoteJsString } from "@amritk/helpers/quote-js-string";
 import { refToName } from "@amritk/helpers/ref-to-name";
 import { resolveRef } from "@amritk/helpers/resolve-ref";
-import { safeAccessor, safeKey } from "@amritk/helpers/safe-accessor";
-import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasConst, hasEnum, hasItems, hasOneOf, hasProperties, hasRef, hasRequired, hasType, isObjectSchema, isSchemaObject } from "@amritk/helpers/schema-guards";
+import { missingCheck, safeAccessor, safeKey } from "@amritk/helpers/safe-accessor";
+import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasConst, hasEnum, hasItems, hasMaxItems, hasMaxProperties, hasMinItems, hasMinProperties, hasOneOf, hasProperties, hasRef, hasRequired, hasType, hasUniqueItems, isObjectSchema, isSchemaObject } from "@amritk/helpers/schema-guards";
 import { unknownKeyCheck } from "@amritk/helpers/unknown-key-check";
 import { findDiscriminator } from "../helpers/find-discriminator.js";
 import { getDefaultValue } from "../helpers/get-default-value.js";
 import { getDiscriminatorValue } from "../helpers/get-discriminator-value.js";
 import { assertNoUnsupportedKeywords } from "./assert-supported-keywords.js";
 import { generateEnumCaseInsensitiveCoercion } from "./generate-enum-check.js";
-import { generateContainsCheck, generateObjectKeywordChecks, generateObjectStrictAssertion, generateScalarStrictAssertion, inlineAllOfMembers } from "./generate-strict-assertion.js";
-import { canEnforceUnion, generatePropertyTypeCheck, generateUnionCheck, getUnionBranches, hasFastPathBlockingKeyword, isInlineObjectArrayProperty, isInlineObjectProperty, shapeValidatorName } from "./generate-type-checks.js";
+import { generateBackstopAssertion, generateCompositionChecks, generateContainsCheck, generateKeyedValueChecks, generateObjectKeywordChecks, generateObjectSizeChecks, generateObjectStrictAssertion, generateScalarStrictAssertion, inlineAllOfMembers } from "./generate-strict-assertion.js";
+import { canEnforceUnion, generatePropertyTypeCheck, generateUnionCheck, getUnionBranches, hasFastPathBlockingKeyword, isExclusiveUnion, isInlineObjectArrayProperty, isInlineObjectProperty, shapeValidatorName } from "./generate-type-checks.js";
+import { generateUniqueItemsCheck } from "./generate-unique-items-check.js";
 import { generatePrefixItemsMap, generateValidationExpression, getPrefixItems, isCoercibleItemSchema, prefixItemsCapsLength } from "./generate-validation-expression.js";
 const generateParserName = (typeName) => {
   return `parse${typeName}`;
@@ -149,6 +150,8 @@ const generateFallbackValue = (_, propSchema, useRefImports, suffix) => {
   }
   return getDefaultValue(propSchema);
 };
+const PROTOTYPE_MEMBER_NAMES = new Set(Object.getOwnPropertyNames(Object.prototype));
+const declaresPrototypeMemberProperty = (schema) => hasProperties(schema) && Object.keys(schema.properties).some((key) => PROTOTYPE_MEMBER_NAMES.has(key));
 const generateFallbackObject = (schema, useRefImports, typeName, suffix, subTypeNames) => {
   if (!hasProperties(schema)) {
     return `{} as ${typeName}`;
@@ -180,7 +183,7 @@ const generateFallbackObject = (schema, useRefImports, typeName, suffix, subType
     }
   }
   result += "\n      }";
-  return result;
+  return declaresPrototypeMemberProperty(schema) ? `${result} as ${typeName}` : result;
 };
 const scalarDefaultLiteral = (schema) => {
   if (!isSchemaObject(schema))
@@ -208,7 +211,7 @@ const scalarDefaultLiteral = (schema) => {
   }
   return "{}";
 };
-const generateRefUnionDispatch = (functionName, typeName, branches, strict, ctx) => {
+const generateRefUnionDispatch = (functionName, typeName, schema, branches, strict, ctx) => {
   const rootSchema = ctx.rootSchema;
   if (!ctx.useRefImports || rootSchema === void 0)
     return null;
@@ -239,17 +242,26 @@ const generateRefUnionDispatch = (functionName, typeName, branches, strict, ctx)
     if (c)
       expr = `_disc === ${JSON.stringify(c.value)} ? ${c.parser}(input) : ${expr}`;
   }
+  const backstop = strict ? generateBackstopAssertion("input", schema, `[${typeName}]`, strictContext(ctx)) : [];
+  const prelude = backstop.length > 0 ? `${backstop.join("\n")}
+` : "";
   return `export const ${functionName} = (input: unknown): ${typeName} => {
-  const _disc = ${discExpr};
+${prelude}  const _disc = ${discExpr};
   return ${expr};
 };`;
 };
+const strictContext = (ctx) => ({
+  useRefImports: ctx?.useRefImports ?? false,
+  suffix: ctx?.suffix ?? "",
+  ...ctx?.rootSchema !== void 0 ? { rootSchema: ctx.rootSchema } : {},
+  ...ctx?.stripUnknown !== void 0 ? { stripUnknown: ctx.stripUnknown } : {}
+});
 const generateNonObjectParser = (typeName, schema, strict, unionCtx) => {
   const functionName = generateParserName(typeName);
   if (unionCtx && isSchemaObject(schema) && (hasOneOf(schema) || hasAnyOf(schema))) {
     const branches = hasOneOf(schema) ? schema.oneOf : hasAnyOf(schema) ? schema.anyOf : [];
     if (branches.length > 0 && branches.every((b) => isSchemaObject(b) && hasRef(b))) {
-      const dispatch = generateRefUnionDispatch(functionName, typeName, branches, strict, unionCtx);
+      const dispatch = generateRefUnionDispatch(functionName, typeName, schema, branches, strict, unionCtx);
       if (dispatch !== null)
         return dispatch;
     }
@@ -257,16 +269,28 @@ const generateNonObjectParser = (typeName, schema, strict, unionCtx) => {
   if (unionCtx?.useRefImports && isSchemaObject(schema) && hasRef(schema) && !hasProperties(schema)) {
     const refName = refToName(schema.$ref, unionCtx.suffix);
     if (refName !== typeName) {
-      return `export const ${functionName} = (input: unknown): ${typeName} => ${generateParserName(refName)}(input) as ${typeName};`;
+      const assertion = strict ? generateBackstopAssertion("input", schema, `[${typeName}]`, strictContext(unionCtx)) : [];
+      if (assertion.length === 0) {
+        return `export const ${functionName} = (input: unknown): ${typeName} => ${generateParserName(refName)}(input) as ${typeName};`;
+      }
+      return `export const ${functionName} = (input: unknown): ${typeName} => {
+${assertion.join("\n")}
+  return ${generateParserName(refName)}(input) as ${typeName};
+};`;
     }
   }
   if (strict && unionCtx && isSchemaObject(schema)) {
     const branches = getUnionBranches(schema);
     if (branches && !unionCtx.stripUnknown && canEnforceUnion(branches, unionCtx.rootSchema)) {
-      const check = generateUnionCheck("input", branches, unionCtx.useRefImports, unionCtx.suffix);
+      const check = generateUnionCheck("input", branches, unionCtx.useRefImports, unionCtx.suffix, isExclusiveUnion(schema));
       if (check !== null) {
+        const backstop = generateBackstopAssertion("input", schema, `[${typeName}]`, strictContext(unionCtx));
+        const assertions = [
+          `  if (!(${check})) throw new Error(${quoteJsString(`[${typeName}] value does not match any union branch`)});`,
+          ...backstop
+        ].join("\n");
         return `export const ${functionName} = (input: unknown): ${typeName} => {
-  if (!(${check})) throw new Error(${quoteJsString(`[${typeName}] value does not match any union branch`)});
+${assertions}
   return input as ${typeName};
 };`;
       }
@@ -296,8 +320,8 @@ const generateNonObjectParser = (typeName, schema, strict, unionCtx) => {
       return `export const ${functionName} = (input: unknown): ${typeName} => input as ${typeName};`;
     }
   }
-  if (strict && isSchemaObject(schema) && !hasType(schema) && (hasConst(schema) || hasEnum(schema))) {
-    const assertion = generateScalarStrictAssertion(schema, typeName, unionCtx?.rootSchema);
+  if (strict && isSchemaObject(schema) && !hasType(schema) && (hasConst(schema) || hasEnum(schema) || hasAllOf(schema) || hasOneOf(schema) || hasAnyOf(schema) || "not" in schema || "if" in schema)) {
+    const assertion = generateScalarStrictAssertion(schema, typeName, strictContext(unionCtx));
     if (assertion !== null) {
       return `export const ${functionName} = (input: unknown): ${typeName} => {
 ${assertion}
@@ -308,7 +332,26 @@ ${assertion}
   if (isSchemaObject(schema) && hasType(schema) && schema.type === "array" && hasItems(schema) && !Array.isArray(schema.items)) {
     const items = schema.items;
     const notArrayThrow = `if (!Array.isArray(input)) throw new Error(\`[${typeName}] expected array, got \${input === null ? "null" : typeof input}\`);`;
-    const strictArrayChecks = strict ? generateContainsCheck("input", schema, `[${typeName}]`).join("\n") : "";
+    const strictArrayChecks = strict ? [
+      // `minItems`/`maxItems` were dropped on this path entirely: a root
+      // array of objects or `$ref`s bypasses generateScalarStrictAssertion,
+      // so `{ type: 'array', minItems: 2, items: { type: 'object' } }`
+      // accepted a one-element array.
+      ...hasMinItems(schema) ? [
+        `  if (input.length < ${schema.minItems}) throw new Error(${quoteJsString(`[${typeName}] must have at least ${schema.minItems} items`)});`
+      ] : [],
+      ...hasMaxItems(schema) ? [
+        `  if (input.length > ${schema.maxItems}) throw new Error(${quoteJsString(`[${typeName}] must have at most ${schema.maxItems} items`)});`
+      ] : [],
+      ...generateContainsCheck("input", schema, `[${typeName}]`),
+      ...hasUniqueItems(schema) && schema.uniqueItems === true ? [
+        `  if (!(${generateUniqueItemsCheck("input", schema)})) throw new Error(${quoteJsString(`[${typeName}] must NOT have duplicate items`)});`
+      ] : [],
+      // This path delegates elements to another parser and so never reaches
+      // generateScalarStrictAssertion — `unevaluatedItems` and friends would
+      // be lost with it.
+      ...generateBackstopAssertion("input", schema, `[${typeName}]`, strictContext(unionCtx))
+    ].join("\n") : "";
     const delegatedBody = (itemParserName) => `  const _parsed = validateArray(input, ${itemParserName});
   return (_parsed === input ? [..._parsed] : _parsed) as ${typeName};`;
     const delegated = (itemParserName) => strict ? `export const ${functionName} = (input: unknown): ${typeName} => {
@@ -342,13 +385,22 @@ ${delegated(generateParserName(itemName))}`;
   }
   const isMultiType = isSchemaObject(schema) && Array.isArray(schema.type);
   if (!isSchemaObject(schema) || !hasType(schema) && !isMultiType) {
+    if (strict) {
+      const assertion = generateScalarStrictAssertion(schema, typeName, strictContext(unionCtx));
+      if (assertion !== null) {
+        return `export const ${functionName} = (input: unknown): ${typeName} => {
+${assertion}
+  return input as ${typeName};
+};`;
+      }
+    }
     return `export const ${functionName} = (input: unknown): ${typeName} => input as ${typeName};`;
   }
   if (!strict && schema.type === "null") {
     return `export const ${functionName} = (input: unknown): ${typeName} => null as ${typeName};`;
   }
   if (strict) {
-    const assertion = generateScalarStrictAssertion(schema, typeName, unionCtx?.rootSchema);
+    const assertion = generateScalarStrictAssertion(schema, typeName, strictContext(unionCtx));
     if (assertion === null) {
       return `export const ${functionName} = (input: unknown): ${typeName} => input as ${typeName};`;
     }
@@ -385,17 +437,50 @@ ${assertion}
       return `export const ${functionName} = (input: unknown): ${typeName} => input as ${typeName};`;
   }
 };
-const strictObjectKeywordPrelude = (schema, typeName) => {
+const strictObjectKeywordPrelude = (schema, typeName, context = {}) => {
   if (!isSchemaObject(schema))
     return "";
-  const lines = generateObjectKeywordChecks("input", schema, `[${typeName}]`, false);
+  const lines = [
+    ...generateObjectKeywordChecks("input", schema, `[${typeName}]`, false, context),
+    // `required` and the size bounds are the object-level constraints these
+    // specialized parsers never had a place for: `{ type: 'object', required:
+    // ['a'] }` and `{ type: 'object', minProperties: 2 }` carry no `properties`,
+    // so they land on the empty-object / record paths, which asserted only
+    // `isObject`. Keys that *are* declared are skipped — the per-property
+    // assertions of the combined parser already demand them.
+    ...requiredWithoutPropertyLines(schema, typeName),
+    ...generateObjectSizeChecks("input", schema, `[${typeName}]`, false),
+    // Values behind `patternProperties` / a schema-valued `additionalProperties`:
+    // these parsers build their result by copying or coercing, so nothing
+    // rejected a wrongly-typed pattern-matched value before this.
+    ...generateKeyedValueChecks("input", schema, `[${typeName}]`, context),
+    // Composition on a property-less object: these parsers delegate nothing, so
+    // `{ type: 'object', allOf: [{ $ref: … }] }` had no check at all.
+    ...generateCompositionChecks("input", schema, `[${typeName}]`, context),
+    // Whatever no specialized check above reaches (`unevaluated*`, a `$ref` with
+    // constraining siblings): these parsers never run generateObjectStrictAssertion,
+    // so the backstop has to be spliced in here too.
+    ...generateBackstopAssertion("input", schema, `[${typeName}]`, context)
+  ];
   return lines.length > 0 ? `
 ${lines.join("\n")}` : "";
 };
-const generateEmptyObjectParser = (typeName, strict, schema) => {
+const requiredWithoutPropertyLines = (schema, typeName) => {
+  if (!isSchemaObject(schema) || !hasRequired(schema))
+    return [];
+  const declared = hasProperties(schema) ? schema.properties : {};
+  const lines = [];
+  for (const key of new Set(schema.required)) {
+    if (key in declared)
+      continue;
+    lines.push(`  if (${missingCheck("input", key)}) throw new Error(${quoteJsString(`[${typeName}] missing required property '${key}'`)});`);
+  }
+  return lines;
+};
+const generateEmptyObjectParser = (typeName, strict, schema, context = {}) => {
   const functionName = generateParserName(typeName);
   if (strict) {
-    const prelude = schema !== void 0 ? strictObjectKeywordPrelude(schema, typeName) : "";
+    const prelude = schema !== void 0 ? strictObjectKeywordPrelude(schema, typeName, context) : "";
     return `export const ${functionName} = (input: unknown): ${typeName} => {
   if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);${prelude}
   return { ...input } as ${typeName};
@@ -476,7 +561,7 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
   if (!hasProperties(schema)) {
     if (strict) {
       return `${exportPrefix}const ${functionName} = (input: unknown): ${typeName} => {
-  if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);${strictObjectKeywordPrelude(schema, typeName)}
+  if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);${strictObjectKeywordPrelude(schema, typeName, { useRefImports, suffix, stripUnknown, ...rootSchema !== void 0 ? { rootSchema } : {} })}
   return input as ${typeName};
 };`;
     }
@@ -566,6 +651,16 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
       fastPathAccessorChecks.push(`(${accessor} === undefined || ${accessorCheck})`);
     }
   }
+  if (canFastPath) {
+    if (hasMinProperties(schema)) {
+      fastPathChecks.push(`Object.keys(input).length >= ${schema.minProperties}`);
+      fastPathAccessorChecks.push(`Object.keys(input).length >= ${schema.minProperties}`);
+    }
+    if (hasMaxProperties(schema)) {
+      fastPathChecks.push(`Object.keys(input).length <= ${schema.maxProperties}`);
+      fastPathAccessorChecks.push(`Object.keys(input).length <= ${schema.maxProperties}`);
+    }
+  }
   if (stripKeys) {
     fastPathChecks.push(exactKeyCount !== null ? `Object.getPrototypeOf(input) === Object.prototype && Object.keys(input).length === ${exactKeyCount}` : `_hasOnlyKnownKeys${typeName}(input)`);
   }
@@ -700,7 +795,13 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
         continue;
       }
       if (!isSchemaObject(propSchema)) {
-        if (isRequired) {
+        if (propSchema === true) {
+          if (isRequired) {
+            objectLines.push(`    ${safeLiteralKey(key)}: ${accessor},`);
+          } else if (stripKeys) {
+            objectLines.push(`    ...(${accessor} !== undefined && { ${safeLiteralKey(key)}: ${accessor} }),`);
+          }
+        } else if (isRequired) {
           objectLines.push(`    ${safeLiteralKey(key)}: undefined,`);
         }
         continue;
@@ -739,8 +840,12 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
     const fields = [];
     for (const { key, varName, isRequired, propSchema } of propInfo) {
       if (!isSchemaObject(propSchema)) {
-        if (isRequired)
+        if (propSchema === true) {
+          const acc = safeAccessor("input", key);
+          fields.push(isRequired ? `    ${safeLiteralKey(key)}: ${acc},` : `    ...(${acc} !== undefined && { ${safeLiteralKey(key)}: ${acc} }),`);
+        } else if (isRequired) {
           fields.push(`    ${safeLiteralKey(key)}: undefined,`);
+        }
         continue;
       }
       const accessor = shouldCacheVariable(propSchema, canFastPath, useRefImports) ? varName : safeAccessor("input", key);
@@ -826,19 +931,19 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
 ${fn}`;
 };
 const safeResultAssign = (keyVar, valueExpr) => `if (${keyVar} === "__proto__") { Object.defineProperty(result, ${keyVar}, { value: ${valueExpr}, writable: true, enumerable: true, configurable: true }); } else { (result as Record<string, unknown>)[${keyVar}] = ${valueExpr}; }`;
-const generateStrictCombinedParser = (schema, typeName, functionName, propertyLines, patterns, useRefImports, suffix, strict) => {
+const generateStrictCombinedParser = (schema, typeName, functionName, propertyLines, patterns, useRefImports, suffix, strict, context = {}) => {
   const declaredKeys = hasProperties(schema) ? Object.keys(schema.properties) : [];
   const knownKeyCheck = unknownKeyCheck(declaredKeys, "_knownKeys");
   const refPattern = useRefImports ? patterns.find(([, ps]) => isSchemaObject(ps) && hasRef(ps)) : void 0;
   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(`    if (${regexLiteral(refPattern[0])}.test(key)) {`);
     loopLines.push(`      ${safeResultAssign("key", `${parserName}(input[key])`)}`);
     loopLines.push(`      continue;`);
     loopLines.push(`    }`);
   }
-  const keepConditions = patterns.filter(([p]) => !(refPattern && p === refPattern[0])).map(([p]) => `/${escapeRegexPattern(p)}/.test(key)`);
+  const keepConditions = patterns.filter(([p]) => !(refPattern && p === refPattern[0])).map(([p]) => `${regexLiteral(p)}.test(key)`);
   if (keepConditions.length > 0) {
     loopLines.push(`    if (${keepConditions.join(" || ")}) {`);
     loopLines.push(`      ${safeResultAssign("key", "input[key]")}`);
@@ -853,7 +958,7 @@ ${propertyLines.join("\n")}
   }` : "{}";
   const knownKeysDeclaration = knownKeyCheck.declarations.map((decl) => `  ${decl};
 `).join("");
-  const assertionPrelude = strict ? generateObjectStrictAssertion(schema, typeName, { useRefImports, suffix }).slice(1) : [];
+  const assertionPrelude = strict ? generateObjectStrictAssertion(schema, typeName, context).slice(1) : [];
   const keywordPrelude = assertionPrelude.length > 0 ? `
 ${assertionPrelude.join("\n")}` : "";
   return `export const ${functionName} = (input: unknown): ${typeName} => {
@@ -867,7 +972,7 @@ ${loopLines.join("\n")}
   return result;
 };`;
 };
-const generateCombinedObjectParser = (schema, typeName, useRefImports, suffix, logWarnings, strict, stripUnknown = false, caseInsensitive = false) => {
+const generateCombinedObjectParser = (schema, typeName, useRefImports, suffix, logWarnings, strict, stripUnknown = false, caseInsensitive = false, context = {}) => {
   const functionName = generateParserName(typeName);
   const entries = generatePropertyEntries(schema, useRefImports, suffix, caseInsensitive);
   const propertyLines = entries.map((entry) => {
@@ -877,26 +982,26 @@ const generateCombinedObjectParser = (schema, typeName, useRefImports, suffix, l
     return `    ${safeLiteralKey(entry.key)}: ${entry.value},`;
   });
   if (!isSchemaObject(schema) || !("patternProperties" in schema)) {
-    return generateObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict, true, stripUnknown, void 0, NO_RESERVED_NAMES, caseInsensitive);
+    return generateObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict, true, stripUnknown, context.rootSchema, NO_RESERVED_NAMES, caseInsensitive);
   }
   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;
   if (strictKeys) {
-    return generateStrictCombinedParser(schema, typeName, functionName, propertyLines, patterns, useRefImports, suffix, strict);
+    return generateStrictCombinedParser(schema, typeName, functionName, propertyLines, patterns, useRefImports, suffix, strict, context);
   }
   if (stripUnknown && !strict) {
-    return generateStrictCombinedParser(schema, typeName, functionName, propertyLines, patterns, useRefImports, suffix, false);
+    return generateStrictCombinedParser(schema, typeName, functionName, propertyLines, patterns, useRefImports, suffix, false, context);
   }
   if (!refPattern || !useRefImports) {
-    return generateObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict, true, stripUnknown, void 0, NO_RESERVED_NAMES, caseInsensitive);
+    return generateObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict, true, stripUnknown, context.rootSchema, NO_RESERVED_NAMES, caseInsensitive);
   }
   const [pattern, patternSchema] = refPattern;
   const ref = patternSchema.$ref;
   const parserName = generateParserName(refToName(ref, suffix));
   const assignmentCode = `(result as Record<string, unknown>)[key] = ${parserName}(value);`;
-  const escapedPattern = escapeRegexPattern(pattern);
+  const patternLiteral = regexLiteral(pattern);
   const inputSpread = "    ...input,";
   let objectProperties = inputSpread;
   if (propertyLines.length > 0) {
@@ -905,7 +1010,7 @@ const generateCombinedObjectParser = (schema, typeName, useRefImports, suffix, l
     }
   }
   const notObjectBranch = strict ? `    throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);` : `    return {} as unknown as ${typeName};`;
-  const keywordPrelude = strict ? strictObjectKeywordPrelude(schema, typeName) : "";
+  const keywordPrelude = strict ? strictObjectKeywordPrelude(schema, typeName, context) : "";
   return `export const ${functionName} = (input: unknown): ${typeName} => {
   if (!isObject(input)) {
 ${notObjectBranch}
@@ -914,7 +1019,7 @@ ${notObjectBranch}
 ${objectProperties}
   } as unknown as ${typeName};
   for (const key in input) {
-    if (/${escapedPattern}/.test(key)) {
+    if (${patternLiteral}.test(key)) {
       const value = input[key];
       ${assignmentCode}
     }
@@ -922,13 +1027,13 @@ ${objectProperties}
   return result;
 };`;
 };
-const generateAdditionalPropertiesParser = (schema, typeName, useRefImports, suffix, strict) => {
+const generateAdditionalPropertiesParser = (schema, typeName, useRefImports, suffix, strict, context = {}) => {
   const functionName = generateParserName(typeName);
   const additionalProps = schema.additionalProperties;
   if (!additionalProps) {
-    return generateEmptyObjectParser(typeName, strict, schema);
+    return generateEmptyObjectParser(typeName, strict, schema, context);
   }
-  const keywordPrelude = strict ? strictObjectKeywordPrelude(schema, typeName) : "";
+  const keywordPrelude = strict ? strictObjectKeywordPrelude(schema, typeName, context) : "";
   if (useRefImports && isSchemaObject(additionalProps) && hasRef(additionalProps)) {
     const ref = additionalProps.$ref;
     const parserName = generateParserName(refToName(ref, suffix));
@@ -996,15 +1101,15 @@ const generateInlineValueParser = (schema, strict = false, label = "") => {
       return null;
   }
 };
-const generatePatternPropertiesParser = (schema, typeName, useRefImports, suffix, strict) => {
+const generatePatternPropertiesParser = (schema, typeName, useRefImports, suffix, strict, context = {}) => {
   const functionName = generateParserName(typeName);
   if (!("patternProperties" in schema) || typeof schema.patternProperties !== "object") {
-    return generateEmptyObjectParser(typeName, strict, schema);
+    return generateEmptyObjectParser(typeName, strict, schema, context);
   }
   const patternProps = schema.patternProperties;
   const patterns = Object.entries(patternProps);
   if (patterns.length === 0) {
-    return generateEmptyObjectParser(typeName, strict, schema);
+    return generateEmptyObjectParser(typeName, strict, schema, context);
   }
   const [pattern, patternSchema] = patterns[0];
   let patternAssignment = "(result as Record<string, unknown>)[key] = value;";
@@ -1018,19 +1123,19 @@ const generatePatternPropertiesParser = (schema, typeName, useRefImports, suffix
     patternAssignment = "";
     patternValueExpr = null;
   }
-  const escapedPattern = escapeRegexPattern(pattern);
+  const patternLiteral = regexLiteral(pattern);
   const notObjectBranch = strict ? `    throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);` : `    return {} as unknown as ${typeName};`;
-  const keywordPrelude = strict ? strictObjectKeywordPrelude(schema, typeName) : "";
+  const keywordPrelude = strict ? strictObjectKeywordPrelude(schema, typeName, context) : "";
   const strictKeys = hasAdditionalProperties(schema) && schema.additionalProperties === false;
   if (strictKeys) {
-    const loopLines = [`    if (/${escapedPattern}/.test(key)) {`];
+    const loopLines = [`    if (${patternLiteral}.test(key)) {`];
     if (patternValueExpr) {
       loopLines.push(`      const value = input[key];`);
       loopLines.push(`      ${safeResultAssign("key", patternValueExpr)}`);
     }
     loopLines.push(`      continue;`);
     loopLines.push(`    }`);
-    const keepConditions = patterns.slice(1).map(([p]) => `/${escapeRegexPattern(p)}/.test(key)`);
+    const keepConditions = patterns.slice(1).map(([p]) => `${regexLiteral(p)}.test(key)`);
     if (keepConditions.length > 0) {
       loopLines.push(`    if (${keepConditions.join(" || ")}) {`);
       loopLines.push(`      ${safeResultAssign("key", "input[key]")}`);
@@ -1058,7 +1163,7 @@ ${notObjectBranch}
     ...input,
   } as unknown as ${typeName};
   for (const key in input) {
-    if (/${escapedPattern}/.test(key)) {
+    if (${patternLiteral}.test(key)) {
       const value = input[key];
       ${patternAssignment}
     }
@@ -1169,6 +1274,12 @@ const selectParserStrategy = (schema, typeName, options) => {
   const stripUnknown = options?.stripUnknown ?? false;
   const caseInsensitive = options?.caseInsensitive ?? false;
   const suffix = options?.typeSuffix ?? "";
+  const context = {
+    useRefImports,
+    suffix,
+    stripUnknown,
+    ...options?.rootSchema !== void 0 ? { rootSchema: options.rootSchema } : {}
+  };
   if (!options?.isRoot && typeName === `Schema${suffix}`) {
     return generateSchemaObjectParser(typeName);
   }
@@ -1185,17 +1296,39 @@ const selectParserStrategy = (schema, typeName, options) => {
     });
   }
   if (hasProperties(schema) && isSchemaObject(schema) && "patternProperties" in schema) {
-    return generateCombinedObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict, stripUnknown, caseInsensitive);
+    return generateCombinedObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict, stripUnknown, caseInsensitive, context);
+  }
+  if (strict && isSchemaObject(schema) && Array.isArray(schema.type) && schema.type.includes("null")) {
+    return generateNonObjectParser(typeName, schema, strict, {
+      useRefImports,
+      suffix,
+      stripUnknown,
+      caseInsensitive,
+      logWarnings,
+      ...options?.rootSchema !== void 0 ? { rootSchema: options.rootSchema } : {},
+      ...options?.reservedNames !== void 0 ? { reservedNames: options.reservedNames } : {}
+    });
   }
   if (hasProperties(schema)) {
     return generateObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict, true, stripUnknown, options?.rootSchema, options?.reservedNames, caseInsensitive, options?.shapeValidatorSource);
   }
+  if (strict && isSchemaObject(schema) && ("if" in schema || "then" in schema || "else" in schema)) {
+    return generateNonObjectParser(typeName, schema, strict, {
+      useRefImports,
+      suffix,
+      stripUnknown,
+      caseInsensitive,
+      logWarnings,
+      ...options?.rootSchema !== void 0 ? { rootSchema: options.rootSchema } : {},
+      ...options?.reservedNames !== void 0 ? { reservedNames: options.reservedNames } : {}
+    });
+  }
   if (isSchemaObject(schema) && "if" in schema && "then" in schema && "else" in schema) {
     return generateConditionalParser(schema, typeName, suffix, stripUnknown, caseInsensitive);
   }
   const conditionalObjectSchema = getConditionalObjectSchema(schema);
   if (conditionalObjectSchema) {
-    return generateObjectParser(conditionalObjectSchema, typeName, useRefImports, suffix, logWarnings, strict, true, stripUnknown, void 0, NO_RESERVED_NAMES, caseInsensitive);
+    return generateObjectParser(conditionalObjectSchema, typeName, useRefImports, suffix, logWarnings, strict, true, stripUnknown, context.rootSchema, NO_RESERVED_NAMES, caseInsensitive);
   }
   if (!isObjectLikeSchema) {
     return generateNonObjectParser(typeName, schema, strict, {
@@ -1209,23 +1342,30 @@ const selectParserStrategy = (schema, typeName, options) => {
     });
   }
   if ("patternProperties" in schema) {
-    return generatePatternPropertiesParser(schema, typeName, useRefImports, suffix, strict);
+    return generatePatternPropertiesParser(schema, typeName, useRefImports, suffix, strict, context);
   }
   if ("additionalProperties" in schema && !hasProperties(schema)) {
     const additionalProps = schema.additionalProperties;
     if (additionalProps === true || additionalProps === false) {
-      return generateEmptyObjectParser(typeName, strict, schema);
+      return generateEmptyObjectParser(typeName, strict, schema, context);
     }
-    return generateAdditionalPropertiesParser(schema, typeName, useRefImports, suffix, strict);
+    return generateAdditionalPropertiesParser(schema, typeName, useRefImports, suffix, strict, context);
   }
   if ("type" in schema && schema.type === "object" && !hasProperties(schema)) {
-    return generateEmptyObjectParser(typeName, strict, schema);
+    return generateEmptyObjectParser(typeName, strict, schema, context);
   }
-  return generateEmptyObjectParser(typeName, strict, schema);
+  return generateEmptyObjectParser(typeName, strict, schema, context);
 };
-const generateParserFunction = (schema, typeName, options) => {
-  if (options?.strict)
-    assertNoUnsupportedKeywords(schema, typeName);
+const generateParserFunction = (schema, typeName, rawOptions) => {
+  const options = rawOptions?.strict && rawOptions.rootSchema === void 0 && isSchemaObject(schema) ? { ...rawOptions, rootSchema: schema } : rawOptions;
+  if (options?.strict) {
+    assertNoUnsupportedKeywords(schema, typeName, {
+      useRefImports: options.useRefImports ?? false,
+      suffix: options.typeSuffix ?? "",
+      ...options.rootSchema !== void 0 ? { rootSchema: options.rootSchema } : {},
+      ...options.stripUnknown !== void 0 ? { stripUnknown: options.stripUnknown } : {}
+    });
+  }
   return selectParserStrategy(schema, typeName, options);
 };
 const shapeValidatorFunctionName = (typeName) => shapeValidatorName(typeName);
@@ -1247,7 +1387,7 @@ const generateShapeValidator = (schema, typeName, useRefImports, suffix = "", ex
   if (!hasProperties(schema) && !("patternProperties" in schema) && !("if" in schema) && !stripUnknown) {
     const branches = getUnionBranches(schema);
     if (branches) {
-      const check = generateUnionCheck("input", branches, useRefImports, suffix);
+      const check = generateUnionCheck("input", branches, useRefImports, suffix, isExclusiveUnion(schema));
       if (check !== null) {
         return `${exportPrefix}const ${fnName} = (input: unknown): boolean => ${check};`;
       }
@@ -1289,6 +1429,10 @@ const generateShapeValidator = (schema, typeName, useRefImports, suffix = "", ex
       checks.push(`(${accessor} === undefined || ${check})`);
     }
   }
+  if (hasMinProperties(schema))
+    checks.push(`Object.keys(input).length >= ${schema.minProperties}`);
+  if (hasMaxProperties(schema))
+    checks.push(`Object.keys(input).length <= ${schema.maxProperties}`);
   if (validatorKeyCount !== null) {
     checks.push(`Object.getPrototypeOf(input) === Object.prototype && Object.keys(input).length === ${validatorKeyCount}`);
   }

package/dist/generators/generate-schema-checks.js

@@ -1,8 +1,10 @@
-import { escapeRegexPattern } from "@amritk/helpers/escape-regex-pattern";
+import { regexLiteral } from "@amritk/helpers/escape-regex-pattern";
 import { getMjstInstanceOf, getMjstPrimitive } from "@amritk/helpers/mjst-extension";
 import { multipleOfPassExpr } from "@amritk/helpers/multiple-of-check";
+import { hasOwnCheck } from "@amritk/helpers/safe-accessor";
 import { hasAdditionalProperties, hasConst, hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasMaxItems, hasMaximum, hasMaxLength, hasMaxProperties, hasMinItems, hasMinimum, hasMinLength, hasMinProperties, hasMultipleOf, hasPattern, hasProperties, hasRequired, hasType, hasUniqueItems, isSchemaObject } from "@amritk/helpers/schema-guards";
 import { generateEnumCheck } from "./generate-enum-check.js";
+import { generateUniqueItemsCheck } from "./generate-unique-items-check.js";
 const OBJECT_KEYWORDS = [
   "properties",
   "required",
@@ -61,7 +63,7 @@ const generateInferredChecks = (accessor, schema, type) => {
       checks.push(`typeof ${accessor} === "object" && ${accessor} !== null && !Array.isArray(${accessor})`);
       if (hasRequired(schema) && schema.required.length > 0) {
         for (const requiredKey of schema.required) {
-          checks.push(`${JSON.stringify(requiredKey)} in ${accessor}`);
+          checks.push(hasOwnCheck(accessor, requiredKey));
         }
       }
       if (hasMinProperties(schema)) {
@@ -84,13 +86,13 @@ const generateInferredChecks = (accessor, schema, type) => {
         checks.push(`${accessor}.length <= ${schema.maxItems}`);
       }
       if (hasUniqueItems(schema) && schema.uniqueItems === true) {
-        checks.push(`new Set(${accessor}).size === ${accessor}.length`);
+        checks.push(generateUniqueItemsCheck(accessor, schema));
       }
       break;
     case "string":
       checks.push(`typeof ${accessor} === "string"`);
       if (hasPattern(schema)) {
-        checks.push(`/${escapeRegexPattern(schema.pattern)}/.test(${accessor})`);
+        checks.push(`${regexLiteral(schema.pattern)}.test(${accessor})`);
       }
       if (hasMinLength(schema)) {
         checks.push(`${accessor}.length >= ${schema.minLength}`);
@@ -145,7 +147,7 @@ const generateSchemaChecks = (accessor, schema) => {
     }
     checks.push(...generateInferredChecks(accessor, schema, inferred));
     if (hasEnum(schema) && schema.enum.length > 0) {
-      checks.push(`${JSON.stringify(schema.enum)}.includes(${accessor} as never)`);
+      checks.push(generateEnumCheck(accessor, schema.enum));
     }
     return checks;
   }
@@ -153,7 +155,7 @@ const generateSchemaChecks = (accessor, schema) => {
     case "string": {
       checks.push(`typeof ${accessor} === "string"`);
       if (hasPattern(schema)) {
-        checks.push(`/${escapeRegexPattern(schema.pattern)}/.test(${accessor})`);
+        checks.push(`${regexLiteral(schema.pattern)}.test(${accessor})`);
       }
       if (hasMinLength(schema)) {
         checks.push(`${accessor}.length >= ${schema.minLength}`);
@@ -197,14 +199,14 @@ const generateSchemaChecks = (accessor, schema) => {
         checks.push(`${accessor}.length <= ${schema.maxItems}`);
       }
       if (hasUniqueItems(schema) && schema.uniqueItems === true) {
-        checks.push(`new Set(${accessor}).size === ${accessor}.length`);
+        checks.push(generateUniqueItemsCheck(accessor, schema));
       }
       break;
     case "object": {
       checks.push(`typeof ${accessor} === "object" && ${accessor} !== null && !Array.isArray(${accessor})`);
       if (hasRequired(schema) && schema.required.length > 0) {
         for (const requiredKey of schema.required) {
-          checks.push(`${JSON.stringify(requiredKey)} in ${accessor}`);
+          checks.push(hasOwnCheck(accessor, requiredKey));
         }
       }
       if (hasMinProperties(schema)) {