@amritk/generate-validators 0.11.12 → 0.12.0

package/dist/generators/unevaluated-match.d.ts

@@ -0,0 +1,29 @@
+import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
+/**
+ * Builds the boolean expression that is TRUE when `accessor` matches `schema`.
+ * Supplied by the caller so this module stays independent of how the validator
+ * spells a match; `depth` lets the caller mint collision-free locals.
+ */
+export type UnevaluatedMatchFn = (accessor: string, schema: JSONSchema, depth: number) => string;
+/** The statements to emit before {@link UnevaluatedExpression.expr}, and the test itself. */
+export type UnevaluatedExpression = {
+    /** `const` declarations for the branch conditions the test reads. */
+    readonly setup: readonly string[];
+    /** TRUE when the value has no unevaluated key / index left over. */
+    readonly expr: string;
+};
+/**
+ * The `unevaluatedProperties` test for an object accessor: every own key the
+ * schema's other keywords did not evaluate must satisfy the unevaluated
+ * subschema (and `false` means there must be no such key).
+ *
+ * Returns `undefined` when the keyword is absent or constrains nothing (a `true`
+ * schema, or a node whose other keywords already sweep every key), and `null`
+ * when it cannot be proven inline.
+ */
+export declare const unevaluatedPropertiesExpr: (acc: string, schema: JSONSchema, rootSchema: Record<string, unknown> | undefined, depth: number, match: UnevaluatedMatchFn) => UnevaluatedExpression | null | undefined;
+/**
+ * The `unevaluatedItems` test for an array accessor — the index counterpart of
+ * {@link unevaluatedPropertiesExpr}.
+ */
+export declare const unevaluatedItemsExpr: (acc: string, schema: JSONSchema, rootSchema: Record<string, unknown> | undefined, depth: number, match: UnevaluatedMatchFn) => UnevaluatedExpression | null | undefined;

package/dist/generators/unevaluated-match.js

