next-openapi-gen 1.4.1 → 1.4.3

package/dist/next/index.js

@@ -923,7 +923,6 @@ function parseJSDocBlock(commentValue, filePath) {
     result.summary = explicitSummary;
   }
   result.description = extractLineValue(normalizedComment, "@description");
-  result.tag = extractLineValue(normalizedComment, "@tag");
   result.tagSummary = extractLineValue(normalizedComment, "@tagSummary");
   result.tagKind = extractLineValue(normalizedComment, "@tagKind");
   result.tagParent = extractLineValue(normalizedComment, "@tagParent");
@@ -957,17 +956,28 @@ function parseJSDocBlock(commentValue, filePath) {
   if (Array.isArray(responsePrefixEncoding)) {
     result.responsePrefixEncoding = responsePrefixEncoding;
   }
-  const parsedResponse = parseResponseTag(normalizedComment);
-  if (parsedResponse) {
-    result.successCode = parsedResponse.successCode;
-    result.responseType = parsedResponse.responseType;
-    if (!result.responseDescription && parsedResponse.responseDescription) {
-      result.responseDescription = parsedResponse.responseDescription;
+  const responseMatches = [...normalizedComment.matchAll(/@response\s+([^\n\r@]+)/g)];
+  if (responseMatches.length > 0) {
+    const firstRaw = responseMatches[0]?.[1]?.trim();
+    if (firstRaw) {
+      const parsedResponse = parseResponseRawValue(firstRaw);
+      result.successCode = parsedResponse.successCode;
+      result.responseType = parsedResponse.responseType;
+      if (!result.responseDescription && parsedResponse.responseDescription) {
+        result.responseDescription = parsedResponse.responseDescription;
+      }
+    }
+    const extraResponses = responseMatches.slice(1).map((m) => m[1]?.trim()).filter((t17) => Boolean(t17));
+    if (extraResponses.length > 0) {
+      result.addResponses = extraResponses.join(",");
     }
   }
   const addMatches = [...normalizedComment.matchAll(/@add\s+([^\n\r@]*)/g)];
   if (addMatches.length > 0) {
-    result.addResponses = addMatches.map((match) => match[1]?.trim() || "").filter(Boolean).join(",");
+    const addEntries = addMatches.map((match) => match[1]?.trim() || "").filter(Boolean).join(",");
+    if (addEntries) {
+      result.addResponses = result.addResponses ? `${result.addResponses},${addEntries}` : addEntries;
+    }
   }
   const examples = collectExampleDefinitions(normalizedComment, "@examples", filePath);
   result.requestExamples = buildExampleMap(examples.definitions, "request");
@@ -980,6 +990,17 @@ function parseJSDocBlock(commentValue, filePath) {
   if (additionalTags.length > 0) {
     result.tags = additionalTags;
   }
+  const tagMatches = [...normalizedComment.matchAll(/@tag\s+([^\n\r@]*)/g)];
+  if (tagMatches.length > 0) {
+    const primaryTag = tagMatches[0]?.[1]?.trim();
+    if (primaryTag) {
+      result.tag = primaryTag;
+    }
+    const extraTags = tagMatches.slice(1).map((m) => m[1]?.trim()).filter((t17) => Boolean(t17));
+    if (extraTags.length > 0) {
+      result.tags = [...result.tags ?? [], ...extraTags];
+    }
+  }
   const servers = parseServersTag(normalizedComment);
   if (servers.length > 0) {
     result.servers = servers;
@@ -1182,11 +1203,7 @@ function parseOpenApiOverrideTag(commentValue) {
 function extractTypeFromComment(commentValue, tag) {
   return commentValue.match(new RegExp(`^\\s*\\*?\\s*${tag}\\s+([\\w<>,\\s[\\]]+)`, "m"))?.[1]?.trim() || "";
 }
-function parseResponseTag(commentValue) {
-  const rawValue = commentValue.match(/@response\s+([^\n\r@]+)/)?.[1]?.trim();
-  if (!rawValue) {
-    return null;
-  }
+function parseResponseRawValue(rawValue) {
   if (isStatusCodeToken(rawValue)) {
     return {
       responseDescription: "",
@@ -1635,6 +1652,18 @@ function getOperationId(routePath, method) {
   const operation = routePath.replaceAll(/\//g, "-").replace(/^-/, "");
   return `${method}-${operation}`;
 }
+function deepMerge(target, source) {
+  for (const key of Object.keys(source)) {
+    const sourceVal = source[key];
+    const targetVal = target[key];
+    if (sourceVal !== null && typeof sourceVal === "object" && !Array.isArray(sourceVal) && targetVal !== null && typeof targetVal === "object" && !Array.isArray(targetVal)) {
+      deepMerge(targetVal, sourceVal);
+    } else {
+      target[key] = sourceVal;
+    }
+  }
+  return target;
+}
 var DEFAULT_PARSER_OPTIONS = {
   sourceType: "module",
   plugins: ["typescript", "jsx", "decorators-legacy"]
@@ -3455,23 +3484,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;
   }
   /**
@@ -13794,6 +13858,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.
@@ -13862,6 +13978,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) {
@@ -13960,53 +14084,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);
@@ -14082,21 +14213,27 @@ 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;
@@ -14120,17 +14257,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;
@@ -17520,7 +17662,7 @@ var OperationProcessor = class {
     this.applyResponseHeaders(definition, responseHeaders);
     this.applyResponseLinks(definition, responseLinks);
     if (openapiOverride) {
-      Object.assign(definition, structuredClone(openapiOverride));
+      deepMerge(definition, structuredClone(openapiOverride));
     }
     return {
       routePath,