next-openapi-gen 1.0.5 → 1.0.7

package/dist/cli.js

@@ -3311,6 +3311,7 @@ function processZodPrimitiveNode(node, context) {
       schema = { type: "array", items: itemsType };
       break;
     }
+    case "nativeEnum":
     case "enum":
       if (node.arguments.length > 0 && t6.isArrayExpression(node.arguments[0])) {
         const enumValues = node.arguments[0].elements.filter((el) => t6.isStringLiteral(el) || t6.isNumericLiteral(el)).map((el) => el.value);
@@ -3331,6 +3332,14 @@ function processZodPrimitiveNode(node, context) {
           type: "string",
           enum: enumValues
         } : { type: "string" };
+      } else if (node.arguments.length > 0 && t6.isIdentifier(node.arguments[0]) && context.resolveEnumValues) {
+        const resolved = context.resolveEnumValues(node.arguments[0].name);
+        if (resolved && resolved.length > 0) {
+          const valueType = typeof resolved[0] === "number" ? "number" : "string";
+          schema = { type: valueType, enum: resolved };
+        } else {
+          schema = { type: "string" };
+        }
       } else {
         schema = { type: "string" };
       }
@@ -11622,9 +11631,93 @@ var ZodSchemaConverter = class {
       },
       getReferenceSchema: (schemaName) => ({
         $ref: `#/components/schemas/${this.getSchemaReferenceName(schemaName)}`
-      })
+      }),
+      resolveEnumValues: (name) => this.resolveEnumValues(name)
     });
   }
+  /**
+   * Resolve enum values from a TS enum declaration or an `as const` object by identifier name.
+   * Searches the current file first, then follows imports.
+   */
+  resolveEnumValues(name) {
+    const extractFromAST = (ast) => {
+      let result = null;
+      resolvedTraverse(ast, {
+        TSEnumDeclaration: (nodePath) => {
+          if (result)
+            return;
+          if (nodePath.node.id && t8.isIdentifier(nodePath.node.id, { name })) {
+            const values = [];
+            for (const member of nodePath.node.members) {
+              if (t8.isTSEnumMember(member) && member.initializer) {
+                if (t8.isStringLiteral(member.initializer)) {
+                  values.push(member.initializer.value);
+                } else if (t8.isNumericLiteral(member.initializer)) {
+                  values.push(member.initializer.value);
+                }
+              }
+            }
+            if (values.length > 0) {
+              result = values;
+            }
+          }
+        },
+        VariableDeclarator: (nodePath) => {
+          if (result)
+            return;
+          if (!t8.isIdentifier(nodePath.node.id, { name }) || !nodePath.node.init)
+            return;
+          let initNode = nodePath.node.init;
+          if (t8.isTSAsExpression(initNode) || t8.isTSSatisfiesExpression(initNode)) {
+            initNode = initNode.expression;
+          }
+          if (t8.isObjectExpression(initNode)) {
+            const values = [];
+            for (const prop of initNode.properties) {
+              if (t8.isObjectProperty(prop)) {
+                if (t8.isStringLiteral(prop.value)) {
+                  values.push(prop.value.value);
+                } else if (t8.isNumericLiteral(prop.value)) {
+                  values.push(prop.value.value);
+                }
+              }
+            }
+            if (values.length > 0) {
+              result = values;
+            }
+          } else if (t8.isArrayExpression(initNode)) {
+            const values = [];
+            for (const element of initNode.elements) {
+              if (t8.isStringLiteral(element)) {
+                values.push(element.value);
+              } else if (t8.isNumericLiteral(element)) {
+                values.push(element.value);
+              }
+            }
+            if (values.length > 0) {
+              result = values;
+            }
+          }
+        }
+      });
+      return result;
+    };
+    if (this.currentAST) {
+      const values = extractFromAST(this.currentAST);
+      if (values)
+        return values;
+    }
+    if (this.currentImports && this.currentFilePath && this.currentImports[name]) {
+      const resolvedPath = this.resolveImportPath(this.currentFilePath, this.currentImports[name]);
+      if (resolvedPath) {
+        const importedAST = this.parseFileWithCache(resolvedPath);
+        if (importedAST) {
+          return extractFromAST(importedAST);
+        }
+      }
+    }
+    return null;
+  }
   /**
    * Extract description from method arguments if it's a .describe() call
    */
