next-openapi-gen 1.4.0 → 1.4.2

package/dist/next/index.js

@@ -737,96 +737,100 @@ function typeToOpenApiSchema(type, checker, seen) {
     return { type: "object" };
   }
   seen.add(seenKey);
-  if (type.isStringLiteral()) {
-    return { type: "string", enum: [type.value] };
-  }
-  if (type.isNumberLiteral()) {
-    return { type: "number", enum: [type.value] };
-  }
-  if (type.flags & ts2.TypeFlags.BooleanLiteral) {
-    return {
-      type: "boolean",
-      enum: [checker.typeToString(type) === "true"]
-    };
-  }
-  if (type.flags & ts2.TypeFlags.TemplateLiteral) {
-    return { type: "string" };
-  }
-  if (type.flags & ts2.TypeFlags.StringLike) {
-    return { type: "string" };
-  }
-  if (type.flags & ts2.TypeFlags.NumberLike) {
-    return { type: "number" };
-  }
-  if (type.flags & ts2.TypeFlags.BooleanLike) {
-    return { type: "boolean" };
-  }
-  if (type.flags & ts2.TypeFlags.Null) {
-    return { type: "null" };
-  }
-  if (type.isUnion()) {
-    const nullable2 = type.types.some((member) => member.flags & ts2.TypeFlags.Null);
-    const nonNullTypes = type.types.filter((member) => !(member.flags & ts2.TypeFlags.Null));
-    const soleNonNullType = nonNullTypes[0];
-    if (nullable2 && soleNonNullType && nonNullTypes.length === 1) {
+  try {
+    if (type.isStringLiteral()) {
+      return { type: "string", enum: [type.value] };
+    }
+    if (type.isNumberLiteral()) {
+      return { type: "number", enum: [type.value] };
+    }
+    if (type.flags & ts2.TypeFlags.BooleanLiteral) {
       return {
-        ...typeToOpenApiSchema(soleNonNullType, checker, seen),
-        nullable: true
+        type: "boolean",
+        enum: [checker.typeToString(type) === "true"]
       };
     }
-    return {
-      oneOf: nonNullTypes.map((member) => typeToOpenApiSchema(member, checker, seen))
-    };
-  }
-  if (checker.isTupleType(type)) {
-    const itemTypes = checker.getTypeArguments(type);
-    return {
-      type: "array",
-      prefixItems: itemTypes.map((itemType) => typeToOpenApiSchema(itemType, checker, seen)),
-      items: false,
-      minItems: itemTypes.length,
-      maxItems: itemTypes.length
-    };
-  }
-  if (checker.isArrayType(type)) {
-    const elementType = checker.getTypeArguments(type)[0];
-    return {
-      type: "array",
-      items: elementType ? typeToOpenApiSchema(elementType, checker, seen) : { type: "object" }
-    };
-  }
-  const properties = checker.getPropertiesOfType(type);
-  if (properties.length > 0) {
-    const schemaProperties = {};
-    const required2 = [];
-    properties.forEach((property) => {
-      const propertyDeclaration = property.valueDeclaration || property.declarations?.[0];
-      if (!propertyDeclaration) {
-        return;
-      }
-      const propertyType = checker.getTypeOfSymbolAtLocation(property, propertyDeclaration);
-      schemaProperties[property.getName()] = typeToOpenApiSchema(propertyType, checker, seen);
-      if (!(property.flags & ts2.SymbolFlags.Optional)) {
-        required2.push(property.getName());
+    if (type.flags & ts2.TypeFlags.TemplateLiteral) {
+      return { type: "string" };
+    }
+    if (type.flags & ts2.TypeFlags.StringLike) {
+      return { type: "string" };
+    }
+    if (type.flags & ts2.TypeFlags.NumberLike) {
+      return { type: "number" };
+    }
+    if (type.flags & ts2.TypeFlags.BooleanLike) {
+      return { type: "boolean" };
+    }
+    if (type.flags & ts2.TypeFlags.Null) {
+      return { type: "null" };
+    }
+    if (type.isUnion()) {
+      const nullable2 = type.types.some((member) => member.flags & ts2.TypeFlags.Null);
+      const nonNullTypes = type.types.filter((member) => !(member.flags & ts2.TypeFlags.Null));
+      const soleNonNullType = nonNullTypes[0];
+      if (nullable2 && soleNonNullType && nonNullTypes.length === 1) {
+        return {
+          ...typeToOpenApiSchema(soleNonNullType, checker, seen),
+          nullable: true
+        };
       }
-    });
-    return required2.length > 0 ? {
-      type: "object",
-      properties: schemaProperties,
-      required: required2
-    } : {
-      type: "object",
-      properties: schemaProperties
-    };
-  }
-  const stringIndexType = type.getStringIndexType();
-  if (stringIndexType) {
-    return {
-      type: "object",
-      additionalProperties: typeToOpenApiSchema(stringIndexType, checker, seen)
-    };
+      return {
+        oneOf: nonNullTypes.map((member) => typeToOpenApiSchema(member, checker, seen))
+      };
+    }
+    if (checker.isTupleType(type)) {
+      const itemTypes = checker.getTypeArguments(type);
+      return {
+        type: "array",
+        prefixItems: itemTypes.map((itemType) => typeToOpenApiSchema(itemType, checker, seen)),
+        items: false,
+        minItems: itemTypes.length,
+        maxItems: itemTypes.length
+      };
+    }
+    if (checker.isArrayType(type)) {
+      const elementType = checker.getTypeArguments(type)[0];
+      return {
+        type: "array",
+        items: elementType ? typeToOpenApiSchema(elementType, checker, seen) : { type: "object" }
+      };
+    }
+    const properties = checker.getPropertiesOfType(type);
+    if (properties.length > 0) {
+      const schemaProperties = {};
+      const required2 = [];
+      properties.forEach((property) => {
+        const propertyDeclaration = property.valueDeclaration || property.declarations?.[0];
+        if (!propertyDeclaration) {
+          return;
+        }
+        const propertyType = checker.getTypeOfSymbolAtLocation(property, propertyDeclaration);
+        schemaProperties[property.getName()] = typeToOpenApiSchema(propertyType, checker, seen);
+        if (!(property.flags & ts2.SymbolFlags.Optional)) {
+          required2.push(property.getName());
+        }
+      });
+      return required2.length > 0 ? {
+        type: "object",
+        properties: schemaProperties,
+        required: required2
+      } : {
+        type: "object",
+        properties: schemaProperties
+      };
+    }
+    const stringIndexType = type.getStringIndexType();
+    if (stringIndexType) {
+      return {
+        type: "object",
+        additionalProperties: typeToOpenApiSchema(stringIndexType, checker, seen)
+      };
+    }
+    return { type: "object" };
+  } finally {
+    seen.delete(seenKey);
   }
-  return { type: "object" };
 }
 function unwrapPromiseType(type, checker) {
   const symbolName = type.getSymbol()?.getName();
@@ -3451,23 +3455,58 @@ var SymbolResolver = class {
   }
   /**
    * Returns a simple literal value (string/number/boolean/null) for a `const` declarator,
-   * or `null` if no such declarator exists.
+   * following imports and re-exports when the name is not declared locally.
    */
   resolveLiteral(filePath, name) {
+    const visited = /* @__PURE__ */ new Set();
+    return this.resolveLiteralInternal(filePath, name, visited);
+  }
+  resolveLiteralInternal(filePath, name, visited) {
+    if (visited.has(filePath))
+      return void 0;
+    visited.add(filePath);
     const index = this.getIndex(filePath);
     if (!index)
       return void 0;
     const literal2 = index.constLiterals.get(name);
-    if (!literal2)
-      return void 0;
-    if (t4.isStringLiteral(literal2))
-      return literal2.value;
-    if (t4.isNumericLiteral(literal2))
-      return literal2.value;
-    if (t4.isBooleanLiteral(literal2))
-      return literal2.value;
-    if (t4.isNullLiteral(literal2))
-      return null;
+    if (literal2) {
+      if (t4.isStringLiteral(literal2))
+        return literal2.value;
+      if (t4.isNumericLiteral(literal2))
+        return literal2.value;
+      if (t4.isBooleanLiteral(literal2))
+        return literal2.value;
+      if (t4.isNullLiteral(literal2))
+        return null;
+    }
+    const imports = this.getImports(filePath);
+    const importInfo = imports?.get(name);
+    if (importInfo) {
+      const resolved = this.resolveImportPath(filePath, importInfo.source);
+      if (resolved) {
+        const targetName = importInfo.importedName === "default" ? name : importInfo.importedName;
+        const result = this.resolveLiteralInternal(resolved, targetName, visited);
+        if (result !== void 0)
+          return result;
+      }
+    }
+    const reExport = index.namedReExports.get(name);
+    if (reExport) {
+      const resolved = this.resolveImportPath(filePath, reExport.source);
+      if (resolved) {
+        const result = this.resolveLiteralInternal(resolved, reExport.importedName, visited);
+        if (result !== void 0)
+          return result;
+      }
+    }
+    for (const starSrc of index.exportsStar) {
+      const resolved = this.resolveImportPath(filePath, starSrc);
+      if (!resolved)
+        continue;
+      const result = this.resolveLiteralInternal(resolved, name, visited);
+      if (result !== void 0)
+        return result;
+    }
     return void 0;
   }
   /**
@@ -13790,6 +13829,58 @@ var ZodSchemaConverter = class {
       this.symbolResolver.primeAST(this.currentFilePath, this.currentAST);
     return this.symbolResolver.resolveLiteral(this.currentFilePath, name);
   }
+  /**
+   * Unwrap a possible `TSAsExpression` / `TSSatisfiesExpression` to get the
+   * underlying expression node.  Returns the node itself when no wrapper is
+   * present.
+   */
+  unwrapTypeAssertion(node) {
+    if (!node)
+      return void 0;
+    if (t11.isTSAsExpression(node) || t11.isTSSatisfiesExpression(node)) {
+      return node.expression;
+    }
+    return node;
+  }
+  /**
+   * Resolve a numeric value from a call-expression argument.
+   * Handles: numeric literals, identifier references to const numbers,
+   * and `x as number` / `x satisfies number` wrappers around either.
+   */
+  resolveNumericArg(arg) {
+    if (!arg)
+      return void 0;
+    const node = this.unwrapTypeAssertion(arg);
+    if (t11.isNumericLiteral(node))
+      return node.value;
+    if (t11.isUnaryExpression(node) && node.operator === "-" && t11.isNumericLiteral(node.argument)) {
+      return -node.argument.value;
+    }
+    if (t11.isIdentifier(node)) {
+      const val = this.resolveLiteralValue(node.name);
+      if (typeof val === "number")
+        return val;
+    }
+    return void 0;
+  }
+  /**
+   * Resolve a string value from a call-expression argument.
+   * Handles: string literals, identifier references to const strings,
+   * and `x as string` / `x satisfies string` wrappers around either.
+   */
+  resolveStringArg(arg) {
+    if (!arg)
+      return void 0;
+    const node = this.unwrapTypeAssertion(arg);
+    if (t11.isStringLiteral(node))
+      return node.value;
+    if (t11.isIdentifier(node)) {
+      const val = this.resolveLiteralValue(node.name);
+      if (typeof val === "string")
+        return val;
+    }
+    return void 0;
+  }
   /**
    * Resolve an identifier referring to a `z.object({...})` (or similar) call expression.
    * This lets callers inline the referenced object's shape.
@@ -13858,6 +13949,14 @@ var ZodSchemaConverter = class {
     if (t11.isNullLiteral(node)) {
       return null;
     }
+    if (t11.isIdentifier(node)) {
+      const val = this.resolveLiteralValue(node.name);
+      if (val !== void 0)
+        return val;
+    }
+    if (t11.isTSAsExpression(node) || t11.isTSSatisfiesExpression(node)) {
+      return this.extractStaticJsonValue(node.expression);
+    }
     if (t11.isArrayExpression(node)) {
       const values = [];
       for (const element of node.elements) {
@@ -13920,7 +14019,7 @@ var ZodSchemaConverter = class {
       return helperName.startsWith("coerce.") || helperName === "templateLiteral" || helperName === "stringbool";
     }
     if (t11.isMemberExpression(node.callee) && t11.isIdentifier(node.callee.property)) {
-      const runtimeMethods = /* @__PURE__ */ new Set(["pipe", "meta"]);
+      const runtimeMethods = /* @__PURE__ */ new Set(["pipe"]);
       if (runtimeMethods.has(node.callee.property.name)) {
         return true;
       }
@@ -13956,53 +14055,60 @@ var ZodSchemaConverter = class {
           schema.nullable = true;
         }
         break;
-      case "describe":
-        if (node.arguments.length > 0 && t11.isStringLiteral(node.arguments[0])) {
-          const description = node.arguments[0].value;
-          if (description.startsWith("@deprecated")) {
+      case "describe": {
+        const descVal = this.resolveStringArg(node.arguments[0]);
+        if (descVal !== void 0) {
+          if (descVal.startsWith("@deprecated")) {
             schema.deprecated = true;
-            schema.description = description.replace("@deprecated", "").trim();
+            schema.description = descVal.replace("@deprecated", "").trim();
           } else {
-            schema.description = description;
+            schema.description = descVal;
           }
         }
         break;
+      }
       case "deprecated":
         schema.deprecated = true;
         break;
-      case "min":
-        if (node.arguments.length > 0 && t11.isNumericLiteral(node.arguments[0])) {
+      case "min": {
+        const minVal = this.resolveNumericArg(node.arguments[0]);
+        if (minVal !== void 0) {
           if (schema.type === "string") {
-            schema.minLength = node.arguments[0].value;
+            schema.minLength = minVal;
           } else if (schema.type === "number" || schema.type === "integer") {
-            schema.minimum = node.arguments[0].value;
+            schema.minimum = minVal;
           } else if (schema.type === "array") {
-            schema.minItems = node.arguments[0].value;
+            schema.minItems = minVal;
           }
         }
         break;
-      case "max":
-        if (node.arguments.length > 0 && t11.isNumericLiteral(node.arguments[0])) {
+      }
+      case "max": {
+        const maxVal = this.resolveNumericArg(node.arguments[0]);
+        if (maxVal !== void 0) {
           if (schema.type === "string") {
-            schema.maxLength = node.arguments[0].value;
+            schema.maxLength = maxVal;
           } else if (schema.type === "number" || schema.type === "integer") {
-            schema.maximum = node.arguments[0].value;
+            schema.maximum = maxVal;
           } else if (schema.type === "array") {
-            schema.maxItems = node.arguments[0].value;
+            schema.maxItems = maxVal;
           }
         }
         break;
-      case "length":
-        if (node.arguments.length > 0 && t11.isNumericLiteral(node.arguments[0])) {
+      }
+      case "length": {
+        const lenVal = this.resolveNumericArg(node.arguments[0]);
+        if (lenVal !== void 0) {
           if (schema.type === "string") {
-            schema.minLength = node.arguments[0].value;
-            schema.maxLength = node.arguments[0].value;
+            schema.minLength = lenVal;
+            schema.maxLength = lenVal;
           } else if (schema.type === "array") {
-            schema.minItems = node.arguments[0].value;
-            schema.maxItems = node.arguments[0].value;
+            schema.minItems = lenVal;
+            schema.maxItems = lenVal;
           }
         }
         break;
+      }
       case "nonempty":
         if (schema.type === "array") {
           schema.minItems = Math.max(schema.minItems ?? 0, 1);
@@ -14078,34 +14184,38 @@ var ZodSchemaConverter = class {
           schema.pattern = node.arguments[0].pattern;
         }
         break;
-      case "startsWith":
-        if (node.arguments.length > 0 && t11.isStringLiteral(node.arguments[0])) {
-          schema.pattern = `^${this.escapeRegExp(node.arguments[0].value)}`;
+      case "startsWith": {
+        const swVal = this.resolveStringArg(node.arguments[0]);
+        if (swVal !== void 0) {
+          schema.pattern = `^${this.escapeRegExp(swVal)}`;
         }
         break;
-      case "endsWith":
-        if (node.arguments.length > 0 && t11.isStringLiteral(node.arguments[0])) {
-          schema.pattern = `${this.escapeRegExp(node.arguments[0].value)}$`;
+      }
+      case "endsWith": {
+        const ewVal = this.resolveStringArg(node.arguments[0]);
+        if (ewVal !== void 0) {
+          schema.pattern = `${this.escapeRegExp(ewVal)}$`;
         }
         break;
-      case "includes":
-        if (node.arguments.length > 0 && t11.isStringLiteral(node.arguments[0])) {
-          schema.pattern = this.escapeRegExp(node.arguments[0].value);
+      }
+      case "includes": {
+        const incVal = this.resolveStringArg(node.arguments[0]);
+        if (incVal !== void 0) {
+          schema.pattern = this.escapeRegExp(incVal);
         }
         break;
+      }
       case "int":
         schema.type = "integer";
         break;
       case "positive":
-        schema.minimum = 0;
-        schema.exclusiveMinimum = true;
+        schema.exclusiveMinimum = 0;
         break;
       case "nonnegative":
         schema.minimum = 0;
         break;
       case "negative":
-        schema.maximum = 0;
-        schema.exclusiveMaximum = true;
+        schema.exclusiveMaximum = 0;
         break;
       case "nonpositive":
         schema.maximum = 0;
@@ -14118,17 +14228,22 @@ var ZodSchemaConverter = class {
         break;
       case "default":
         if (node.arguments.length > 0) {
-          if (t11.isStringLiteral(node.arguments[0])) {
-            schema.default = node.arguments[0].value;
-          } else if (t11.isNumericLiteral(node.arguments[0])) {
-            schema.default = node.arguments[0].value;
-          } else if (t11.isBooleanLiteral(node.arguments[0])) {
-            schema.default = node.arguments[0].value;
-          } else if (t11.isNullLiteral(node.arguments[0])) {
+          const defaultArg = this.unwrapTypeAssertion(node.arguments[0]);
+          if (t11.isStringLiteral(defaultArg)) {
+            schema.default = defaultArg.value;
+          } else if (t11.isNumericLiteral(defaultArg)) {
+            schema.default = defaultArg.value;
+          } else if (t11.isBooleanLiteral(defaultArg)) {
+            schema.default = defaultArg.value;
+          } else if (t11.isNullLiteral(defaultArg)) {
             schema.default = null;
-          } else if (t11.isObjectExpression(node.arguments[0])) {
+          } else if (t11.isIdentifier(defaultArg)) {
+            const val = this.resolveLiteralValue(defaultArg.name);
+            if (val !== void 0)
+              schema.default = val;
+          } else if (t11.isObjectExpression(defaultArg)) {
             const defaultObj = {};
-            node.arguments[0].properties.forEach((prop) => {
+            defaultArg.properties.forEach((prop) => {
               if (t11.isObjectProperty(prop) && (t11.isIdentifier(prop.key) || t11.isStringLiteral(prop.key)) && (t11.isStringLiteral(prop.value) || t11.isNumericLiteral(prop.value) || t11.isBooleanLiteral(prop.value))) {
                 const key = t11.isIdentifier(prop.key) ? prop.key.name : prop.key.value;
                 const value = t11.isStringLiteral(prop.value) ? prop.value.value : t11.isNumericLiteral(prop.value) ? prop.value.value : t11.isBooleanLiteral(prop.value) ? prop.value.value : null;
@@ -17961,6 +18076,7 @@ function applyExcludeSchemas(document, mergedSchemas, excludedSchemas) {
   if (excludedNames.size === 0)
     return;
   walkAndInline(document, excludedSchemas, excludedNames, /* @__PURE__ */ new Set());
+  walkAndInline(mergedSchemas, excludedSchemas, excludedNames, /* @__PURE__ */ new Set());
   for (const name of excludedNames) {
     delete mergedSchemas[name];
   }