next-openapi-gen 0.10.5 → 1.0.1

package/dist/commands/init.js

@@ -1,194 +0,0 @@
-import path from "path";
-import fse from "fs-extra";
-import fs from "fs";
-import ora from "ora";
-import { exec } from "child_process";
-import util from "util";
-import openapiTemplate from "../openapi-template.js";
-import { scalarDeps, scalarDevDeps, ScalarUI } from "../components/scalar.js";
-import { swaggerDeps, swaggerDevDeps, SwaggerUI } from "../components/swagger.js";
-import { redocDeps, redocDevDeps, RedocUI } from "../components/redoc.js";
-import { stoplightDeps, stoplightDevDeps, StoplightUI } from "../components/stoplight.js";
-import { rapidocDeps, rapidocDevDeps, RapidocUI } from "../components/rapidoc.js";
-const execPromise = util.promisify(exec);
-const spinner = ora("Initializing project with OpenAPI template...\n");
-async function hasDependency(packageName) {
-    try {
-        const packageJsonPath = path.join(process.cwd(), "package.json");
-        const packageJson = await fse.readJson(packageJsonPath);
-        return !!(packageJson.dependencies?.[packageName] || packageJson.devDependencies?.[packageName]);
-    }
-    catch {
-        return false;
-    }
-}
-const getPackageManager = async () => {
-    let currentDir = process.cwd();
-    while (true) {
-        // Check for Yarn lock file
-        if (fs.existsSync(path.join(currentDir, "yarn.lock"))) {
-            return "yarn";
-        }
-        // Check for PNPM lock file
-        if (fs.existsSync(path.join(currentDir, "pnpm-lock.yaml"))) {
-            return "pnpm";
-        }
-        // If we're at the root directory, break the loop
-        const parentDir = path.dirname(currentDir);
-        if (parentDir === currentDir) {
-            break; // We've reached the root
-        }
-        currentDir = parentDir; // Move up one directory
-    }
-    // Default to npm if no lock files are found
-    return "npm";
-};
-function getDocsPage(ui, outputFile) {
-    let DocsComponent = ScalarUI;
-    if (ui === "swagger") {
-        DocsComponent = SwaggerUI;
-    }
-    else if (ui === "redoc") {
-        DocsComponent = RedocUI;
-    }
-    else if (ui === "stoplight") {
-        DocsComponent = StoplightUI;
-    }
-    else if (ui === "rapidoc") {
-        DocsComponent = RapidocUI;
-    }
-    return DocsComponent(outputFile);
-}
-function getDocsPageInstallFlags(ui, packageManager) {
-    let installFlags = "";
-    if (ui === "swagger") {
-        // @temp: swagger-ui-react does not support React 19 now.
-        if (packageManager === "pnpm") {
-            installFlags = "--no-strict-peer-dependencies";
-        }
-        else if (packageManager === "yarn") {
-            installFlags = ""; // flag for legacy peer deps is not needed for yarn
-        }
-        else {
-            installFlags = "--legacy-peer-deps";
-        }
-    }
-    return installFlags;
-}
-function getDocsPageDependencies(ui) {
-    let deps = [];
-    if (ui === "scalar") {
-        deps = scalarDeps;
-    }
-    else if (ui === "swagger") {
-        deps = swaggerDeps;
-    }
-    else if (ui === "redoc") {
-        deps = redocDeps;
-    }
-    else if (ui === "stoplight") {
-        deps = stoplightDeps;
-    }
-    else if (ui === "rapidoc") {
-        deps = rapidocDeps;
-    }
-    return deps.join(" ");
-}
-function getDocsPageDevDependencies(ui) {
-    let devDeps = [];
-    if (ui === "scalar") {
-        devDeps = scalarDevDeps;
-    }
-    else if (ui === "swagger") {
-        devDeps = swaggerDevDeps;
-    }
-    else if (ui === "redoc") {
-        devDeps = redocDevDeps;
-    }
-    else if (ui === "stoplight") {
-        devDeps = stoplightDevDeps;
-    }
-    else if (ui === "rapidoc") {
-        devDeps = rapidocDevDeps;
-    }
-    return devDeps.join(" ");
-}
-async function createDocsPage(ui, outputFile) {
-    if (ui === "none") {
-        return;
-    }
-    const paths = ["app", "api-docs"];
-    const srcPath = path.join(process.cwd(), "src");
-    if (fs.existsSync(srcPath)) {
-        paths.unshift("src");
-    }
-    const docsDir = path.join(process.cwd(), ...paths);
-    await fs.promises.mkdir(docsDir, { recursive: true });
-    const docsPage = getDocsPage(ui, outputFile);
-    const componentPath = path.join(docsDir, "page.tsx");
-    await fs.promises.writeFile(componentPath, docsPage.trim());
-    spinner.succeed(`Created ${paths.join("/")}/page.tsx for ${ui}.`);
-}
-async function installDependencies(ui, schema) {
-    const packageManager = await getPackageManager();
-    const installCmd = `${packageManager} ${packageManager === "npm" ? "install" : "add"}`;
-    // Install UI dependencies
-    if (ui !== "none") {
-        const deps = getDocsPageDependencies(ui);
-        const devDeps = getDocsPageDevDependencies(ui);
-        const flags = getDocsPageInstallFlags(ui, packageManager);
-        if (deps) {
-            spinner.succeed(`Installing ${deps} dependencies...`);
-            await execPromise(`${installCmd} ${deps} ${flags}`);
-            spinner.succeed(`Successfully installed ${deps}.`);
-        }
-        if (devDeps) {
-            const devFlag = packageManager === "npm" ? "--save-dev" : "-D";
-            spinner.succeed(`Installing ${devDeps} dev dependencies...`);
-            await execPromise(`${installCmd} ${devFlag} ${devDeps} ${flags}`);
-            spinner.succeed(`Successfully installed ${devDeps}.`);
-        }
-    }
-    // Install schema dependencies
-    const schemaTypes = Array.isArray(schema) ? schema : [schema];
-    for (const schemaType of schemaTypes) {
-        if (schemaType === "zod" && !(await hasDependency("zod"))) {
-            spinner.succeed(`Installing zod...`);
-            await execPromise(`${installCmd} zod`);
-            spinner.succeed(`Successfully installed zod.`);
-        }
-        else if (schemaType === "typescript" && !(await hasDependency("typescript"))) {
-            const devFlag = packageManager === "npm" ? "--save-dev" : "-D";
-            spinner.succeed(`Installing typescript...`);
-            await execPromise(`${installCmd} ${devFlag} typescript`);
-            spinner.succeed(`Successfully installed typescript.`);
-        }
-    }
-}
-function extendOpenApiTemplate(spec, options) {
-    spec.ui = options.ui ?? spec.ui;
-    spec.docsUrl = options.docsUrl ?? spec.docsUrl;
-    spec.schemaType = options.schema ?? spec.schemaType;
-}
-function getOutputPath(output) {
-    if (output) {
-        return path.isAbsolute(output) ? output : path.join(process.cwd(), output);
-    }
-    return path.join(process.cwd(), "next.openapi.json");
-}
-export async function init(options) {
-    const { ui, output, schema } = options;
-    spinner.start();
-    try {
-        const outputPath = getOutputPath(output);
-        const template = { ...openapiTemplate };
-        extendOpenApiTemplate(template, options);
-        await fse.writeJson(outputPath, template, { spaces: 2 });
-        spinner.succeed(`Created OpenAPI template in ${outputPath}`);
-        createDocsPage(ui, template.outputFile);
-        installDependencies(ui, schema);
-    }
-    catch (error) {
-        spinner.fail(`Failed to initialize project: ${error.message}`);
-    }
-}