@@ -16269,12 +16362,14 @@ var NextFrameworkSource = class {
   }
   getScanRoots() {
     const roots = [this.config.apiDir];
+    const resolvedApiDir = path22.resolve(this.config.apiDir);
     const candidateRoots = [
       path22.join(process.cwd(), "src", "app", "api"),
       path22.join(process.cwd(), "app", "api")
     ];
     candidateRoots.forEach((candidateRoot) => {
-      if (fs17.existsSync(candidateRoot) && path22.resolve(candidateRoot) !== path22.resolve(this.config.apiDir) && !roots.includes(candidateRoot)) {
+      const resolvedCandidate = path22.resolve(candidateRoot);
+      if (fs17.existsSync(candidateRoot) && resolvedCandidate !== resolvedApiDir && !resolvedApiDir.startsWith(resolvedCandidate + path22.sep) && !roots.includes(candidateRoot)) {
         roots.push(candidateRoot);
       }
     });

package/dist/index.js

@@ -2860,6 +2860,7 @@ function processZodPrimitiveNode(node, context) {
       schema = { type: "array", items: itemsType };
       break;
     }
+    case "nativeEnum":
     case "enum":
       if (node.arguments.length > 0 && t6.isArrayExpression(node.arguments[0])) {
         const enumValues = node.arguments[0].elements.filter((el) => t6.isStringLiteral(el) || t6.isNumericLiteral(el)).map((el) => el.value);
@@ -2880,6 +2881,14 @@ function processZodPrimitiveNode(node, context) {
           type: "string",
           enum: enumValues
         } : { type: "string" };
+      } else if (node.arguments.length > 0 && t6.isIdentifier(node.arguments[0]) && context.resolveEnumValues) {
+        const resolved = context.resolveEnumValues(node.arguments[0].name);
+        if (resolved && resolved.length > 0) {
+          const valueType = typeof resolved[0] === "number" ? "number" : "string";
+          schema = { type: valueType, enum: resolved };
+        } else {
+          schema = { type: "string" };
+        }
       } else {
         schema = { type: "string" };
       }
@@ -11171,9 +11180,93 @@ var ZodSchemaConverter = class {
       },
       getReferenceSchema: (schemaName) => ({
         $ref: `#/components/schemas/${this.getSchemaReferenceName(schemaName)}`
-      })
+      }),
+      resolveEnumValues: (name) => this.resolveEnumValues(name)
     });
   }
+  /**
+   * Resolve enum values from a TS enum declaration or an `as const` object by identifier name.
+   * Searches the current file first, then follows imports.
+   */
+  resolveEnumValues(name) {
+    const extractFromAST = (ast) => {
+      let result = null;
+      resolvedTraverse(ast, {
+        TSEnumDeclaration: (nodePath) => {
+          if (result)
+            return;
+          if (nodePath.node.id && t8.isIdentifier(nodePath.node.id, { name })) {
+            const values = [];
+            for (const member of nodePath.node.members) {
+              if (t8.isTSEnumMember(member) && member.initializer) {
+                if (t8.isStringLiteral(member.initializer)) {
+                  values.push(member.initializer.value);
+                } else if (t8.isNumericLiteral(member.initializer)) {
+                  values.push(member.initializer.value);
+                }
+              }
+            }
+            if (values.length > 0) {
+              result = values;
+            }
+          }
+        },
+        VariableDeclarator: (nodePath) => {
+          if (result)
+            return;
+          if (!t8.isIdentifier(nodePath.node.id, { name }) || !nodePath.node.init)
+            return;
+          let initNode = nodePath.node.init;
+          if (t8.isTSAsExpression(initNode) || t8.isTSSatisfiesExpression(initNode)) {
+            initNode = initNode.expression;
+          }
+          if (t8.isObjectExpression(initNode)) {
+            const values = [];
+            for (const prop of initNode.properties) {
+              if (t8.isObjectProperty(prop)) {
+                if (t8.isStringLiteral(prop.value)) {
+                  values.push(prop.value.value);
+                } else if (t8.isNumericLiteral(prop.value)) {
+                  values.push(prop.value.value);
+                }
+              }
+            }
+            if (values.length > 0) {
+              result = values;
+            }
+          } else if (t8.isArrayExpression(initNode)) {
+            const values = [];
+            for (const element of initNode.elements) {
+              if (t8.isStringLiteral(element)) {
+                values.push(element.value);
+              } else if (t8.isNumericLiteral(element)) {
+                values.push(element.value);
+              }
+            }
+            if (values.length > 0) {
+              result = values;
+            }
+          }
+        }
+      });
+      return result;
+    };
+    if (this.currentAST) {
+      const values = extractFromAST(this.currentAST);
+      if (values)
+        return values;
+    }
+    if (this.currentImports && this.currentFilePath && this.currentImports[name]) {
+      const resolvedPath = this.resolveImportPath(this.currentFilePath, this.currentImports[name]);
+      if (resolvedPath) {
+        const importedAST = this.parseFileWithCache(resolvedPath);
+        if (importedAST) {
+          return extractFromAST(importedAST);
+        }
+      }
+    }
+    return null;
+  }
   /**
    * Extract description from method arguments if it's a .describe() call
    */
