effect 4.0.5 → 4.0.6

package/dist/internal/schema/fromJsonSchemaDocument.js

@@ -4,6 +4,7 @@ import { remainder } from "../../Number.js";
 import * as InternalAST from "../../SchemaAST.js";
 import { errorWithPath } from "../errors.js";
 import * as InternalRecord from "../record.js";
+import * as InternalAnnotations from "./annotations.js";
 import { fromRepresentation, fromRepresentations } from "./fromRepresentation.js";
 const never = {
   _tag: "Never",
@@ -38,6 +39,7 @@ function makeJsonLiteral(input, path) {
 }
 const jsonSchemaValueTypes = ["null", "string", "number", "boolean", "object", "array"];
 const jsonSchemaTypeSpecificKeys = ["minLength", "maxLength", "pattern", "minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum", "multipleOf", "properties", "required", "additionalProperties", "patternProperties", "propertyNames", "minProperties", "maxProperties", "items", "prefixItems", "minItems", "maxItems", "uniqueItems"];
+const jsonSchemaAnnotationExcludedKeys = /*#__PURE__*/new Set([...jsonSchemaTypeSpecificKeys, ...InternalAnnotations.jsonSchemaAnnotationKeys, ...InternalAnnotations.annotationExcludedKeys, "$schema", "$id", "$ref", "$defs", "$anchor", "$dynamicRef", "$dynamicAnchor", "$vocabulary", "$comment", "type", "const", "enum", "allOf", "anyOf", "oneOf", "not", "if", "then", "else", "contains", "minContains", "maxContains", "dependentRequired", "dependentSchemas", "unevaluatedItems", "unevaluatedProperties", "definitions", "dependencies", "additionalItems", "identifier", "expected", "message", "messageMissingKey", "messageUnexpectedKey"]);
 function isImportedJsonSchemaType(input) {
   return input === "integer" || typeof input === "string" && jsonSchemaValueTypes.some(type => type === input);
 }
@@ -64,7 +66,7 @@ function addNumberCheck(checks, value, id, key) {
     }));
   }
 }
-function jsonSchemaAnnotations(schema) {
+function jsonSchemaAnnotations(schema, options) {
   const annotations = {};
   if (typeof schema.title === "string") annotations.title = schema.title;
   if (typeof schema.description === "string") annotations.description = schema.description;
@@ -76,7 +78,18 @@ function jsonSchemaAnnotations(schema) {
   if (typeof schema.contentEncoding === "string") annotations.contentEncoding = schema.contentEncoding;
   if (typeof schema.contentMediaType === "string") annotations.contentMediaType = schema.contentMediaType;
   if (InternalAST.isJson(schema.contentSchema)) annotations.contentSchema = schema.contentSchema;
-  return Object.keys(annotations).length === 0 ? undefined : annotations;
+  let customAnnotations;
+  if (options?.includeAnnotationKey !== undefined) {
+    for (const key of Object.keys(schema)) {
+      if (key.startsWith("~") || jsonSchemaAnnotationExcludedKeys.has(key) || !options.includeAnnotationKey(key)) continue;
+      const value = schema[key];
+      if (InternalAST.isJson(value)) InternalRecord.assignProperty(customAnnotations ??= {}, key, value);
+    }
+  }
+  return {
+    annotations: Object.keys(annotations).length === 0 ? undefined : annotations,
+    customAnnotations
+  };
 }
 function jsonDeclaration(annotations) {
   return {
@@ -95,24 +108,38 @@ function jsonDeclaration(annotations) {
 }
 function translateJsonSchemaMultiDocument(document, options, singleRoot = false) {
   const definitionCache = new Map();
-  const reachableDefinitions = new Map();
-  const objectScopesByProperties = new WeakMap();
-  const annotatedReferences = [];
   const resolvingChoices = new Set();
-  const finalReferences = new Set();
+  const finalReferences = new Map();
   let inNestedResource = false;
-  function finalize(representation) {
+  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
+      };
+    }
+    const {
+      customAnnotations,
+      ...node
+    } = input;
+    const representation = {
+      ...node,
+      annotations,
+      checks: node.checks.map(finalizeCheck)
+    };
     switch (representation._tag) {
       case "Unknown":
-        return jsonDeclaration(representation.annotations);
-      case "Reference":
-        finalReferences.add(representation.$ref);
-        return representation;
-      case "Suspend":
-        return {
-          ...representation,
-          thunk: finalize(representation.thunk)
-        };
+        return jsonDeclaration(annotations);
       case "Arrays":
         return {
           ...representation,
@@ -123,24 +150,29 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
           rest: representation.rest.map(finalize)
         };
       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] = objectScopesByProperties.get(representation.propertySignatures);
-        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 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);
+          }
+          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)
+            }))
+          };
         }
