next-openapi-gen 1.0.6 → 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
    */

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
    */

package/dist/next/index.js

@@ -3894,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);
@@ -3914,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" };
       }
@@ -12205,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.6",
+  "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",