next-openapi-gen 0.10.5 → 1.0.0

package/dist/lib/openapi-generator.js

@@ -1,171 +0,0 @@
-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;
-    routeProcessor;
-    constructor(opts = {}) {
-        const templatePath = opts.templatePath || path.resolve("./next.openapi.json");
-        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, routerType, schemaDir, docsUrl, ui, outputFile, outputDir, includeOpenApiRoutes, ignoreRoutes, schemaType = "typescript", schemaFiles, defaultResponseSet, responseSets, errorConfig, debug } = this.template;
-        return {
-            apiDir: apiDir || "./src/app/api",
-            routerType: routerType || "app",
-            schemaDir: schemaDir || "./src",
-            docsUrl: docsUrl || "api-docs",
-            ui: ui || "scalar",
-            outputFile: outputFile || "openapi.json",
-            outputDir: outputDir || "./public",
-            includeOpenApiRoutes: includeOpenApiRoutes || false,
-            ignoreRoutes: ignoreRoutes || [],
-            schemaType,
-            schemaFiles: schemaFiles || [],
-            defaultResponseSet,
-            responseSets,
-            errorConfig,
-            debug: debug || false,
-        };
-    }
-    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");
-            logger.debug(`Found app router API directory at ${appRouterApiDir}`);
-        }
-        // Scan pages router routes
-        this.routeProcessor.scanApiRoutes(apiDir);
-        // If app router directory exists, scan it as well
-        if (appRouterApiDir) {
-            this.routeProcessor.scanApiRoutes(appRouterApiDir);
-        }
-        this.template.paths = this.routeProcessor.getSwaggerPaths();
-        // Add server URL for examples if not already defined
-        if (!this.template.servers || this.template.servers.length === 0) {
-            this.template.servers = [
-                {
-                    url: this.template.basePath || "",
-                    description: "API server",
-                },
-            ];
-        }
-        // Ensure there's a components section if not already defined
-        if (!this.template.components) {
-            this.template.components = {};
-        }
-        // Add schemas section if not already defined
-        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()
-            .getDefinedSchemas();
-        if (definedSchemas && Object.keys(definedSchemas).length > 0) {
-            this.template.components.schemas = {
-                ...this.template.components.schemas,
-                ...definedSchemas,
-            };
-        }
-        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 numericCode = parseInt(errorCode);
-        if (numericCode >= 100 && numericCode < 600) {
-            return numericCode;
-        }
-        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/pages-router-strategy.js

