@amritk/validation 0.3.1 → 0.4.0

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

@@ -101,18 +101,20 @@ const getTypeArray = (schema) => {
 const ROOT_ERROR_SINK = "(errors ??= [])";
 const ACCUMULATING = { on: false, blocked: false };
 const FAIL_FAST_SINK = "\0fail-fast";
+const MATCH_BOOL_SINK = "\0match-bool";
+const returnsOnReport = (sink) => sink === FAIL_FAST_SINK || sink === MATCH_BOOL_SINK;
 const LITERAL_CONDITION = /^[\s()!&|]*(?:(?:true|false)[\s()!&|]*)+$/;
 const blockFailFast = (ctx) => {
-  if (ctx.sink === FAIL_FAST_SINK)
+  if (returnsOnReport(ctx.sink))
     ctx.failFast.blocked = true;
 };
-const hoistPrefix = (ctx) => ctx.failFast.on ? "_check" : "";
-const typeTestAccessor = (raw, ctx) => ctx.sink === FAIL_FAST_SINK ? `(${raw} as unknown)` : raw;
+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"];
 const errorsVerdict = (failFast) => failFast.on ? "  return true" : "  return errors !== undefined ? { valid: false, errors } : true";
 const returnError = (message, path, keyword, params = "{}") => `return { valid: false, errors: [{ message: ${message}, path: ${path}, keyword: ${JSON.stringify(keyword)}, params: ${params} }] }`;
-const pushError = (sink, message, path, keyword, params = "{}") => sink === FAIL_FAST_SINK ? returnError(message, path, keyword, params) : `${sink}.push({ message: ${message}, path: ${path}, keyword: ${JSON.stringify(keyword)}, params: ${params} })`;
+const pushError = (sink, message, path, keyword, params = "{}") => sink === FAIL_FAST_SINK ? returnError(message, path, keyword, params) : sink === MATCH_BOOL_SINK ? "return false" : `${sink}.push({ message: ${message}, path: ${path}, keyword: ${JSON.stringify(keyword)}, params: ${params} })`;
 const MATCH_ERROR_SINK = "_m";
 const createRootContext = (rootSchema, formats = NO_FORMATS, branchErrors = false, failFast = ACCUMULATING) => ({
   objVar: "obj",
@@ -127,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");
@@ -143,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);
@@ -251,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`] : [
+    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)`
     ];
@@ -411,10 +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}.push(..._ir.errors)`;
       lines.push(`  if (Array.isArray(${raw})) {`);
       lines.push(`    for (let ${iv} = ${firstTailIndex}; ${iv} < ${raw}.length; ${iv}++) {`);
-      lines.push(`      const _ir = ${failFast ? checkerName(target) : validatorName(target)}(${raw}[${iv}], ${itemPath})`);
-      lines.push(`      if (_ir !== true) ${failFast ? "return _ir" : `${ctx.sink}.push(..._ir.errors)`}`);
+      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)) {
@@ -541,12 +565,50 @@ 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 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 generateMatchesExpr = (raw, sub, suffix, ctx, required = false, branch) => {
   if (sub === true)
     return "true";
@@ -556,12 +618,26 @@ const generateMatchesExpr = (raw, sub, suffix, ctx, required = false, branch) =>
     return "true";
   const value = NARROWABLE_REFERENCE.test(raw) ? raw : `_mv${ctx.depth}`;
   const valuePath = branch === void 0 ? "`${_path}`" : branch.path;
+  const binding = value === raw ? "" : `const ${value}: unknown = ${raw}
+`;
+  if (branch === void 0) {
+    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 binding = value === raw ? "" : `const ${value}: unknown = ${raw}
-`;
   const collect = branch === void 0 ? "" : `
     if (_m.length !== 0) (${branch.buffer} ??= []).push(_m)`;
   return `((): boolean => { const _m: ValidationError[] = []
@@ -768,7 +844,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 : {};
@@ -806,7 +885,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)
@@ -1372,7 +1454,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`;
@@ -1380,12 +1463,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.
@@ -1393,11 +1476,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);
@@ -1652,16 +1736,24 @@ const rewriteNullable = (node) => {
     return { anyOf: [{ type: "null" }, out] };
   return out;
 };
-const generateValidatorFunction = (schema, typeName, suffix = "", rootSchema, unknownKeys = DEFAULT_UNKNOWN_KEYS, formats = NO_FORMATS, branchErrors = false) => generateValidatorSource(schema, typeName, suffix, rootSchema, unknownKeys, formats, branchErrors, {
-  on: false,
-  blocked: false
-});
+const generateValidatorFunction = (schema, typeName, suffix = "", rootSchema, unknownKeys = DEFAULT_UNKNOWN_KEYS, formats = NO_FORMATS, branchErrors = false) => {
+  const source = generateValidatorSource(schema, typeName, suffix, rootSchema, unknownKeys, formats, branchErrors, {
+    on: false,
+    blocked: false
+  });
+  assertNoSinkLeaked(source, MATCH_BOOL_SINK, typeName, "validator");
+  return source;
+};
+const assertNoSinkLeaked = (source, sink, typeName, what) => {
+  if (!source.includes(sink))
+    return;
+  throw new Error(`the ${what} for "${typeName}" emitted the error sink verbatim, which means some emitter reported through \`ctx.sink\` without going through \`pushError\`. That report has to take the short-circuiting form (a \`return\`) or stay on the accumulating path.`);
+};
 const generateCheckFunction = (schema, typeName, suffix = "", rootSchema, unknownKeys = DEFAULT_UNKNOWN_KEYS, formats = NO_FORMATS) => {
   const failFast = { on: true, blocked: false };
   const source = generateValidatorSource(schema, typeName, suffix, rootSchema, unknownKeys, formats, false, failFast);
-  if (source.includes(FAIL_FAST_SINK)) {
-    throw new Error(`the fail-fast validator for "${typeName}" emitted the error sink verbatim, which means some emitter reported through \`ctx.sink\` without going through \`pushError\`. That report has to take the fail-fast form (a \`return\`) or stay on the accumulating path.`);
-  }
+  assertNoSinkLeaked(source, FAIL_FAST_SINK, typeName, "fail-fast validator");
+  assertNoSinkLeaked(source, MATCH_BOOL_SINK, typeName, "fail-fast validator");
   if (!failFast.blocked)
     return source;
   return [
@@ -1671,6 +1763,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);
@@ -1685,7 +1802,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.1",
+  "version": "0.4.0",
   "description": "One generator surface over mjst's types, validators, coercers, repairers and parsers.",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -73,11 +73,11 @@
     }
   },
   "dependencies": {
-    "@amritk/helpers": "^0.23.2",
+    "@amritk/helpers": "^0.24.0",
     "json-schema-typed": "^8.0.1"
   },
   "devDependencies": {
-    "@amritk/runtime-validators": "^0.15.0",
+    "@amritk/runtime-validators": "^0.15.1",
     "@ryoppippi/unplugin-typia": "^2.6.5",
     "@scalar/openapi-parser": "^0.26.1",
     "@sinclair/typebox": "^0.34.49",