@@ -15971,12 +16064,14 @@ var NextFrameworkSource = class {
   }
   getScanRoots() {
     const roots = [this.config.apiDir];
+    const resolvedApiDir = path19.resolve(this.config.apiDir);
     const candidateRoots = [
       path19.join(process.cwd(), "src", "app", "api"),
       path19.join(process.cwd(), "app", "api")
     ];
     candidateRoots.forEach((candidateRoot) => {
-      if (fs15.existsSync(candidateRoot) && path19.resolve(candidateRoot) !== path19.resolve(this.config.apiDir) && !roots.includes(candidateRoot)) {
+      const resolvedCandidate = path19.resolve(candidateRoot);
+      if (fs15.existsSync(candidateRoot) && resolvedCandidate !== resolvedApiDir && !resolvedApiDir.startsWith(resolvedCandidate + path19.sep) && !roots.includes(candidateRoot)) {
         roots.push(candidateRoot);
       }
     });

package/dist/next/index.js

@@ -1938,12 +1938,14 @@ var NextFrameworkSource = class {
   }
   getScanRoots() {
     const roots = [this.config.apiDir];
+    const resolvedApiDir = path5.resolve(this.config.apiDir);
     const candidateRoots = [
       path5.join(process.cwd(), "src", "app", "api"),
       path5.join(process.cwd(), "app", "api")
     ];
     candidateRoots.forEach((candidateRoot) => {
-      if (fs5.existsSync(candidateRoot) && path5.resolve(candidateRoot) !== path5.resolve(this.config.apiDir) && !roots.includes(candidateRoot)) {
+      const resolvedCandidate = path5.resolve(candidateRoot);
+      if (fs5.existsSync(candidateRoot) && resolvedCandidate !== resolvedApiDir && !resolvedApiDir.startsWith(resolvedCandidate + path5.sep) && !roots.includes(candidateRoot)) {
         roots.push(candidateRoot);
       }
     });
@@ -3892,6 +3894,7 @@ function processZodPrimitiveNode(node, context) {
       schema = { type: "array", items: itemsType };
       break;
     }
+    case "nativeEnum":
     case "enum":
       if (node.arguments.length > 0 && t7.isArrayExpression(node.arguments[0])) {
         const enumValues = node.arguments[0].elements.filter((el) => t7.isStringLiteral(el) || t7.isNumericLiteral(el)).map((el) => el.value);
@@ -3912,6 +3915,14 @@ function processZodPrimitiveNode(node, context) {
           type: "string",
           enum: enumValues
         } : { type: "string" };
+      } else if (node.arguments.length > 0 && t7.isIdentifier(node.arguments[0]) && context.resolveEnumValues) {
+        const resolved = context.resolveEnumValues(node.arguments[0].name);
+        if (resolved && resolved.length > 0) {
+          const valueType = typeof resolved[0] === "number" ? "number" : "string";
+          schema = { type: valueType, enum: resolved };
+        } else {
+          schema = { type: "string" };
+        }
       } else {
         schema = { type: "string" };
       }
@@ -12203,9 +12214,93 @@ var ZodSchemaConverter = class {
       },
       getReferenceSchema: (schemaName) => ({
         $ref: `#/components/schemas/${this.getSchemaReferenceName(schemaName)}`
-      })
+      }),
+      resolveEnumValues: (name) => this.resolveEnumValues(name)
     });
   }
