@json-schema-engine/core 0.0.1

package/src/keywords/metaschemas7.ts

@@ -0,0 +1,253 @@
+// The draft-07 metaschema, vendored verbatim from
+// https://json-schema.org/draft-07/schema (JSON Schema specification
+// artifact, BSD-licensed). Same role as metaschemas2020.ts; the $id's empty
+// fragment is stripped to the resource URI.
+import { JsonValue } from "../json.js";
+
+export const METASCHEMAS_DRAFT_07: readonly (readonly [string, JsonValue])[] = [
+  ["http://json-schema.org/draft-07/schema", {
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "$id": "http://json-schema.org/draft-07/schema#",
+    "title": "Core schema meta-schema",
+    "definitions": {
+      "schemaArray": {
+        "type": "array",
+        "minItems": 1,
+        "items": {
+          "$ref": "#"
+        }
+      },
+      "nonNegativeInteger": {
+        "type": "integer",
+        "minimum": 0
+      },
+      "nonNegativeIntegerDefault0": {
+        "allOf": [
+          {
+            "$ref": "#/definitions/nonNegativeInteger"
+          },
+          {
+            "default": 0
+          }
+        ]
+      },
+      "simpleTypes": {
+        "enum": [
+          "array",
+          "boolean",
+          "integer",
+          "null",
+          "number",
+          "object",
+          "string"
+        ]
+      },
+      "stringArray": {
+        "type": "array",
+        "items": {
+          "type": "string"
+        },
+        "uniqueItems": true,
+        "default": []
+      }
+    },
+    "type": [
+      "object",
+      "boolean"
+    ],
+    "properties": {
+      "$id": {
+        "type": "string",
+        "format": "uri-reference"
+      },
+      "$schema": {
+        "type": "string",
+        "format": "uri"
+      },
+      "$ref": {
+        "type": "string",
+        "format": "uri-reference"
+      },
+      "$comment": {
+        "type": "string"
+      },
+      "title": {
+        "type": "string"
+      },
+      "description": {
+        "type": "string"
+      },
+      "default": true,
+      "readOnly": {
+        "type": "boolean",
+        "default": false
+      },
+      "writeOnly": {
+        "type": "boolean",
+        "default": false
+      },
+      "examples": {
+        "type": "array",
+        "items": true
+      },
+      "multipleOf": {
+        "type": "number",
+        "exclusiveMinimum": 0
+      },
+      "maximum": {
+        "type": "number"
+      },
+      "exclusiveMaximum": {
+        "type": "number"
+      },
+      "minimum": {
+        "type": "number"
+      },
+      "exclusiveMinimum": {
+        "type": "number"
+      },
+      "maxLength": {
+        "$ref": "#/definitions/nonNegativeInteger"
+      },
+      "minLength": {
+        "$ref": "#/definitions/nonNegativeIntegerDefault0"
+      },
+      "pattern": {
+        "type": "string",
+        "format": "regex"
+      },
+      "additionalItems": {
+        "$ref": "#"
+      },
+      "items": {
+        "anyOf": [
+          {
+            "$ref": "#"
+          },
+          {
+            "$ref": "#/definitions/schemaArray"
+          }
+        ],
+        "default": true
+      },
+      "maxItems": {
+        "$ref": "#/definitions/nonNegativeInteger"
+      },
+      "minItems": {
+        "$ref": "#/definitions/nonNegativeIntegerDefault0"
+      },
+      "uniqueItems": {
+        "type": "boolean",
+        "default": false
+      },
+      "contains": {
+        "$ref": "#"
+      },
+      "maxProperties": {
+        "$ref": "#/definitions/nonNegativeInteger"
+      },
+      "minProperties": {
+        "$ref": "#/definitions/nonNegativeIntegerDefault0"
+      },
+      "required": {
+        "$ref": "#/definitions/stringArray"
+      },
+      "additionalProperties": {
+        "$ref": "#"
+      },
+      "definitions": {
+        "type": "object",
+        "additionalProperties": {
+          "$ref": "#"
+        },
+        "default": {}
+      },
+      "properties": {
+        "type": "object",
+        "additionalProperties": {
+          "$ref": "#"
+        },
+        "default": {}
+      },
+      "patternProperties": {
+        "type": "object",
+        "additionalProperties": {
+          "$ref": "#"
+        },
+        "propertyNames": {
+          "format": "regex"
+        },
+        "default": {}
+      },
+      "dependencies": {
+        "type": "object",
+        "additionalProperties": {
+          "anyOf": [
+            {
+              "$ref": "#"
+            },
+            {
+              "$ref": "#/definitions/stringArray"
+            }
+          ]
+        }
+      },
+      "propertyNames": {
+        "$ref": "#"
+      },
+      "const": true,
+      "enum": {
+        "type": "array",
+        "items": true,
+        "minItems": 1,
+        "uniqueItems": true
+      },
+      "type": {
+        "anyOf": [
+          {
+            "$ref": "#/definitions/simpleTypes"
+          },
+          {
+            "type": "array",
+            "items": {
+              "$ref": "#/definitions/simpleTypes"
+            },
+            "minItems": 1,
+            "uniqueItems": true
+          }
+        ]
+      },
+      "format": {
+        "type": "string"
+      },
+      "contentMediaType": {
+        "type": "string"
+      },
+      "contentEncoding": {
+        "type": "string"
+      },
+      "if": {
+        "$ref": "#"
+      },
+      "then": {
+        "$ref": "#"
+      },
+      "else": {
+        "$ref": "#"
+      },
+      "allOf": {
+        "$ref": "#/definitions/schemaArray"
+      },
+      "anyOf": {
+        "$ref": "#/definitions/schemaArray"
+      },
+      "oneOf": {
+        "$ref": "#/definitions/schemaArray"
+      },
+      "not": {
+        "$ref": "#"
+      }
+    },
+    "default": true
+  }],
+];