@@ -0,0 +1,209 @@
+import { regexLiteral } from "@amritk/helpers/escape-regex-pattern";
+import { resolveRef } from "@amritk/helpers/resolve-ref";
+import { isSchemaObject } from "@amritk/helpers/schema-guards";
+const NONE = { all: false, terms: [] };
+const ALL = { all: true, terms: [] };
+const MAX_COVERAGE_DEPTH = 8;
+const orJoin = (terms) => terms.length === 1 ? terms[0] : `(${terms.join(" || ")})`;
+const nest = (ctx) => ({ ...ctx, depth: ctx.depth + 1 });
+const hoistCondition = (sink, condition) => {
+  const name = `${sink.prefix}${sink.setup.length}`;
+  sink.setup.push(`const ${name} = ${condition}`);
+  return name;
+};
+const conditioned = (coverage, condition) => {
+  if (coverage.all)
+    return { all: false, terms: [condition] };
+  if (coverage.terms.length === 0)
+    return NONE;
+  return { all: false, terms: [`(${condition} && ${orJoin(coverage.terms)})`] };
+};
+const merge = (into, from) => into.all || from.all ? ALL : { all: false, terms: [...into.terms, ...from.terms] };
+const ownPropertyCoverage = (schema, keyVar, ignoreOwnUnevaluated) => {
+  if ("additionalProperties" in schema)
+    return ALL;
+  if (!ignoreOwnUnevaluated && "unevaluatedProperties" in schema && schema["unevaluatedProperties"] !== false) {
+    return ALL;
+  }
+  const terms = [];
+  const properties = schema["properties"];
+  if (typeof properties === "object" && properties !== null && !Array.isArray(properties)) {
+    const keys = Object.keys(properties);
+    if (keys.length > 0)
+      terms.push(`${JSON.stringify(keys)}.includes(${keyVar})`);
+  }
+  const patterns = schema["patternProperties"];
+  if (typeof patterns === "object" && patterns !== null && !Array.isArray(patterns)) {
+    for (const pattern of Object.keys(patterns)) {
+      terms.push(`${regexLiteral(pattern)}.test(${keyVar})`);
+    }
+  }
+  return { all: false, terms };
+};
+const ownItemCoverage = (schema, indexVar, itemVar, ignoreOwnUnevaluated, ctx, match) => {
+  const tupleItems = Array.isArray(schema["items"]);
+  if (!tupleItems && "items" in schema)
+    return ALL;
+  if (tupleItems && "additionalItems" in schema)
+    return ALL;
+  if (!ignoreOwnUnevaluated && "unevaluatedItems" in schema && schema["unevaluatedItems"] !== false) {
+    return ALL;
+  }
+  const terms = [];
+  const prefix = Array.isArray(schema["prefixItems"]) ? schema["prefixItems"] : tupleItems ? schema["items"] : null;
+  if (prefix && prefix.length > 0)
+    terms.push(`${indexVar} < ${prefix.length}`);
+  if ("contains" in schema) {
+    terms.push(match(itemVar, schema["contains"], ctx.depth));
+  }
+  return { all: false, terms };
+};
+const coverageOf = (kind, schema, indexVar, itemVar, acc, ctx, sink, match, ignoreOwnUnevaluated = false) => {
+  if (typeof schema === "boolean")
+    return NONE;
+  if (!isSchemaObject(schema))
+    return null;
+  if (ctx.depth > MAX_COVERAGE_DEPTH)
+    return null;
+  const s = schema;
+  if (typeof s["$dynamicRef"] === "string")
+    return null;
+  let coverage = kind === "properties" ? ownPropertyCoverage(s, indexVar, ignoreOwnUnevaluated) : ownItemCoverage(s, indexVar, itemVar, ignoreOwnUnevaluated, ctx, match);
+  const ref = s["$ref"];
+  if (typeof ref === "string") {
+    if (ctx.rootSchema === void 0 || ctx.seen.has(ref))
+      return null;
+    const target = resolveRef(ref, ctx.rootSchema);
+    if (target === void 0)
+      return null;
+    const seen = new Set(ctx.seen);
+    seen.add(ref);
+    const refCoverage = coverageOf(kind, target, indexVar, itemVar, acc, { ...nest(ctx), seen }, sink, match);
+    if (refCoverage === null)
+      return null;
+    coverage = merge(coverage, refCoverage);
+  }
+  if (Array.isArray(s["allOf"])) {
+    for (const member of s["allOf"]) {
+      const memberCoverage = coverageOf(kind, member, indexVar, itemVar, acc, nest(ctx), sink, match);
+      if (memberCoverage === null)
+        return null;
+      coverage = merge(coverage, memberCoverage);
+    }
+  }
+  for (const keyword of ["anyOf", "oneOf"]) {
+    if (!Array.isArray(s[keyword]))
+      continue;
+    for (const branch of s[keyword]) {
+      const branchCoverage = coverageOf(kind, branch, indexVar, itemVar, acc, nest(ctx), sink, match);
+      if (branchCoverage === null)
+        return null;
+      if (!branchCoverage.all && branchCoverage.terms.length === 0)
+        continue;
+      coverage = merge(coverage, conditioned(branchCoverage, hoistCondition(sink, match(acc, branch, ctx.depth))));
+    }
+  }
+  if ("if" in s) {
+    const branches = [];
+    for (const [keyword, negated] of [
+      ["if", false],
+      ["then", false],
+      ["else", true]
+    ]) {
+      if (!(keyword in s))
+        continue;
+      const branchCoverage = coverageOf(kind, s[keyword], indexVar, itemVar, acc, nest(ctx), sink, match);
+      if (branchCoverage === null)
+        return null;
+      if (!branchCoverage.all && branchCoverage.terms.length === 0)
+        continue;
+      branches.push({ coverage: branchCoverage, negated });
+    }
+    if (branches.length > 0) {
+      const ifMatch = hoistCondition(sink, match(acc, s["if"], ctx.depth));
+      for (const branch of branches) {
+        coverage = merge(coverage, conditioned(branch.coverage, branch.negated ? `!${ifMatch}` : ifMatch));
+      }
+    }
+  }
+  for (const keyword of ["dependentSchemas", "dependencies"]) {
+    const dependents = s[keyword];
+    if (typeof dependents !== "object" || dependents === null || Array.isArray(dependents))
+      continue;
+    for (const [trigger, sub] of Object.entries(dependents)) {
+      if (Array.isArray(sub))
+        continue;
+      const subCoverage = coverageOf(kind, sub, indexVar, itemVar, acc, nest(ctx), sink, match);
+      if (subCoverage === null)
+        return null;
+      if (!subCoverage.all && subCoverage.terms.length === 0)
+        continue;
+      const present = `Object.hasOwn(${acc} as object, ${JSON.stringify(trigger)})`;
+      coverage = merge(coverage, conditioned(subCoverage, hoistCondition(sink, present)));
+    }
+  }
+  return coverage;
+};
+const unevaluatedPropertiesExpr = (acc, schema, rootSchema, depth, match) => {
+  if (!isSchemaObject(schema))
+    return void 0;
+  const s = schema;
+  if (!("unevaluatedProperties" in s))
+    return void 0;
+  const unevaluated = s["unevaluatedProperties"];
+  if (unevaluated === true)
+    return void 0;
+  const keyVar = `_uk${depth}`;
+  const sink = { setup: [], prefix: `_uc${depth}_` };
+  const ctx = { rootSchema, depth: 0, seen: /* @__PURE__ */ new Set() };
+  const coverage = coverageOf("properties", schema, keyVar, "", acc, ctx, sink, match, true);
+  if (coverage === null)
+    return null;
+  if (coverage.all)
+    return void 0;
+  const record = `(${acc} as Record<string, unknown>)`;
+  const covered = coverage.terms.length > 0 ? orJoin(coverage.terms) : null;
+  if (unevaluated === false) {
+    const expr2 = covered === null ? `Object.keys(${record}).length === 0` : `Object.keys(${record}).every((${keyVar}) => ${covered})`;
+    return { setup: sink.setup, expr: expr2 };
+  }
+  const valueMatch = match(`${record}[${keyVar}]`, unevaluated, depth);
+  if (valueMatch === "true")
+    return void 0;
+  const expr = covered === null ? `Object.keys(${record}).every((${keyVar}) => ${valueMatch})` : `Object.keys(${record}).every((${keyVar}) => ${covered} || ${valueMatch})`;
+  return { setup: sink.setup, expr };
+};
+const unevaluatedItemsExpr = (acc, schema, rootSchema, depth, match) => {
+  if (!isSchemaObject(schema))
+    return void 0;
+  const s = schema;
+  if (!("unevaluatedItems" in s))
+    return void 0;
+  const unevaluated = s["unevaluatedItems"];
+  if (unevaluated === true)
+    return void 0;
+  const indexVar = `_un${depth}`;
+  const itemVar = `_ue${depth}`;
+  const sink = { setup: [], prefix: `_ud${depth}_` };
+  const ctx = { rootSchema, depth: 0, seen: /* @__PURE__ */ new Set() };
+  const coverage = coverageOf("items", schema, indexVar, itemVar, acc, ctx, sink, match, true);
+  if (coverage === null)
+    return null;
+  if (coverage.all)
+    return void 0;
+  const elements = `(${acc} as unknown[])`;
+  const covered = coverage.terms.length > 0 ? orJoin(coverage.terms) : null;
+  if (unevaluated === false) {
+    const expr2 = covered === null ? `${elements}.length === 0` : `${elements}.every((${itemVar}, ${indexVar}) => ${covered})`;
+    return { setup: sink.setup, expr: expr2 };
+  }
+  const valueMatch = match(itemVar, unevaluated, depth);
+  if (valueMatch === "true")
+    return void 0;
+  const expr = covered === null ? `${elements}.every((${itemVar}) => ${valueMatch})` : `${elements}.every((${itemVar}, ${indexVar}) => ${covered} || ${valueMatch})`;
+  return { setup: sink.setup, expr };
+};
+export {
+  unevaluatedItemsExpr,
+  unevaluatedPropertiesExpr
+};

package/package.json

@@ -1,8 +1,10 @@
 {
   "name": "@amritk/generate-validators",
-  "version": "0.11.12",
+  "version": "0.12.0",
   "description": "Generate TypeScript validation functions from JSON Schemas.",
+  "main": "./dist/index.js",
   "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "type": "module",
   "sideEffects": false,
   "engines": {
@@ -51,10 +53,10 @@
   },
   "dependencies": {
     "json-schema-typed": "^8.0.1",
-    "@amritk/helpers": "0.14.0"
+    "@amritk/helpers": "^0.15.0"
   },
   "devDependencies": {
-    "@amritk/runtime-validators": "0.9.1",
+    "@amritk/runtime-validators": "^0.10.0",
     "@ryoppippi/unplugin-typia": "^2.6.5",
     "@scalar/openapi-parser": "^0.26.1",
     "@sinclair/typebox": "^0.34.49",