next-openapi-gen 0.6.2 → 0.6.5

package/README.md

@@ -61,7 +61,8 @@ During initialization (`npx next-openapi-gen init`), a configuration file `next.
   "schemaType": "typescript", // or "zod" for Zod schemas
   "outputFile": "openapi.json",
   "docsUrl": "/api-docs",
-  "includeOpenApiRoutes": false
+  "includeOpenApiRoutes": false,
+  "debug": false
 }
 ```
 
@@ -75,6 +76,10 @@ During initialization (`npx next-openapi-gen init`), a configuration file `next.
 | `outputFile`           | Path to the OpenAPI output file                  |
 | `docsUrl`              | API documentation URL (for Swagger UI)           |
 | `includeOpenApiRoutes` | Whether to include only routes with @openapi tag |
+| `defaultResponseSet`   | Default error response set for all endpoints     |
+| `responseSets`         | Named sets of error response codes               |
+| `errorConfig`          | Error schema configuration                       |
+| `debug`                | Enable detailed logging during generation        |
 
 ## Documenting Your API
 
@@ -154,6 +159,8 @@ export async function GET(
 | `@bodyDescription`     | Request body description                                                            |
 | `@response`            | Response type/schema                                                                |
 | `@responseDescription` | Response description                                                                |
+| `@responseSet`         | Override default response set (`public`, `auth`, `none`)                            |
+| `@add`                 | Add custom response codes (`409:ConflictResponse`, `429`)                           |
 | `@contentType`         | Request body content type (`application/json`, `multipart/form-data`)               |
 | `@auth`                | Authorization type (`bearer`, `basic`, `apikey`)                                    |
 | `@tag`                 | Custom tag                                                                          |
@@ -373,6 +380,89 @@ export async function POST() {
 }
 ```
 
+## Response Management
+
+### Zero Config + Response Sets
+
+Configure reusable error sets in `next.openapi.json`:
+
+```json
+{
+  "defaultResponseSet": "common",
+  "responseSets": {
+    "common": ["400", "401", "500"],
+    "public": ["400", "500"],
+    "auth": ["400", "401", "403", "500"]
+  }
+}
+```
+
+### Usage Examples
+
+```typescript
+/**
+ * Auto-default responses
+ * @response UserResponse
+ * @openapi
+ */
+export async function GET() {}
+// Generates: 200:UserResponse + common errors (400, 401, 500)
+
+/**
+ * Override response set
+ * @response ProductResponse
+ * @responseSet public
+ * @openapi
+ */
+export async function GET() {}
+// Generates: 200:ProductResponse + public errors (400, 500)
+
+/**
+ * Add custom responses
+ * @response 201:UserResponse
+ * @add 409:ConflictResponse
+ * @openapi
+ */
+export async function POST() {}
+// Generates: 201:UserResponse + common errors + 409:ConflictResponse
+
+/**
+ * Combine multiple sets
+ * @response UserResponse
+ * @responseSet auth,crud
+ * @add 429:RateLimitResponse
+ * @openapi
+ */
+export async function PUT() {}
+// Combines: auth + crud errors + custom 429
+```
+
+### Error Schema Configuration
+
+#### Define consistent error schemas using templates:
+
+```json
+{
+  "errorConfig": {
+    "template": {
+      "type": "object",
+      "properties": {
+        "error": {
+          "type": "string",
+          "example": "{{ERROR_MESSAGE}}"
+        }
+      }
+    },
+    "codes": {
+      "invalid_request": {
+        "description": "Invalid request",
+        "variables": { "ERROR_MESSAGE": "Validation failed" }
+      }
+    }
+  }
+}
+```
+
 ## Advanced Usage
 
 ### Automatic Path Parameter Detection

package/dist/lib/logger.js