-        return {
-          ...representation,
-          propertySignatures: representation.propertySignatures.map(property => ({
-            ...property,
-            type: finalize(property.type)
-          })),
-          indexSignatures: representation.indexSignatures.map(indexSignature => ({
-            parameter: finalize(indexSignature.parameter),
-            type: finalize(indexSignature.type)
-          })),
-          checks: representation.checks.map(finalizeCheck)
-        };
       case "Union":
         return {
           ...representation,
@@ -151,9 +183,15 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
     }
   }
   function finalizeCheck(check) {
+    if (check._tag === "FilterGroup") {
+      return {
+        ...check,
+        checks: check.checks.map(finalizeCheck)
+      };
+    }
     const representation = check.representation;
-    const schemas = representation?.schemas;
-    if (representation === undefined || schemas === undefined) {
+    const schemas = representation.schemas;
+    if (schemas === undefined) {
       return check;
     }
     return {
@@ -164,22 +202,12 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
       }
     };
   }
-  function annotate(representation, annotations) {
-    if (annotations === undefined) return representation;
-    if (representation._tag === "Reference") {
-      return {
-        _tag: "Suspend",
-        annotations,
-        checks: [],
-        thunk: representation
-      };
-    }
+  function annotate(representation, source) {
+    if (source.annotations === undefined && source.customAnnotations === undefined) return representation;
     return {
       ...representation,
-      annotations: {
-        ...representation.annotations,
-        ...annotations
-      }
+      annotations: mergeAnnotations(representation.annotations, source.annotations),
+      customAnnotations: mergeAnnotations(representation.customAnnotations, source.customAnnotations)
     };
   }
   function translateDefinition(key, path, recursiveReferenceError) {
@@ -202,10 +230,7 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
     seen.add(reference.$ref);
     const representation = translateDefinition(reference.$ref, path, recursiveReferenceError);
     if (representation._tag === "Reference") {
-      return resolveReference(representation, path, recursiveReferenceError, seen);
-    }
-    if (representation._tag === "Suspend" && representation.thunk._tag === "Reference") {
-      return annotate(resolveReference(representation.thunk, path, recursiveReferenceError, seen), representation.annotations);
+      return annotate(resolveReference(representation, path, recursiveReferenceError, seen), representation);
     }
     return representation;
   }
@@ -218,7 +243,7 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
     };
   }
   function annotateIntersection(representation, left, right) {
-    return annotate(representation, mergeAnnotations(left._tag === "Reference" ? undefined : left.annotations, right._tag === "Reference" ? undefined : right.annotations));
+    return annotate(annotate(representation, left), right);
   }
   function intersectChecks(left, right, deduplicate = []) {
     let checks = right.checks;
@@ -227,11 +252,8 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
         checks = checks.filter(check => check._tag !== "Filter" || check.representation?.id !== id);
       }
     }