package/dist/components/redoc.js

@@ -1,17 +0,0 @@
-export const redocDeps = ["redoc"];
-export const redocDevDeps = [];
-export function RedocUI(outputFile) {
-    return `
-"use client";
-
-import { RedocStandalone } from "redoc";
-
-export default async function ApiDocsPage() {
-  return (
-    <section>
-      <RedocStandalone specUrl="/${outputFile}" />
-    </section>
-  );
-}
-`;
-}

package/dist/components/swagger.js

@@ -1,21 +0,0 @@
-export const swaggerDeps = ["swagger-ui", "swagger-ui-react"];
-export const swaggerDevDeps = ["@types/swagger-ui-react"];
-export function SwaggerUI(outputFile) {
-    return `
-import "swagger-ui-react/swagger-ui.css";
-
-import dynamic from "next/dynamic";
-
-const SwaggerUI = dynamic(() => import("swagger-ui-react"), {
-  loading: () => <p>Loading Component...</p>,
-});
-
-export default async function ApiDocsPage() {
-  return (
-    <section>
-      <SwaggerUI url="/${outputFile}" />
-    </section>
-  );
-}
-`;
-}

package/dist/lib/app-router-strategy.js

@@ -1,66 +0,0 @@
-import * as t from "@babel/types";
-import fs from "fs";
-import traverseModule from "@babel/traverse";
-const traverse = traverseModule.default || traverseModule;
-import { HTTP_METHODS } from "./router-strategy.js";
-import { extractJSDocComments, parseTypeScriptFile } from "./utils.js";
-export class AppRouterStrategy {
-    config;
-    constructor(config) {
-        this.config = config;
-    }
-    shouldProcessFile(fileName) {
-        return fileName === "route.ts" || fileName === "route.tsx";
-    }
-    processFile(filePath, addRoute) {
-        const content = fs.readFileSync(filePath, "utf-8");
-        const ast = parseTypeScriptFile(content);
-        traverse(ast, {
-            ExportNamedDeclaration: (path) => {
-                const declaration = path.node.declaration;
-                if (t.isFunctionDeclaration(declaration) &&
-                    t.isIdentifier(declaration.id)) {
-                    if (HTTP_METHODS.includes(declaration.id.name)) {
-                        const dataTypes = extractJSDocComments(path);
-                        addRoute(declaration.id.name, filePath, dataTypes);
-                    }
-                }
-                if (t.isVariableDeclaration(declaration)) {
-                    declaration.declarations.forEach((decl) => {
-                        if (t.isVariableDeclarator(decl) && t.isIdentifier(decl.id)) {
-                            if (HTTP_METHODS.includes(decl.id.name)) {
-                                const dataTypes = extractJSDocComments(path);
-                                addRoute(decl.id.name, 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 /route.ts or /route.tsx suffix
-        relativePath = relativePath.replace(/\/route\.tsx?$/, "");
-        if (!relativePath.startsWith("/")) {
-            relativePath = "/" + relativePath;
-        }
-        relativePath = relativePath.replace(/\/$/, "");
-        // Remove Next.js route groups (folders in parentheses like (authenticated))
-        relativePath = relativePath.replace(/\/\([^)]+\)/g, "");
-        // 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 || "/";
-    }
-}

package/dist/lib/drizzle-zod-processor.js

@@ -1,329 +0,0 @@
-import * as t from "@babel/types";
-import { logger } from "./logger.js";
-/**
- * Processor for drizzle-zod schemas
- *
- * Drizzle-zod is a library that generates Zod schemas from Drizzle ORM table definitions.
- * It provides helper functions like:
- * - createInsertSchema(tableDefinition, refinements)
- * - createSelectSchema(tableDefinition, refinements)
- *
- * This processor extracts field definitions and refinements to generate OpenAPI schemas.
- */
-export class DrizzleZodProcessor {
-    /**
-     * Known drizzle-zod helper function names
-     */
-    static DRIZZLE_ZOD_HELPERS = [
-        "createInsertSchema",
-        "createSelectSchema",
-        "createUpdateSchema",
-    ];
-    /**
-     * Process a drizzle-zod schema node
-     *
-     * @param node - The CallExpression node representing a drizzle-zod function call
-     * @returns OpenAPI schema object
-     */
-    static processSchema(node) {
-        const functionName = t.isIdentifier(node.callee)
-            ? node.callee.name
-            : "unknown";
-        logger.debug(`Processing drizzle-zod schema: ${functionName}`);
-        const schema = {
-            type: "object",
-            properties: {},
-            required: [],
-        };
-        // Check if there's a refinements object (second argument)
-        if (node.arguments.length > 1 && t.isObjectExpression(node.arguments[1])) {
-            const refinements = node.arguments[1];
-            // Process each property in the refinements object
-            refinements.properties.forEach((prop) => {
-                if (t.isObjectProperty(prop) || t.isObjectMethod(prop)) {
-                    const key = this.extractPropertyKey(prop);
-                    if (!key)
-                        return;
-                    // The value is typically an arrow function: (schema) => schema.field.method()
-                    if (t.isObjectProperty(prop) &&
-                        t.isArrowFunctionExpression(prop.value)) {
-                        const arrowFunc = prop.value;
-                        const fieldSchema = this.extractFieldSchema(arrowFunc.body);
-                        if (fieldSchema) {
-                            schema.properties[key] = fieldSchema;
-                            // Determine if field is required based on schema modifiers
-                            if (!this.isFieldOptional(arrowFunc.body)) {
-                                schema.required.push(key);
-                            }
-                        }
-                    }
-                }
-            });
-        }
-        // If no properties were extracted, return a generic object schema
-        if (Object.keys(schema.properties).length === 0) {
-            logger.debug("No properties extracted from drizzle-zod schema, returning generic object");
-            return { type: "object" };
-        }
-        return schema;
-    }
-    /**
-     * Extract property key from object property or method
-     */
-    static extractPropertyKey(prop) {
-        if (t.isIdentifier(prop.key)) {
-            return prop.key.name;
-        }
-        if (t.isStringLiteral(prop.key)) {
-            return prop.key.value;
-        }
-        return null;
-    }
-    /**
-     * Extract OpenAPI schema from a drizzle-zod field refinement
-     *
-     * Handles patterns like:
-     * - schema.field
-     * - schema.field.min(1)
-     * - schema.field.min(1).max(100).email()
-     */
-    static extractFieldSchema(node) {
-        // Handle member expressions like: schema.field
-        if (t.isMemberExpression(node)) {
-            if (t.isIdentifier(node.property)) {
-                const fieldType = node.property.name;
-                return this.mapFieldTypeToOpenApi(fieldType);
-            }
-        }
-        // Handle call expressions (chained methods like schema.field.min(1).max(100))
-        if (t.isCallExpression(node)) {
-            const baseSchema = this.extractFieldSchema(t.isMemberExpression(node.callee) ? node.callee.object : node);
-            if (baseSchema && t.isMemberExpression(node.callee)) {
-                const methodName = t.isIdentifier(node.callee.property)
-                    ? node.callee.property.name
-                    : null;
-                if (methodName) {
-                    return this.applyZodMethod(baseSchema, methodName, node.arguments);
-                }
-            }
-            return baseSchema;
-        }
-        return null;
-    }
-    /**
-     * Check if a drizzle-zod field is optional
-     */
-    static isFieldOptional(node) {
-        if (t.isCallExpression(node) && t.isMemberExpression(node.callee)) {
-            const methodName = t.isIdentifier(node.callee.property)
-                ? node.callee.property.name
-                : null;
-            if (methodName === "optional" ||
-                methodName === "nullish") {
-                return true;
-            }
-            // Check parent chain recursively
-            return this.isFieldOptional(node.callee.object);
-        }
-        return false;
-    }
-    /**
-     * Map Drizzle field types to OpenAPI types
-     *
-     * This provides intelligent mapping based on common field naming patterns.
-     * For more accurate type detection, the drizzle table schema would need to be analyzed.
-     */
-    static mapFieldTypeToOpenApi(fieldType) {
-        // Common mappings based on field naming conventions
-        const lowercaseField = fieldType.toLowerCase();
-        // String types
-        if (lowercaseField.includes("title") ||
-            lowercaseField.includes("name") ||
-            lowercaseField.includes("description") ||
-            lowercaseField.includes("content") ||
-            lowercaseField.includes("text") ||
-            lowercaseField.includes("slug") ||
-            lowercaseField.includes("email") ||
-            lowercaseField.includes("url") ||
-            lowercaseField.includes("phone")) {
-            const schema = { type: "string" };
-            // Add format hints
-            if (lowercaseField.includes("email")) {
-                schema.format = "email";
-            }
-            else if (lowercaseField.includes("url") ||
-                lowercaseField.includes("uri")) {
-                schema.format = "uri";
-            }
-            else if (lowercaseField.includes("uuid")) {
-                schema.format = "uuid";
-            }
-            return schema;
-        }
-        // Integer types
-        if (lowercaseField.includes("id") ||
-            lowercaseField.includes("count") ||
-            lowercaseField.includes("stock") ||
-            lowercaseField.includes("quantity") ||
-            lowercaseField.includes("age") ||
-            lowercaseField.includes("year")) {
-            return { type: "integer" };
-        }
-        // Number types
-        if (lowercaseField.includes("price") ||
-            lowercaseField.includes("amount") ||
-            lowercaseField.includes("rate") ||
-            lowercaseField.includes("percent")) {
-            return { type: "number" };
-        }
-        // Boolean types
-        if (lowercaseField.startsWith("is") ||
-            lowercaseField.startsWith("has") ||
-            lowercaseField.includes("active") ||
-            lowercaseField.includes("enabled") ||
-            lowercaseField.includes("published")) {
-            return { type: "boolean" };
-        }
-        // Date/time types
-        if (lowercaseField.includes("date") ||
-            lowercaseField.includes("time") ||
-            lowercaseField.includes("createdat") ||
-            lowercaseField.includes("updatedat") ||
-            lowercaseField.includes("deletedat")) {
-            return { type: "string", format: "date-time" };
-        }
-        // Default to string for unknown types
-        return { type: "string" };
-    }
-    /**
-     * Apply a Zod validation method to a schema
-     *
-     * Translates Zod validation methods to OpenAPI constraints:
-     * - min/max for strings become minLength/maxLength
-     * - min/max for numbers become minimum/maximum
-     * - email/url/uuid become format constraints
-     */
-    static applyZodMethod(schema, methodName, args) {
-        const result = { ...schema };
-        switch (methodName) {
-            case "min":
-                if (args.length > 0 && t.isNumericLiteral(args[0])) {
-                    if (schema.type === "string") {
-                        result.minLength = args[0].value;
-                    }
-                    else if (schema.type === "number" || schema.type === "integer") {
-                        result.minimum = args[0].value;
-                    }
-                    else if (schema.type === "array") {
-                        result.minItems = args[0].value;
-                    }
-                }
-                break;
-            case "max":
-                if (args.length > 0 && t.isNumericLiteral(args[0])) {
-                    if (schema.type === "string") {
-                        result.maxLength = args[0].value;
-                    }
-                    else if (schema.type === "number" || schema.type === "integer") {
-                        result.maximum = args[0].value;
-                    }
-                    else if (schema.type === "array") {
-                        result.maxItems = args[0].value;
-                    }
-                }
-                break;
-            case "length":
-                if (args.length > 0 && t.isNumericLiteral(args[0])) {
-                    if (schema.type === "string") {
-                        result.minLength = args[0].value;
-                        result.maxLength = args[0].value;
-                    }
-                    else if (schema.type === "array") {
-                        result.minItems = args[0].value;
-                        result.maxItems = args[0].value;
-                    }
-                }
-                break;
-            case "email":
-                result.format = "email";
-                break;
-            case "url":
-                result.format = "uri";
-                break;
-            case "uuid":
-                result.format = "uuid";
-                break;
-            case "datetime":
-                result.format = "date-time";
-                break;
-            case "regex":
-                if (args.length > 0) {
-                    // Try to extract pattern from regex literal
-                    if (t.isRegExpLiteral(args[0])) {
-                        result.pattern = args[0].pattern;
-                    }
-                }
-                break;
-            case "positive":
-                if (schema.type === "number" || schema.type === "integer") {
-                    result.minimum = 0;
-                    result.exclusiveMinimum = true;
-                }
-                break;
-            case "nonnegative":
-                if (schema.type === "number" || schema.type === "integer") {
-                    result.minimum = 0;
-                }
-                break;
-            case "negative":
-                if (schema.type === "number" || schema.type === "integer") {
-                    result.maximum = 0;
-                    result.exclusiveMaximum = true;
-                }
-                break;
-            case "nonpositive":
-                if (schema.type === "number" || schema.type === "integer") {
-                    result.maximum = 0;
-                }
-                break;
-            case "int":
-                result.type = "integer";
-                break;
-            case "optional":
-                // Handled by isFieldOptional check, no schema modification needed
-                break;
-            case "nullable":
-                result.nullable = true;
-                break;
-            case "nullish":
-                result.nullable = true;
-                break;
-            case "describe":
-                if (args.length > 0 && t.isStringLiteral(args[0])) {
-                    result.description = args[0].value;
-                }
-                break;
-            case "default":
-                if (args.length > 0) {
-                    // Extract default value
-                    if (t.isStringLiteral(args[0])) {
-                        result.default = args[0].value;
-                    }
-                    else if (t.isNumericLiteral(args[0])) {
-                        result.default = args[0].value;
-                    }
-                    else if (t.isBooleanLiteral(args[0])) {
-                        result.default = args[0].value;
-                    }
-                }
-                break;
-        }
-        return result;
-    }
-    /**
-     * Check if a function name is a drizzle-zod helper
-     */
-    static isDrizzleZodHelper(name) {
-        return this.DRIZZLE_ZOD_HELPERS.includes(name);
-    }
-}

package/dist/lib/logger.js

@@ -1,39 +0,0 @@
-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) {
-        const source = this.getCallerInfo();
-        console.log(`[${source}] ${message}`, ...args);
-    }
-    warn(message, ...args) {
-        const source = this.getCallerInfo();
-        console.warn(`[${source}] ${message}`, ...args);
-    }
-    error(message, ...args) {
-        const source = this.getCallerInfo();
-        console.error(`[${source}] ${message}`, ...args);
-    }
-    debug(message, ...args) {
-        if (this.config?.debug) {
-            const source = this.getCallerInfo();
-            console.log(`[${source}] ${message}`, ...args);
-        }
-    }
-}
-export const logger = new Logger();