@amritk/generate-validators 0.12.2 → 0.13.1

package/dist/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/generators/tuple-shape.js

@@ -0,0 +1,18 @@
+const tupleShapeOf = (schema) => {
+  const items = schema["items"];
+  const prefix = schema["prefixItems"];
+  if (Array.isArray(prefix)) {
+    return {
+      tuple: prefix,
+      tail: "items" in schema && !Array.isArray(items) ? items : void 0,
+      tailIsClosed: items === false
+    };
+  }
+  if (Array.isArray(items)) {
+    return { tuple: items, tail: schema["additionalItems"], tailIsClosed: schema["additionalItems"] === false };
+  }
+  return { tuple: void 0, tail: "items" in schema ? items : void 0, tailIsClosed: items === false };
+};
+export {
+  tupleShapeOf
+};

package/dist/generators/unevaluated-match.js

@@ -4,6 +4,7 @@ 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) => {
@@ -54,7 +55,11 @@ const ownItemCoverage = (schema, indexVar, itemVar, ignoreOwnUnevaluated, ctx, m
   if (prefix && prefix.length > 0)
     terms.push(`${indexVar} < ${prefix.length}`);
   if ("contains" in schema) {
-    terms.push(match(itemVar, schema["contains"], ctx.depth));
+    const contained = match(itemVar, schema["contains"], ctx.depth);
+    if (contained === "true")
+      return ALL;
+    if (contained !== "false")
+      terms.push(contained);
   }
   return { all: false, terms };
 };
@@ -167,10 +172,14 @@ const unevaluatedPropertiesExpr = (acc, schema, rootSchema, depth, match) => {
     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);
+  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(${record}).every((${keyVar}) => ${valueMatch})` : `Object.keys(${record}).every((${keyVar}) => ${covered} || ${valueMatch})`;
+  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) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/generate-validators",
-  "version": "0.12.2",
+  "version": "0.13.1",
   "description": "Generate TypeScript validation functions from JSON Schemas.",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -54,10 +54,10 @@
   },
   "dependencies": {
     "json-schema-typed": "^8.0.1",
-    "@amritk/helpers": "^0.15.2"
+    "@amritk/helpers": "^0.15.4"
   },
   "devDependencies": {
-    "@amritk/runtime-validators": "^0.10.1",
+    "@amritk/runtime-validators": "^0.11.0",
     "@ryoppippi/unplugin-typia": "^2.6.5",
     "@scalar/openapi-parser": "^0.26.1",
     "@sinclair/typebox": "^0.34.49",