@@ -1,198 +0,0 @@
-import fs from "fs";
-import traverseModule from "@babel/traverse";
-const traverse = traverseModule.default || traverseModule;
-import { HTTP_METHODS } from "./router-strategy.js";
-import { parseTypeScriptFile, performAuthPresetReplacements } from "./utils.js";
-export class PagesRouterStrategy {
-    config;
-    constructor(config) {
-        this.config = config;
-    }
-    shouldProcessFile(fileName) {
-        return (!fileName.startsWith("_") &&
-            (fileName.endsWith(".ts") || fileName.endsWith(".tsx")));
-    }
-    processFile(filePath, addRoute) {
-        const content = fs.readFileSync(filePath, "utf-8");
-        const ast = parseTypeScriptFile(content);
-        const methodComments = [];
-        traverse(ast, {
-            ExportDefaultDeclaration: (nodePath) => {
-                const allComments = ast.comments || [];
-                const exportStart = nodePath.node.start || 0;
-                allComments.forEach((comment) => {
-                    if (comment.type === "CommentBlock" &&
-                        (comment.end || 0) < exportStart) {
-                        const commentValue = comment.value;
-                        if (commentValue.includes("@method")) {
-                            const dataTypes = this.extractJSDocFromComment(commentValue);
-                            if (dataTypes.method && HTTP_METHODS.includes(dataTypes.method)) {
-                                methodComments.push({
-                                    method: dataTypes.method,
-                                    dataTypes,
-                                });
-                            }
-                        }
-                    }
-                });
-                methodComments.forEach(({ method, dataTypes }) => {
-                    addRoute(method, filePath, dataTypes);
-                });
-            },
-        });
-    }
-    getRoutePath(filePath) {
-        const normalizedPath = filePath.replaceAll("\\", "/");
-        const normalizedApiDir = this.config.apiDir
-            .replaceAll("\\", "/")
-            .replace(/^\.\//, "")
-            .replace(/\/$/, "");
-        const apiDirIndex = normalizedPath.indexOf(normalizedApiDir);
-        if (apiDirIndex === -1) {
-            throw new Error(`Could not find apiDir "${this.config.apiDir}" in file path "${filePath}"`);
-        }
-        let relativePath = normalizedPath.substring(apiDirIndex + normalizedApiDir.length);
-        // Remove the file extension (.ts or .tsx)
-        relativePath = relativePath.replace(/\.tsx?$/, "");
-        // Remove /index suffix (pages/api/users/index.ts -> /users)
-        relativePath = relativePath.replace(/\/index$/, "");
-        if (!relativePath.startsWith("/")) {
-            relativePath = "/" + relativePath;
-        }
-        relativePath = relativePath.replace(/\/$/, "");
-        // Handle catch-all routes before dynamic routes
-        relativePath = relativePath.replace(/\/\[\.\.\.(.*?)\]/g, "/{$1}");
-        // Convert Next.js dynamic route syntax to OpenAPI parameter syntax
-        relativePath = relativePath.replace(/\/\[([^\]]+)\]/g, "/{$1}");
-        return relativePath || "/";
-    }
-    /**
-     * Extract JSDoc data from a raw comment string (Pages Router specific)
-     */
-    extractJSDocFromComment(commentValue) {
-        const cleanedComment = commentValue.replace(/\*\s*/g, "").trim();
-        let tag = "";
-        let summary = "";
-        let description = "";
-        let paramsType = "";
-        let pathParamsType = "";
-        let bodyType = "";
-        let auth = "";
-        let isOpenApi = cleanedComment.includes("@openapi");
-        let isIgnored = cleanedComment.includes("@ignore");
-        let deprecated = cleanedComment.includes("@deprecated");
-        let bodyDescription = "";
-        let contentType = "";
-        let responseType = "";
-        let responseDescription = "";
-        let responseSet = "";
-        let addResponses = "";
-        let successCode = "";
-        let operationId = "";
-        let method = "";
-        const methodMatch = cleanedComment.match(/@method\s+(\S+)/);
-        if (methodMatch) {
-            method = methodMatch[1].trim().toUpperCase();
-        }
-        const firstLine = cleanedComment.split("\n")[0];
-        if (!firstLine.trim().startsWith("@")) {
-            summary = firstLine.trim();
-        }
-        const descMatch = cleanedComment.match(/@description\s+(.*)/);
-        if (descMatch) {
-            description = descMatch[1].trim();
-        }
-        const tagMatch = cleanedComment.match(/@tag\s+(.*)/);
-        if (tagMatch) {
-            tag = tagMatch[1].trim();
-        }
-        const paramsMatch = cleanedComment.match(/@queryParams\s+([\w<>,\s\[\]]+)/) ||
-            cleanedComment.match(/@params\s+([\w<>,\s\[\]]+)/);
-        if (paramsMatch) {
-            paramsType = paramsMatch[1].trim();
-        }
-        const pathParamsMatch = cleanedComment.match(/@pathParams\s+([\w<>,\s\[\]]+)/);
-        if (pathParamsMatch) {
-            pathParamsType = pathParamsMatch[1].trim();
-        }
-        const bodyMatch = cleanedComment.match(/@body\s+([\w<>,\s\[\]]+)/);
-        if (bodyMatch) {
-            bodyType = bodyMatch[1].trim();
-        }
-        const bodyDescMatch = cleanedComment.match(/@bodyDescription\s+(.*)/);
-        if (bodyDescMatch) {
-            bodyDescription = bodyDescMatch[1].trim();
-        }
-        const contentTypeMatch = cleanedComment.match(/@contentType\s+(.*)/);
-        if (contentTypeMatch) {
-            contentType = contentTypeMatch[1].trim();
-        }
-        const responseMatch = cleanedComment.match(/@response\s+(?:(\d+):)?([^@\n\r]+)/);
-        if (responseMatch) {
-            const [, code, type] = responseMatch;
-            const trimmedType = type?.trim();
-            if (!code && trimmedType && /^\d{3}$/.test(trimmedType)) {
-                successCode = trimmedType;
-                responseType = undefined;
-            }
-            else {
-                successCode = code || "";
-                responseType = trimmedType;
-            }
-        }
-        const respDescMatch = cleanedComment.match(/@responseDescription\s+(.*)/);
-        if (respDescMatch) {
-            responseDescription = respDescMatch[1].trim();
-        }
-        const respSetMatch = cleanedComment.match(/@responseSet\s+(.*)/);
-        if (respSetMatch) {
-            responseSet = respSetMatch[1].trim();
-        }
-        const addMatches = [...cleanedComment.matchAll(/@add\s+([^\n\r@]*)/g)];
-        if (addMatches.length > 0) {
-            addResponses = addMatches.map((m) => m[1].trim()).join(",");
-        }
-        const opIdMatch = cleanedComment.match(/@operationId\s+(\S+)/);
-        if (opIdMatch) {
-            operationId = opIdMatch[1].trim();
-        }
-        const authMatch = cleanedComment.match(/@auth\s+(.*)/);
-        if (authMatch) {
-            const authValue = authMatch[1].trim();
-            switch (authValue) {
-                case "bearer":
-                    auth = "BearerAuth";
-                    break;
-                case "basic":
-                    auth = "BasicAuth";
-                    break;
-                case "apikey":
-                    auth = "ApiKeyAuth";
-                    break;
-                default:
-                    auth = performAuthPresetReplacements(authValue);
-            }
-        }
-        return {
-            tag,
-            auth,
-            summary,
-            description,
-            paramsType,
-            pathParamsType,
-            bodyType,
-            isOpenApi,
-            isIgnored,
-            deprecated,
-            bodyDescription,
-            contentType,
-            responseType,
-            responseDescription,
-            responseSet,
-            addResponses,
-            successCode,
-            operationId,
-            method,
-        };
-    }
-}