-    if (checks.length === 0) {
-      const annotations = mergeAnnotations(left.annotations, right.annotations);
-      return [left.checks, annotations];
-    }
-    if (right.annotations !== undefined) {
+    const annotations = checks.length === 0 ? mergeAnnotations(left.annotations, right.annotations) : left.annotations;
+    if (checks.length > 0 && right.annotations !== undefined) {
       checks = checks.length === 1 && checks[0].annotations === undefined ? [{
         ...checks[0],
         annotations: right.annotations
@@ -241,7 +263,11 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
         annotations: right.annotations
       }];
     }
-    return [[...left.checks, ...checks], left.annotations];
+    return {
+      checks: [...left.checks, ...checks],
+      annotations,
+      customAnnotations: mergeAnnotations(left.customAnnotations, right.customAnnotations)
+    };
   }
   function satisfiesPrimitiveCheck(check, value) {
     if (check._tag === "FilterGroup") {
@@ -333,7 +359,7 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
     }
     return out;
   }
-  function lowerObject(scopes, checks, annotations, path) {
+  function lowerObject(scopes, checked, path) {
     const names = new Set();
     let hasFiniteKeyDomain = false;
     let requiresFiniteKeyDomain = false;
@@ -384,15 +410,14 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
       parameter: string,
       type: never
     }] : [];
-    const representation = {
+    return {
       _tag: "Objects",
       propertySignatures: properties,
       indexSignatures,
-      checks,
-      annotations
+      scopes,
+      path,
+      ...checked
     };
-    objectScopesByProperties.set(properties, [scopes, path]);
-    return representation;
   }
   const jsonRootTags = ["Null", "String", "Number", "Boolean", "Objects", "Arrays"];
   const allMasks = (1 << jsonRootTags.length) - 1;
@@ -414,8 +439,6 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
           default:
             return 0;
         }
-      case "Suspend":
-        return rootMask(representation.thunk);
       case "Union":
         {
           let out = 0;
@@ -436,28 +459,26 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
           const cached = definitionCache.get(key);
           if (cached === null || resolvingChoices.has(key)) return true;
           resolvingChoices.add(key);
-          const out = hasChoices(cached ?? translateDefinition(key, reachableDefinitions.get(key)));
+          const out = hasChoices(cached ?? translateDefinition(key, representation.path));
           resolvingChoices.delete(key);
           return out;
         }
-      case "Suspend":
-        return hasChoices(representation.thunk);
       case "Union":
-        return representation.types.length > 1 || representation.types.some(type => hasChoices(type));
+        return representation.types.length > 1 || representation.types.some(hasChoices);
       case "Arrays":
-        return representation.elements.some(element => hasChoices(element.type)) || representation.rest.some(type => hasChoices(type));
+        return representation.elements.some(element => hasChoices(element.type)) || representation.rest.some(hasChoices);
       case "Objects":
