@amritk/validation 0.2.0

package/dist/validators/generators/tuple-shape.d.ts

@@ -0,0 +1,31 @@
+/**
+ * How a schema spells its array positions, normalised across the two dialects
+ * the generator accepts.
+ *
+ * 2020-12 lists the fixed positions in `prefixItems` and types the rest with
+ * `items`. Draft-07 (and anything a converter left in that shape — see the note
+ * in `@amritk/adapters`' Valibot converter) puts the fixed positions in an
+ * *array* `items` and types the rest with `additionalItems`. Reading only the
+ * 2020-12 spelling is what let a draft-07 tuple emit no array validation at all
+ * while the type generator wrote out a real tuple type.
+ *
+ * - `tuple` — the fixed positions, or `undefined` when the array is not a tuple.
+ * - `tail` — the schema for every index past the tuple, or `undefined` when none
+ *   is declared. `false` means "there must be no such index".
+ * - `tailIsClosed` — whether a tuple's length is capped: `items: false` past a
+ *   `prefixItems`, or `additionalItems: false` past an array `items`. Each
+ *   dialect's own spelling only — `additionalItems` is not a 2020-12 keyword, and
+ *   honouring it next to `prefixItems` made the validator cap a length that Ajv,
+ *   the interpreter, and the tuple type emitted beside it all leave open.
+ *
+ * `prefixItems` wins when a node carries both, which is the order
+ * `@amritk/helpers/generate-type-definition` and `@amritk/runtime-validators`
+ * already read them in. Reading the array `items` first instead made the
+ * validator enforce one tuple while the *type* emitted beside it described the
+ * other — the same type/validator split this normalisation exists to close.
+ */
+export declare const tupleShapeOf: (schema: Record<string, unknown>) => {
+    tuple: unknown[] | undefined;
+    tail: unknown;
+    tailIsClosed: boolean;
+};

package/dist/validators/generators/tuple-shape.js

@@ -0,0 +1,20 @@
+import { declaresKey, readKey } from "@amritk/helpers/read-key";
+const tupleShapeOf = (schema) => {
+  const items = readKey(schema, "items");
+  const prefix = readKey(schema, "prefixItems");
+  if (Array.isArray(prefix)) {
+    return {
+      tuple: prefix,
+      tail: declaresKey(schema, "items") && !Array.isArray(items) ? items : void 0,
+      tailIsClosed: items === false
+    };
+  }
+  if (Array.isArray(items)) {
+    const additionalItems = readKey(schema, "additionalItems");
+    return { tuple: items, tail: additionalItems, tailIsClosed: additionalItems === false };
+  }
+  return { tuple: void 0, tail: declaresKey(schema, "items") ? items : void 0, tailIsClosed: items === false };
+};
+export {
+  tupleShapeOf
+};

package/dist/validators/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/validators/generators/unevaluated-match.js

