@amritk/validation 0.3.2 → 0.4.1

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

@@ -108,7 +108,7 @@ const blockFailFast = (ctx) => {
   if (returnsOnReport(ctx.sink))
     ctx.failFast.blocked = true;
 };
-const hoistPrefix = (ctx) => ctx.failFast.on ? "_check" : "";
+const hoistPrefix = (ctx) => ctx.hoistNamespace;
 const typeTestAccessor = (raw, ctx) => returnsOnReport(ctx.sink) ? `(${raw} as unknown)` : raw;
 const emittedName = (typeName, failFast) => failFast.on ? checkerName(typeName) : validatorName(typeName);
 const errorsBinding = (failFast) => failFast.on ? [] : ["  let errors: ValidationError[] | undefined"];
@@ -129,7 +129,10 @@ const createRootContext = (rootSchema, formats = NO_FORMATS, branchErrors = fals
   // `selectBranchErrors` sweep *after* the `return` that ends the function, which
   // is unreachable code the consumer's build rejects.
   branchErrors: branchErrors && !failFast.on,
-  failFast
+  failFast,
+  hoistNamespace: failFast.on ? "_check" : "",
+  refGuard: guardName,
+  namedMatchers: /* @__PURE__ */ new Map()
 });
 const pointerSegment = (key) => {
   const pointer = key.replace(/~/g, "~0").replace(/\//g, "~1");
@@ -145,8 +148,22 @@ const patternPropertySources = (schema) => {
 };
 const readsBinding = (name, text) => new RegExp(`\\b${name}\\b`).test(text);
 const readsObjBinding = (text) => readsBinding("obj", text);
+const keptHoisted = (hoisted, text) => {
+  const kept = /* @__PURE__ */ new Set();
+  const scan = (source) => {
+    for (const entry of hoisted) {
+      if (kept.has(entry) || !source.includes(entry.reference))
+        continue;
+      kept.add(entry);
+      if (entry.calls === true)
+        scan(entry.declaration);
+    }
+  };
+  scan(text);
+  return hoisted.filter((entry) => kept.has(entry)).map((entry) => entry.declaration);
+};
 const withHoisted = (hoisted, text) => {
-  const kept = hoisted.filter((entry) => text.includes(entry.reference)).map((entry) => entry.declaration);
+  const kept = keptHoisted(hoisted, text);
   const firstBreak = text.indexOf("\n");
   const signature = firstBreak === -1 ? text : text.slice(0, firstBreak);
   const rest = firstBreak === -1 ? "" : text.slice(firstBreak);
@@ -253,7 +270,7 @@ const generateKeywordChecks = (key, raw, path, schema, suffix, ctx, presence) =>
   const lines = [];
   if (hasRef(schema)) {
     const target = refToName(schema.$ref, suffix);
-    const delegate = ctx.sink === FAIL_FAST_SINK ? [`  const _r = ${checkerName(target)}(${raw}, ${path})`, `  if (_r !== true) return _r`] : ctx.sink === MATCH_BOOL_SINK ? [`  const _r = ${emittedName(target, ctx.failFast)}(${raw}, ${path})`, `  if (_r !== true) return false`] : [
+    const delegate = ctx.sink === FAIL_FAST_SINK ? [`  const _r = ${checkerName(target)}(${raw}, ${path})`, `  if (_r !== true) return _r`] : ctx.sink === MATCH_BOOL_SINK ? [`  if (!${ctx.refGuard(target)}(${raw})) return false`] : [
       `  const _r = ${validatorName(target)}(${raw}, ${path})`,
       `  if (_r !== true) ${ctx.sink}.push(..._r.errors)`
     ];
@@ -275,7 +292,7 @@ const generateKeywordChecks = (key, raw, path, schema, suffix, ctx, presence) =>
     lines.push(`  }`);
   }
   if (hasConst(schema)) {
-    const mismatch = constMismatchCondition(raw, schema.const);
+    const mismatch = constMismatchCondition(typeTestAccessor(raw, ctx), schema.const);
     const msg = JSON.stringify(`must be ${JSON.stringify(schema.const)}`);
     lines.push(`  if (${presence}${mismatch}) {`);
     lines.push(`    ${pushError(ctx.sink, msg, path, "const", JSON.stringify({ allowedValue: schema.const }))}`);
@@ -283,7 +300,7 @@ const generateKeywordChecks = (key, raw, path, schema, suffix, ctx, presence) =>
   }
   if (hasEnum(schema)) {
     const label = schema.enum.map((v) => JSON.stringify(v)).join(", ");
-    lines.push(`  if (${presence}!${enumMembershipExpr(schema.enum, raw)}) {`);
+    lines.push(`  if (${presence}!${enumMembershipExpr(schema.enum, typeTestAccessor(raw, ctx))}) {`);
     lines.push(`    ${pushError(ctx.sink, JSON.stringify(`must be one of: ${label}`), path, "enum", JSON.stringify({ allowedValues: schema.enum }))}`);
     lines.push(`  }`);
   }
@@ -413,11 +430,15 @@ const generateConstraintChecks = (key, raw, path, propSchema, suffix, ctx) => {
     if (hasRef(itemSchema) && !declaresKeywordOutside(itemSchema, ["$ref"])) {
       const failFast = ctx.sink === FAIL_FAST_SINK;
       const target = refToName(itemSchema.$ref, suffix);
-      const onFailure = failFast ? "return _ir" : ctx.sink === MATCH_BOOL_SINK ? "return false" : `${ctx.sink}.push(..._ir.errors)`;
+      const onFailure = failFast ? "return _ir" : `${ctx.sink}.push(..._ir.errors)`;
       lines.push(`  if (Array.isArray(${raw})) {`);
       lines.push(`    for (let ${iv} = ${firstTailIndex}; ${iv} < ${raw}.length; ${iv}++) {`);
-      lines.push(`      const _ir = ${emittedName(target, ctx.failFast)}(${raw}[${iv}], ${itemPath})`);
-      lines.push(`      if (_ir !== true) ${onFailure}`);
+      if (ctx.sink === MATCH_BOOL_SINK) {
+        lines.push(`      if (!${ctx.refGuard(target)}(${raw}[${iv}])) return false`);
+      } else {
+        lines.push(`      const _ir = ${emittedName(target, ctx.failFast)}(${raw}[${iv}], ${itemPath})`);
+        lines.push(`      if (_ir !== true) ${onFailure}`);
+      }
       lines.push(`    }`);
       lines.push(`  }`);
     } else if (isSchemaObject(itemSchema)) {
@@ -544,13 +565,75 @@ const generateValueCheckLines = (_key, raw, path, propSchema, suffix, ctx, requi
     hoisted: ctx.hoisted,
     rootSchema: ctx.rootSchema,
     sink: ctx.sink,
-    formats: ctx.formats
+    formats: ctx.formats,
+    hoistNamespace: ctx.hoistNamespace,
+    refGuard: ctx.refGuard,
+    namedMatchers: ctx.namedMatchers
   };
   lines.push(...generateKeywordChecks("", raw, path, propSchema, suffix, valueCtx, presence));
   return lines;
 };
 const NARROWABLE_REFERENCE = /^[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\[[A-Za-z_$][\w$]*\]|\[\d+\])*$/;
-const generateMatchesExpr = (raw, sub, suffix, ctx, required = false, branch) => {
+const namedMatcher = (sub, suffix, ctx) => {
+  const key = JSON.stringify(sub);
+  const existing = ctx.namedMatchers.get(key);
+  if (existing !== void 0)
+    return existing;
+  const state = { on: false, blocked: false };
+  const fnCtx = {
+    ...ctx,
+    objVar: "obj",
+    pathPrefix: "${_path}",
+    depth: 0,
+    sink: MATCH_BOOL_SINK,
+    failFast: state,
+    branchErrors: false
+  };
+  const checks = generateValueChecks("", "input", "`${_path}`", sub, suffix, fnCtx, true);
+  if (checks.length === 0)
+    return "true";
+  if (state.blocked)
+    return null;
+  const body = checks.join("\n");
+  const name = `${hoistPrefix(ctx)}_match${ctx.namedMatchers.size}`;
+  const declaration = [
+    `const ${name} = (${readsBinding("input", body) ? "input" : "_input"}: unknown): boolean => {`,
+    // Some checks build a path for a key or an index before they know whether
+    // they fail. Nothing reports it here, so it is rooted at nothing.
+    ...readsBinding("_path", body) ? [`  const _path = ''`] : [],
+    body,
+    `  return true`,
+    `}`
+  ].join("\n");
+  ctx.namedMatchers.set(key, name);
+  ctx.hoisted.push({ declaration, reference: `${name}(`, calls: true });
+  return name;
+};
+const namedBranchErrors = (sub, suffix, ctx) => {
+  if (!isSchemaObject(sub))
+    return null;
+  const key = `explain:${JSON.stringify(sub)}`;
+  const existing = ctx.namedMatchers.get(key);
+  if (existing !== void 0)
+    return existing;
+  const fnCtx = { ...ctx, objVar: "obj", pathPrefix: "${_path}", depth: 0, sink: MATCH_ERROR_SINK };
+  const checks = generateValueChecks("", "input", "`${_path}`", sub, suffix, fnCtx, true);
+  if (checks.length === 0)
+    return null;
+  const body = checks.join("\n");
+  const name = `${hoistPrefix(ctx)}_explain${ctx.namedMatchers.size}`;
+  const declaration = [
+    `const ${name} = (${readsBinding("input", body) ? "input" : "_input"}: unknown, _path: string): ValidationError[] => {`,
+    `  const ${MATCH_ERROR_SINK}: ValidationError[] = []`,
+    body,
+    `  return ${MATCH_ERROR_SINK}`,
+    `}`
+  ].join("\n");
+  ctx.namedMatchers.set(key, name);
+  ctx.hoisted.push({ declaration, reference: `${name}(`, calls: true });
+  return name;
+};
+const generateMatchesExpr = (raw, sub, suffix, ctx, required = false) => {
   if (sub === true)
     return "true";
   if (sub === false)
@@ -558,28 +641,26 @@ const generateMatchesExpr = (raw, sub, suffix, ctx, required = false, branch) =>
   if (!isSchemaObject(sub))
     return "true";
   const value = NARROWABLE_REFERENCE.test(raw) ? raw : `_mv${ctx.depth}`;
-  const valuePath = branch === void 0 ? "`${_path}`" : branch.path;
+  const valuePath = "`${_path}`";
   const binding = value === raw ? "" : `const ${value}: unknown = ${raw}
 `;
-  if (branch === void 0) {
-    const matchState = { on: ctx.failFast.on, blocked: false };
-    const matchCtx = { ...ctx, sink: MATCH_BOOL_SINK, failFast: matchState, branchErrors: false };
-    const boolChecks = generateValueChecks("", value, valuePath, sub, suffix, matchCtx, required);
-    if (boolChecks.length === 0)
-      return "true";
-    if (!matchState.blocked)
-      return `((): boolean => {
+  const named = namedMatcher(sub, suffix, ctx);
+  if (named !== null)
+    return named === "true" ? "true" : `${named}(${raw})`;
+  const matchState = { on: ctx.failFast.on, blocked: false };
+  const matchCtx = { ...ctx, sink: MATCH_BOOL_SINK, failFast: matchState, branchErrors: false };
+  const boolChecks = generateValueChecks("", value, valuePath, sub, suffix, matchCtx, required);
+  if (boolChecks.length === 0)
+    return "true";
+  if (!matchState.blocked)
+    return `((): boolean => {
 ${binding}${boolChecks.join("\n")}
     return true })()`;
-  }
   const checks = generateValueChecks("", value, valuePath, sub, suffix, { ...ctx, sink: MATCH_ERROR_SINK }, required);
   if (checks.length === 0)
     return "true";
-  const body = checks.join("\n");
-  const collect = branch === void 0 ? "" : `
-    if (_m.length !== 0) (${branch.buffer} ??= []).push(_m)`;
   return `((): boolean => { const _m: ValidationError[] = []
-${binding}${body}${collect}
+${binding}${checks.join("\n")}
     return _m.length === 0 })()`;
 };
 const unevaluatedMatcher = (suffix, ctx) => (accessor, schema, depth) => (
@@ -629,17 +710,18 @@ const generateUnevaluatedChecks = (raw, path, schema, suffix, ctx) => {
   }
   return lines;
 };
-const BRANCH_BUFFER = "_br";
-const selectBranchErrorsLine = (path, ctx) => `for (const _e of selectBranchErrors(${BRANCH_BUFFER} ?? [], ${path})) ${ctx.sink}.push(_e)`;
-const branchBufferBlock = (guard, message, keyword, path, ctx) => [
-  `  {`,
-  `    let ${BRANCH_BUFFER}: ValidationError[][] | null = null`,
-  `    if (${guard}) {`,
-  `      ${pushError(ctx.sink, message, path, keyword)}`,
-  `      ${selectBranchErrorsLine(path, ctx)}`,
-  `    }`,
+const branchErrorsReport = (guard, raw, explain, message, keyword, path, ctx) => [
+  `  if (${guard}) {`,
+  `    ${pushError(ctx.sink, message, path, keyword)}`,
+  ...explain.length === 0 ? [] : [
+    `    const _bp = ${path}`,
+    `    const _br: ValidationError[][] = []`,
+    `    for (const _b of [${explain.map((name) => `${name}(${raw}, _bp)`).join(", ")}]) if (_b.length !== 0) _br.push(_b)`,
+    `    for (const _e of selectBranchErrors(_br, _bp)) ${ctx.sink}.push(_e)`
+  ],
   `  }`
 ];
+const branchExplainers = (branches, suffix, ctx) => branches.map((branch) => namedBranchErrors(branch, suffix, ctx)).filter((name) => name !== null);
 const generateCombinatorChecks = (key, raw, path, schema, suffix, ctx) => {
   if (!isSchemaObject(schema))
     return [];
@@ -649,11 +731,10 @@ const generateCombinatorChecks = (key, raw, path, schema, suffix, ctx) => {
       lines.push(...generateValueChecks(key, raw, path, branch, suffix, ctx, true));
   }
   if (hasAnyOf(schema) && schema.anyOf.length > 0) {
-    const collector = ctx.branchErrors ? { buffer: BRANCH_BUFFER, path } : void 0;
-    const conds = schema.anyOf.map((b) => generateMatchesExpr(raw, b, suffix, ctx, true, collector));
+    const conds = schema.anyOf.map((b) => generateMatchesExpr(raw, b, suffix, ctx, true));
     if (!conds.includes("true")) {
       if (ctx.branchErrors) {
-        lines.push(...branchBufferBlock(`!(${conds.join(" || ")})`, `'must match a schema in anyOf'`, "anyOf", path, ctx));
+        lines.push(...branchErrorsReport(`!(${conds.join(" || ")})`, raw, branchExplainers(schema.anyOf, suffix, ctx), `'must match a schema in anyOf'`, "anyOf", path, ctx));
       } else {
         const condition = `!(${conds.join(" || ")})`;
         if (LITERAL_CONDITION.test(condition))
@@ -665,20 +746,18 @@ const generateCombinatorChecks = (key, raw, path, schema, suffix, ctx) => {
     }
   }
   if (hasOneOf(schema) && schema.oneOf.length > 0) {
-    const collector = ctx.branchErrors ? { buffer: BRANCH_BUFFER, path } : void 0;
-    const conds = schema.oneOf.map((b) => `(${generateMatchesExpr(raw, b, suffix, ctx, true, collector)} ? 1 : 0)`);
+    const conds = schema.oneOf.map((b) => `(${generateMatchesExpr(raw, b, suffix, ctx, true)} ? 1 : 0)`);
     const message = `'must match exactly one schema in oneOf'`;
     if (!ctx.branchErrors) {
       lines.push(`  if ((${conds.join(" + ")}) !== 1) {`);
       lines.push(`    ${pushError(ctx.sink, message, path, "oneOf")}`);
       lines.push(`  }`);
     } else {
+      const explain = branchExplainers(schema.oneOf, suffix, ctx);
       lines.push(`  {`);
-      lines.push(`    let ${BRANCH_BUFFER}: ValidationError[][] | null = null`);
       lines.push(`    const _n = ${conds.join(" + ")}`);
-      lines.push(`    if (_n === 0) {`);
-      lines.push(`      ${pushError(ctx.sink, message, path, "oneOf")}`);
-      lines.push(`      ${selectBranchErrorsLine(path, ctx)}`);
+      const report = branchErrorsReport("_n === 0", raw, explain, message, "oneOf", path, ctx).map((line) => `  ${line}`);
+      lines.push(...report.slice(0, -1));
       lines.push(`    } else if (_n !== 1) {`);
       lines.push(`      ${pushError(ctx.sink, message, path, "oneOf")}`);
       lines.push(`    }`);
@@ -782,7 +861,10 @@ const generateInlineObjectChecks = (key, propSchema, raw, suffix, ctx) => {
     hoisted: ctx.hoisted,
     rootSchema: ctx.rootSchema,
     sink: ctx.sink,
-    formats: ctx.formats
+    formats: ctx.formats,
+    hoistNamespace: ctx.hoistNamespace,
+    refGuard: ctx.refGuard,
+    namedMatchers: ctx.namedMatchers
   };
   const required = new Set(hasRequired(propSchema) ? propSchema.required : []);
   const properties = hasProperties(propSchema) ? propSchema.properties : {};
@@ -820,7 +902,10 @@ const generatePropertyNameChecks = (nameSchema, suffix, ctx) => {
     hoisted: ctx.hoisted,
     rootSchema: ctx.rootSchema,
     sink: ctx.sink,
-    formats: ctx.formats
+    formats: ctx.formats,
+    hoistNamespace: ctx.hoistNamespace,
+    refGuard: ctx.refGuard,
+    namedMatchers: ctx.namedMatchers
   };
   const checks = generateValueChecks("", "_name", at, nameSchema, suffix, nameCtx, true);
   if (checks.length === 0)
@@ -1386,7 +1471,8 @@ const typeDescribesEveryAcceptedValue = (schema) => {
   }
   return !IMPLICIT_OBJECT_KEYWORDS.some((keyword) => declaresKey(s, keyword));
 };
-const generateBooleanGuard = (schema, typeName, _suffix = "", unknownKeys = DEFAULT_UNKNOWN_KEYS, formats = NO_FORMATS) => {
+const generateBooleanGuard = (schema, typeName, _suffix = "", unknownKeys = DEFAULT_UNKNOWN_KEYS, formats = NO_FORMATS) => generateBooleanGuardSource(schema, typeName, unknownKeys, formats).code;
+const generateBooleanGuardSource = (schema, typeName, unknownKeys = DEFAULT_UNKNOWN_KEYS, formats = NO_FORMATS) => {
   const name = guardName(typeName);
   const returns = typeDescribesEveryAcceptedValue(rewriteNullable(schema)) ? `input is ${typeName}` : "boolean";
   const fallback = `export const ${name} = (input: unknown): ${returns} => ${validatorName(typeName)}(input) === true`;
@@ -1394,12 +1480,12 @@ const generateBooleanGuard = (schema, typeName, _suffix = "", unknownKeys = DEFA
   const ctx = createGuardContext(unknownKeys, formats);
   if (declaresObjectType(rewritten)) {
     if (!objectRootIsSelfContained(rewritten))
-      return fallback;
+      return { code: fallback, standalone: false };
     const block = booleanObjectParts(rewritten, "input", "obj", ctx);
     if (block === null)
-      return fallback;
+      return { code: fallback, standalone: false };
     const body = isFlatGuardBlock(block) ? [`  return (`, block.conditions.map((part) => `    ${part}`).join(" &&\n"), `  )`] : [...renderGuardBlock(block, "return false", "  ", "lines", unknownKeys), `  return true`];
-    return [
+    const code = [
       `export const ${name} = (input: unknown): ${returns} => {`,
       // Same unused-local as the validator's hot guard: a node with no property
       // to read guards on the shape alone and never touches the narrowing.
@@ -1407,11 +1493,12 @@ const generateBooleanGuard = (schema, typeName, _suffix = "", unknownKeys = DEFA
       ...body,
       `}`
     ].join("\n");
+    return { code, standalone: true };
   }
   const expr = booleanLeafExpr(rewritten, "input", ctx);
   if (expr === null)
-    return fallback;
-  return `export const ${name} = (input: unknown): ${returns} => ${expr}`;
+    return { code: fallback, standalone: false };
+  return { code: `export const ${name} = (input: unknown): ${returns} => ${expr}`, standalone: true };
 };
 const generateScalarValidator = (schema, typeName, suffix, rootSchema, formats, branchErrors, failFast) => {
   const vName = emittedName(typeName, failFast);
@@ -1693,6 +1780,31 @@ const generateCheckFunction = (schema, typeName, suffix = "", rootSchema, unknow
     `}`
   ].join("\n");
 };
+const createSubschemaMatcher = (suffix, rootSchema, formats, hoistNamespace, refGuard = guardName) => {
+  const ctx = { ...createRootContext(rootSchema, formats), hoistNamespace, refGuard };
+  return {
+    test: (sub) => {
+      if (sub === false)
+        return false;
+      const rewritten = rewriteNullable(sub);
+      const state = { on: false, blocked: false };
+      const checks = generateValueChecks("", "input", "`${_path}`", rewritten, suffix, { ...ctx, sink: MATCH_BOOL_SINK, failFast: state, branchErrors: false }, true);
+      if (checks.length === 0)
+        return true;
+      if (!state.blocked)
+        return `${checks.join("\n")}
+  return true`;
+      return `  return ${generateMatchesExpr("input", rewritten, suffix, ctx, true)}`;
+    },
+    named: (sub) => {
+      if (sub === false)
+        return false;
+      const name = namedMatcher(rewriteNullable(sub), suffix, ctx);
+      return name === "true" ? true : name;
+    },
+    declarations: (text) => keptHoisted(ctx.hoisted, text)
+  };
+};
 const generateValidatorSource = (schema, typeName, suffix, rootSchema, unknownKeys, formats, branchErrors, failFast) => {
   assertGeneratableRefs(schema, typeName);
   const rewritten = rewriteNullable(schema);
@@ -1707,7 +1819,9 @@ const generateValidatorSource = (schema, typeName, suffix, rootSchema, unknownKe
   return generateScalarValidator(rewritten, typeName, suffix, document, formats, branchErrors, failFast);
 };
 export {
+  createSubschemaMatcher,
   generateBooleanGuard,
+  generateBooleanGuardSource,
   generateCheckFunction,
   generateValidatorFunction
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/validation",
-  "version": "0.3.2",
+  "version": "0.4.1",
   "description": "One generator surface over mjst's types, validators, coercers, repairers and parsers.",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -73,7 +73,7 @@
     }
   },
   "dependencies": {
-    "@amritk/helpers": "^0.23.3",
+    "@amritk/helpers": "^0.24.0",
     "json-schema-typed": "^8.0.1"
   },
   "devDependencies": {