next-openapi-gen 0.3.2 → 0.4.1

package/dist/lib/route-processor.js

@@ -18,6 +18,12 @@ export class RouteProcessor {
         this.config = config;
         this.schemaProcessor = new SchemaProcessor(config.schemaDir);
     }
+    /**
+     * Get the SchemaProcessor instance
+     */
+    getSchemaProcessor() {
+        return this.schemaProcessor;
+    }
     isRoute(varName) {
         return HTTP_METHODS.includes(varName);
     }
@@ -39,8 +45,16 @@ export class RouteProcessor {
                     if (this.isRoute(declaration.id.name)) {
                         // Don't bother adding routes for processing if only including OpenAPI routes and the route is not OpenAPI
                         if (!this.config.includeOpenApiRoutes ||
-                            (this.config.includeOpenApiRoutes && dataTypes.isOpenApi))
+                            (this.config.includeOpenApiRoutes && dataTypes.isOpenApi)) {
+                            // Check for URL parameters in the route path
+                            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) {
+                                console.warn(`Route ${routePath} contains path parameters ${pathParams.join(", ")} but no @pathParams type is defined.`);
+                            }
                             this.addRouteToPaths(declaration.id.name, filePath, dataTypes);
+                        }
                     }
                 }
                 if (t.isVariableDeclaration(declaration)) {
@@ -50,8 +64,14 @@ export class RouteProcessor {
                                 const dataTypes = extractJSDocComments(path);
                                 // Don't bother adding routes for processing if only including OpenAPI routes and the route is not OpenAPI
                                 if (!this.config.includeOpenApiRoutes ||
-                                    (this.config.includeOpenApiRoutes && dataTypes.isOpenApi))
+                                    (this.config.includeOpenApiRoutes && dataTypes.isOpenApi)) {
+                                    const routePath = this.getRoutePath(filePath);
+                                    const pathParams = extractPathParameters(routePath);
+                                    if (pathParams.length > 0 && !dataTypes.pathParams) {
+                                        console.warn(`Route ${routePath} contains path parameters ${pathParams.join(", ")} but no @pathParams type is defined.`);
+                                    }
                                     this.addRouteToPaths(decl.id.name, filePath, dataTypes);
+                                }
                             }
                         }
                     });
@@ -103,6 +123,7 @@ export class RouteProcessor {
             summary: summary,
             description: description,
             tags: [rootPath],
+            parameters: [],
         };
         // Add auth
         if (auth) {
@@ -112,7 +133,6 @@ export class RouteProcessor {
                 },
             ];
         }