package/src/keywords/unevaluated.ts

@@ -0,0 +1,329 @@
+// Unevaluated vocabulary: the channel-consumer keyword class. Phase 1: runs
+// after every other keyword in the same schema object has merged.
+
+import { isObject } from "../json.js";
+import { KeywordBehavior } from "../dialect.js";
+import { LowerExpr, LowerStmt, lowerIR } from "../lowering.js";
+import { childCursor } from "../cursor.js";
+import { SELF } from "./core.js";
+import {
+  properties,
+  patternProperties,
+  additionalProperties,
+  prefixItems,
+  items,
+  contains,
+} from "./applicator.js";
+
+/** 2020-12 unevaluated vocabulary URI. */
+export const VOCAB_UNEVALUATED =
+  "https://json-schema.org/draft/2020-12/vocab/unevaluated";
+
+/**
+ * EXEMPLAR (consumer class): reads visible dependency records (engine.ts
+ * visibility rule), applies the subschema to properties nobody evaluated,
+ * and produces like any other applicator.
+ */
+export const unevaluatedProperties: KeywordBehavior = {
+  id: `${VOCAB_UNEVALUATED}#unevaluatedProperties`,
+  phase: 1,
+  analyze: () => ({
+    subschemas: SELF.subschemas,
+    consumes: [
+      properties.id,
+      patternProperties.id,
+      additionalProperties.id,
+      `${VOCAB_UNEVALUATED}#unevaluatedProperties`,
+    ],
+    produces: [`${VOCAB_UNEVALUATED}#unevaluatedProperties`],
+    evaluatesNames: { kind: "all" },
+    applications: [
+      { path: [], mode: "childSweep", conditional: false, asserts: true },
+    ],
+  }),
+  // Static-coverage path only (D9a): the planner classifies this schema
+  // object as interpreted when any coverage contributor is dynamic, so
+  // lower() is never called with a null coverage.
+  lower: (_value, lctx) => {
+    // Runtime-coverage path (phase B activates it): fold the unit's runtime
+    // channel into an evaluated-name set and sweep the names it does not
+    // cover, mirroring evaluate()'s seen-set skip. The object-gated
+    // collectedNames produce is the same one the static path emits — its
+    // attempted-apply accumulator is exactly the interpreter's `matched`.
+    if (lctx.runtimeCoverage()) {
+      const f = lctx.binding();
+      const b = lctx.binding();
+      lctx.emit(
+        lowerIR.when(lowerIR.typeIs(lctx.instance, "object"), [
+          { kind: "coverageFold", half: "names", binding: f },
+          {
+            kind: "forEachKey",
+            target: lctx.instance,
+            binding: b,
+            body: [
+              lowerIR.when(
+                lowerIR.not({
+                  kind: "coverageCovers",
+                  fold: f,
+                  target: { kind: "binding", id: b },
+                }),
+                [
+                  {
+                    kind: "apply",
+                    apply: {
+                      path: [],
+                      cursor: {
+                        kind: "child",
+                        of: { kind: "here" },
+                        segment: { kind: "binding", id: b },
+                      },
+                      fold: "allMustPass",
+                    },
+                  },
+                ],
+              ),
+            ],
+          },
+          { kind: "produce", value: { kind: "collectedNames" } },
+        ]),
+      );
+      return;
+    }
+    const coverage = lctx.staticCoverage();
+    if (coverage === null) {
+      throw new Error(
+        "unevaluatedProperties lowering requires static coverage (planner bug)",
+      );
+    }
+    // The sweep is statically vacuous when sibling coverage is total, but the
+    // produce is not: evaluate() emits an (empty) names annotation for every
+    // object regardless. So the object-type guard always wraps a produce; the
+    // sweep is added only when some name can still be unevaluated.
+    const body: LowerStmt[] = [];
+    if (!coverage.coversAllNames) {
+      const b = lctx.binding();
+      const covered: LowerExpr[] = [
+        ...coverage.names.map((n): LowerExpr =>
+          lowerIR.cmp("===", { kind: "binding", id: b }, lowerIR.constant(n)),
+        ),
+        ...coverage.patterns.map((p): LowerExpr =>
+          lowerIR.regexTest(p, { kind: "binding", id: b }),
+        ),
+      ];
+      body.push({
+        kind: "forEachKey",
+        target: lctx.instance,
+        binding: b,
+        body: [
+          lowerIR.when(
+            covered.length === 0
+              ? lowerIR.constant(true)
+              : lowerIR.not(lowerIR.or(...covered)),
+            [
+              {
+                kind: "apply",
+                apply: {
+                  path: [],
+                  cursor: {
+                    kind: "child",
+                    of: { kind: "here" },
+                    segment: { kind: "binding", id: b },
+                  },
+                  fold: "allMustPass",
+                },
+              },
+            ],
+          ),
+        ],
+      });
+    }
+    body.push({ kind: "produce", value: { kind: "collectedNames" } });
+    // Produce iff the instance is an object (nothing otherwise), matching
+    // evaluate()'s object-type guard before ctx.produce.
+    lctx.emit(lowerIR.when(lowerIR.typeIs(lctx.instance, "object"), body));
+  },
+  evaluate: (_value, cursor, ctx) => {
+    if (!isObject(cursor.value)) return true;
+    const seen = new Set<string>();
+    for (const p of ctx.visible([
+      properties.id,
+      patternProperties.id,
+      additionalProperties.id,
+      unevaluatedProperties.id,
+    ])) {
+      for (const name of p.data as string[]) seen.add(name);
+    }
+    let ok = true;
+    const matched: string[] = [];
+    for (const name of Object.keys(cursor.value)) {
+      if (seen.has(name)) continue;
+      matched.push(name);
+      if (
+        !ctx.apply(
+          ["unevaluatedProperties"],
+          childCursor(cursor, name, cursor.value[name]!),
+        )
+      )
+        ok = false;
+    }
+    // Dependency data only from an accepting keyword (Appendix D; see
+    // applicator.ts properties).
+    if (ok) ctx.produce(matched);
+    return ok;
+  },
+};
+
+/** Same consumer shape as {@link unevaluatedProperties}, over array indexes not covered by `prefixItems`/`items`/`contains`. */
+export const unevaluatedItems: KeywordBehavior = {
+  id: `${VOCAB_UNEVALUATED}#unevaluatedItems`,
+  phase: 1,
+  analyze: () => ({
+    subschemas: SELF.subschemas,
+    consumes: [
+      prefixItems.id,
+      items.id,
+      contains.id,
+      `${VOCAB_UNEVALUATED}#unevaluatedItems`,
+    ],
+    produces: [`${VOCAB_UNEVALUATED}#unevaluatedItems`],
+    evaluatesIndexes: { kind: "all" },
+    applications: [
+      { path: [], mode: "childSweep", conditional: false, asserts: true },
+    ],
+  }),
+  // Static-coverage path only (D9a), same discipline as
+  // unevaluatedProperties: the planner classifies this schema object as
+  // interpreted whenever any index-coverage contributor is dynamic (e.g. a
+  // sibling `contains`, whose coverage is instance-dependent), so lower() is
+  // never called with a null/incomplete coverage.
+  lower: (_value, lctx) => {
+    // Runtime-coverage path (phase B activates it): fold the unit's runtime
+    // channel into a coveredPrefix/coveredIdx summary over this array's
+    // length and sweep the indexes it does not cover, mirroring evaluate()'s
+    // skip loop. The appliedTrue produce is the same one the static path
+    // emits (any attempted apply -> true, the interpreter's `applied` flag).
+    if (lctx.runtimeCoverage()) {
+      const f = lctx.binding();
+      const b = lctx.binding();
+      lctx.emit(
+        lowerIR.when(lowerIR.typeIs(lctx.instance, "array"), [
+          { kind: "coverageFold", half: "indexes", binding: f },
+          {
+            kind: "forEachIndex",
+            target: lctx.instance,
+            binding: b,
+            start: 0,
+            body: [
+              lowerIR.when(
+                lowerIR.not({
+                  kind: "coverageCovers",
+                  fold: f,
+                  target: { kind: "binding", id: b },
+                }),
+                [
+                  {
+                    kind: "apply",
+                    apply: {
+                      path: [],
+                      cursor: {
+                        kind: "child",
+                        of: { kind: "here" },
+                        segment: { kind: "binding", id: b },
+                      },
+                      fold: "allMustPass",
+                    },
+                  },
+                ],
+              ),
+            ],
+          },
+          {
+            kind: "produce",
+            value: { kind: "collectedIndexes", render: "appliedTrue" },
+          },
+        ]),
+      );
+      return;
+    }
+    const coverage = lctx.staticCoverage();
+    if (coverage === null) {
+      throw new Error(
+        "unevaluatedItems lowering requires static coverage (planner bug)",
+      );
+    }
+    if (coverage.coversAllIndexes) return; // statically vacuous
+    const b = lctx.binding();
+    lctx.emit(
+      lowerIR.when(lowerIR.typeIs(lctx.instance, "array"), [
+        {
+          kind: "forEachIndex",
+          target: lctx.instance,
+          binding: b,
+          start: coverage.prefixCount,
+          body: [
+            {
+              kind: "apply",
+              apply: {
+                path: [],
+                cursor: {
+                  kind: "child",
+                  of: { kind: "here" },
+                  segment: { kind: "binding", id: b },
+                },
+                fold: "allMustPass",
+              },
+            },
+          ],
+        },
+      ]),
+    );
+    // Annotation: true iff it applied to any unevaluated index.
+    lctx.emit({
+      kind: "produce",
+      value: { kind: "collectedIndexes", render: "appliedTrue" },
+    });
+  },
+  evaluate: (_value, cursor, ctx) => {
+    if (!Array.isArray(cursor.value)) return true;
+    const length = cursor.value.length;
+    let coveredPrefix = 0;
+    const coveredIdx = new Set<number>();
+    for (const p of ctx.visible([
+      prefixItems.id,
+      items.id,
+      contains.id,
+      unevaluatedItems.id,
+    ])) {
+      if (p.behaviorId === contains.id) {
+        if (p.data === true) coveredPrefix = length;
+        else for (const i of p.data as number[]) coveredIdx.add(i);
+      } else if (p.data === true) {
+        coveredPrefix = length;
+      } else if (p.behaviorId === prefixItems.id) {
+        coveredPrefix = Math.max(coveredPrefix, (p.data as number) + 1);
+      }
+    }
+    let ok = true;
+    let applied = false;
+    for (let i = coveredPrefix; i < length; i++) {
+      if (coveredIdx.has(i)) continue;
+      applied = true;
+      if (
+        !ctx.apply(
+          ["unevaluatedItems"],
+          childCursor(cursor, i, cursor.value[i]!),
+        )
+      ) {
+        ok = false;
+      }
+    }
+    if (applied && ok) ctx.produce(true);
+    return ok;
+  },
+};
+
+/** The 2020-12 unevaluated vocabulary's keyword behaviors, by name. */
+export const unevaluatedVocabulary: Record<string, KeywordBehavior> = {
+  unevaluatedProperties,
+  unevaluatedItems,
+};