next-openapi-gen 0.5.2 → 0.5.4

package/dist/lib/route-processor.js

@@ -109,7 +109,7 @@ export class RouteProcessor {
         const routePath = this.getRoutePath(filePath);
         const rootPath = capitalize(routePath.split("/")[1]);
         const operationId = getOperationId(routePath, method);
-        const { tag, summary, description, auth, isOpenApi } = dataTypes;
+        const { tag, summary, description, auth, isOpenApi, deprecated, bodyDescription, responseDescription, } = dataTypes;
         if (this.config.includeOpenApiRoutes && !isOpenApi) {
             // If flag is enabled and there is no @openapi tag, then skip path
             return;
@@ -125,6 +125,9 @@ export class RouteProcessor {
             tags: [tag || rootPath],
             parameters: [],
         };
+        if (deprecated) {
+            definition.deprecated = true;
+        }
         // Add auth
         if (auth) {
             definition.security = [
@@ -157,12 +160,11 @@ export class RouteProcessor {
         }
         // Add request body
         if (MUTATION_HTTP_METHODS.includes(method.toUpperCase())) {
-            definition.requestBody =
-                this.schemaProcessor.createRequestBodySchema(body);
+            definition.requestBody = this.schemaProcessor.createRequestBodySchema(body, bodyDescription);
         }
         // Add responses
         definition.responses = responses
-            ? this.schemaProcessor.createResponseSchema(responses)
+            ? this.schemaProcessor.createResponseSchema(responses, responseDescription)
             : {};
         this.swaggerPaths[routePath][method] = definition;
     }

package/dist/lib/schema-processor.js

@@ -555,19 +555,23 @@ export class SchemaProcessor {
         }
         return queryParams;
     }
-    createRequestBodySchema(body) {
-        return {
+    createRequestBodySchema(body, description) {
+        const schema = {
             content: {
                 "application/json": {
                     schema: body,
                 },
             },
         };
+        if (description) {
+            schema.description = description;
+        }
+        return schema;
     }
-    createResponseSchema(responses) {
+    createResponseSchema(responses, description) {
         return {
             200: {
-                description: "Successful response",
+                description: description || "Successful response",
                 content: {
                     "application/json": {
                         schema: responses,

package/dist/lib/utils.js

@@ -25,10 +25,30 @@ export function extractJSDocComments(path) {
     let responseType = "";
     let auth = "";
     let isOpenApi = false;
+    let deprecated = false;
+    let bodyDescription = "";
+    let responseDescription = "";
     if (comments) {
         comments.forEach((comment) => {
             const commentValue = cleanComment(comment.value);
             isOpenApi = commentValue.includes("@openapi");
+            if (commentValue.includes("@deprecated")) {
+                deprecated = true;
+            }
+            if (commentValue.includes("@bodyDescription")) {
+                const regex = /@bodyDescription\s*(.*)/;
+                const match = commentValue.match(regex);
+                if (match && match[1]) {
+                    bodyDescription = match[1].trim();
+                }
+            }
+            if (commentValue.includes("@responseDescription")) {
+                const regex = /@responseDescription\s*(.*)/;
+                const match = commentValue.match(regex);
+                if (match && match[1]) {
+                    responseDescription = match[1].trim();
+                }
+            }
             if (!summary) {
                 summary = commentValue.split("\n")[0];
             }
@@ -82,6 +102,9 @@ export function extractJSDocComments(path) {
         bodyType,
         responseType,
         isOpenApi,
+        deprecated,
+        bodyDescription,
+        responseDescription,
     };
 }
 export function extractTypeFromComment(commentValue, tag) {

package/dist/lib/zod-converter.js

@@ -138,6 +138,12 @@ export class ZodSchemaConverter {
             if (!content.includes(schemaName)) {
                 return;
             }
+            // Pre-process all schemas in file
+            this.preprocessAllSchemasInFile(filePath);
+            // Return it, if the schema has already been processed during pre-processing
+            if (this.zodSchemas[schemaName]) {
+                return;
+            }
             // Parse the file
             const ast = parse(content, {
                 sourceType: "module",
@@ -593,6 +599,44 @@ export class ZodSchemaConverter {
                     console.log(`Skipping property ${index} - unsupported key type`);
                     return; // Skip if key is not identifier or string literal
                 }
+                if (t.isCallExpression(prop.value) &&
+                    t.isMemberExpression(prop.value.callee) &&
+                    t.isIdentifier(prop.value.callee.object)) {
+                    const schemaName = prop.value.callee.object.name;
+                    // @ts-ignore
+                    const methodName = prop.value.callee.property.name;
+                    // Process base schema first
+                    if (!this.zodSchemas[schemaName]) {
+                        this.convertZodSchemaToOpenApi(schemaName);
+                    }
+                    // For describe method, use reference with description
+                    if (methodName === "describe" && this.zodSchemas[schemaName]) {
+                        if (prop.value.arguments.length > 0 &&
+                            t.isStringLiteral(prop.value.arguments[0])) {
+                            properties[propName] = {
+                                allOf: [{ $ref: `#/components/schemas/${schemaName}` }],
+                                description: prop.value.arguments[0].value,
+                            };
+                        }
+                        else {
+                            properties[propName] = {
+                                $ref: `#/components/schemas/${schemaName}`,
+                            };
+                        }
+                        required.push(propName);
+                        return;
+                    }
+                    // For other methods, process normally
+                    const processedSchema = this.processZodNode(prop.value);
+                    if (processedSchema) {
+                        properties[propName] = processedSchema;
+                        const isOptional = this.isOptional(prop.value) || this.hasOptionalMethod(prop.value);
+                        if (!isOptional) {
+                            required.push(propName);
+                        }
+                    }
+                    return;
+                }
                 // Check if the property value is an identifier (reference to another schema)
                 if (t.isIdentifier(prop.value)) {
                     const referencedSchemaName = prop.value.name;
@@ -833,6 +877,9 @@ export class ZodSchemaConverter {
                     schema.description = node.arguments[0].value;
                 }
                 break;
+            case "deprecated":
+                schema.deprecated = true;
+                break;
             case "min":
                 if (node.arguments.length > 0 &&
                     t.isNumericLiteral(node.arguments[0])) {
@@ -1181,4 +1228,59 @@ export class ZodSchemaConverter {
             console.error(`Error scanning directory ${dir} for type mappings:`, error);
         }
     }
+    /**
+     * Pre-process all Zod schemas in a file
+     */
+    preprocessAllSchemasInFile(filePath) {
+        try {
+            const content = fs.readFileSync(filePath, "utf-8");
+            const ast = parse(content, {
+                sourceType: "module",
+                plugins: ["typescript", "decorators-legacy"],
+            });
+            // Collect all exported Zod schemas
+            traverse.default(ast, {
+                ExportNamedDeclaration: (path) => {
+                    if (t.isVariableDeclaration(path.node.declaration)) {
+                        path.node.declaration.declarations.forEach((declaration) => {
+                            if (t.isIdentifier(declaration.id) && declaration.init) {
+                                const schemaName = declaration.id.name;
+                                // Check if is Zos schema
+                                if (this.isZodSchema(declaration.init) &&
+                                    !this.zodSchemas[schemaName]) {
+                                    console.log(`Pre-processing Zod schema: ${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 pre-processing file ${filePath}:`, error);
+        }
+    }
+    /**
+     * Check if node is Zod schema
+     */
+    isZodSchema(node) {
+        if (t.isCallExpression(node)) {
+            if (t.isMemberExpression(node.callee) &&
+                t.isIdentifier(node.callee.object) &&
+                node.callee.object.name === "z") {
+                return true;
+            }
+            if (t.isMemberExpression(node.callee) &&
+                t.isCallExpression(node.callee.object)) {
+                return this.isZodSchema(node.callee.object);
+            }
+        }
+        return false;
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next-openapi-gen",
-  "version": "0.5.2",
+  "version": "0.5.4",
   "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",