next-openapi-gen 0.4.5 → 0.5.0

package/dist/lib/route-processor.js

@@ -50,7 +50,7 @@ export class RouteProcessor {
                             const routePath = this.getRoutePath(filePath);
                             const pathParams = extractPathParameters(routePath);
                             // If we have path parameters but no pathParamsType defined, we should log a warning
-                            if (pathParams.length > 0 && !dataTypes.pathParams) {
+                            if (pathParams.length > 0 && !dataTypes.pathParamsType) {
                                 console.warn(`Route ${routePath} contains path parameters ${pathParams.join(", ")} but no @pathParams type is defined.`);
                             }
                             this.addRouteToPaths(declaration.id.name, filePath, dataTypes);
@@ -67,7 +67,7 @@ export class RouteProcessor {
                                     (this.config.includeOpenApiRoutes && dataTypes.isOpenApi)) {
                                     const routePath = this.getRoutePath(filePath);
                                     const pathParams = extractPathParameters(routePath);
-                                    if (pathParams.length > 0 && !dataTypes.pathParams) {
+                                    if (pathParams.length > 0 && !dataTypes.pathParamsType) {
                                         console.warn(`Route ${routePath} contains path parameters ${pathParams.join(", ")} but no @pathParams type is defined.`);
                                     }
                                     this.addRouteToPaths(decl.id.name, filePath, dataTypes);

package/dist/lib/schema-processor.js

@@ -26,6 +26,14 @@ export class SchemaProcessor {
      * Get all defined schemas (for components.schemas section)
      */
     getDefinedSchemas() {
+        // If using Zod, also include all processed Zod schemas
+        if (this.schemaType === "zod" && this.zodSchemaConverter) {
+            const zodSchemas = this.zodSchemaConverter.getProcessedSchemas();
+            return {
+                ...this.openapiDefinitions,
+                ...zodSchemas,
+            };
+        }
         return this.openapiDefinitions;
     }
     findSchemaDefinition(schemaName, contentType) {
@@ -441,10 +449,7 @@ export class SchemaProcessor {
         if (description) {
             options.description = description;
         }
-        if (this.contentType === "params") {
-            options.required = !isOptional;
-        }
-        else if (this.contentType === "body") {
+        if (this.contentType === "body") {
             options.nullable = isOptional;
         }
         return options;
@@ -526,7 +531,7 @@ export class SchemaProcessor {
                     schema: {
                         type: value.type,
                     },
-                    required: isPathParam ? true : value.required, // Path parameters are always required
+                    required: isPathParam ? true : !!value.required, // Path parameters are always required
                 };
                 if (value.enum) {
                     param.schema.enum = value.enum;
@@ -589,6 +594,19 @@ export class SchemaProcessor {
             this.findSchemaDefinition(responseType, "response");
             responses = this.openapiDefinitions[responseType] || {};
         }
+        if (this.schemaType === "zod") {
+            const schemasToProcess = [
+                paramsType,
+                pathParamsType,
+                bodyType,
+                responseType,
+            ].filter(Boolean);
+            schemasToProcess.forEach((schemaName) => {
+                if (!this.openapiDefinitions[schemaName]) {
+                    this.findSchemaDefinition(schemaName, "");
+                }
+            });
+        }
         return {
             params,
             pathParams,

package/dist/lib/utils.js

@@ -18,10 +18,10 @@ export function extractJSDocComments(path) {
     const comments = path.node.leadingComments;
     let summary = "";
     let description = "";
-    let params = "";
-    let pathParams = "";
-    let body = "";
-    let response = "";
+    let paramsType = "";
+    let pathParamsType = "";
+    let bodyType = "";
+    let responseType = "";
     let auth = "";
     let isOpenApi = false;
     if (comments) {
@@ -51,16 +51,16 @@ export function extractJSDocComments(path) {
                 description = commentValue.match(regex)[1].trim();
             }
             if (commentValue.includes("@params")) {
-                params = extractTypeFromComment(commentValue, "@params");
+                paramsType = extractTypeFromComment(commentValue, "@params");
             }
             if (commentValue.includes("@pathParams")) {
-                pathParams = extractTypeFromComment(commentValue, "@pathParams");
+                pathParamsType = extractTypeFromComment(commentValue, "@pathParams");
             }
             if (commentValue.includes("@body")) {
-                body = extractTypeFromComment(commentValue, "@body");
+                bodyType = extractTypeFromComment(commentValue, "@body");
             }
             if (commentValue.includes("@response")) {
-                response = extractTypeFromComment(commentValue, "@response");
+                responseType = extractTypeFromComment(commentValue, "@response");
             }
         });
     }
@@ -68,10 +68,10 @@ export function extractJSDocComments(path) {
         auth,
         summary,
         description,
-        params,
-        pathParams,
-        body,
-        response,
+        paramsType,
+        pathParamsType,
+        bodyType,
+        responseType,
         isOpenApi,
     };
 }

package/dist/lib/zod-converter.js

@@ -9,7 +9,6 @@ import * as t from "@babel/types";
 export class ZodSchemaConverter {
     schemaDir;
     zodSchemas = {};
-    processedFiles = {};
     processingSchemas = new Set();
     processedModules = new Set();
     constructor(schemaDir) {
@@ -111,10 +110,6 @@ export class ZodSchemaConverter {
                 }
                 else if (file.endsWith(".ts") || file.endsWith(".tsx")) {
                     this.processFileForZodSchema(filePath, schemaName);
-                    // Stop searching if we found the schema
-                    if (this.zodSchemas[schemaName]) {
-                        break;
-                    }
                 }
             }
         }
@@ -126,12 +121,12 @@ export class ZodSchemaConverter {
      * Process a file to find Zod schema definitions
      */
     processFileForZodSchema(filePath, schemaName) {
-        // Skip if already processed
-        if (this.processedFiles[filePath])
-            return;
-        this.processedFiles[filePath] = true;
         try {
             const content = fs.readFileSync(filePath, "utf-8");
+            // Check if file contains schema we are looking for
+            if (!content.includes(schemaName)) {
+                return;
+            }
             // Parse the file
             const ast = parse(content, {
                 sourceType: "module",
@@ -161,9 +156,25 @@ export class ZodSchemaConverter {
                             if (t.isIdentifier(declaration.id) &&
                                 declaration.id.name === schemaName &&
                                 declaration.init) {
-                                const schema = this.processZodNode(declaration.init);
-                                if (schema) {
-                                    this.zodSchemas[schemaName] = schema;
+                                // Check if this is a call expression with .extend()
+                                if (t.isCallExpression(declaration.init) &&
+                                    t.isMemberExpression(declaration.init.callee) &&
+                                    t.isIdentifier(declaration.init.callee.property) &&
+                                    declaration.init.callee.property.name === "extend") {
+                                    const schema = this.processZodNode(declaration.init);
+                                    if (schema) {
+                                        this.zodSchemas[schemaName] = schema;
+                                    }
+                                }
+                                // Existing code for z.object({...})
+                                else if (t.isCallExpression(declaration.init) &&
+                                    t.isMemberExpression(declaration.init.callee) &&
+                                    t.isIdentifier(declaration.init.callee.object) &&
+                                    declaration.init.callee.object.name === "z") {
+                                    const schema = this.processZodNode(declaration.init);
+                                    if (schema) {
+                                        this.zodSchemas[schemaName] = schema;
+                                    }
                                 }
                             }
                         });
@@ -208,9 +219,22 @@ export class ZodSchemaConverter {
                     if (t.isIdentifier(path.node.id) &&
                         path.node.id.name === schemaName &&
                         path.node.init) {
-                        const schema = this.processZodNode(path.node.init);
-                        if (schema) {
-                            this.zodSchemas[schemaName] = schema;
+                        // Check if it is .extend()
+                        if (t.isCallExpression(path.node.init) &&
+                            t.isMemberExpression(path.node.init.callee) &&
+                            t.isIdentifier(path.node.init.callee.property) &&
+                            path.node.init.callee.property.name === "extend") {
+                            const schema = this.processZodNode(path.node.init);
+                            if (schema) {
+                                this.zodSchemas[schemaName] = schema;
+                            }
+                        }
+                        // Existing code
+                        else {
+                            const schema = this.processZodNode(path.node.init);
+                            if (schema) {
+                                this.zodSchemas[schemaName] = schema;
+                            }
                         }
                     }
                 },
@@ -243,10 +267,64 @@ export class ZodSchemaConverter {
             console.error(`Error processing file ${filePath} for schema ${schemaName}: ${error}`);
         }
     }
+    /**
+     * Process all exported schemas in a file, not just the one we're looking for
+     */
+    processAllSchemasInFile(filePath) {
+        try {
+            const content = fs.readFileSync(filePath, "utf-8");
+            const ast = parse(content, {
+                sourceType: "module",
+                plugins: ["typescript", "decorators-legacy"],
+            });
+            traverse.default(ast, {
+                ExportNamedDeclaration: (path) => {
+                    if (t.isVariableDeclaration(path.node.declaration)) {
+                        path.node.declaration.declarations.forEach((declaration) => {
+                            if (t.isIdentifier(declaration.id) &&
+                                declaration.init &&
+                                t.isCallExpression(declaration.init) &&
+                                t.isMemberExpression(declaration.init.callee) &&
+                                t.isIdentifier(declaration.init.callee.object) &&
+                                declaration.init.callee.object.name === "z") {
+                                const schemaName = declaration.id.name;
+                                if (!this.zodSchemas[schemaName] &&
+                                    !this.processingSchemas.has(schemaName)) {
+                                    this.processingSchemas.add(schemaName);
+                                    const schema = this.processZodNode(declaration.init);
+                                    if (schema) {
+                                        this.zodSchemas[schemaName] = schema;
+                                    }
+                                    this.processingSchemas.delete(schemaName);
+                                }
+                            }
+                        });
+                    }
+                },
+            });
+        }
+        catch (error) {
+            console.error(`Error processing all schemas in file ${filePath}: ${error}`);
+        }
+    }
     /**
      * Process a Zod node and convert it to OpenAPI schema
      */
     processZodNode(node) {
+        // Handle reference to another schema (e.g. UserBaseSchema.extend)
+        if (t.isCallExpression(node) &&
+            t.isMemberExpression(node.callee) &&
+            t.isIdentifier(node.callee.object) &&
+            t.isIdentifier(node.callee.property) &&
+            node.callee.property.name === "extend") {
+            const baseSchemaName = node.callee.object.name;
+            // Check if the base schema already exists
+            if (!this.zodSchemas[baseSchemaName]) {
+                // Try to find the basic pattern
+                this.convertZodSchemaToOpenApi(baseSchemaName);
+            }
+            return this.processZodChain(node);
+        }
         // Handle z.object({...})
         if (t.isCallExpression(node) &&
             t.isMemberExpression(node.callee) &&
@@ -461,7 +539,7 @@ export class ZodSchemaConverter {
         const objectExpression = node.arguments[0];
         const properties = {};
         const required = [];
-        objectExpression.properties.forEach((prop) => {
+        objectExpression.properties.forEach((prop, index) => {
             if (t.isObjectProperty(prop)) {
                 let propName;
                 // Handle both identifier and string literal keys
@@ -472,15 +550,56 @@ export class ZodSchemaConverter {
                     propName = prop.key.value;
                 }
                 else {
+                    console.log(`Skipping property ${index} - unsupported key type`);
                     return; // Skip if key is not identifier or string literal
                 }
+                // Check if the property value is an identifier (reference to another schema)
+                if (t.isIdentifier(prop.value)) {
+                    const referencedSchemaName = prop.value.name;
+                    // Try to find and convert the referenced schema
+                    if (!this.zodSchemas[referencedSchemaName]) {
+                        this.convertZodSchemaToOpenApi(referencedSchemaName);
+                    }
+                    // Create a reference
+                    properties[propName] = {
+                        $ref: `#/components/schemas/${referencedSchemaName}`,
+                    };
+                    required.push(propName); // Assuming it's required unless marked optional
+                }
+                // For array of schemas (like z.array(PaymentMethodSchema))
+                if (t.isCallExpression(prop.value) &&
+                    t.isMemberExpression(prop.value.callee) &&
+                    t.isIdentifier(prop.value.callee.object) &&
+                    prop.value.callee.object.name === "z" &&
+                    t.isIdentifier(prop.value.callee.property) &&
+                    prop.value.callee.property.name === "array" &&
+                    prop.value.arguments.length > 0 &&
+                    t.isIdentifier(prop.value.arguments[0])) {
+                    const itemSchemaName = prop.value.arguments[0].name;
+                    // Try to find and convert the referenced schema
+                    if (!this.zodSchemas[itemSchemaName]) {
+                        this.convertZodSchemaToOpenApi(itemSchemaName);
+                    }
+                    // Process as array with reference
+                    const arraySchema = this.processZodNode(prop.value);
+                    arraySchema.items = {
+                        $ref: `#/components/schemas/${itemSchemaName}`,
+                    };
+                    properties[propName] = arraySchema;
+                    const isOptional = this.isOptional(prop.value) || this.hasOptionalMethod(prop.value);
+                    if (!isOptional) {
+                        required.push(propName);
+                    }
+                }
                 // Process property value (a Zod schema)
                 const propSchema = this.processZodNode(prop.value);
                 if (propSchema) {
                     properties[propName] = propSchema;
                     // If the property is not marked as optional, add it to required list
+                    const isOptional = 
                     // @ts-ignore
-                    if (!this.isOptional(prop.value)) {
+                    this.isOptional(prop.value) || this.hasOptionalMethod(prop.value);
+                    if (!isOptional) {
                         required.push(propName);
                     }
                 }
@@ -534,7 +653,20 @@ export class ZodSchemaConverter {
             case "array":
                 let itemsType = { type: "string" };
                 if (node.arguments.length > 0) {
-                    itemsType = this.processZodNode(node.arguments[0]);
+                    // Check if argument is an identifier (schema reference)
+                    if (t.isIdentifier(node.arguments[0])) {
+                        const schemaName = node.arguments[0].name;
+                        // Try to find and convert the referenced schema
+                        if (!this.zodSchemas[schemaName]) {
+                            this.convertZodSchemaToOpenApi(schemaName);
+                        }
+                        // @ts-ignore
+                        itemsType = { $ref: `#/components/schemas/${schemaName}` };
+                    }
+                    else {
+                        // @ts-ignore
+                        itemsType = this.processZodNode(node.arguments[0]);
+                    }
                 }
                 schema = { type: "array", items: itemsType };
                 break;
@@ -806,7 +938,10 @@ export class ZodSchemaConverter {
             case "extend":
                 if (node.arguments.length > 0 &&
                     t.isObjectExpression(node.arguments[0])) {
-                    const extendedProps = this.processZodObject({
+                    // Get the base schema by processing the object that extend is called on
+                    const baseSchema = this.processZodNode(node.callee.object);
+                    // Process the extension object
+                    const extendNode = {
                         type: "CallExpression",
                         callee: {
                             type: "MemberExpression",
@@ -816,18 +951,28 @@ export class ZodSchemaConverter {
                             optional: false,
                         },
                         arguments: [node.arguments[0]],
-                    });
-                    if (extendedProps && extendedProps.properties) {
-                        schema.properties = {
-                            ...schema.properties,
-                            ...extendedProps.properties,
+                    };
+                    const extendedProps = this.processZodObject(extendNode);
+                    // Merge base schema and extensions
+                    if (baseSchema && baseSchema.properties) {
+                        schema = {
+                            type: "object",
+                            properties: {
+                                ...baseSchema.properties,
+                                ...(extendedProps?.properties || {}),
+                            },
+                            required: [
+                                ...(baseSchema.required || []),
+                                ...(extendedProps?.required || []),
+                            ].filter((item, index, arr) => arr.indexOf(item) === index), // Remove duplicates
                         };
-                        if (extendedProps.required) {
-                            schema.required = [
-                                ...(schema.required || []),
-                                ...extendedProps.required,
-                            ];
-                        }
+                        // Copy other properties from base schema
+                        if (baseSchema.description)
+                            schema.description = baseSchema.description;
+                    }
+                    else {
+                        console.log(`Warning: Could not resolve base schema for extend`);
+                        schema = extendedProps || { type: "object" };
                     }
                 }
                 break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next-openapi-gen",
-  "version": "0.4.5",
+  "version": "0.5.0",
   "description": "Automatically generate OpenAPI 3.0 documentation from Next.js projects, with support for TypeScript types and Zod schemas.",
   "type": "module",
   "main": "dist/index.js",