effect 4.0.5 → 4.0.7

package/dist/internal/schema/toJsonSchemaDocument.js

@@ -14,25 +14,22 @@ const jsonSchemaAnnotationExcludedKeys = /*#__PURE__*/new Set([...InternalAnnota
 function collectJsonSchemaAnnotations(annotations, options) {
   if (annotations === undefined) return undefined;
   const out = {};
-  const title = annotations.title;
-  if (typeof title === "string") out.title = title;
-  const description = annotations.description;
+  for (const key of ["title", "description", "format", "contentEncoding", "contentMediaType"]) {
+    const value = annotations[key];
+    if (typeof value === "string") out[key] = value;
+  }
+  for (const key of ["readOnly", "writeOnly"]) {
+    const value = annotations[key];
+    if (typeof value === "boolean") out[key] = value;
+  }
   const expected = annotations.expected;
-  if (typeof description === "string") out.description = description;else if (options?.generateDescriptions === true && typeof expected === "string") out.description = expected;
+  if (out.description === undefined && options?.generateDescriptions === true && typeof expected === "string") {
+    out.description = expected;
+  }
   const defaultValue = annotations.default;
   if (InternalAST.isJson(defaultValue)) out.default = defaultValue;
   const examples = annotations.examples;
   if (Array.isArray(examples) && InternalAST.isJson(examples)) out.examples = examples;
-  const readOnly = annotations.readOnly;
-  if (typeof readOnly === "boolean") out.readOnly = readOnly;
-  const writeOnly = annotations.writeOnly;
-  if (typeof writeOnly === "boolean") out.writeOnly = writeOnly;
-  const format = annotations.format;
-  if (typeof format === "string") out.format = format;
-  const contentEncoding = annotations.contentEncoding;
-  if (typeof contentEncoding === "string") out.contentEncoding = contentEncoding;
-  const contentMediaType = annotations.contentMediaType;
-  if (typeof contentMediaType === "string") out.contentMediaType = contentMediaType;
   const contentSchema = annotations.contentSchema;
   if (InternalAST.isJson(contentSchema)) out.contentSchema = contentSchema;
   if (options?.includeAnnotationKey !== undefined) {
@@ -177,6 +174,7 @@ function isApproximateCheckOutput(output) {
   return Array.isArray(output);
 }
 function compileJsonSchema(representations, rootPaths, references, options) {
+  const numberKeyPattern = `^(?:${InternalAST.FINITE_PATTERN}|Infinity|-Infinity|NaN)$`;
   const compiledDefinitions = new Map();
   const definitionAliases = new Map();
   const compiledRepresentations = new WeakMap();
@@ -187,7 +185,10 @@ function compileJsonSchema(representations, rootPaths, references, options) {
     compileDefinition(key, ["references", key]);
   }
   const compiledSchemas = Arr.map(representations, (representation, index) => recur(representation, rootPaths[index], []));
-  for (const [branches, schemas] of pendingOneOf.values()) {
+  for (const {
+    branches,
+    schemas
+  } of pendingOneOf.values()) {
     if (!isExact(branches)) {
       for (const schema of schemas) {
         if (Array.isArray(schema.oneOf)) {
@@ -201,9 +202,9 @@ function compileJsonSchema(representations, rootPaths, references, options) {
     const representation = references[key];
     const fallback = getIdentifierFallback(representation);
     if (fallback === undefined) continue;
-    const schema = compiledDefinitions.get(key)[0];
+    const schema = compiledDefinitions.get(key).schema;
     const candidates = fallbackDefinitions.get(fallback);
-    const match = candidates?.find(candidate => Equal.equals(compiledDefinitions.get(candidate)[0], schema));
+    const match = candidates?.find(candidate => Equal.equals(compiledDefinitions.get(candidate).schema, schema));
     if (match === undefined) {
       if (candidates === undefined) fallbackDefinitions.set(fallback, [key]);else candidates.push(key);
     } else {
@@ -214,7 +215,7 @@ function compileJsonSchema(representations, rootPaths, references, options) {
   const definitions = {};
   for (const key of referenceKeys) {
     if (!definitionAliases.has(key)) {
-      InternalRecord.assignProperty(definitions, key, finalizeJsonSchema(compiledDefinitions.get(key)[0]));
+      InternalRecord.assignProperty(definitions, key, finalizeJsonSchema(compiledDefinitions.get(key).schema));
     }
   }
   return {
@@ -223,9 +224,14 @@ function compileJsonSchema(representations, rootPaths, references, options) {
     definitions
   };
   function registerPendingOneOf(schema) {
-    if (Array.isArray(schema.oneOf)) pendingOneOf.get(schema.oneOf)?.[1].push(schema);
+    if (Array.isArray(schema.oneOf)) pendingOneOf.get(schema.oneOf)?.schemas.push(schema);
     return schema;
   }
+  function compileAnnotatedMember(member, path, dependencies) {
+    const schema = recur(member.type, [...path, "type"], dependencies);
+    const annotations = collectJsonSchemaAnnotations(member.annotations, options);
+    return annotations === undefined ? schema : registerPendingOneOf(appendJsonSchema(schema, annotations));
+  }
   function compileDefinition(key, path) {
     if (!Object.hasOwn(references, key)) {
       throw errorWithPath(`Invalid reference ${key}`, [...path, "$ref"]);
@@ -233,9 +239,12 @@ function compileJsonSchema(representations, rootPaths, references, options) {
     const cached = compiledDefinitions.get(key);
     if (cached !== undefined) return cached;
     // Register the dependency cell before compiling so recursive references share it.
-    const result = [{}, []];
+    const result = {
+      schema: {},
+      dependencies: []
+    };
     compiledDefinitions.set(key, result);
-    result[0] = recur(references[key], ["references", key], result[1]);
+    result.schema = recur(references[key], ["references", key], result.dependencies);
     return result;
   }
   function finalizeJsonSchema(schema) {
@@ -302,32 +311,39 @@ function compileJsonSchema(representations, rootPaths, references, options) {
   }
   function recur(representation, path, dependencies) {
     if (representation._tag === "Reference") {
-      dependencies.push(compileDefinition(representation.$ref, path)[1]);
+      dependencies.push(compileDefinition(representation.$ref, path).dependencies);
       return {
         $ref: formatDefinitionReference(representation.$ref)
       };
     }
     const cached = compiledRepresentations.get(representation);
     if (cached !== undefined) {
-      dependencies.push(cached[1]);
-      return cached[0];
+      dependencies.push(cached.dependencies);
+      return cached.schema;
     }
     const local = [];
     dependencies.push(local);
-    let output = on(representation, path, local);
-    const ordinary = collectJsonSchemaAnnotations(representation.annotations, options);
-    if (ordinary !== undefined) {
-      output = {
-        ...output,
-        ...ordinary
-      };
+    let output = {
+      ...on(representation, path, local),
+      ...collectJsonSchemaAnnotations(representation.annotations, options)
+    };
+    if (representation._tag === "String" && representation.content !== undefined) {
+      const content = representation.content;
+      output.contentMediaType = content.mediaType;
+      delete output.contentSchema;
+      if (content.schema !== undefined) {
+        output.contentSchema = recur(content.schema, [...path, "content", "schema"], []);
+      }
     }
     for (let index = 0; index < representation.checks.length; index++) {
       const type = typeof output.type === "string" && isJsonSchemaType(output.type) ? output.type : undefined;
       const check = compileCheck(representation.checks[index], type, [...path, "checks", index], local);
       if (check !== undefined) output = appendJsonSchema(output, ...check);
     }
-    compiledRepresentations.set(representation, [output, local]);
+    compiledRepresentations.set(representation, {
+      schema: output,
+      dependencies: local
+    });
     return registerPendingOneOf(output);
   }
   function on(representation, path, dependencies) {
@@ -409,16 +425,11 @@ function compileJsonSchema(representations, rootPaths, references, options) {
         }
       case "Enum":
         {
-          const types = representation.enums.map(([title, literal], index) => {
-            if (typeof literal === "number" && !globalThis.Number.isFinite(literal)) {
-              throw errorWithPath(`Invalid numeric enum value ${globalThis.String(literal)}`, [...path, "enums", index, 1]);
-            }
-            return {
-              type: typeof literal,
-              enum: [literal],
-              title
-            };
-          });
+          const types = representation.enums.map(([title, literal]) => ({
+            type: typeof literal,
+            enum: [literal],
+            title
+          }));
           return types.length === 0 ? {
             not: {}
           } : {
@@ -426,24 +437,26 @@ function compileJsonSchema(representations, rootPaths, references, options) {
           };
         }
       case "TemplateLiteral":
-        return {
-          type: "string",
-          pattern: `^${representation.parts.map(getPartPattern).join("")}$`
-        };
+        {
+          const {
+            exact,
+            pattern
+          } = getTemplateLiteralPattern(representation.parts);
+          if (!exact) dependencies.push(false);
+          return {
+            type: "string",
+            pattern
+          };
+        }
       case "Arrays":
         {
-          if (representation.rest.length > 1) {
-            throw errorWithPath("Invalid schema representation document", [...path, "rest"]);
-          }
           const out = {
             type: "array"
           };
           let minItems = representation.elements.length;
           const prefixItems = representation.elements.map((element, index) => {
             if (element.isOptional) minItems--;
-            const schema = recur(element.type, [...path, "elements", index, "type"], dependencies);
-            const annotations = collectJsonSchemaAnnotations(element.annotations, options);
-            return annotations === undefined ? schema : registerPendingOneOf(appendJsonSchema(schema, annotations));
+            return compileAnnotatedMember(element, [...path, "elements", index], dependencies);
           });
           if (prefixItems.length > 0) {
             out.prefixItems = prefixItems;
@@ -456,103 +469,16 @@ function compileJsonSchema(representations, rootPaths, references, options) {
             delete out.maxItems;
             const rest = recur(representation.rest[0], [...path, "rest", 0], dependencies);
             if (Object.keys(rest).length > 0) out.items = rest;else delete out.items;
+          } else if (representation.rest.length > 1) {
+            delete out.maxItems;
+            delete out.items;
+            out.minItems = minItems + representation.rest.length - 1;
+            dependencies.push(false);
           }
           return out;
         }
       case "Objects":
-        {
-          if (representation.propertySignatures.length === 0 && representation.indexSignatures.length === 0) {
-            return {
-              not: {
-                type: "null"
-              }
-            };
-          }
-          const out = {
-            type: "object"
-          };
-          const properties = {};
-          const required = [];
-          for (let index = 0; index < representation.propertySignatures.length; index++) {
-            const property = representation.propertySignatures[index];
-            if (typeof property.name !== "string") {
-              throw errorWithPath("Invalid schema representation document", [...path, "propertySignatures", index, "name"]);
-            }
-            const name = property.name;
-            const schema = recur(property.type, [...path, "propertySignatures", index, "type"], dependencies);
-            const annotations = collectJsonSchemaAnnotations(property.annotations, options);
-            InternalRecord.assignProperty(properties, name, annotations === undefined ? schema : registerPendingOneOf(appendJsonSchema(schema, annotations)));
-            if (!property.isOptional) required.push(name);
-          }
-          if (representation.propertySignatures.length > 0) out.properties = properties;
-          if (required.length > 0) out.required = required;
-          const patternProperties = {};
-          const additionalPropertySchemas = [];
-          const indexValueSchemas = [];
-          let hasUnrepresentableIndexPattern = false;
-          for (let index = 0; index < representation.indexSignatures.length; index++) {
-            const signature = representation.indexSignatures[index];
-            let type = recur(signature.type, [...path, "indexSignatures", index, "type"], dependencies);
-            if (Equal.equals(type, {
-              not: {}
-            })) type = false;
-            indexValueSchemas.push(type);
-            const patterns = getParameterPatterns(signature.parameter, [...path, "indexSignatures", index, "parameter"], new Set());
-            if (patterns === undefined) {
-              hasUnrepresentableIndexPattern = true;
-              dependencies.push(false);
-              continue;
-            }
-            if (patterns.length === 0) {
-              additionalPropertySchemas.push(type);
-            } else {
-              for (const pattern of patterns) {
-                const previous = patternProperties[pattern];
-                InternalRecord.assignProperty(patternProperties, pattern, previous === undefined ? type : previous === false || type === false ? false : registerPendingOneOf(appendJsonSchema(previous, type)));
-              }
-            }
-          }
-          const hasPatternProperties = Object.keys(patternProperties).length > 0;
-          if (hasPatternProperties) {
-            out.patternProperties = patternProperties;
-          }
-          if (hasUnrepresentableIndexPattern && options?.onExcessProperty === "error") {
-            const propertyNames = [];
-            if (representation.propertySignatures.length > 0) {
-              propertyNames.push({
-                enum: Object.keys(properties)
-              });
-            }
-            for (let index = 0; index < representation.indexSignatures.length; index++) {
-              propertyNames.push(recur(representation.indexSignatures[index].parameter, [...path, "indexSignatures", index, "parameter"], dependencies));
-            }
-            out.propertyNames = propertyNames.length === 1 ? propertyNames[0] : {
-              anyOf: propertyNames
-            };
-            out.additionalProperties = indexValueSchemas.length === 1 ? indexValueSchemas[0] : {
-              anyOf: indexValueSchemas
-            };
-            if (additionalPropertySchemas.length > 0) {
-              out.allOf = additionalPropertySchemas.map(type => ({
-                type: "object",
-                additionalProperties: type
-              }));
-            }
-          } else if (additionalPropertySchemas.length === 0) {
-            out.additionalProperties = hasUnrepresentableIndexPattern || options?.onExcessProperty !== "error";
-          } else if (additionalPropertySchemas.length === 1 && representation.propertySignatures.length === 0 && !hasPatternProperties) {
-            out.additionalProperties = additionalPropertySchemas[0];
-          } else if (additionalPropertySchemas.length > 0) {
-            out.allOf = additionalPropertySchemas.map(type => ({
-              type: "object",
-              additionalProperties: type
-            }));
-          }
-          if (typeof out.additionalProperties === "object" && out.additionalProperties !== null && Object.keys(out.additionalProperties).length === 0) {
-            delete out.additionalProperties;
-          }
-          return out;
-        }
+        return compileObjects(representation, path, dependencies);
       case "Union":
         {
           const branches = [];
@@ -561,25 +487,148 @@ function compileJsonSchema(representations, rootPaths, references, options) {
           if (types.length === 0) return {
             not: {}
           };
-          const mode = representation.options?.mode ?? "anyOf";
-          if (mode === "anyOf" && types.length > 1) {
+          if (representation.options?.mode === "oneOf") {
+            pendingOneOf.set(types, {
+              branches,
+              schemas: []
+            });
+            return {
+              oneOf: types
+            };
+          }
+          if (types.length > 1) {
             const compacted = compactEnums(types);
             if (compacted !== undefined) return compacted;
           }
-          if (mode === "oneOf") pendingOneOf.set(types, [branches, []]);
+          // A member that is only an `anyOf` adds no constraints of its own, so its alternatives can be spliced in.
           return {
-            [mode]: types
+            anyOf: types.flatMap(type => Array.isArray(type.anyOf) && Object.keys(type).length === 1 ? type.anyOf : [type])
           };
         }
     }
   }
+  function compileObjects(representation, path, dependencies) {
+    const {
+      indexSignatures,
+      propertySignatures
+    } = representation;
+    if (propertySignatures.length === 0 && indexSignatures.length === 0) return {
+      not: {
+        type: "null"
+      }
+    };
+    const out = {
+      type: "object"
+    };
+    const properties = {};
+    const required = [];
+    for (const [index, property] of propertySignatures.entries()) {
+      const propertyPath = [...path, "propertySignatures", index];
+      if (typeof property.name !== "string") {
+        throw errorWithPath("Objects property names must be strings", [...propertyPath, "name"]);
+      }
+      InternalRecord.assignProperty(properties, property.name, compileAnnotatedMember(property, propertyPath, dependencies));
+      if (!property.isOptional) required.push(property.name);
+    }
+    if (propertySignatures.length > 0) out.properties = properties;
+    if (required.length > 0) out.required = required;
+    const indexes = indexSignatures.map((signature, index) => {
+      const indexPath = [...path, "indexSignatures", index];
+      const schema = recur(signature.type, [...indexPath, "type"], dependencies);
+      const type = Equal.equals(schema, {
+        not: {}
+      }) ? false : schema;
+      const patterns = getParameterPatterns(signature.parameter, [...indexPath, "parameter"], new Set());
+      if (patterns === undefined) dependencies.push(false);
+      return {
+        type,
+        patterns
+      };
+    });
+    const patternProperties = {};
+    for (const {
+      patterns,
+      type
+    } of indexes) {
+      for (const pattern of patterns ?? []) {
+        const previous = patternProperties[pattern];
+        InternalRecord.assignProperty(patternProperties, pattern, previous === undefined ? type : previous === false || type === false ? false : registerPendingOneOf(appendJsonSchema(previous, type)));
+      }
+    }
+    const hasPatternProperties = Object.keys(patternProperties).length > 0;
+    if (hasPatternProperties) out.patternProperties = patternProperties;
+    const additionalPropertySchemas = indexes.filter(({
+      patterns
+    }) => patterns?.length === 0).map(({
+      type
+    }) => type);
+    const hasUnrepresentableIndexPattern = indexes.some(({
+      patterns
+    }) => patterns === undefined);
+    if (hasUnrepresentableIndexPattern && options?.onExcessProperty === "error") {
+      const propertyNames = [];
+      if (propertySignatures.length > 0) propertyNames.push({
+        enum: Object.keys(properties)
+      });
+      for (const [index, signature] of indexSignatures.entries()) {
+        propertyNames.push(getPropertyNameSchema(signature.parameter, [...path, "indexSignatures", index, "parameter"], dependencies, new Set()));
+      }
+      out.propertyNames = propertyNames.length === 1 ? propertyNames[0] : {
+        anyOf: propertyNames
+      };
+      const values = indexes.map(({
+        type
+      }) => type);
+      out.additionalProperties = values.length === 1 ? values[0] : {
+        anyOf: values
+      };
+      if (additionalPropertySchemas.length > 0) {
+        out.allOf = additionalPropertySchemas.map(type => ({
+          type: "object",
+          additionalProperties: type
+        }));
+      }
+    } else if (additionalPropertySchemas.length === 0) {
+      out.additionalProperties = hasUnrepresentableIndexPattern || options?.onExcessProperty !== "error";
+    } else if (additionalPropertySchemas.length === 1 && propertySignatures.length === 0 && !hasPatternProperties) {
+      out.additionalProperties = additionalPropertySchemas[0];
+    } else {
+      out.allOf = additionalPropertySchemas.map(type => ({
+        type: "object",
+        additionalProperties: type
+      }));
+    }
+    if (typeof out.additionalProperties === "object" && out.additionalProperties !== null && Object.keys(out.additionalProperties).length === 0) {
+      delete out.additionalProperties;
+    }
+    return out;
+  }
+  function getPropertyNameSchema(parameter, path, dependencies, seenReferences) {
+    switch (parameter._tag) {
+      case "Number":
+        return {
+          type: "string",
+          pattern: numberKeyPattern
+        };
+      case "Reference":
+        {
+          if (seenReferences.has(parameter.$ref)) return {
+            type: "string"
+          };
+          return getPropertyNameSchema(references[parameter.$ref], ["references", parameter.$ref], dependencies, new Set(seenReferences).add(parameter.$ref));
+        }
+      case "Union":
+        return {
+          anyOf: parameter.types.map(type => getPropertyNameSchema(type, path, dependencies, seenReferences))
+        };
+      default:
+        return recur(parameter, path, dependencies);
+    }
+  }
   function getParameterPatterns(parameter, path, seenReferences) {
     switch (parameter._tag) {
       case "Reference":
         {
-          if (!Object.hasOwn(references, parameter.$ref)) {
-            throw errorWithPath(`Invalid reference ${parameter.$ref}`, [...path, "$ref"]);
-          }
           compileDefinition(parameter.$ref, path);
           if (seenReferences.has(parameter.$ref)) return undefined;
           const next = new Set(seenReferences).add(parameter.$ref);
@@ -597,7 +646,14 @@ function compileJsonSchema(representations, rootPaths, references, options) {
           return schema.type === "string" && typeof schema.pattern === "string" && hasOnlyKeywords(schema, "|type|pattern|title|description|default|examples|readOnly|writeOnly|") ? [schema.pattern] : undefined;
         }
       case "TemplateLiteral":
-        return parameter.checks.length === 0 ? [`^${parameter.parts.map(getPartPattern).join("")}$`] : undefined;
+        {
+          if (parameter.checks.length > 0) return undefined;
+          const {
+            exact,
+            pattern
+          } = getTemplateLiteralPattern(parameter.parts);
+          return exact ? [pattern] : undefined;
+        }
       case "Union":
         {
           if (parameter.types.length === 0 || parameter.checks.length > 0 || parameter.options?.mode === "oneOf") {
@@ -612,8 +668,55 @@ function compileJsonSchema(representations, rootPaths, references, options) {
           }
           return patterns;
         }
+      case "Number":
+        return parameter.checks.length === 0 ? [numberKeyPattern] : undefined;
       default:
-        throw errorWithPath("Invalid schema representation document", path);
+        throw errorWithPath(`Invalid index signature parameter ${parameter._tag}`, path);
+    }
+  }
+  function getTemplateLiteralPattern(parts) {
+    const activeReferences = new Set();
+    let exact = true;
+    const pattern = `^${parts.map(getPartPattern).join("")}$`;
+    return {
+      pattern,
+      exact
+    };
+    function getPartPattern(part) {
+      // A segment check cannot generally be embedded in the enclosing pattern, even when it has a JSON Schema exporter.
+      if (part._tag !== "Reference" && part.checks.length > 0) exact = false;
+      switch (part._tag) {
+        case "Reference":
+          {
+            if (!Object.hasOwn(references, part.$ref)) {
+              throw errorWithPath(`Invalid reference ${part.$ref}`, []);
+            }
+            if (activeReferences.has(part.$ref)) {
+              throw errorWithPath(`Invalid recursive TemplateLiteral part ${part.$ref}`, []);
+            }
+            activeReferences.add(part.$ref);
+            const pattern = getPartPattern(references[part.$ref]);
+            activeReferences.delete(part.$ref);
+            return pattern;
+          }
+        case "Literal":
+          return RegEx.escape(globalThis.String(part.literal));
+        case "String":
+          return InternalAST.STRING_PATTERN;
+        case "Number":
+          return InternalAST.FINITE_PATTERN;
+        case "BigInt":
+          return "-?\\d+";
+        case "TemplateLiteral":
+          return part.parts.map(getPartPattern).join("");
+        case "Union":
+          if (part.types.length === 0) return "(?!)";
+          // Regex alternatives do not enforce that exactly one branch matches.
+          if (part.options?.mode === "oneOf") exact = false;
+          return `(?:${part.types.map(getPartPattern).join("|")})`;
+        default:
+          throw errorWithPath(`Invalid TemplateLiteral part ${part._tag}`, []);
+      }
     }
   }
 }
@@ -639,22 +742,6 @@ function compactEnums(schemas) {
     enum: values
   };
 }
-function getPartPattern(part) {
-  switch (part._tag) {
-    case "Literal":
-      return RegEx.escape(globalThis.String(part.literal));
-    case "String":
-      return InternalAST.STRING_PATTERN;
-    case "Number":
-      return InternalAST.FINITE_PATTERN;
-    case "TemplateLiteral":
-      return part.parts.map(getPartPattern).join("");
-    case "Union":
-      return `(?:${part.types.map(getPartPattern).join("|")})`;
-    default:
-      throw errorWithPath("Invalid schema representation document", []);
-  }
-}
 /** @internal */
 export function toJsonSchemaDocument(document, options) {
   const output = compileJsonSchema([document.representation], [["representation"]], document.references, options);