@@ -0,0 +1,39 @@
+class Logger {
+    config = null;
+    init(config) {
+        this.config = config;
+    }
+    getCallerInfo() {
+        const stack = new Error().stack;
+        if (!stack)
+            return 'Unknown';
+        const lines = stack.split('\n');
+        // Skip: Error, getCallerInfo, log/warn/error
+        const callerLine = lines[3] || lines[2];
+        // Extract class/function name
+        const match = callerLine.match(/at (\w+)\.(\w+)|at (\w+)/);
+        if (match) {
+            return match[1] || match[3] || 'Unknown';
+        }
+        return 'Unknown';
+    }
+    log(message, ...args) {
+        if (this.config?.debug) {
+            const source = this.getCallerInfo();
+            console.log(`[${source}] ${message}`, ...args);
+        }
+    }
+    warn(message, ...args) {
+        if (this.config?.debug) {
+            const source = this.getCallerInfo();
+            console.warn(`[${source}] ${message}`, ...args);
+        }
+    }
+    error(message, ...args) {
+        if (this.config?.debug) {
+            const source = this.getCallerInfo();
+            console.error(`[${source}] ${message}`, ...args);
+        }
+    }
+}
+export const logger = new Logger();

package/dist/lib/openapi-generator.js

@@ -2,6 +2,7 @@ import path from "path";
 import fs from "fs";
 import { RouteProcessor } from "./route-processor.js";
 import { cleanSpec } from "./utils.js";
