@amritk/validation 0.4.1 → 0.6.0

package/dist/validators/generators/repair-walkable.d.ts

@@ -0,0 +1,33 @@
+import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
+/**
+ * Assertions the walk leaves to the validator's own test of the position, and
+ * repairs by replacing the position — which is what the loop does with the
+ * errors they produce, since each is reported at the position it judges.
+ * Their subschemas (an `anyOf` branch, a `not`) are never descended into, so
+ * whatever they contain is the validator's business alone.
+ */
+export declare const LEAF_KEYWORDS: Set<string>;
+/**
+ * Why the single-pass repair walk cannot be emitted for `schema`, or `null` when
+ * it can.
+ *
+ * Asked of every definition in the graph, because the walk crosses files the
+ * same way validation does: one definition the walk cannot cover means none of
+ * them get it, and `repairX` keeps the loop everywhere. The answer names the
+ * keyword and where it is, for the error a schema that asked for something only
+ * the walk does (`"x-repair": "ref"`) gets.
+ */
+export declare const repairWalkBlocker: (schema: JSONSchema, isRoot?: boolean) => string | null;
+/**
+ * Whether any schema in `schema` opts into instance `$ref` following. Values
+ * under `default`, `const`, `enum` and `examples` are documents, not schemas, so
+ * the same words in an example opt nothing in.
+ */
+export declare const asksForRefs: (schema: unknown) => boolean;
+/**
+ * Whether `schema` is — directly or through a chain of `$ref`s — a Reference
+ * schema that opted into instance `$ref` following with `"x-repair": "ref"`.
+ */
+export declare const isReferenceSchema: (schema: JSONSchema, rootSchema: Record<string, unknown> | undefined) => boolean;
+/** The keywords the walk checks through the validator's own test. */
+export declare const leafKeywords: (node: Record<string, unknown>) => Record<string, unknown> | null;

package/dist/validators/generators/repair-walkable.js

@@ -0,0 +1,148 @@
+import { getMjstInstanceOf, getMjstPrimitive } from "@amritk/helpers/mjst-extension";
+import { readKey } from "@amritk/helpers/read-key";
+import { resolveRef } from "@amritk/helpers/resolve-ref";
+import { isSchemaObject } from "@amritk/helpers/schema-guards";
+const LEAF_KEYWORDS = /* @__PURE__ */ new Set([
+  "minLength",
+  "maxLength",
+  "pattern",
+  "format",
+  "minimum",
+  "maximum",
+  "exclusiveMinimum",
+  "exclusiveMaximum",
+  "multipleOf",
+  "maxItems",
+  "uniqueItems",
+  "contains",
+  "minContains",
+  "maxContains",
+  "minProperties",
+  "maxProperties",
+  "dependentRequired",
+  "not",
+  "anyOf",
+  "oneOf"
+]);
+const BLOCKING_KEYWORDS = /* @__PURE__ */ new Set([
+  "prefixItems",
+  "additionalItems",
+  "unevaluatedProperties",
+  "unevaluatedItems",
+  "dependentSchemas",
+  "dependencies",
+  "propertyNames",
+  "minItems",
+  "$dynamicRef",
+  "$dynamicAnchor",
+  "$recursiveRef",
+  "$recursiveAnchor",
+  "nullable"
+]);
+const KNOWN_TYPES = /* @__PURE__ */ new Set(["string", "number", "integer", "boolean", "null", "array", "object"]);
+const repairWalkBlocker = (schema, isRoot = true) => blockerAt(schema, "#", isRoot);
+const blockerAt = (schema, at, isRoot) => {
+  if (typeof schema === "boolean")
+    return null;
+  if (!isSchemaObject(schema))
+    return `${at} is not a schema`;
+  const node = schema;
+  for (const key of Object.keys(node)) {
+    if (BLOCKING_KEYWORDS.has(key))
+      return `${at}/${key}`;
+    if (key === "x-mjst" && (getMjstInstanceOf(schema) !== void 0 || getMjstPrimitive(schema) !== void 0)) {
+      return `${at}/x-mjst`;
+    }
+    if (key === "$id" && !isRoot)
+      return `${at}/$id`;
+  }
+  const type = readKey(node, "type");
+  if (type !== void 0) {
+    const types = Array.isArray(type) ? type : [type];
+    if (types.length === 0 || !types.every((entry) => typeof entry === "string" && KNOWN_TYPES.has(entry))) {
+      return `${at}/type`;
+    }
+  }
+  const items = readKey(node, "items");
+  if (Array.isArray(items))
+    return `${at}/items`;
+  for (const key of ["properties", "patternProperties"]) {
+    const map = readKey(node, key);
+    if (map === void 0)
+      continue;
+    if (typeof map !== "object" || map === null || Array.isArray(map))
+      return `${at}/${key}`;
+    for (const [name, child] of Object.entries(map)) {
+      const found = blockerAt(child, `${at}/${key}/${name}`, false);
+      if (found !== null)
+        return found;
+    }
+  }
+  for (const key of ["additionalProperties", "items", "then", "else"]) {
+    const child = readKey(node, key);
+    if (child === void 0)
+      continue;
+    const found = blockerAt(child, `${at}/${key}`, false);
+    if (found !== null)
+      return found;
+  }
+  const allOf = readKey(node, "allOf");
+  if (allOf !== void 0) {
+    if (!Array.isArray(allOf))
+      return `${at}/allOf`;
+    for (let i = 0; i < allOf.length; i++) {
+      const found = blockerAt(allOf[i], `${at}/allOf/${i}`, false);
+      if (found !== null)
+        return found;
+    }
+  }
+  return null;
+};
+const DATA_KEYWORDS = /* @__PURE__ */ new Set(["default", "const", "enum", "examples", "example"]);
+const asksForRefs = (schema) => {
+  if (Array.isArray(schema))
+    return schema.some(asksForRefs);
+  if (typeof schema !== "object" || schema === null)
+    return false;
+  const node = schema;
+  if (readKey(node, "x-repair") === "ref")
+    return true;
+  for (const [key, value] of Object.entries(node)) {
+    if (!DATA_KEYWORDS.has(key) && asksForRefs(value))
+      return true;
+  }
+  return false;
+};
+const isReferenceSchema = (schema, rootSchema) => {
+  let node = schema;
+  for (let hops = 0; hops < 32; hops++) {
+    if (!isSchemaObject(node))
+      return false;
+    const record = node;
+    if (readKey(record, "x-repair") === "ref")
+      return true;
+    const ref = readKey(record, "$ref");
+    if (typeof ref !== "string" || rootSchema === void 0)
+      return false;
+    node = resolveRef(ref, rootSchema);
+  }
+  return false;
+};
+const leafKeywords = (node) => {
+  const leaf = {};
+  let any = false;
+  for (const key of Object.keys(node)) {
+    if (!LEAF_KEYWORDS.has(key))
+      continue;
+    leaf[key] = node[key];
+    any = true;
+  }
+  return any ? leaf : null;
+};
+export {
+  LEAF_KEYWORDS,
+  asksForRefs,
+  isReferenceSchema,
+  leafKeywords,
+  repairWalkBlocker
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/validation",
-  "version": "0.4.1",
+  "version": "0.6.0",
   "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.24.0",
+    "@amritk/helpers": "^0.25.0",
     "json-schema-typed": "^8.0.1"
   },
   "devDependencies": {
-    "@amritk/runtime-validators": "^0.15.1",
+    "@amritk/runtime-validators": "^0.15.2",
     "@ryoppippi/unplugin-typia": "^2.6.5",
     "@scalar/openapi-parser": "^0.26.1",
     "@sinclair/typebox": "^0.34.49",