+  /**
+   * Resolve enum values from a TS enum declaration or an `as const` object by identifier name.
+   * Searches the current file first, then follows imports.
+   */
+  resolveEnumValues(name) {
+    const extractFromAST = (ast) => {
+      let result = null;
+      resolvedTraverse(ast, {
+        TSEnumDeclaration: (nodePath) => {
+          if (result)
+            return;
+          if (nodePath.node.id && t9.isIdentifier(nodePath.node.id, { name })) {
+            const values = [];
+            for (const member of nodePath.node.members) {
+              if (t9.isTSEnumMember(member) && member.initializer) {
+                if (t9.isStringLiteral(member.initializer)) {
+                  values.push(member.initializer.value);
+                } else if (t9.isNumericLiteral(member.initializer)) {
+                  values.push(member.initializer.value);
+                }
+              }
+            }
+            if (values.length > 0) {
+              result = values;
+            }
+          }
+        },
+        VariableDeclarator: (nodePath) => {
+          if (result)
+            return;
+          if (!t9.isIdentifier(nodePath.node.id, { name }) || !nodePath.node.init)
+            return;
+          let initNode = nodePath.node.init;
+          if (t9.isTSAsExpression(initNode) || t9.isTSSatisfiesExpression(initNode)) {
+            initNode = initNode.expression;
+          }
+          if (t9.isObjectExpression(initNode)) {
+            const values = [];
+            for (const prop of initNode.properties) {
+              if (t9.isObjectProperty(prop)) {
+                if (t9.isStringLiteral(prop.value)) {
+                  values.push(prop.value.value);
+                } else if (t9.isNumericLiteral(prop.value)) {
+                  values.push(prop.value.value);
+                }
+              }
+            }
+            if (values.length > 0) {
+              result = values;
+            }
+          } else if (t9.isArrayExpression(initNode)) {
+            const values = [];
+            for (const element of initNode.elements) {
+              if (t9.isStringLiteral(element)) {
+                values.push(element.value);
+              } else if (t9.isNumericLiteral(element)) {
+                values.push(element.value);
+              }
+            }
+            if (values.length > 0) {
+              result = values;
+            }
+          }
+        }
+      });
+      return result;
+    };
+    if (this.currentAST) {
+      const values = extractFromAST(this.currentAST);
+      if (values)
+        return values;
+    }
+    if (this.currentImports && this.currentFilePath && this.currentImports[name]) {
+      const resolvedPath = this.resolveImportPath(this.currentFilePath, this.currentImports[name]);
+      if (resolvedPath) {
+        const importedAST = this.parseFileWithCache(resolvedPath);
+        if (importedAST) {
+          return extractFromAST(importedAST);
+        }
+      }
+    }
+    return null;
+  }
   /**
    * Extract description from method arguments if it's a .describe() call
    */

package/dist/react-router/index.js

@@ -2898,6 +2898,7 @@ function processZodPrimitiveNode(node, context) {
       schema = { type: "array", items: itemsType };
       break;
     }