-        return representation.propertySignatures.some(property => hasChoices(property.type)) || representation.indexSignatures.some(indexSignature => hasChoices(indexSignature.parameter) || hasChoices(indexSignature.type)) || objectScopesByProperties.get(representation.propertySignatures)[0].some(scope => scope.patterns.some(pattern => hasChoices(pattern.type))) || representation.checks.some(checkHasChoices);
+        return representation.propertySignatures.some(property => hasChoices(property.type)) || representation.indexSignatures.some(indexSignature => hasChoices(indexSignature.parameter) || hasChoices(indexSignature.type)) || representation.scopes.some(scope => scope.patterns.some(pattern => hasChoices(pattern.type))) || representation.checks.some(checkHasChoices);
       default:
         return false;
     }
   }
   function checkHasChoices(check) {
-    return check._tag === "FilterGroup" ? check.checks.some(checkHasChoices) : check.representation?.schemas?.some(schema => hasChoices(schema)) === true;
+    return check._tag === "FilterGroup" ? check.checks.some(checkHasChoices) : check.representation.schemas?.some(hasChoices) === true;
   }
   function makeUnion(source, types) {
     if (types.length === 0) return never;
-    if (types.length === 1 && source.checks.length === 0) return annotate(types[0], source.annotations);
+    if (types.length === 1 && source.checks.length === 0) return annotate(types[0], source);
     return {
       ...source,
       types
@@ -466,27 +487,28 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
   function literalValue(representation) {
     if (representation._tag === "Null") return null;
     if (representation._tag !== "Literal") return undefined;
-    const literal = representation.literal;
-    return typeof literal === "string" || typeof literal === "number" || typeof literal === "boolean" ? literal : undefined;
+    return representation.literal;
   }
   function intersectLiteralUnions(left, right, path) {
     if ((left.options?.mode ?? "anyOf") !== "anyOf" || (right.options?.mode ?? "anyOf") !== "anyOf") {
       return undefined;
     }
     const rightByValue = new Map();
-    for (const type of right.types) {
-      const representation = type;
+    for (const representation of right.types) {
       const value = literalValue(representation);
       if (value === undefined) return undefined;
-      rightByValue.set(value, representation);
+      const previous = rightByValue.get(value);
+      rightByValue.set(value, {
+        ...representation,
+        customAnnotations: mergeAnnotations(previous?.customAnnotations, representation.customAnnotations)
+      });
     }
     const types = [];
-    for (const type of left.types) {
-      const representation = type;
+    for (const representation of left.types) {
       const value = literalValue(representation);
       if (value === undefined) return undefined;
       const match = rightByValue.get(value);
-      if (match !== undefined) types.push(intersect(representation, annotate(match, right.annotations), path));
+      if (match !== undefined) types.push(intersect(representation, annotate(match, right), path));
     }
     return makeUnion(left, types);
   }
@@ -500,7 +522,7 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
       return unsupportedIntersection(path);
     }
     if (members.length === 1 && union.checks.length === 0) {
-      const member = annotate(members[0].type, union.annotations);
+      const member = annotate(members[0].type, union);
       return unionOnLeft ? intersect(member, type, [...path, "types", members[0].index]) : intersect(type, member, [...path, "types", members[0].index]);
     }
     return makeUnion(union, members.map(member => unionOnLeft ? intersect(member.type, type, [...path, "types", member.index]) : intersect(type, member.type, [...path, "types", member.index])).filter(type => type._tag !== "Never"));
@@ -546,13 +568,16 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
     if (right._tag === "Never") return right;
     if (left._tag === "Unknown") return annotateIntersection(right, left, right);
     if (right._tag === "Unknown") return annotateIntersection(left, left, right);
-    if (left._tag === "Reference") return intersect(resolveReference(left, path), right, path);
-    if (right._tag === "Reference") return intersect(left, resolveReference(right, path), path);
-    if (left._tag === "Suspend") {
-      return annotate(intersect(left.thunk, right, path), left.annotations);
+    if (left._tag === "Reference") {
+      // Resolve an unannotated reference first. An annotated empty definition
+      // could otherwise leave the other reference unresolved during union partitioning.
+      if ((left.annotations !== undefined || left.customAnnotations !== undefined) && right._tag === "Reference" && right.annotations === undefined && right.customAnnotations === undefined) {
+        return intersect(left, resolveReference(right, path), path);
+      }
+      return annotate(intersect(resolveReference(left, path), right, path), left);
     }
-    if (right._tag === "Suspend") {
-      return annotate(intersect(left, right.thunk, path), right.annotations);
+    if (right._tag === "Reference") {
+      return annotate(intersect(left, resolveReference(right, path), path), right);
     }
     if (left._tag === "Union" && right._tag === "Union") return intersectUnions(left, right, path);
     if (left._tag === "Union") return intersectUnionWithType(left, right, path, true);
@@ -568,21 +593,19 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
           return intersectPrimitiveWithLiteral(left, right);
         }
         if (right._tag !== "String") return never;
-        const [stringChecks, stringAnnotations] = intersectChecks(left, right);
-        return annotate({
+        return {
           _tag: "String",
-          checks: stringChecks
-        }, stringAnnotations);
+          ...intersectChecks(left, right)
+        };
       case "Number":
         if (right._tag === "Literal") {
           return intersectPrimitiveWithLiteral(left, right);
         }
         if (right._tag !== "Number") return never;
-        const [numberChecks, numberAnnotations] = intersectChecks(left, right, ["effect/schema/isFinite", "effect/schema/isInt"]);
-        return annotate({
+        return {
           _tag: "Number",
-          checks: numberChecks
-        }, numberAnnotations);
+          ...intersectChecks(left, right, ["effect/schema/isFinite", "effect/schema/isInt"])
+        };
       case "Boolean":
         if (right._tag === "Literal") {
           return intersectPrimitiveWithLiteral(left, right);
@@ -607,19 +630,17 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
           if (right._tag !== "Arrays") return never;
           const arrays = intersectArrays(left, right, path);
           if (arrays === undefined) return never;
-          const [checks, annotations] = intersectChecks(left, right, ["effect/schema/isUnique"]);
-          return annotate({
+          return {
             _tag: "Arrays",
             ...arrays,
-            checks
-          }, annotations);
+            ...intersectChecks(left, right, ["effect/schema/isUnique"])
+          };
         }
       case "Objects":
         {
           if (right._tag !== "Objects") return never;
-          const [checks, annotations] = intersectChecks(left, right);
-          const scopes = [...objectScopesByProperties.get(left.propertySignatures)[0], ...objectScopesByProperties.get(right.propertySignatures)[0]];
-          return lowerObject(scopes, checks, annotations, path);
+          const scopes = [...left.scopes, ...right.scopes];
+          return lowerObject(scopes, intersectChecks(left, right), path);
         }
     }
   }
@@ -632,7 +653,7 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
     if (schema === undefined) {
       return unknown;
     }
-    if (isObject(schema.not) && Object.keys(schema.not).length === 0) return annotate(never, jsonSchemaAnnotations(schema));
+    if (isObject(schema.not) && Object.keys(schema.not).length === 0) return annotate(never, jsonSchemaAnnotations(schema, options));
     const wasInNestedResource = inNestedResource;
     inNestedResource ||= !isRoot && typeof schema.$id === "string";
     for (const keyword of Object.keys(schema)) {
@@ -674,21 +695,14 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
       if (!Object.hasOwn(document.definitions, $ref)) {
         throw errorWithPath(`Missing definition ${JSON.stringify($ref)} for $ref ${JSON.stringify(schema.$ref)}.`, [...path, "$ref"]);
       }
-      if (!reachableDefinitions.has($ref)) reachableDefinitions.set($ref, path);
       const reference = {
         _tag: "Reference",
-        $ref
+        $ref,
+        path
       };
       representation = representation._tag === "Unknown" ? reference : representation._tag === "Never" ? never : intersect(resolveReference(reference, path, `Recursive $ref ${JSON.stringify(reference.$ref)} cannot have sibling constraints.`), representation, path);
     }
-    const annotations = jsonSchemaAnnotations(schema);
-    if (annotations !== undefined && representation._tag === "Reference") {
-      annotatedReferences.push({
-        reference: representation,
-        path
-      });
-    }
-    representation = annotate(representation, annotations);
+    representation = annotate(representation, jsonSchemaAnnotations(schema, options));
     if (Array.isArray(schema.allOf)) {
       for (let index = 0; index < schema.allOf.length; index++) {
         representation = intersect(representation, translateSchema(schema.allOf[index], [...path, "allOf", index]), [...path, "allOf", index]);
@@ -768,7 +782,9 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
       case "object":
         {
           const scope = collectObjectScope(schema, path);
-          return lowerObject([scope], collectObjectChecks(schema, path), undefined, path);
+          return lowerObject([scope], {
+            checks: collectObjectChecks(schema, path)
+          }, path);
         }
       default:
         return unknown;
@@ -882,14 +898,8 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
   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 of finalReferences) {
-    InternalRecord.assignProperty(references, key, finalize(translateDefinition(key, reachableDefinitions.get(key))));
-  }
-  for (const {
-    reference,
-    path
-  } of annotatedReferences) {
-    resolveReference(reference, path);
+  for (const [key, reference] of finalReferences) {
+    InternalRecord.assignProperty(references, key, finalize(translateDefinition(key, reference.path)));
   }
   return {
     representations,