@amritk/generate-validators 0.13.0 → 0.14.0

package/dist/generators/tuple-shape.js

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

package/dist/generators/unevaluated-match.js

@@ -1,4 +1,5 @@
 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: [] };
@@ -21,19 +22,19 @@ const conditioned = (coverage, condition) => {
 };
 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)
+  if (declaresKey(schema, "additionalProperties"))
     return ALL;
-  if (!ignoreOwnUnevaluated && "unevaluatedProperties" in schema && schema["unevaluatedProperties"] !== false) {
+  if (!ignoreOwnUnevaluated && declaresKey(schema, "unevaluatedProperties") && schema["unevaluatedProperties"] !== false) {
     return ALL;
   }
   const terms = [];
-  const properties = schema["properties"];
+  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 = schema["patternProperties"];
+  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})`);
@@ -42,20 +43,21 @@ const ownPropertyCoverage = (schema, keyVar, ignoreOwnUnevaluated) => {
   return { all: false, terms };
 };
 const ownItemCoverage = (schema, indexVar, itemVar, ignoreOwnUnevaluated, ctx, match) => {
-  const tupleItems = Array.isArray(schema["items"]);
-  if (!tupleItems && "items" in schema)
+  const tupleItems = Array.isArray(readKey(schema, "items"));
+  if (!tupleItems && declaresKey(schema, "items"))
     return ALL;
-  if (tupleItems && "additionalItems" in schema)
+  if (tupleItems && declaresKey(schema, "additionalItems"))
     return ALL;
-  if (!ignoreOwnUnevaluated && "unevaluatedItems" in schema && schema["unevaluatedItems"] !== false) {
+  if (!ignoreOwnUnevaluated && declaresKey(schema, "unevaluatedItems") && schema["unevaluatedItems"] !== false) {
     return ALL;
   }
   const terms = [];
-  const prefix = Array.isArray(schema["prefixItems"]) ? schema["prefixItems"] : tupleItems ? schema["items"] : null;
+  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 ("contains" in schema) {
-    const contained = match(itemVar, schema["contains"], ctx.depth);
+  if (declaresKey(schema, "contains")) {
+    const contained = match(itemVar, readKey(schema, "contains"), ctx.depth);
     if (contained === "true")
       return ALL;
     if (contained !== "false")
@@ -71,10 +73,10 @@ const coverageOf = (kind, schema, indexVar, itemVar, acc, ctx, sink, match, igno
   if (ctx.depth > MAX_COVERAGE_DEPTH)
     return null;
   const s = schema;
-  if (typeof s["$dynamicRef"] === "string")
+  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 = s["$ref"];
+  const ref = readKey(s, "$ref");
   if (typeof ref === "string") {
     if (ctx.rootSchema === void 0 || ctx.seen.has(ref))
       return null;
@@ -88,8 +90,9 @@ const coverageOf = (kind, schema, indexVar, itemVar, acc, ctx, sink, match, igno
       return null;
     coverage = merge(coverage, refCoverage);
   }
-  if (Array.isArray(s["allOf"])) {
-    for (const member of s["allOf"]) {
+  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;
@@ -97,9 +100,10 @@ const coverageOf = (kind, schema, indexVar, itemVar, acc, ctx, sink, match, igno
     }
   }
   for (const keyword of ["anyOf", "oneOf"]) {
-    if (!Array.isArray(s[keyword]))
+    const branches = readKey(s, keyword);
+    if (!Array.isArray(branches))
       continue;
-    for (const branch of s[keyword]) {
+    for (const branch of branches) {
       const branchCoverage = coverageOf(kind, branch, indexVar, itemVar, acc, nest(ctx), sink, match);
       if (branchCoverage === null)
         return null;
@@ -108,16 +112,16 @@ const coverageOf = (kind, schema, indexVar, itemVar, acc, ctx, sink, match, igno
       coverage = merge(coverage, conditioned(branchCoverage, hoistCondition(sink, match(acc, branch, ctx.depth))));
     }
   }
-  if ("if" in s) {
+  if (declaresKey(s, "if")) {
     const branches = [];
     for (const [keyword, negated] of [
       ["if", false],
       ["then", false],
       ["else", true]
     ]) {
-      if (!(keyword in s))
+      if (!declaresKey(s, keyword))
         continue;
-      const branchCoverage = coverageOf(kind, s[keyword], indexVar, itemVar, acc, nest(ctx), sink, match);
+      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)
@@ -125,14 +129,14 @@ const coverageOf = (kind, schema, indexVar, itemVar, acc, ctx, sink, match, igno
       branches.push({ coverage: branchCoverage, negated });
     }
     if (branches.length > 0) {
-      const ifMatch = hoistCondition(sink, match(acc, s["if"], ctx.depth));
+      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 = s[keyword];
+    const dependents = readKey(s, keyword);
     if (typeof dependents !== "object" || dependents === null || Array.isArray(dependents))
       continue;
     for (const [trigger, sub] of Object.entries(dependents)) {
@@ -153,9 +157,9 @@ const unevaluatedPropertiesExpr = (acc, schema, rootSchema, depth, match) => {
   if (!isSchemaObject(schema))
     return void 0;
   const s = schema;
-  if (!("unevaluatedProperties" in s))
+  if (!declaresKey(s, "unevaluatedProperties"))
     return void 0;
-  const unevaluated = s["unevaluatedProperties"];
+  const unevaluated = readKey(s, "unevaluatedProperties");
   if (unevaluated === true)
     return void 0;
   const keyVar = `_uk${depth}`;
@@ -186,9 +190,9 @@ const unevaluatedItemsExpr = (acc, schema, rootSchema, depth, match) => {
   if (!isSchemaObject(schema))
     return void 0;
   const s = schema;
-  if (!("unevaluatedItems" in s))
+  if (!declaresKey(s, "unevaluatedItems"))
     return void 0;
-  const unevaluated = s["unevaluatedItems"];
+  const unevaluated = readKey(s, "unevaluatedItems");
   if (unevaluated === true)
     return void 0;
   const indexVar = `_un${depth}`;
@@ -201,15 +205,16 @@ const unevaluatedItemsExpr = (acc, schema, rootSchema, depth, match) => {
   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` : `${elements}.every((${itemVar}, ${indexVar}) => ${covered})`;
+    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 ? `${elements}.every((${itemVar}) => ${valueMatch})` : `${elements}.every((${itemVar}, ${indexVar}) => ${covered} || ${valueMatch})`;
+  const expr = covered === null ? `${visited}.every((${itemVar}) => ${valueMatch})` : `${visited}.every((${itemVar}, ${indexVar}) => ${covered} || ${valueMatch})`;
   return { setup: sink.setup, expr };
 };
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/generate-validators",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "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.3"
+    "@amritk/helpers": "^0.16.0"
   },
   "devDependencies": {
-    "@amritk/runtime-validators": "^0.10.1",
+    "@amritk/runtime-validators": "^0.12.0",
     "@ryoppippi/unplugin-typia": "^2.6.5",
     "@scalar/openapi-parser": "^0.26.1",
     "@sinclair/typebox": "^0.34.49",