+    case "nativeEnum":
     case "enum":
       if (node.arguments.length > 0 && t6.isArrayExpression(node.arguments[0])) {
         const enumValues = node.arguments[0].elements.filter((el) => t6.isStringLiteral(el) || t6.isNumericLiteral(el)).map((el) => el.value);
@@ -2918,6 +2919,14 @@ function processZodPrimitiveNode(node, context) {
           type: "string",
           enum: enumValues
         } : { type: "string" };
+      } else if (node.arguments.length > 0 && t6.isIdentifier(node.arguments[0]) && context.resolveEnumValues) {
+        const resolved = context.resolveEnumValues(node.arguments[0].name);
+        if (resolved && resolved.length > 0) {
+          const valueType = typeof resolved[0] === "number" ? "number" : "string";
+          schema = { type: valueType, enum: resolved };
+        } else {
+          schema = { type: "string" };
+        }
       } else {
         schema = { type: "string" };
       }
@@ -11209,9 +11218,93 @@ var ZodSchemaConverter = class {
       },
       getReferenceSchema: (schemaName) => ({
         $ref: `#/components/schemas/${this.getSchemaReferenceName(schemaName)}`
-      })
+      }),
+      resolveEnumValues: (name) => this.resolveEnumValues(name)
     });
   }
+  /**
+   * Resolve enum values from a TS enum declaration or an `as const` object by identifier name.
+   * Searches the current file first, then follows imports.
+   */
+  resolveEnumValues(name) {
+    const extractFromAST = (ast) => {
+      let result = null;
+      resolvedTraverse(ast, {
+        TSEnumDeclaration: (nodePath) => {
+          if (result)
+            return;
+          if (nodePath.node.id && t8.isIdentifier(nodePath.node.id, { name })) {
+            const values = [];
+            for (const member of nodePath.node.members) {
+              if (t8.isTSEnumMember(member) && member.initializer) {
+                if (t8.isStringLiteral(member.initializer)) {
+                  values.push(member.initializer.value);
+                } else if (t8.isNumericLiteral(member.initializer)) {
+                  values.push(member.initializer.value);
+                }
+              }
+            }
+            if (values.length > 0) {
+              result = values;
+            }
+          }
+        },
+        VariableDeclarator: (nodePath) => {
+          if (result)
+            return;
+          if (!t8.isIdentifier(nodePath.node.id, { name }) || !nodePath.node.init)
+            return;
+          let initNode = nodePath.node.init;
+          if (t8.isTSAsExpression(initNode) || t8.isTSSatisfiesExpression(initNode)) {
+            initNode = initNode.expression;
+          }
+          if (t8.isObjectExpression(initNode)) {
+            const values = [];
+            for (const prop of initNode.properties) {
+              if (t8.isObjectProperty(prop)) {
+                if (t8.isStringLiteral(prop.value)) {
+                  values.push(prop.value.value);
+                } else if (t8.isNumericLiteral(prop.value)) {
+                  values.push(prop.value.value);
+                }
+              }
+            }
+            if (values.length > 0) {
+              result = values;
+            }
+          } else if (t8.isArrayExpression(initNode)) {
+            const values = [];
+            for (const element of initNode.elements) {
+              if (t8.isStringLiteral(element)) {
+                values.push(element.value);
+              } else if (t8.isNumericLiteral(element)) {
+                values.push(element.value);
+              }
+            }
+            if (values.length > 0) {
+              result = values;
+            }
+          }
+        }
+      });
+      return result;
+    };
+    if (this.currentAST) {
+      const values = extractFromAST(this.currentAST);
+      if (values)
+        return values;
+    }
+    if (this.currentImports && this.currentFilePath && this.currentImports[name]) {
+      const resolvedPath = this.resolveImportPath(this.currentFilePath, this.currentImports[name]);
+      if (resolvedPath) {
+        const importedAST = this.parseFileWithCache(resolvedPath);
+        if (importedAST) {
+          return extractFromAST(importedAST);
+        }
+      }
+    }
+    return null;
+  }
   /**
    * Extract description from method arguments if it's a .describe() call
    */

package/dist/vite/index.js

@@ -2898,6 +2898,7 @@ function processZodPrimitiveNode(node, context) {
       schema = { type: "array", items: itemsType };
       break;
     }