-        definition.parameters = [];
         if (params) {
             definition.parameters =
                 this.schemaProcessor.createRequestParamsSchema(params);

package/dist/lib/schema-processor.js

@@ -3,6 +3,7 @@ import path from "path";
 import { parse } from "@babel/parser";
 import traverse from "@babel/traverse";
 import * as t from "@babel/types";
+import { ZodSchemaConverter } from "./zod-converter";
 export class SchemaProcessor {
     schemaDir;
     typeDefinitions = {};
@@ -12,13 +13,38 @@ export class SchemaProcessor {
     statCache = {};
     processSchemaTracker = {};
     processingTypes = new Set();
-    constructor(schemaDir) {
+    zodSchemaConverter;
+    schemaType;
+    constructor(schemaDir, schemaType = "typescript") {
         this.schemaDir = path.resolve(schemaDir);
+        this.schemaType = schemaType;
+        if (schemaType === "zod") {
+            this.zodSchemaConverter = new ZodSchemaConverter(schemaDir);
+        }
+    }
+    /**
+     * Get all defined schemas (for components.schemas section)
+     */
+    getDefinedSchemas() {
+        return this.openapiDefinitions;
     }
     findSchemaDefinition(schemaName, contentType) {
         let schemaNode = null;
-        // assign type that is actually processed
+        // Assign type that is actually processed
         this.contentType = contentType;
+        // Check if we should use Zod schemas
+        if (this.schemaType === "zod") {
+            console.log(`Looking for Zod schema: ${schemaName}`);
+            // Try to convert Zod schema
+            const zodSchema = this.zodSchemaConverter.convertZodSchemaToOpenApi(schemaName);
+            if (zodSchema) {
+                console.log(`Found and processed Zod schema: ${schemaName}`);
+                this.openapiDefinitions[schemaName] = zodSchema;
+                return zodSchema;
+            }
+            console.log(`No Zod schema found for ${schemaName}, trying TypeScript fallback`);
+        }
+        // Fall back to TypeScript types
         this.scanSchemaDir(this.schemaDir, schemaName);
         return schemaNode;
     }
@@ -38,7 +64,7 @@ export class SchemaProcessor {
             if (stat.isDirectory()) {
                 this.scanSchemaDir(filePath, schemaName);
             }
-            else if (file.endsWith(".ts")) {
+            else if (file.endsWith(".ts") || file.endsWith(".tsx")) {
                 this.processSchemaFile(filePath, schemaName);
             }
         });
@@ -69,6 +95,25 @@ export class SchemaProcessor {
                     this.typeDefinitions[name] = path.node;
                 }
             },
+            // Collect exported zod schemas
+            ExportNamedDeclaration: (path) => {
+                if (t.isVariableDeclaration(path.node.declaration)) {
+                    path.node.declaration.declarations.forEach((declaration) => {
+                        if (t.isIdentifier(declaration.id) &&
+                            declaration.id.name === schemaName &&
+                            declaration.init) {
+                            // Check if is Zod schema
+                            if (t.isCallExpression(declaration.init) &&
+                                t.isMemberExpression(declaration.init.callee) &&
+                                t.isIdentifier(declaration.init.callee.object) &&
+                                declaration.init.callee.object.name === "z") {
+                                const name = declaration.id.name;
+                                this.typeDefinitions[name] = declaration.init;
+                            }
+                        }
+                    });
+                }
+            },
         });
     }
     resolveType(typeName) {
@@ -76,12 +121,33 @@ export class SchemaProcessor {
             // Return reference to type to avoid infinite recursion
             return { $ref: `#/components/schemas/${typeName}` };
         }
-        // Add type to precessing types
+        // Add type to processing types
         this.processingTypes.add(typeName);
         try {
+            // If we are using Zod and the given type is not found yet, try using Zod converter first
+            if (this.schemaType === "zod" && !this.openapiDefinitions[typeName]) {
+                const zodSchema = this.zodSchemaConverter.convertZodSchemaToOpenApi(typeName);
+                if (zodSchema) {
+                    this.openapiDefinitions[typeName] = zodSchema;
+                    return zodSchema;
+                }
+            }
             const typeNode = this.typeDefinitions[typeName.toString()];
             if (!typeNode)
                 return {};
+            // Check if node is Zod
+            if (t.isCallExpression(typeNode) &&
+                t.isMemberExpression(typeNode.callee) &&
+                t.isIdentifier(typeNode.callee.object) &&
+                typeNode.callee.object.name === "z") {
+                if (this.schemaType === "zod") {
+                    const zodSchema = this.zodSchemaConverter.processZodNode(typeNode);
+                    if (zodSchema) {
+                        this.openapiDefinitions[typeName] = zodSchema;
+                        return zodSchema;
+                    }
+                }
+            }
             if (t.isTSEnumDeclaration(typeNode)) {
                 const enumValues = this.processEnum(typeNode);
                 return enumValues;
@@ -296,7 +362,6 @@ export class SchemaProcessor {
                 if (resolvedType.type === "object" && resolvedType.properties) {
                     Object.entries(resolvedType.properties).forEach(([key, value]) => {
                         allProperties[key] = value;
-                        // @ts-ignore
                         if (value.required) {
                             requiredProperties.push(key);
                         }
@@ -358,7 +423,9 @@ export class SchemaProcessor {
                     enumSchema.type = "number";
                 }
                 const targetValue = value || name;
-                enumSchema.enum.push(targetValue);
+                if (enumSchema.enum) {
+                    enumSchema.enum.push(targetValue);
+                }
             }
         });
         return enumSchema;
@@ -390,12 +457,12 @@ export class SchemaProcessor {
         if (paramName === "id" ||
             paramName.endsWith("Id") ||
             paramName.endsWith("_id")) {
-            return type === "string" ? "123abc" : 123;
+            return type === "string" ? "123" : 123;
         }
         // For specific common parameter names
         switch (paramName.toLowerCase()) {
             case "slug":
-                return "example-slug";
+                return "slug";
             case "uuid":
                 return "123e4567-e89b-12d3-a456-426614174000";
             case "username":
@@ -403,11 +470,13 @@ export class SchemaProcessor {
             case "email":
                 return "user@example.com";
             case "name":
-                return "example-name";
+                return "name";
             case "date":
                 return "2023-01-01";
             case "page":
                 return 1;
+            case "role":
+                return "admin";
             default:
                 // Default examples by type
                 if (type === "string")
@@ -498,25 +567,27 @@ export class SchemaProcessor {
         };
     }
     getSchemaContent({ paramsType, pathParamsType, bodyType, responseType, }) {
-        let params = this.openapiDefinitions[paramsType];
-        let pathParams = this.openapiDefinitions[pathParamsType];
-        let body = this.openapiDefinitions[bodyType];
-        let responses = this.openapiDefinitions[responseType];
+        let params = paramsType ? this.openapiDefinitions[paramsType] : {};
+        let pathParams = pathParamsType
+            ? this.openapiDefinitions[pathParamsType]
+            : {};
+        let body = bodyType ? this.openapiDefinitions[bodyType] : {};
+        let responses = responseType ? this.openapiDefinitions[responseType] : {};
         if (paramsType && !params) {
             this.findSchemaDefinition(paramsType, "params");
-            params = this.openapiDefinitions[paramsType];
+            params = this.openapiDefinitions[paramsType] || {};
         }
         if (pathParamsType && !pathParams) {
             this.findSchemaDefinition(pathParamsType, "pathParams");
-            pathParams = this.openapiDefinitions[pathParamsType];
+            pathParams = this.openapiDefinitions[pathParamsType] || {};
         }
         if (bodyType && !body) {
             this.findSchemaDefinition(bodyType, "body");
-            body = this.openapiDefinitions[bodyType];
+            body = this.openapiDefinitions[bodyType] || {};
         }
         if (responseType && !responses) {
             this.findSchemaDefinition(responseType, "response");
-            responses = this.openapiDefinitions[responseType];
+            responses = this.openapiDefinitions[responseType] || {};
         }
         return {
             params,

package/dist/lib/utils.js

@@ -18,10 +18,10 @@ export function extractJSDocComments(path) {
     const comments = path.node.leadingComments;
     let summary = "";
     let description = "";
-    let paramsType = "";
-    let pathParamsType = "";
-    let bodyType = "";
-    let responseType = "";
+    let params = "";
+    let pathParams = "";
+    let body = "";
+    let response = "";
     let auth = "";
     let isOpenApi = false;
     if (comments) {
@@ -32,7 +32,7 @@ export function extractJSDocComments(path) {
                 summary = commentValue.split("\n")[0];
             }
             if (commentValue.includes("@auth")) {
-                const regex = /@auth:\s*(.*)/;
+                const regex = /@auth\s*(.*)/;
                 const value = commentValue.match(regex)[1].trim();
                 switch (value) {
                     case "bearer":
@@ -47,20 +47,20 @@ export function extractJSDocComments(path) {
                 }
             }
             if (commentValue.includes("@desc")) {
-                const regex = /@desc:\s*(.*)/;
+                const regex = /@desc\s*(.*)/;
                 description = commentValue.match(regex)[1].trim();
             }
             if (commentValue.includes("@params")) {
-                paramsType = extractTypeFromComment(commentValue, "@params");
+                params = extractTypeFromComment(commentValue, "@params");
             }
             if (commentValue.includes("@pathParams")) {
-                pathParamsType = extractTypeFromComment(commentValue, "@pathParams");
+                pathParams = extractTypeFromComment(commentValue, "@pathParams");
             }
             if (commentValue.includes("@body")) {
-                bodyType = extractTypeFromComment(commentValue, "@body");
+                body = extractTypeFromComment(commentValue, "@body");
             }
             if (commentValue.includes("@response")) {
-                responseType = extractTypeFromComment(commentValue, "@response");
+                response = extractTypeFromComment(commentValue, "@response");
             }
         });
     }
@@ -68,10 +68,10 @@ export function extractJSDocComments(path) {
         auth,
         summary,
         description,
-        paramsType,
-        pathParamsType,
-        bodyType,
-        responseType,
+        params,
+        pathParams,
+        body,
+        response,
         isOpenApi,
     };
 }