+import { logger } from "./logger.js";
 export class OpenApiGenerator {
     config;
     template;
@@ -11,10 +12,12 @@ export class OpenApiGenerator {
         this.template = JSON.parse(fs.readFileSync(templatePath, "utf-8"));
         this.config = this.getConfig();
         this.routeProcessor = new RouteProcessor(this.config);
+        // Initialize logger
+        logger.init(this.config);
     }
     getConfig() {
         // @ts-ignore
-        const { apiDir, schemaDir, docsUrl, ui, outputFile, includeOpenApiRoutes, schemaType = "typescript" } = this.template;
+        const { apiDir, schemaDir, docsUrl, ui, outputFile, includeOpenApiRoutes, schemaType = "typescript", defaultResponseSet, responseSets, errorConfig, debug } = this.template;
         return {
             apiDir,
             schemaDir,
@@ -23,15 +26,20 @@ export class OpenApiGenerator {
             outputFile,
             includeOpenApiRoutes,
             schemaType,
+            defaultResponseSet,
+            responseSets,
+            errorConfig,
+            debug,
         };
     }
     generate() {
+        logger.log("Starting OpenAPI generation...");
         const { apiDir } = this.config;
         // Check if app router structure exists
         let appRouterApiDir = "";
         if (fs.existsSync(path.join(path.dirname(apiDir), "app", "api"))) {
             appRouterApiDir = path.join(path.dirname(apiDir), "app", "api");
-            console.log(`Found app router API directory at ${appRouterApiDir}`);
+            logger.log(`Found app router API directory at ${appRouterApiDir}`);
         }
         // Scan pages router routes
         this.routeProcessor.scanApiRoutes(apiDir);
@@ -57,6 +65,21 @@ export class OpenApiGenerator {
         if (!this.template.components.schemas) {
             this.template.components.schemas = {};
         }
+        // Generate error responses using errorConfig or manual definitions
+        if (!this.template.components.responses) {
+            this.template.components.responses = {};
+        }
+        const errorConfig = this.config.errorConfig;
+        if (errorConfig) {
+            this.generateErrorResponsesFromConfig(errorConfig);
+        }
+        else if (this.config.errorDefinitions) {
+            // Use manual definitions (existing logic - if exists)
+            Object.entries(this.config.errorDefinitions).forEach(([code, errorDef]) => {
+                this.template.components.responses[code] =
+                    this.createErrorResponseComponent(code, errorDef);
+            });
+        }
         // Get defined schemas from the processor
         const definedSchemas = this.routeProcessor
             .getSchemaProcessor()
@@ -68,6 +91,73 @@ export class OpenApiGenerator {
             };
         }
         const openapiSpec = cleanSpec(this.template);
+        logger.log("OpenAPI generation completed");
         return openapiSpec;
     }
+    generateErrorResponsesFromConfig(errorConfig) {
+        const { template, codes, variables: globalVars = {} } = errorConfig;
+        Object.entries(codes).forEach(([errorCode, config]) => {
+            const httpStatus = (config.httpStatus || this.guessHttpStatus(errorCode)).toString();
+            // Merge variables: global + per-code + built-in
+            const allVariables = {
+                ...globalVars,
+                ...config.variables,
+                ERROR_CODE: errorCode,
+                DESCRIPTION: config.description,
+                HTTP_STATUS: httpStatus,
+            };
+            const processedSchema = this.processTemplate(template, allVariables);
+            this.template.components.responses[httpStatus] = {
+                description: config.description,
+                content: {
+                    "application/json": {
+                        schema: processedSchema,
+                    },
+                },
+            };
+        });
+    }
+    processTemplate(template, variables) {
+        const jsonStr = JSON.stringify(template);
+        let result = jsonStr;
+        Object.entries(variables).forEach(([key, value]) => {
+            result = result.replace(new RegExp(`{{${key}}}`, "g"), value);
+        });
+        return JSON.parse(result);
+    }
+    guessHttpStatus(errorCode) {
+        const statusMap = {
+            bad: 400,
+            invalid: 400,
+            validation: 422,
+            unauthorized: 401,
+            auth: 401,
+            forbidden: 403,
+            permission: 403,
+            not_found: 404,
+            missing: 404,
+            conflict: 409,
+            duplicate: 409,
+            rate_limit: 429,
+            too_many: 429,
+            server: 500,
+            internal: 500,
+        };
+        for (const [key, status] of Object.entries(statusMap)) {
+            if (errorCode.toLowerCase().includes(key)) {
+                return status;
+            }
+        }
+        return 500;
+    }
+    createErrorResponseComponent(code, errorDef) {
+        return {
+            description: errorDef.description,
+            content: {
+                "application/json": {
+                    schema: errorDef.schema,
+                },
+            },
+        };
+    }
 }

package/dist/lib/route-processor.js

@@ -5,6 +5,7 @@ import traverse from "@babel/traverse";
 import { parse } from "@babel/parser";
 import { SchemaProcessor } from "./schema-processor.js";
 import { capitalize, extractJSDocComments, extractPathParameters, getOperationId, } from "./utils.js";
+import { logger } from "./logger.js";
 const HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE"];
 const MUTATION_HTTP_METHODS = ["PATCH", "POST", "PUT"];
 export class RouteProcessor {
@@ -18,6 +19,91 @@ export class RouteProcessor {
         this.config = config;
         this.schemaProcessor = new SchemaProcessor(config.schemaDir, config.schemaType);
     }
+    buildResponsesFromConfig(dataTypes, method) {
+        const responses = {};
+        // 1. Add success response
+        const successCode = dataTypes.successCode || this.getDefaultSuccessCode(method);
+        if (dataTypes.responseType) {
+            const responseSchema = this.schemaProcessor.getSchemaContent({
+                responseType: dataTypes.responseType,
+            }).responses;
+            responses[successCode] = {
+                description: dataTypes.responseDescription || "Successful response",
+                content: {
+                    "application/json": {
+                        schema: responseSchema,
+                    },
+                },
+            };
+        }
+        // 2. Add responses from ResponseSet
+        const responseSetName = dataTypes.responseSet || this.config.defaultResponseSet;
+        if (responseSetName && responseSetName !== "none") {
+            const responseSets = this.config.responseSets || {};
+            const setNames = responseSetName.split(",").map((s) => s.trim());
+            setNames.forEach((setName) => {
+                const responseSet = responseSets[setName];
+                if (responseSet) {
+                    responseSet.forEach((errorCode) => {
+                        // Use $ref for components/responses
+                        responses[errorCode] = {
+                            $ref: `#/components/responses/${errorCode}`,
+                        };
+                    });
+                }
+            });
+        }
+        // 3. Add custom responses (@add)
+        if (dataTypes.addResponses) {
+            const customResponses = dataTypes.addResponses
+                .split(",")
+                .map((s) => s.trim());
+            customResponses.forEach((responseRef) => {
+                const [code, ref] = responseRef.split(":");
+                if (ref) {
+                    // Custom schema: "409:ConflictResponse"
+                    responses[code] = {
+                        description: this.getDefaultErrorDescription(code) || `HTTP ${code} response`,
+                        content: {
+                            "application/json": {
+                                schema: { $ref: `#/components/schemas/${ref}` },
+                            },
+                        },
+                    };
+                }
+                else {
+                    // Only code: "409" - use $ref fro components/responses
+                    responses[code] = {
+                        $ref: `#/components/responses/${code}`,
+                    };
+                }
+            });
+        }
+        return responses;
+    }
+    getDefaultSuccessCode(method) {
+        switch (method.toUpperCase()) {
+            case "POST":
+                return "201";
+            case "DELETE":
+                return "204";
+            default:
+                return "200";
+        }
+    }
+    getDefaultErrorDescription(code) {
+        const defaults = {
+            400: "Bad Request",
+            401: "Unauthorized",
+            403: "Forbidden",
+            404: "Not Found",
+            409: "Conflict",
+            422: "Unprocessable Entity",
+            429: "Too Many Requests",
+            500: "Internal Server Error",
+        };
+        return defaults[code] || `HTTP ${code}`;
+    }
     /**
      * Get the SchemaProcessor instance
      */
@@ -51,7 +137,7 @@ export class RouteProcessor {
                             const pathParams = extractPathParameters(routePath);
                             // If we have path parameters but no pathParamsType defined, we should log a warning
                             if (pathParams.length > 0 && !dataTypes.pathParamsType) {
-                                console.warn(`Route ${routePath} contains path parameters ${pathParams.join(", ")} but no @pathParams type is defined.`);
+                                logger.warn(`Route ${routePath} contains path parameters ${pathParams.join(", ")} but no @pathParams type is defined.`);
                             }
                             this.addRouteToPaths(declaration.id.name, filePath, dataTypes);
                         }
@@ -68,7 +154,7 @@ export class RouteProcessor {
                                     const routePath = this.getRoutePath(filePath);
                                     const pathParams = extractPathParameters(routePath);
                                     if (pathParams.length > 0 && !dataTypes.pathParamsType) {
-                                        console.warn(`Route ${routePath} contains path parameters ${pathParams.join(", ")} but no @pathParams type is defined.`);
+                                        logger.warn(`Route ${routePath} contains path parameters ${pathParams.join(", ")} but no @pathParams type is defined.`);
                                     }
                                     this.addRouteToPaths(decl.id.name, filePath, dataTypes);
                                 }
@@ -81,6 +167,7 @@ export class RouteProcessor {
         this.processFileTracker[filePath] = true;
     }
     scanApiRoutes(dir) {
+        logger.log(`Scanning API routes in: ${dir}`);
         let files = this.directoryCache[dir];
         if (!files) {
             files = fs.readdirSync(dir);
@@ -163,9 +250,13 @@ export class RouteProcessor {
             definition.requestBody = this.schemaProcessor.createRequestBodySchema(body, bodyDescription, dataTypes.contentType);
         }
         // Add responses
-        definition.responses = responses
-            ? this.schemaProcessor.createResponseSchema(responses, responseDescription)
-            : {};
+        definition.responses = this.buildResponsesFromConfig(dataTypes, method);
+        // If there are no responses from config, use the old logic
+        if (Object.keys(definition.responses).length === 0) {
+            definition.responses = responses
+                ? this.schemaProcessor.createResponseSchema(responses, responseDescription)
+                : {};
+        }
         this.swaggerPaths[routePath][method] = definition;
     }
     getRoutePath(filePath) {

package/dist/lib/schema-processor.js

@@ -4,6 +4,7 @@ import { parse } from "@babel/parser";
 import traverse from "@babel/traverse";
 import * as t from "@babel/types";
 import { ZodSchemaConverter } from "./zod-converter.js";
+import { logger } from "./logger.js";
 export class SchemaProcessor {
     schemaDir;
     typeDefinitions = {};
@@ -42,20 +43,20 @@ export class SchemaProcessor {
         this.contentType = contentType;
         // Check if we should use Zod schemas
         if (this.schemaType === "zod") {
-            console.log(`Looking for Zod schema: ${schemaName}`);
+            logger.log(`Looking for Zod schema: ${schemaName}`);
             // Check type mapping first
             const mappedSchemaName = this.zodSchemaConverter.typeToSchemaMapping[schemaName];
             if (mappedSchemaName) {
-                console.log(`Type '${schemaName}' is mapped to Zod schema '${mappedSchemaName}'`);
+                logger.log(`Type '${schemaName}' is mapped to Zod schema '${mappedSchemaName}'`);
             }
             // Try to convert Zod schema
             const zodSchema = this.zodSchemaConverter.convertZodSchemaToOpenApi(schemaName);
             if (zodSchema) {
-                console.log(`Found and processed Zod schema: ${schemaName}`);
+                logger.log(`Found and processed Zod schema: ${schemaName}`);
                 this.openapiDefinitions[schemaName] = zodSchema;
                 return zodSchema;
             }
-            console.log(`No Zod schema found for ${schemaName}, trying TypeScript fallback`);
+            logger.log(`No Zod schema found for ${schemaName}, trying TypeScript fallback`);
         }
         // Fall back to TypeScript types
         this.scanSchemaDir(this.schemaDir, schemaName);
@@ -394,7 +395,7 @@ export class SchemaProcessor {
         if (t.isTSTypeReference(node) && t.isIdentifier(node.typeName)) {
             return { $ref: `#/components/schemas/${node.typeName.name}` };
         }
-        console.warn("Unrecognized TypeScript type node:", node);
+        logger.log("Unrecognized TypeScript type node:", node);
         return { type: "object" }; // By default we return an object
     }
     processSchemaFile(filePath, schemaName) {
@@ -417,7 +418,7 @@ export class SchemaProcessor {
             return definition;
         }
         catch (error) {
-            console.error(`Error processing schema file ${filePath} for schema ${schemaName}:`, error);
+            logger.error(`Error processing schema file ${filePath} for schema ${schemaName}: ${error}`);
             return { type: "object" }; // By default we return an empty object on error
         }
     }
@@ -514,6 +515,26 @@ export class SchemaProcessor {
         }
         return "application/json";
     }
+    createMultipleResponsesSchema(responses, defaultDescription) {
+        const result = {};
+        Object.entries(responses).forEach(([code, response]) => {
+            if (typeof response === "string") {
+                // Reference do components/responses
+                result[code] = { $ref: `#/components/responses/${response}` };
+            }
+            else {
+                result[code] = {
+                    description: response.description || defaultDescription || "Response",
+                    content: {
+                        "application/json": {
+                            schema: response.schema || response,
+                        },
+                    },
+                };
+            }
+        });
+        return result;
+    }
     createFormDataSchema(body) {
         if (!body.properties) {
             return body;

package/dist/lib/utils.js

@@ -22,13 +22,16 @@ export function extractJSDocComments(path) {
     let paramsType = "";
     let pathParamsType = "";
     let bodyType = "";
-    let responseType = "";
     let auth = "";
     let isOpenApi = false;
     let deprecated = false;
     let bodyDescription = "";
-    let responseDescription = "";
     let contentType = "";
+    let responseType = "";
+    let responseDescription = "";
+    let responseSet = "";
+    let addResponses = "";
+    let successCode = "";
     if (comments) {
         comments.forEach((comment) => {
             const commentValue = cleanComment(comment.value);
@@ -43,13 +46,6 @@ export function extractJSDocComments(path) {
                     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];
             }
@@ -98,6 +94,38 @@ export function extractJSDocComments(path) {
                     contentType = 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 (commentValue.includes("@responseSet")) {
+                const regex = /@responseSet\s*(.*)/;
+                const match = commentValue.match(regex);
+                if (match && match[1]) {
+                    responseSet = match[1].trim();
+                }
+            }
+            if (commentValue.includes("@add")) {
+                const regex = /@add\s*(.*)/;
+                const match = commentValue.match(regex);
+                if (match && match[1]) {
+                    addResponses = match[1].trim();
+                }
+            }
+            if (commentValue.includes("@response")) {
+                const responseMatch = commentValue.match(/@response\s+(?:(\d+):)?(\w+)(?:\s+(.*))?/);
+                if (responseMatch) {
+                    const [, code, type] = responseMatch;
+                    successCode = code || "";
+                    responseType = type;
+                }
+                else {
+                    responseType = extractTypeFromComment(commentValue, "@response");
+                }
+            }
         });
     }
     return {
@@ -108,12 +136,15 @@ export function extractJSDocComments(path) {
         paramsType,
         pathParamsType,
         bodyType,
-        responseType,
         isOpenApi,
         deprecated,
         bodyDescription,
-        responseDescription,
         contentType,
+        responseType,
+        responseDescription,
+        responseSet,
+        addResponses,
+        successCode,
     };
 }
 export function extractTypeFromComment(commentValue, tag) {
@@ -130,6 +161,11 @@ export function cleanSpec(spec) {
         "ui",
         "outputFile",
         "includeOpenApiRoutes",
+        "schemaType",
+        "defaultResponseSet",
+        "responseSets",
+        "errorConfig",
+        "debug",
     ];
     const newSpec = { ...spec };
     propsToRemove.forEach((key) => delete newSpec[key]);

package/dist/lib/zod-converter.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 { logger } from "./logger.js";
 /**
  * Class for converting Zod schemas to OpenAPI specifications
  */
@@ -23,11 +24,11 @@ export class ZodSchemaConverter {
         if (Object.keys(this.typeToSchemaMapping).length === 0) {
             this.preScanForTypeMappings();
         }
-        console.log(`Looking for Zod schema: ${schemaName}`);
+        logger.log(`Looking for Zod schema: ${schemaName}`);
         // Check mapped types
         const mappedSchemaName = this.typeToSchemaMapping[schemaName];
         if (mappedSchemaName) {
-            console.log(`Type '${schemaName}' is mapped to schema '${mappedSchemaName}'`);
+            logger.log(`Type '${schemaName}' is mapped to schema '${mappedSchemaName}'`);
             schemaName = mappedSchemaName;
         }
         // Check for circular references
@@ -46,7 +47,7 @@ export class ZodSchemaConverter {
             for (const routeFile of routeFiles) {
                 this.processFileForZodSchema(routeFile, schemaName);
                 if (this.zodSchemas[schemaName]) {
-                    console.log(`Found Zod schema '${schemaName}' in route file: ${routeFile}`);
+                    logger.log(`Found Zod schema '${schemaName}' in route file: ${routeFile}`);
                     return this.zodSchemas[schemaName];
                 }
             }
@@ -54,10 +55,10 @@ export class ZodSchemaConverter {
             this.scanDirectoryForZodSchema(this.schemaDir, schemaName);
             // Return the schema if found, or null if not
             if (this.zodSchemas[schemaName]) {
-                console.log(`Found and processed Zod schema: ${schemaName}`);
+                logger.log(`Found and processed Zod schema: ${schemaName}`);
                 return this.zodSchemas[schemaName];
             }
-            console.log(`Could not find Zod schema: ${schemaName}`);
+            logger.log(`Could not find Zod schema: ${schemaName}`);
             return null;
         }
         finally {
@@ -104,7 +105,7 @@ export class ZodSchemaConverter {
             }
         }
         catch (error) {
-            console.error(`Error scanning directory ${dir} for route files:`, error);
+            logger.log(`Error scanning directory ${dir} for route files: ${error}`);
         }
     }
     /**
@@ -125,7 +126,7 @@ export class ZodSchemaConverter {
             }
         }
         catch (error) {
-            console.error(`Error scanning directory ${dir}:`, error);
+            logger.log(`Error scanning directory ${dir}: ${error}`);
         }
     }
     /**
@@ -272,7 +273,7 @@ export class ZodSchemaConverter {
                                                         ? prop.key.value
                                                         : null;
                                                 if (key && schema.properties) {
-                                                    console.log(`Removing property: ${key}`);
+                                                    logger.log(`Removing property: ${key}`);
                                                     delete schema.properties[key];
                                                     if (schema.required) {
                                                         schema.required = schema.required.filter((r) => r !== key);
@@ -357,20 +358,20 @@ export class ZodSchemaConverter {
                         if (t.isCallExpression(path.node.init)) {
                             const baseSchemaName = findBaseSchema(path.node.init);
                             if (baseSchemaName && baseSchemaName !== "z") {
-                                console.log(`Found chained call starting from: ${baseSchemaName}`);
+                                logger.log(`Found chained call starting from: ${baseSchemaName}`);
                                 // First make sure the underlying schema is processed
                                 if (!this.zodSchemas[baseSchemaName]) {
-                                    console.log(`Base schema ${baseSchemaName} not found, processing it first`);
+                                    logger.log(`Base schema ${baseSchemaName} not found, processing it first`);
                                     this.processFileForZodSchema(filePath, baseSchemaName);
                                 }
                                 if (this.zodSchemas[baseSchemaName]) {
-                                    console.log(`Base schema found, applying transformations`);
+                                    logger.log("Base schema found, applying transformations");
                                     // Copy base schema
                                     const baseSchema = JSON.parse(JSON.stringify(this.zodSchemas[baseSchemaName]));
                                     // Process the entire call chain
                                     const finalSchema = processChainedCall(path.node.init, baseSchema);
                                     this.zodSchemas[schemaName] = finalSchema;
-                                    console.log(`Created ${schemaName} with properties:`, Object.keys(finalSchema.properties || {}));
+                                    logger.log(`Created ${schemaName} with properties: ${Object.keys(finalSchema.properties || {})}`);
                                     return;
                                 }
                             }
@@ -412,7 +413,7 @@ export class ZodSchemaConverter {
                                     const referencedSchemaName = param.exprName.name;
                                     // Save mapping: TypeName -> SchemaName
                                     this.typeToSchemaMapping[typeName] = referencedSchemaName;
-                                    console.log(`Mapped type '${typeName}' to schema '${referencedSchemaName}'`);
+                                    logger.log(`Mapped type '${typeName}' to schema '${referencedSchemaName}'`);
                                     // Process the referenced schema if not already processed
                                     if (!this.zodSchemas[referencedSchemaName]) {
                                         this.processFileForZodSchema(filePath, referencedSchemaName);
@@ -1222,7 +1223,7 @@ export class ZodSchemaConverter {
                             schema.description = baseSchema.description;
                     }
                     else {
-                        console.log(`Warning: Could not resolve base schema for extend`);
+                        logger.warn("Could not resolve base schema for extend");
                         schema = extendedProps || { type: "object" };
                     }
                 }
@@ -1313,7 +1314,7 @@ export class ZodSchemaConverter {
      * Pre-scan all files to build type mappings
      */
     preScanForTypeMappings() {
-        console.log("Pre-scanning for type mappings...");
+        logger.log("Pre-scanning for type mappings...");
         // Scan route files
         const routeFiles = this.findRouteFiles();
         for (const routeFile of routeFiles) {
@@ -1359,7 +1360,7 @@ export class ZodSchemaConverter {
                                 if (t.isTSTypeQuery(param) && t.isIdentifier(param.exprName)) {
                                     const referencedSchemaName = param.exprName.name;
                                     this.typeToSchemaMapping[typeName] = referencedSchemaName;
-                                    console.log(`Pre-scan: Mapped type '${typeName}' to schema '${referencedSchemaName}'`);
+                                    logger.log(`Pre-scan: Mapped type '${typeName}' to schema '${referencedSchemaName}'`);
                                 }
                             }
                         }
@@ -1368,7 +1369,7 @@ export class ZodSchemaConverter {
             });
         }
         catch (error) {
-            console.error(`Error scanning file ${filePath} for type mappings:`, error);
+            logger.log(`Error scanning file ${filePath} for type mappings: ${error}`);
         }
     }
     /**
@@ -1389,7 +1390,7 @@ export class ZodSchemaConverter {
             }
         }
         catch (error) {
-            console.error(`Error scanning directory ${dir} for type mappings:`, error);
+            logger.error(`Error scanning directory ${dir} for type mappings: ${error}`);
         }
     }
     /**
@@ -1412,7 +1413,7 @@ export class ZodSchemaConverter {
                                 // Check if is Zos schema
                                 if (this.isZodSchema(declaration.init) &&
                                     !this.zodSchemas[schemaName]) {
-                                    console.log(`Pre-processing Zod schema: ${schemaName}`);
+                                    logger.log(`Pre-processing Zod schema: ${schemaName}`);
                                     this.processingSchemas.add(schemaName);
                                     const schema = this.processZodNode(declaration.init);
                                     if (schema) {
@@ -1432,7 +1433,7 @@ export class ZodSchemaConverter {
                             if (this.isZodSchema(declaration.init) &&
                                 !this.zodSchemas[schemaName] &&
                                 !this.processingSchemas.has(schemaName)) {
-                                console.log(`Pre-processing Zod schema: ${schemaName}`);
+                                logger.log(`Pre-processing Zod schema: ${schemaName}`);
                                 this.processingSchemas.add(schemaName);
                                 const schema = this.processZodNode(declaration.init);
                                 if (schema) {
@@ -1446,7 +1447,7 @@ export class ZodSchemaConverter {
             });
         }
         catch (error) {
-            console.error(`Error pre-processing file ${filePath}:`, error);
+            logger.error(`Error pre-processing file ${filePath}: ${error}`);
         }
     }
     /**

package/dist/openapi-template.js

@@ -20,6 +20,49 @@ export default {
             },
         },
     },
+    defaultResponseSet: "common",
+    responseSets: {
+        common: ["400", "500"],
+        auth: ["401"],
+    },
+    errorConfig: {
+        template: {
+            type: "object",
+            properties: {
+                success: {
+                    type: "boolean",
+                    example: false,
+                },
+                error: {
+                    type: "string",
+                    example: "{{ERROR_MESSAGE}}",
+                },
+            },
+        },
+        codes: {
+            invalid: {
+                description: "Bad request",
+                httpStatus: 400,
+                variables: {
+                    ERROR_MESSAGE: "Validation error",
+                },
+            },
+            auth: {
+                description: "Unauthorized",
+                httpStatus: 401,
+                variables: {
+                    ERROR_MESSAGE: "Unathorized",
+                },
+            },
+            server_error: {
+                description: "Internal server error",
+                httpStatus: 500,
+                variables: {
+                    ERROR_MESSAGE: "Something went wrong",
+                },
+            },
+        },
+    },
     apiDir: "./src/app/api",
     schemaDir: "./src",
     schemaType: "typescript",
@@ -27,4 +70,5 @@ export default {
     ui: "scalar",
     outputFile: "openapi.json",
     includeOpenApiRoutes: false,
+    debug: false,
 };

package/package.json

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