+    case "nativeEnum":
     case "enum":
       if (node.arguments.length > 0 && t6.isArrayExpression(node.arguments[0])) {
         const enumValues = node.arguments[0].elements.filter((el) => t6.isStringLiteral(el) || t6.isNumericLiteral(el)).map((el) => el.value);
@@ -2918,6 +2919,14 @@ function processZodPrimitiveNode(node, context) {
           type: "string",
           enum: enumValues
         } : { type: "string" };
+      } else if (node.arguments.length > 0 && t6.isIdentifier(node.arguments[0]) && context.resolveEnumValues) {
+        const resolved = context.resolveEnumValues(node.arguments[0].name);
+        if (resolved && resolved.length > 0) {
+          const valueType = typeof resolved[0] === "number" ? "number" : "string";
+          schema = { type: valueType, enum: resolved };
+        } else {
+          schema = { type: "string" };
+        }
       } else {
         schema = { type: "string" };
       }
@@ -11209,9 +11218,93 @@ var ZodSchemaConverter = class {
       },
       getReferenceSchema: (schemaName) => ({
         $ref: `#/components/schemas/${this.getSchemaReferenceName(schemaName)}`
-      })
+      }),
+      resolveEnumValues: (name) => this.resolveEnumValues(name)
     });
   }
+  /**
+   * Resolve enum values from a TS enum declaration or an `as const` object by identifier name.
+   * Searches the current file first, then follows imports.
+   */
+  resolveEnumValues(name) {
+    const extractFromAST = (ast) => {
+      let result = null;
+      resolvedTraverse(ast, {
+        TSEnumDeclaration: (nodePath) => {
+          if (result)
+            return;
+          if (nodePath.node.id && t8.isIdentifier(nodePath.node.id, { name })) {
+            const values = [];
+            for (const member of nodePath.node.members) {
+              if (t8.isTSEnumMember(member) && member.initializer) {
+                if (t8.isStringLiteral(member.initializer)) {
+                  values.push(member.initializer.value);
+                } else if (t8.isNumericLiteral(member.initializer)) {
+                  values.push(member.initializer.value);
+                }
+              }
+            }
+            if (values.length > 0) {
+              result = values;
+            }
+          }
+        },
+        VariableDeclarator: (nodePath) => {
+          if (result)
+            return;
+          if (!t8.isIdentifier(nodePath.node.id, { name }) || !nodePath.node.init)
+            return;
+          let initNode = nodePath.node.init;
+          if (t8.isTSAsExpression(initNode) || t8.isTSSatisfiesExpression(initNode)) {
+            initNode = initNode.expression;
+          }
+          if (t8.isObjectExpression(initNode)) {
+            const values = [];
+            for (const prop of initNode.properties) {
+              if (t8.isObjectProperty(prop)) {
+                if (t8.isStringLiteral(prop.value)) {
+                  values.push(prop.value.value);
+                } else if (t8.isNumericLiteral(prop.value)) {
+                  values.push(prop.value.value);
+                }
+              }
+            }
+            if (values.length > 0) {
+              result = values;
+            }
+          } else if (t8.isArrayExpression(initNode)) {
+            const values = [];
+            for (const element of initNode.elements) {
+              if (t8.isStringLiteral(element)) {
+                values.push(element.value);
+              } else if (t8.isNumericLiteral(element)) {
+                values.push(element.value);
+              }
+            }
+            if (values.length > 0) {
+              result = values;
+            }
+          }
+        }
+      });
+      return result;
+    };
+    if (this.currentAST) {
+      const values = extractFromAST(this.currentAST);
+      if (values)
+        return values;
+    }
+    if (this.currentImports && this.currentFilePath && this.currentImports[name]) {
+      const resolvedPath = this.resolveImportPath(this.currentFilePath, this.currentImports[name]);
+      if (resolvedPath) {
+        const importedAST = this.parseFileWithCache(resolvedPath);
+        if (importedAST) {
+          return extractFromAST(importedAST);
+        }
+      }
+    }
+    return null;
+  }
   /**
    * Extract description from method arguments if it's a .describe() call
    */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next-openapi-gen",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "Automatically generate OpenAPI 3.0, 3.1, and 3.2 documentation from Next.js projects, with support for Zod schemas, TypeScript types, and reusable OpenAPI fragments.",
   "keywords": [
     "api",