@amritk/validation 0.3.0 → 0.3.2

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

@@ -12,7 +12,7 @@ import { DEFAULT_UNKNOWN_KEYS } from "@amritk/helpers/unknown-keys-strategy";
 import { findDiscriminator } from "../helpers/find-discriminator.js";
 import { getDiscriminatorValue } from "../helpers/get-discriminator-value.js";
 import { assertNoUnsupportedKeywords } from "./assert-supported-keywords.js";
-import { generateEnumCaseInsensitiveCoercion } from "./generate-enum-check.js";
+import { generateEnumCaseInsensitiveCoercion, generateEnumCheck } from "./generate-enum-check.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, isInlineUnionProperty, isUnionArrayProperty, shapeValidatorName } from "./generate-type-checks.js";
 import { generateUniqueItemsCheck } from "./generate-unique-items-check.js";
@@ -472,11 +472,11 @@ ${assertions}
       return isPrimitive ? `export const ${functionName} = (input: unknown): ${typeName} => input === ${literal} ? input as ${typeName} : ${literal} as ${typeName};` : `export const ${functionName} = (input: unknown): ${typeName} => ${literal} as ${typeName};`;
     }
     if (hasEnum(schema) && schema.enum.length > 0) {
-      const values = JSON.stringify(schema.enum);
       const fallback = JSON.stringify(schema.enum[0]);
       const ci = unionCtx?.caseInsensitive ? generateEnumCaseInsensitiveCoercion("input", schema.enum, fallback) : null;
       const coerced = ci ? `(${ci})` : fallback;
-      return `export const ${functionName} = (input: unknown): ${typeName} => ${values}.includes(input as never) ? input as ${typeName} : ${coerced} as ${typeName};`;
+      const member = generateEnumCheck("input", schema.enum);
+      return `export const ${functionName} = (input: unknown): ${typeName} => ${member} ? input as ${typeName} : ${coerced} as ${typeName};`;
     }
     if (hasOneOf(schema) || hasAnyOf(schema)) {
       const branches = hasOneOf(schema) ? schema.oneOf : hasAnyOf(schema) ? schema.anyOf : [];

package/dist/parsers/helpers/collect-imports.js

@@ -57,6 +57,23 @@ const collectImportTargets = (schema, options) => {
     }
     typeOnlyDepth--;
   };
+  const scoredBranchRefs = /* @__PURE__ */ new Set();
+  const collectScoredBranchRefs = (branch) => {
+    if (rootSchema === void 0 || !isSchemaObject(branch))
+      return;
+    const ref = readKey(branch, "$ref");
+    if (typeof ref !== "string" || !ref.startsWith("#") || scoredBranchRefs.has(ref))
+      return;
+    scoredBranchRefs.add(ref);
+    const target = resolveRef(ref, rootSchema);
+    if (!isSchemaObject(target))
+      return;
+    const properties = readKey(target, "properties");
+    if (typeof properties !== "object" || properties === null)
+      return;
+    for (const value of Object.values(properties))
+      collectRefsFromValue(value);
+  };
   const collectRefsFromValue = (value) => {
     if (typeof value !== "object" || value === null) {
       return;
@@ -108,11 +125,13 @@ const collectImportTargets = (schema, options) => {
     if (hasOneOf(record)) {
       for (const item of record.oneOf) {
         collectRefsFromValue(item);
+        collectScoredBranchRefs(item);
       }
     }
     if (hasAnyOf(record)) {
       for (const item of record.anyOf) {
         collectRefsFromValue(item);
+        collectScoredBranchRefs(item);
       }
     }
     if (hasAllOf(record)) {
@@ -184,11 +203,13 @@ const collectImportTargets = (schema, options) => {
   if (typeof schema === "object" && schema !== null && hasOneOf(schema)) {
     for (const item of schema.oneOf) {
       collectRefsFromValue(item);
+      collectScoredBranchRefs(item);
     }
   }
   if (typeof schema === "object" && schema !== null && hasAnyOf(schema)) {
     for (const item of schema.anyOf) {
       collectRefsFromValue(item);
+      collectScoredBranchRefs(item);
     }
   }
   if (typeof schema === "object" && schema !== null && hasAllOf(schema)) {

package/dist/rehome-parser-file.js

@@ -11,7 +11,17 @@ const declarationEnd = (source, start) => {
         quote = null;
       continue;
     }
-    if (char === '"' || char === "'" || char === "`")
+    if (char === "/" && source[i + 1] === "*") {
+      const close = source.indexOf("*/", i + 2);
+      if (close === -1)
+        return -1;
+      i = close + 1;
+    } else if (char === "/" && source[i + 1] === "/") {
+      const newline = source.indexOf("\n", i + 2);
+      if (newline === -1)
+        return -1;
+      i = newline;
+    } else if (char === '"' || char === "'" || char === "`")
       quote = char;
     else if (char === "{" || char === "[" || char === "(")
       depth++;

package/dist/validators/generators/enforced-keywords.js

@@ -1,4 +1,4 @@
-import { MJST_EXTENSION_KEY } from "@amritk/helpers/mjst-extension";
+import { hasMjstHint, MJST_EXTENSION_KEY } from "@amritk/helpers/mjst-extension";
 import { isSchemaObject } from "@amritk/helpers/schema-guards";
 const ENFORCED_KEYWORDS = /* @__PURE__ */ new Set([
   "$ref",
@@ -50,6 +50,8 @@ const declaresKeywordOutside = (schema, owned, formats = NO_FORMATS) => {
   for (const keyword of Object.keys(record)) {
     if (owned.includes(keyword))
       continue;
+    if (keyword === MJST_EXTENSION_KEY && !hasMjstHint(record))
+      continue;
     if (ENFORCED_KEYWORDS.has(keyword))
       return true;
     if (keyword === "format" && enforcesFormat(record, formats))

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 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",
@@ -251,7 +253,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 ? [`  const _r = ${emittedName(target, ctx.failFast)}(${raw}, ${path})`, `  if (_r !== true) return false`] : [
       `  const _r = ${validatorName(target)}(${raw}, ${path})`,
       `  if (_r !== true) ${ctx.sink}.push(..._r.errors)`
     ];
@@ -411,10 +413,11 @@ 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)`;
       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)`}`);
+      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)) {
@@ -556,12 +559,23 @@ 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 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[] = []
@@ -1652,16 +1666,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 [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/validation",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "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.1",
+    "@amritk/helpers": "^0.23.3",
     "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",