@@ -0,0 +1,223 @@
+import { regexLiteral } from "@amritk/helpers/escape-regex-pattern";
+import { declaresKey, readKey } from "@amritk/helpers/read-key";
+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 PLAIN_IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
+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 (declaresKey(schema, "additionalProperties"))
+    return ALL;
+  if (!ignoreOwnUnevaluated && declaresKey(schema, "unevaluatedProperties") && schema["unevaluatedProperties"] !== false) {
+    return ALL;
+  }
+  const terms = [];
+  const properties = readKey(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 = readKey(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(readKey(schema, "items"));
+  if (!tupleItems && declaresKey(schema, "items"))
+    return ALL;
+  if (tupleItems && declaresKey(schema, "additionalItems"))
+    return ALL;
+  if (!ignoreOwnUnevaluated && declaresKey(schema, "unevaluatedItems") && schema["unevaluatedItems"] !== false) {
+    return ALL;
+  }
+  const terms = [];
+  const declaredPrefix = readKey(schema, "prefixItems");
+  const prefix = Array.isArray(declaredPrefix) ? declaredPrefix : tupleItems ? readKey(schema, "items") : null;
+  if (prefix && prefix.length > 0)
+    terms.push(`${indexVar} < ${prefix.length}`);
+  if (declaresKey(schema, "contains")) {
+    const contained = match(itemVar, readKey(schema, "contains"), ctx.depth);
+    if (contained === "true")
+      return ALL;
+    if (contained !== "false")
+      terms.push(contained);
+  }
+  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 readKey(s, "$dynamicRef") === "string")
+    return null;
+  let coverage = kind === "properties" ? ownPropertyCoverage(s, indexVar, ignoreOwnUnevaluated) : ownItemCoverage(s, indexVar, itemVar, ignoreOwnUnevaluated, ctx, match);
+  const ref = readKey(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);
+  }
+  const allOf = readKey(s, "allOf");
+  if (Array.isArray(allOf)) {
+    for (const member of 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"]) {
+    const branches = readKey(s, keyword);
+    if (!Array.isArray(branches))
+      continue;
+    for (const branch of branches) {
+      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 (declaresKey(s, "if")) {
+    const branches = [];
+    for (const [keyword, negated] of [
+      ["if", false],
+      ["then", false],
+      ["else", true]
+    ]) {
+      if (!declaresKey(s, keyword))
+        continue;
+      const branchCoverage = coverageOf(kind, readKey(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, readKey(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 = readKey(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 (!declaresKey(s, "unevaluatedProperties"))
+    return void 0;
+  const unevaluated = readKey(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 bound = PLAIN_IDENTIFIER.test(acc) ? null : `_uo${depth}`;
+  if (bound !== null)
+    sink.setup.push(`const ${bound} = ${acc} as Record<string, unknown>`);
+  const source = bound ?? record;
+  const valueMatch = match(`${source}[${keyVar}]`, unevaluated, depth);
+  if (valueMatch === "true")
+    return void 0;
+  const expr = covered === null ? `Object.keys(${source}).every((${keyVar}) => ${valueMatch})` : `Object.keys(${source}).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 (!declaresKey(s, "unevaluatedItems"))
+    return void 0;
+  const unevaluated = readKey(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 visited = `Array.from(${elements})`;
+  const covered = coverage.terms.length > 0 ? orJoin(coverage.terms) : null;
+  if (unevaluated === false) {
+    const expr2 = covered === null ? `${elements}.length === 0` : `${visited}.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 ? `${visited}.every((${itemVar}) => ${valueMatch})` : `${visited}.every((${itemVar}, ${indexVar}) => ${covered} || ${valueMatch})`;
+  return { setup: sink.setup, expr };
+};
+export {
+  unevaluatedItemsExpr,
+  unevaluatedPropertiesExpr
+};

package/dist/validators/index.d.ts

@@ -0,0 +1,2 @@
+export type { GeneratedFile } from './generators/build-schema.js';
+export { buildValidatorSchema } from './generators/build-schema.js';

package/dist/validators/index.js

@@ -0,0 +1,4 @@
+import { buildValidatorSchema } from "./generators/build-schema.js";
+export {
+  buildValidatorSchema
+};

package/package.json

@@ -0,0 +1,92 @@
+{
+  "name": "@amritk/validation",
+  "version": "0.2.0",
+  "description": "One generator surface over mjst's types, validators, coercers, repairers and parsers.",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "MIT",
+  "author": "amritk",
+  "keywords": [
+    "json-schema",
+    "typescript",
+    "validator",
+    "parser",
+    "code-generation",
+    "mjst"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/amritk/mjst.git",
+    "directory": "packages/validation"
+  },
+  "homepage": "https://github.com/amritk/mjst/tree/main/packages/validation#readme",
+  "bugs": {
+    "url": "https://github.com/amritk/mjst/issues"
+  },
+  "files": [
+    "dist",
+    "AI.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsgo -p tsconfig.build.json && tsc-alias -p tsconfig.build.json -f && node ../../scripts/strip-comments.mjs",
+    "prepublishOnly": "node ../../scripts/check-publishable.mjs",
+    "types:check": "tsgo -p . --noEmit",
+    "test": "NODE_ENV=production vitest run --root ../.. packages/validation/",
+    "prebench": "bun run --filter='@amritk/helpers' build",
+    "bench": "bun --conditions development ./bench/compare.ts",
+    "prebench:parsers": "bun run --filter='@amritk/helpers' build && bun run build",
+    "bench:parsers": "bun --conditions development ./bench/parsers/run.ts",
+    "prebench:parsers:node": "bun run --filter='@amritk/helpers' build && bun run build",
+    "bench:parsers:node": "node ./bench/parsers/run.ts",
+    "bench:parsers:moltar": "bun --conditions development ./bench/parsers/moltar.ts",
+    "prebench:validators": "bun run --filter='@amritk/helpers' build && bun run build",
+    "bench:validators": "bun --conditions development ./bench/validators/run.ts",
+    "prebench:validators:node": "bun run --filter='@amritk/helpers' build && bun run build",
+    "bench:validators:node": "node ./bench/validators/run.ts",
+    "prebench:validators:check": "bun run --filter='@amritk/helpers' build && bun run build",
+    "bench:validators:check": "bun --conditions development ./bench/validators/check.ts",
+    "prebench:validators:coerce": "bun run --filter='@amritk/helpers' build && bun run build",
+    "bench:validators:coerce": "bun --conditions development ./bench/validators/coerce.ts",
+    "prebench:validators:coerce:node": "bun run --filter='@amritk/helpers' build && bun run build",
+    "bench:validators:coerce:node": "node ./bench/validators/coerce.ts",
+    "bench:validators:moltar": "bun --conditions development ./bench/validators/moltar.ts",
+    "bench:validators:moltar:leaderboard": "bun --conditions development ./bench/validators/moltar-leaderboard.ts"
+  },
+  "imports": {
+    "#internal/*": "./src/*.ts",
+    "#parsers/*": "./src/parsers/*.ts",
+    "#validators/*": "./src/validators/*.ts"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@amritk/helpers": "^0.23.0",
+    "json-schema-typed": "^8.0.1"
+  },
+  "devDependencies": {
+    "@amritk/runtime-validators": "^0.15.0",
+    "@ryoppippi/unplugin-typia": "^2.6.5",
+    "@scalar/openapi-parser": "^0.26.1",
+    "@sinclair/typebox": "^0.34.49",
+    "ajv": "^8.17.1",
+    "ajv-formats": "^3.0.1",
+    "benny": "^3.7.1",
+    "esbuild": "^0.28.1",
+    "typescript": "^5.9.3",
+    "typia": "^12.1.1",
+    "zod": "^4.4.3"
+  }
+}