effect 4.0.6 → 4.1.0

package/dist/internal/schema/fromJsonSchemaDocument.js

@@ -1,11 +1,12 @@
-import * as Iterable from "../../Iterable.js";
+import { escapeToken, parseUriFragment } from "../../JsonPointer.js";
 import * as JsonSchema from "../../JsonSchema.js";
-import { remainder } from "../../Number.js";
+import * as Schema from "../../Schema.js";
 import * as InternalAST from "../../SchemaAST.js";
 import { errorWithPath } from "../errors.js";
+import * as InternalJsonSchema from "../jsonSchema.js";
 import * as InternalRecord from "../record.js";
 import * as InternalAnnotations from "./annotations.js";
-import { fromRepresentation, fromRepresentations } from "./fromRepresentation.js";
+import { ReferenceSlot } from "./fromRepresentation.js";
 const never = {
   _tag: "Never",
   checks: []
@@ -18,6 +19,13 @@ const string = {
   _tag: "String",
   checks: []
 };
+const primitiveSchemas = {
+  Never: Schema.Never,
+  Null: Schema.Null,
+  String: Schema.String,
+  Number: Schema.Number,
+  Boolean: Schema.Boolean
+};
 const unsupportedStructuredValue = "Only primitive values are supported in \"const\" and \"enum\".";
 const jsonSchemaPatternFlags = "u";
 function isObject(input) {
@@ -46,24 +54,15 @@ function isImportedJsonSchemaType(input) {
 function hasTypeSpecificKeywords(schema) {
   return jsonSchemaTypeSpecificKeys.some(key => schema[key] !== undefined);
 }
-function jsonSchemaFilter(id, payload, schemas) {
+function makeFilter(filter) {
   return {
     _tag: "Filter",
-    aborted: false,
-    representation: {
-      id,
-      payload,
-      ...(schemas === undefined ? undefined : {
-        schemas
-      })
-    }
+    filter
   };
 }
-function addNumberCheck(checks, value, id, key) {
+function addNumberCheck(checks, value, make) {
   if (typeof value === "number") {
-    checks.push(jsonSchemaFilter(id, {
-      [key]: value
-    }));
+    checks.push(makeFilter(make(value)));
   }
 }
 function jsonSchemaAnnotations(schema, options) {
@@ -91,116 +90,84 @@ function jsonSchemaAnnotations(schema, options) {
     customAnnotations
   };
 }
-function jsonDeclaration(annotations) {
-  return {
-    _tag: "Declaration",
-    representation: {
-      id: "effect/schema/Json",
-      payload: null
-    },
-    annotations: {
-      ...annotations,
-      expected: "JSON value"
-    },
-    checks: [],
-    typeParameters: []
-  };
-}
-function translateJsonSchemaMultiDocument(document, options, singleRoot = false) {
+/** @internal */
+export function fromJsonSchemaMultiDocument(document, options, singleRoot = false) {
   const definitionCache = new Map();
+  const validatedAliases = new Set();
   const resolvingChoices = new Set();
-  const finalReferences = new Map();
+  const references = new Map();
   let inNestedResource = false;
   function finalize(input) {
     const annotations = mergeAnnotations(input.annotations, input.customAnnotations);
     if (input._tag === "Reference") {
-      if (!finalReferences.has(input.$ref)) finalReferences.set(input.$ref, input);
-      const reference = {
-        _tag: "Reference",
-        $ref: input.$ref
-      };
-      if (annotations === undefined) return reference;
-      resolveReference(input, input.path);
-      return {
-        _tag: "Suspend",
-        thunk: reference,
-        checks: [],
-        annotations
-      };
+      if (annotations !== undefined) resolveReference(input, input.path);
+      let slot = references.get(input.$ref);
+      if (slot === undefined) {
+        slot = new ReferenceSlot(input.$ref);
+        references.set(input.$ref, slot);
+        slot.body = finalize(translateDefinition(input.$ref, input.path)).annotate({
+          identifier: input.$ref
+        });
+      }
+      return annotations === undefined ? slot.body ?? slot.wrapper : slot.wrapper.annotate(annotations);
     }
-    const {
-      customAnnotations,
-      ...node
-    } = input;
-    const representation = {
-      ...node,
-      annotations,
-      checks: node.checks.map(finalizeCheck)
-    };
-    switch (representation._tag) {
+    let schema;
+    switch (input._tag) {
       case "Unknown":
-        return jsonDeclaration(annotations);
+        return Schema.Json.annotate({
+          ...annotations,
+          expected: "JSON value"
+        });
+      case "Never":
+      case "Null":
+      case "String":
+      case "Number":
+      case "Boolean":
+        schema = primitiveSchemas[input._tag];
+        break;
+      case "Literal":
+        schema = Schema.Literal(input.literal);
+        break;
       case "Arrays":
-        return {
-          ...representation,
-          elements: representation.elements.map(element => ({
-            ...element,
-            type: finalize(element.type)
-          })),
-          rest: representation.rest.map(finalize)
-        };
+        {
+          const elements = input.elements.map(element => {
+            const type = finalize(element.type);
+            return element.isOptional ? Schema.optionalKey(type) : type;
+          });
+          const rest = input.rest[0] === undefined ? undefined : finalize(input.rest[0]);
+          schema = rest !== undefined ? elements.length === 0 ? Schema.Array(rest) : Schema.TupleWithRest(Schema.Tuple(elements), [rest]) : Schema.Tuple(elements);
+          break;
+        }
       case "Objects":
         {
-          // Intersections may reduce open patterns to fixed properties, so reject only
-          // if an open pattern remains in the final representation.
-          const {
-            scopes,
-            path,
-            ...object
-          } = representation;
-          if (representation.indexSignatures[0]?.parameter === string && scopes.some(scope => scope.patterns.length > 0)) {
-            throw errorWithPath("Cannot import open \"patternProperties\": unmatched keys cannot be typed correctly.", path);
+          // Intersections may remove open patterns, so check the normalized object.
+          if (input.indexSignatures[0]?.parameter === string && input.scopes.some(scope => scope.patterns.length > 0)) {
+            throw errorWithPath("Cannot import open \"patternProperties\": unmatched keys cannot be typed correctly.", input.path);
           }
-          return {
-            ...object,
-            propertySignatures: representation.propertySignatures.map(property => ({
-              ...property,
-              type: finalize(property.type)
-            })),
-            indexSignatures: representation.indexSignatures.map(indexSignature => ({
-              parameter: finalize(indexSignature.parameter),
-              type: finalize(indexSignature.type)
-            }))
-          };
+          const fields = {};
+          for (const property of input.propertySignatures) {
+            const type = finalize(property.type);
+            InternalRecord.assignProperty(fields, property.name, property.isOptional ? Schema.optionalKey(type) : type);
+          }
+          const index = input.indexSignatures[0];
+          const record = index === undefined ? undefined : Schema.Record(finalize(index.parameter), finalize(index.type));
+          schema = record !== undefined ? input.propertySignatures.length === 0 ? record : Schema.StructWithRest(Schema.Struct(fields), [record]) : Schema.Struct(fields);
+          break;
         }
       case "Union":
-        return {
-          ...representation,
-          types: representation.types.map(finalize)
-        };
-      default:
-        return representation;
+        schema = Schema.Union(input.types.map(finalize), input.options);
+        break;
     }
+    if (annotations !== undefined) schema = schema.annotate(annotations);
+    const checks = input.checks.map(finalizeCheck);
+    return checks.length > 0 ? schema.check(...checks) : schema;
   }
   function finalizeCheck(check) {
     if (check._tag === "FilterGroup") {
-      return {
-        ...check,
-        checks: check.checks.map(finalizeCheck)
-      };
+      return Schema.makeFilterGroup(check.checks.map(finalizeCheck), check.annotations);
     }
-    const representation = check.representation;
-    const schemas = representation.schemas;
-    if (schemas === undefined) {
-      return check;
-    }
-    return {
-      ...check,
-      representation: {
-        ...representation,
-        schemas: schemas.map(finalize)
-      }
-    };
+    const filter = check._tag === "PropertyNames" ? Schema.isPropertyNames(finalize(check.type)) : check.filter;
+    return check.annotations === undefined ? filter : filter.annotate(check.annotations);
   }
   function annotate(representation, source) {
     if (source.annotations === undefined && source.customAnnotations === undefined) return representation;
@@ -219,10 +186,36 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
       return cached;
     }
     definitionCache.set(key, null);
-    const representation = translateSchema(document.definitions[key], ["definitions", key]);
+    const pointer = pointers.get(key);
+    const wasInNestedResource = inNestedResource;
+    if (pointer !== undefined) inNestedResource = pointer.crossesResource;
+    const representation = pointer === undefined ? translateSchema(document.definitions[key], ["definitions", key]) : translateSchema(pointer.target, ["definitions", ...pointer.tokens]);
+    inNestedResource = wasInNestedResource;
     definitionCache.set(key, representation);
+    if (pointer !== undefined) {
+      validatePointerAliases(representation, path, recursiveReferenceError);
+    }
     return representation;
   }
+  function validatePointerAliases(representation, path, recursiveReferenceError, visiting = new Set()) {
+    if (representation._tag === "Reference") {
+      const key = representation.$ref;
+      if (validatedAliases.has(key)) return;
+      if (visiting.has(key)) {
+        throw errorWithPath(`Definition ${JSON.stringify(key)} is a circular alias.`, [...path, "$ref"]);
+      }
+      visiting.add(key);
+      validatePointerAliases(translateDefinition(key, path, recursiveReferenceError), path, recursiveReferenceError, visiting);
+      visiting.delete(key);
+      validatedAliases.add(key);
+    } else if (representation._tag === "Union") {
+      // Alternatives share completed checks, but only ancestors belong to the active path.
+      for (const type of representation.types) {
+        validatePointerAliases(type, path, recursiveReferenceError, visiting);
+      }
+    }
+    // Recursion through object properties or array items consumes a child value.
+  }
   function resolveReference(reference, path, recursiveReferenceError, seen = new Set()) {
     if (seen.has(reference.$ref)) {
       throw errorWithPath(`Definition ${JSON.stringify(reference.$ref)} is a circular alias.`, [...path, "$ref"]);
@@ -234,6 +227,46 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
     }
     return representation;
   }
+  // Pointers below a definition are registered as definitions keyed by their escaped tokens, e.g. "O/properties/v"
+  const pointers = new Map();
+  function resolvePointer($ref, path) {
+    const pointer = $ref.startsWith("#") ? parseUriFragment($ref) : undefined;
+    if (pointer === undefined || pointer.length < 3 || pointer[0] !== "$defs") {
+      throw errorWithPath(`Unsupported $ref ${JSON.stringify($ref)}. Use "#/$defs/Name".`, [...path, "$ref"]);
+    }
+    const tokens = pointer.slice(1);
+    const key = tokens.map(escapeToken).join("/");
+    if (Object.hasOwn(document.definitions, key)) {
+      throw errorWithPath(`Pointer $ref ${JSON.stringify($ref)} conflicts with definition ${JSON.stringify(key)}.`, [...path, "$ref"]);
+    }
+    if (pointers.has(key)) return key;
+    // Walk through the onEnter result of each ancestor schema, as translateSchema would see it
+    let node = document.definitions;
+    let position = "container";
+    let crossesResource = false;
+    for (const token of tokens) {
+      if (position === "container") {
+        position = "schema";
+      } else if (position === "schema" && isObject(node)) {
+        if (options?.onEnter !== undefined) node = options.onEnter(node);
+        crossesResource ||= isObject(node) && typeof node.$id === "string";
+        const kind = InternalJsonSchema.getSubschemaKind(token);
+        position = kind === "schema" ? "schema" : kind === undefined ? "value" : "container";
+      } else {
+        position = "value";
+      }
+      node = typeof node === "object" && node !== null && Object.hasOwn(node, token) ? node[token] : undefined;
+    }
+    if (!isObject(node) && typeof node !== "boolean") {
+      throw errorWithPath(`Unresolvable $ref ${JSON.stringify($ref)}. Nothing exists at that location.`, [...path, "$ref"]);
+    }
+    pointers.set(key, {
+      target: node,
+      tokens,
+      crossesResource
+    });
+    return key;
+  }
   function mergeAnnotations(left, right) {
     if (left === undefined) return right;
     if (right === undefined) return left;
@@ -248,8 +281,8 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
   function intersectChecks(left, right, deduplicate = []) {
     let checks = right.checks;
     for (const id of deduplicate) {
-      if (left.checks.some(check => check._tag === "Filter" && check.representation?.id === id)) {
-        checks = checks.filter(check => check._tag !== "Filter" || check.representation?.id !== id);
+      if (left.checks.some(check => check._tag === "Filter" && check.filter.annotations?.representation?.id === id)) {
+        checks = checks.filter(check => check._tag !== "Filter" || check.filter.annotations?.representation?.id !== id);
       }
     }
     const annotations = checks.length === 0 ? mergeAnnotations(left.annotations, right.annotations) : left.annotations;
@@ -273,32 +306,7 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
     if (check._tag === "FilterGroup") {
       return check.checks.every(check => satisfiesPrimitiveCheck(check, value));
     }
-    const representation = check.representation;
-    const payload = representation.payload;
-    switch (representation.id) {
-      case "effect/schema/isMinLength":
-        return value.length >= payload.minLength;
-      case "effect/schema/isMinCodePoints":
-        return Iterable.size(value) >= payload.minCodePoints;
-      case "effect/schema/isMaxCodePoints":
-        return Iterable.size(value) <= payload.maxCodePoints;
-      case "effect/schema/isPattern":
-        return new RegExp(payload.source, payload.flags).test(value);
-      case "effect/schema/isFinite":
-        return globalThis.Number.isFinite(value);
-      case "effect/schema/isInt":
-        return globalThis.Number.isSafeInteger(value);
-      case "effect/schema/isMultipleOf":
-        return remainder(value, payload.divisor) === 0;
-      case "effect/schema/isGreaterThan":
-        return value > payload.exclusiveMinimum;
-      case "effect/schema/isGreaterThanOrEqualTo":
-        return value >= payload.minimum;
-      case "effect/schema/isLessThan":
-        return value < payload.exclusiveMaximum;
-      case "effect/schema/isLessThanOrEqualTo":
-        return value <= payload.maximum;
-    }
+    return check._tag === "Filter" && check.filter.run(value, Schema.Unknown.ast, {}) === undefined;
   }
   function satisfiesLiteral(representation, literal) {
     const value = literal.literal;
@@ -396,8 +404,7 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
       properties.push({
         name,
         type,
-        isOptional,
-        isMutable: false
+        isOptional
       });
     }
     const indexSignatures = closedPattern !== undefined ? [{
@@ -474,7 +481,7 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
     }
   }
   function checkHasChoices(check) {
-    return check._tag === "FilterGroup" ? check.checks.some(checkHasChoices) : check.representation.schemas?.some(hasChoices) === true;
+    return check._tag === "FilterGroup" ? check.checks.some(checkHasChoices) : check._tag === "PropertyNames" && hasChoices(check.type);
   }
   function makeUnion(source, types) {
     if (types.length === 0) return never;
@@ -688,13 +695,11 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
       if (inNestedResource) {
         throw errorWithPath("Cannot resolve $ref under a nested \"$id\". Resolve or flatten it first.", [...path, "$ref"]);
       }
-      const $ref = JsonSchema.getReferenceKey(schema.$ref);
-      if ($ref === undefined) {
-        throw errorWithPath(`Unsupported $ref ${JSON.stringify(schema.$ref)}. Use "#/$defs/Name".`, [...path, "$ref"]);
-      }
-      if (!Object.hasOwn(document.definitions, $ref)) {
-        throw errorWithPath(`Missing definition ${JSON.stringify($ref)} for $ref ${JSON.stringify(schema.$ref)}.`, [...path, "$ref"]);
+      const key = JsonSchema.getReferenceKey(schema.$ref);
+      if (key !== undefined && !Object.hasOwn(document.definitions, key)) {
+        throw errorWithPath(`Missing definition ${JSON.stringify(key)} for $ref ${JSON.stringify(schema.$ref)}.`, [...path, "$ref"]);
       }
+      const $ref = key ?? resolvePointer(schema.$ref, path);
       const reference = {
         _tag: "Reference",
         $ref,
@@ -755,7 +760,7 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
       case "integer":
         return {
           _tag: "Number",
-          checks: [jsonSchemaFilter(type === "number" ? "effect/schema/isFinite" : "effect/schema/isInt", null), ...collectNumberChecks(schema)]
+          checks: [makeFilter(type === "number" ? Schema.isFinite() : Schema.isInt()), ...collectNumberChecks(schema)]
         };
       case "boolean":
         return {
@@ -804,21 +809,18 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
           } catch {
             throw errorWithPath("Cannot import pattern using ECMAScript Unicode mode.", path);
           }
-          return jsonSchemaFilter("effect/schema/isPattern", {
-            source: regex.source,
-            flags: regex.flags
-          });
+          return makeFilter(Schema.isPattern(regex));
         }
     }
   }
   function collectStringChecks(schema, path) {
     const checks = [];
     if (schema.minLength === 1) {
-      addNumberCheck(checks, schema.minLength, "effect/schema/isMinLength", "minLength");
+      addNumberCheck(checks, schema.minLength, Schema.isMinLength);
     } else {
-      addNumberCheck(checks, schema.minLength, "effect/schema/isMinCodePoints", "minCodePoints");
+      addNumberCheck(checks, schema.minLength, Schema.isMinCodePoints);
     }
-    addNumberCheck(checks, schema.maxLength, "effect/schema/isMaxCodePoints", "maxCodePoints");
+    addNumberCheck(checks, schema.maxLength, Schema.isMaxCodePoints);
     if (typeof schema.pattern === "string") {
       const check = importPatternCheck(schema.pattern, [...path, "pattern"]);
       if (check !== undefined) checks.push(check);
@@ -827,23 +829,23 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
   }
   function collectNumberChecks(schema) {
     const checks = [];
-    addNumberCheck(checks, schema.minimum, "effect/schema/isGreaterThanOrEqualTo", "minimum");
-    addNumberCheck(checks, schema.maximum, "effect/schema/isLessThanOrEqualTo", "maximum");
-    addNumberCheck(checks, schema.exclusiveMinimum, "effect/schema/isGreaterThan", "exclusiveMinimum");
-    addNumberCheck(checks, schema.exclusiveMaximum, "effect/schema/isLessThan", "exclusiveMaximum");
-    addNumberCheck(checks, schema.multipleOf, "effect/schema/isMultipleOf", "divisor");
+    addNumberCheck(checks, schema.minimum, Schema.isGreaterThanOrEqualTo);
+    addNumberCheck(checks, schema.maximum, Schema.isLessThanOrEqualTo);
+    addNumberCheck(checks, schema.exclusiveMinimum, Schema.isGreaterThan);
+    addNumberCheck(checks, schema.exclusiveMaximum, Schema.isLessThan);
+    addNumberCheck(checks, schema.multipleOf, Schema.isMultipleOf);
     return checks;
   }
   function collectArrayChecks(schema, isMaxItemsRedundant) {
     const checks = [];
     if (!Array.isArray(schema.prefixItems) || typeof schema.minItems === "number" && schema.minItems > schema.prefixItems.length) {
-      addNumberCheck(checks, schema.minItems, "effect/schema/isMinLength", "minLength");
+      addNumberCheck(checks, schema.minItems, Schema.isMinLength);
     }
     if (!isMaxItemsRedundant) {
-      addNumberCheck(checks, schema.maxItems, "effect/schema/isMaxLength", "maxLength");
+      addNumberCheck(checks, schema.maxItems, Schema.isMaxLength);
     }
     if (schema.uniqueItems === true) {
-      checks.push(jsonSchemaFilter("effect/schema/isUnique", null));
+      checks.push(makeFilter(Schema.isUnique()));
     }
     return checks;
   }
@@ -887,39 +889,25 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
   }
   function collectObjectChecks(schema, path) {
     const checks = [];
-    addNumberCheck(checks, schema.minProperties, "effect/schema/isMinProperties", "minProperties");
-    addNumberCheck(checks, schema.maxProperties, "effect/schema/isMaxProperties", "maxProperties");
+    addNumberCheck(checks, schema.minProperties, Schema.isMinProperties);
+    addNumberCheck(checks, schema.maxProperties, Schema.isMaxProperties);
     if (schema.propertyNames !== undefined) {
       const propertyNamesPath = [...path, "propertyNames"];
-      checks.push(jsonSchemaFilter("effect/schema/isPropertyNames", null, [intersect(string, translateSchema(schema.propertyNames, propertyNamesPath), propertyNamesPath)]));
+      checks.push({
+        _tag: "PropertyNames",
+        type: intersect(string, translateSchema(schema.propertyNames, propertyNamesPath), propertyNamesPath)
+      });
     }
     return checks;
   }
-  const references = {};
-  const representations = document.schemas.map((schema, index) => finalize(translateSchema(schema, singleRoot ? ["schema"] : ["schemas", index], true)));
-  // Definitions expanded away by intersections do not need a standalone output schema.
-  for (const [key, reference] of finalReferences) {
-    InternalRecord.assignProperty(references, key, finalize(translateDefinition(key, reference.path)));
-  }
-  return {
-    representations,
-    references
-  };
+  return document.schemas.map((schema, index) => finalize(translateSchema(schema, singleRoot ? ["schema"] : ["schemas", index], true)));
 }
 /** @internal */
-export function fromJsonSchemaDocument(document, options, revivers) {
-  const translated = translateJsonSchemaMultiDocument({
+export function fromJsonSchemaDocument(document, options) {
+  return fromJsonSchemaMultiDocument({
     dialect: document.dialect,
     schemas: [document.schema],
     definitions: document.definitions
-  }, options, true);
-  return fromRepresentation({
-    representation: translated.representations[0],
-    references: translated.references
-  }, revivers);
-}
-/** @internal */
-export function fromJsonSchemaMultiDocument(document, options, revivers) {
-  return fromRepresentations(translateJsonSchemaMultiDocument(document, options), revivers);
+  }, options, true)[0];
 }
 //# sourceMappingURL=fromJsonSchemaDocument.js.map