@gyeonghokim/bruno-to-openapi 0.0.0 → 1.0.1

package/dist/utils/bruno-parser.js

@@ -0,0 +1,391 @@
+import path from 'node:path';
+import { FileReader } from './file-reader';
+/**
+ * Utility functions for parsing Bruno collection structures
+ */
+export class BrunoParser {
+    /**
+     * Parses a Bruno collection from a directory path
+     */
+    static async parseCollection(collectionPath) {
+        // Check if the path exists and is a directory
+        const isDir = await FileReader.isDirectory(collectionPath);
+        if (!isDir) {
+            throw new Error(`Collection path does not exist or is not a directory: ${collectionPath}`);
+        }
+        // Look for the required collection files
+        const brunoJsonPath = path.join(collectionPath, 'bruno.json');
+        const collectionBruPath = path.join(collectionPath, 'collection.bru');
+        let collection = {
+            version: '1',
+            uid: BrunoParser.generateUid(), // We'll generate a UID if not provided
+            name: path.basename(collectionPath), // Default to directory name
+            items: [],
+            pathname: collectionPath,
+            brunoConfig: undefined,
+        };
+        // Try to read bruno.json if it exists
+        if (await FileReader.fileExists(brunoJsonPath)) {
+            try {
+                const brunoJsonContent = await FileReader.readFile(brunoJsonPath);
+                let brunoJson;
+                try {
+                    brunoJson = JSON.parse(brunoJsonContent);
+                }
+                catch (parseError) {
+                    throw new Error(`Invalid JSON in bruno.json: ${parseError instanceof Error ? parseError.message : 'Unknown error'}`);
+                }
+                // Validate that brunoJson is an object
+                if (typeof brunoJson !== 'object' || brunoJson === null) {
+                    throw new Error('bruno.json must contain a valid JSON object');
+                }
+                // Type guard to check if it has the required properties
+                if (typeof brunoJson.name === 'string' &&
+                    brunoJson.name) {
+                    collection = { ...collection, name: brunoJson.name };
+                }
+                // Validate version
+                if (typeof brunoJson.version === 'string' &&
+                    ['1'].includes(brunoJson.version)) {
+                    collection = { ...collection, version: '1' };
+                }
+                // Store bruno config
+                if (typeof brunoJson === 'object' && brunoJson !== null) {
+                    collection = { ...collection, brunoConfig: brunoJson };
+                }
+            }
+            catch (error) {
+                if (error instanceof Error && error.message.includes('Invalid JSON')) {
+                    throw error; // Re-throw specific JSON errors
+                }
+                throw new Error(`Failed to parse bruno.json: ${error.message}`);
+            }
+        }
+        // Try to read collection.bru if it exists
+        if (await FileReader.fileExists(collectionBruPath)) {
+            try {
+                const collectionBruContent = await FileReader.readFile(collectionBruPath);
+                // TODO: Parse collection.bru content properly using bruno-lang if needed
+                // For now, we'll just acknowledge its existence
+                collection.root = { type: 'collection', name: collection.name };
+            }
+            catch (error) {
+                throw new Error(`Failed to parse collection.bru: ${error.message}`);
+            }
+        }
+        // Parse all .bru files in the collection directory
+        const bruFiles = await FileReader.getBruFiles(collectionPath);
+        if (bruFiles.length === 0) {
+            console.warn(`No .bru files found in collection directory: ${collectionPath}`);
+        }
+        const collectionItems = await BrunoParser.parseBruFiles(bruFiles, collectionPath);
+        collection = { ...collection, items: collectionItems };
+        return collection;
+    }
+    /**
+     * Parses individual .bru files into BrunoItem structures
+     */
+    static async parseBruFiles(bruFilePaths, collectionPath) {
+        const items = [];
+        for (const bruPath of bruFilePaths) {
+            try {
+                const content = await FileReader.readFile(bruPath);
+                const relativePath = path.relative(collectionPath, bruPath);
+                const parsedItem = await BrunoParser.parseBruContent(content, relativePath);
+                items.push(parsedItem);
+            }
+            catch (error) {
+                throw new Error(`Failed to parse .bru file ${bruPath}: ${error.message}`);
+            }
+        }
+        return items;
+    }
+    /**
+     * Parses the content of a single .bru file into a BrunoItem
+     */
+    static async parseBruContent(content, relativePath) {
+        // This is a more comprehensive parser for .bru files
+        const lines = content.split('\n');
+        const item = {
+            name: path.basename(relativePath, '.bru'),
+            pathname: relativePath,
+            type: 'http-request', // Default type
+            depth: relativePath.split('/').length - 1 || 0,
+            request: {}, // Initialize with empty request
+        };
+        // Parse the .bru content into sections
+        const sections = {};
+        let currentSection = null;
+        let currentSectionContent = [];
+        for (const line of lines) {
+            const trimmedLine = line.trim();
+            // Check if this is a section header like [sectionName]
+            if (trimmedLine.startsWith('[') && trimmedLine.endsWith(']')) {
+                // Save previous section if exists
+                if (currentSection) {
+                    sections[currentSection] = currentSectionContent;
+                }
+                // Start new section
+                currentSection = trimmedLine.substring(1, trimmedLine.length - 1);
+                currentSectionContent = [];
+            }
+            else {
+                // Add line to current section
+                currentSectionContent.push(line);
+            }
+        }
+        // Save the last section
+        if (currentSection) {
+            sections[currentSection] = currentSectionContent;
+        }
+        // Process each section
+        for (const [sectionName, sectionLines] of Object.entries(sections)) {
+            switch (sectionName) {
+                case 'meta':
+                    BrunoParser.parseMetaSection(sectionLines, item);
+                    break;
+                case 'request':
+                    BrunoParser.parseRequestSection(sectionLines, item);
+                    break;
+                case 'headers':
+                    if (!item.request)
+                        item.request = {};
+                    item.request.headers = BrunoParser.parseHeadersSection(sectionLines);
+                    break;
+                case 'params':
+                    if (!item.request)
+                        item.request = {};
+                    item.request.params = BrunoParser.parseParamsSection(sectionLines);
+                    break;
+                case 'body':
+                    if (!item.request)
+                        item.request = {};
+                    item.request.body = BrunoParser.parseBodySection(sectionLines);
+                    break;
+                case 'auth':
+                    if (!item.request)
+                        item.request = {};
+                    item.request.auth = BrunoParser.parseAuthSection(sectionLines);
+                    break;
+                default:
+                    // Process general properties not in sections
+                    for (const line of sectionLines) {
+                        if (line.includes('=')) {
+                            const parts = line.split('=', 2);
+                            const key = parts[0];
+                            const value = parts[1];
+                            const trimmedKey = key?.trim();
+                            const trimmedValue = value ? value.trim() : '';
+                            if (trimmedKey === 'name') {
+                                item.name = trimmedValue;
+                            }
+                            else if (trimmedKey === 'type' && trimmedValue) {
+                                item.type = trimmedValue;
+                            }
+                        }
+                    }
+            }
+        }
+        // If no name was extracted, use the filename
+        if (!item.name) {
+            item.name = path.basename(relativePath, '.bru');
+        }
+        return item;
+    }
+    /**
+     * Parses the meta section of a .bru file
+     */
+    static parseMetaSection(lines, item) {
+        for (const line of lines) {
+            if (line.includes('=')) {
+                const parts = line.split('=', 2);
+                const key = parts[0];
+                const value = parts[1];
+                const trimmedKey = key?.trim();
+                const trimmedValue = value ? value.trim() : '';
+                if (trimmedKey === 'name') {
+                    item.name = trimmedValue;
+                }
+                else if (trimmedKey === 'seq') {
+                    item.depth = Number.parseInt(trimmedValue, 10) || 0;
+                }
+            }
+        }
+    }
+    /**
+     * Parses the request section of a .bru file
+     */
+    static parseRequestSection(lines, item) {
+        if (!item.request)
+            item.request = {};
+        for (const line of lines) {
+            if (line.includes('=')) {
+                const parts = line.split('=', 2);
+                const key = parts[0];
+                const value = parts[1];
+                const trimmedKey = key?.trim();
+                const trimmedValue = value ? value.trim() : '';
+                if (trimmedKey === 'method') {
+                    item.request.method = trimmedValue;
+                }
+                else if (trimmedKey === 'url') {
+                    item.request.url = trimmedValue;
+                }
+            }
+        }
+    }
+    /**
+     * Parses the headers section of a .bru file
+     */
+    static parseHeadersSection(lines) {
+        const headers = [];
+        for (const line of lines) {
+            if (line.includes('=')) {
+                const parts = line.split('=', 2);
+                const key = parts[0];
+                const value = parts[1];
+                const trimmedKey = key?.trim();
+                const trimmedValue = value ? value.trim() : '';
+                if (trimmedKey && trimmedKey !== 'enabled') {
+                    // Skip the 'enabled' line if it's not part of a header
+                    headers.push({
+                        uid: BrunoParser.generateUid(),
+                        name: trimmedKey,
+                        value: trimmedValue,
+                        enabled: true,
+                    });
+                }
+            }
+        }
+        return headers;
+    }
+    /**
+     * Parses the params section of a .bru file
+     */
+    static parseParamsSection(lines) {
+        const params = [];
+        for (const line of lines) {
+            if (line.includes('=')) {
+                const parts = line.split('=', 2);
+                const key = parts[0];
+                const value = parts[1];
+                const trimmedKey = key?.trim();
+                const trimmedValue = value ? value.trim() : '';
+                if (trimmedKey && trimmedKey !== 'enabled') {
+                    // Skip the 'enabled' line if it's not part of a param
+                    params.push({
+                        uid: BrunoParser.generateUid(),
+                        name: trimmedKey,
+                        value: trimmedValue,
+                        type: 'query', // default type
+                        enabled: true,
+                    });
+                }
+            }
+        }
+        return params;
+    }
+    /**
+     * Parses the body section of a .bru file
+     */
+    static parseBodySection(lines) {
+        const body = {};
+        for (const line of lines) {
+            if (line.includes('=')) {
+                const parts = line.split('=', 2);
+                const key = parts[0];
+                const value = parts[1];
+                const trimmedKey = key?.trim();
+                const trimmedValue = value ? value.trim() : '';
+                if (trimmedKey === 'mode') {
+                    body.mode = trimmedValue;
+                }
+                else if (trimmedKey === 'json') {
+                    body.json = trimmedValue;
+                }
+                else if (trimmedKey === 'xml') {
+                    body.xml = trimmedValue;
+                }
+                else if (trimmedKey === 'text') {
+                    body.text = trimmedValue;
+                }
+            }
+        }
+        return body;
+    }
+    /**
+     * Parses the auth section of a .bru file
+     */
+    static parseAuthSection(lines) {
+        const auth = { mode: 'none' };
+        for (const line of lines) {
+            if (line.includes('=')) {
+                const parts = line.split('=', 2);
+                const key = parts[0];
+                const value = parts[1];
+                const trimmedKey = key?.trim();
+                const trimmedValue = value ? value.trim() : '';
+                if (trimmedKey === 'mode') {
+                    auth.mode = trimmedValue;
+                }
+                else if (trimmedKey === 'username') {
+                    if (auth.mode === 'basic' || auth.mode === 'digest') {
+                        if (!auth.basic)
+                            auth.basic = { username: '', password: '' };
+                        auth.basic.username = trimmedValue;
+                    }
+                    else if (auth.mode === 'oauth2') {
+                        if (!auth.oauth2)
+                            auth.oauth2 = { grantType: 'password', accessTokenUrl: '' };
+                        // Note: OAuth2 has more complex structure that needs to be handled properly
+                    }
+                }
+                else if (trimmedKey === 'password') {
+                    if (auth.mode === 'basic' || auth.mode === 'digest') {
+                        if (!auth.basic)
+                            auth.basic = { username: '', password: '' };
+                        auth.basic.password = trimmedValue;
+                    }
+                }
+                else if (trimmedKey === 'token') {
+                    if (auth.mode === 'bearer') {
+                        if (!auth.bearer)
+                            auth.bearer = { token: '' };
+                        auth.bearer.token = trimmedValue;
+                    }
+                }
+            }
+        }
+        return auth;
+    }
+    /**
+     * Validates if a given path contains a valid Bruno collection
+     */
+    static async isValidCollection(collectionPath) {
+        try {
+            // A Bruno collection should have either:
+            // 1. A bruno.json file, OR
+            // 2. At least one .bru file
+            const brunoJsonPath = path.join(collectionPath, 'bruno.json');
+            const hasBrunoJson = await FileReader.fileExists(brunoJsonPath);
+            if (hasBrunoJson) {
+                return true;
+            }
+            // Check for .bru files in the directory
+            const bruFiles = await FileReader.getBruFiles(collectionPath);
+            return bruFiles.length > 0;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Generates a unique identifier
+     */
+    static generateUid() {
+        // In a real implementation, you might want to use nanoid or similar
+        // For now, we'll create a simple UID based on timestamp and random number
+        return Date.now().toString(36) + Math.random().toString(36).substr(2, 5);
+    }
+}
+//# sourceMappingURL=bruno-parser.js.map

package/dist/utils/file-reader.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Utility functions for reading files in the Bruno collection
+ */
+export declare class FileReader {
+    /**
+     * Reads a file and returns its content as a string
+     */
+    static readFile(filePath: string): Promise<string>;
+    /**
+     * Checks if a file exists
+     */
+    static fileExists(filePath: string): Promise<boolean>;
+    /**
+     * Checks if a path is a directory
+     */
+    static isDirectory(dirPath: string): Promise<boolean>;
+    /**
+     * Reads all files in a directory recursively
+     */
+    static readDirRecursively(dirPath: string): Promise<string[]>;
+    /**
+     * Gets all JSON files in a directory
+     */
+    static getJsonFiles(dirPath: string): Promise<string[]>;
+    /**
+     * Gets all .bru files in a directory
+     */
+    static getBruFiles(dirPath: string): Promise<string[]>;
+    /**
+     * Safely resolves a path to prevent path traversal
+     */
+    static safeResolve(basePath: string, relativePath: string): string;
+}
+//# sourceMappingURL=file-reader.d.ts.map

package/dist/utils/file-reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-reader.d.ts","sourceRoot":"","sources":["../../src/utils/file-reader.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,qBAAa,UAAU;IACrB;;OAEG;WACU,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAoBxD;;OAEG;WACU,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAS3D;;OAEG;WACU,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAS3D;;OAEG;WACU,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAsBnE;;OAEG;WACU,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAK7D;;OAEG;WACU,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAK5D;;OAEG;IACH,MAAM,CAAC,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM;CAWnE"}

package/dist/utils/file-reader.js

@@ -0,0 +1,104 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+/**
+ * Utility functions for reading files in the Bruno collection
+ */
+export class FileReader {
+    /**
+     * Reads a file and returns its content as a string
+     */
+    static async readFile(filePath) {
+        try {
+            // Validate file path to prevent path traversal attacks
+            const resolvedPath = path.resolve(filePath);
+            if (!(resolvedPath.startsWith(path.resolve('.')) || resolvedPath.startsWith(process.cwd()))) {
+                throw new Error('Invalid file path: path traversal detected');
+            }
+            return await fs.readFile(filePath, 'utf-8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                throw new Error(`File does not exist: ${filePath}`);
+            }
+            if (error.code === 'EACCES') {
+                throw new Error(`Access denied reading file: ${filePath}`);
+            }
+            throw new Error(`Failed to read file ${filePath}: ${error.message}`);
+        }
+    }
+    /**
+     * Checks if a file exists
+     */
+    static async fileExists(filePath) {
+        try {
+            await fs.access(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Checks if a path is a directory
+     */
+    static async isDirectory(dirPath) {
+        try {
+            const stats = await fs.stat(dirPath);
+            return stats.isDirectory();
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Reads all files in a directory recursively
+     */
+    static async readDirRecursively(dirPath) {
+        try {
+            const entries = await fs.readdir(dirPath, { withFileTypes: true });
+            const files = [];
+            for (const entry of entries) {
+                // Prevent symbolic link loops and other path issues
+                const fullPath = path.resolve(dirPath, entry.name);
+                if (entry.isDirectory()) {
+                    const nestedFiles = await FileReader.readDirRecursively(fullPath);
+                    files.push(...nestedFiles);
+                }
+                else {
+                    files.push(fullPath);
+                }
+            }
+            return files;
+        }
+        catch (error) {
+            throw new Error(`Failed to read directory ${dirPath}: ${error.message}`);
+        }
+    }
+    /**
+     * Gets all JSON files in a directory
+     */
+    static async getJsonFiles(dirPath) {
+        const files = await FileReader.readDirRecursively(dirPath);
+        return files.filter(file => path.extname(file) === '.json');
+    }
+    /**
+     * Gets all .bru files in a directory
+     */
+    static async getBruFiles(dirPath) {
+        const files = await FileReader.readDirRecursively(dirPath);
+        return files.filter(file => path.extname(file) === '.bru');
+    }
+    /**
+     * Safely resolves a path to prevent path traversal
+     */
+    static safeResolve(basePath, relativePath) {
+        const resolved = path.resolve(basePath, relativePath);
+        const normalizedBase = path.resolve(basePath);
+        // Ensure the resolved path is within the base path
+        if (!resolved.startsWith(normalizedBase)) {
+            throw new Error('Path traversal detected');
+        }
+        return resolved;
+    }
+}
+//# sourceMappingURL=file-reader.js.map

package/dist/utils/openapi-generator.d.ts

@@ -0,0 +1,53 @@
+import type { BrunoCollection } from '../types/bruno';
+import type { ResponsesObject, SchemaObject } from '../types/openapi';
+import type { ConvertResult } from '../types/result';
+/**
+ * Utility functions for generating OpenAPI specifications
+ */
+export declare class OpenApiGenerator {
+    /**
+     * Generates an OpenAPI specification from a Bruno collection
+     */
+    static generateOpenApiSpec(collection: BrunoCollection): ConvertResult;
+    /**
+     * Processes collection items to build OpenAPI paths
+     */
+    private static processCollectionItems;
+    /**
+     * Processes an HTTP request item to add to OpenAPI paths
+     */
+    private static processHttpRequest;
+    /**
+     * Creates an OpenAPI operation from a Bruno request
+     */
+    private static createOperationFromRequest;
+    /**
+     * Creates OpenAPI parameters from Bruno parameters
+     */
+    private static createParametersFromBrunoParams;
+    /**
+     * Creates OpenAPI header parameters from Bruno headers
+     */
+    private static createParametersFromBrunoHeaders;
+    /**
+     * Creates security requirements from Bruno auth configuration
+     */
+    private static createSecurityRequirementsFromAuth;
+    /**
+     * Creates an OpenAPI request body from Bruno body
+     */
+    private static createRequestBodyFromBrunoBody;
+    /**
+     * Infers a schema from JSON content
+     */
+    private static inferSchemaFromJson;
+    /**
+     * Infers a schema from a JavaScript value
+     */
+    static inferSchemaFromValue(value: unknown): SchemaObject;
+    /**
+     * Creates default responses for an operation
+     */
+    static createDefaultResponses(): ResponsesObject;
+}
+//# sourceMappingURL=openapi-generator.d.ts.map

package/dist/utils/openapi-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openapi-generator.d.ts","sourceRoot":"","sources":["../../src/utils/openapi-generator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,eAAe,EAKhB,MAAM,gBAAgB,CAAA;AACvB,OAAO,KAAK,EAUV,eAAe,EACf,YAAY,EACb,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EAAE,aAAa,EAAkB,MAAM,iBAAiB,CAAA;AAEpE;;GAEG;AACH,qBAAa,gBAAgB;IAC3B;;OAEG;IACH,MAAM,CAAC,mBAAmB,CAAC,UAAU,EAAE,eAAe,GAAG,aAAa;IAsDtE;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,sBAAsB;IAiBrC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,kBAAkB;IAmFjC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,0BAA0B;IAgEzC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,+BAA+B;IAsB9C;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,gCAAgC;IAmB/C;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,kCAAkC;IAwCjD;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,8BAA8B;IA6H7C;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,mBAAmB;IAUlC;;OAEG;IACH,MAAM,CAAC,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,YAAY;IAiDzD;;OAEG;IACH,MAAM,CAAC,sBAAsB,IAAI,eAAe;CA8EjD"}