@gyeonghokim/bruno-to-openapi 1.0.2 → 1.1.0

package/README.md

@@ -1,6 +1,6 @@
 # Bruno to OpenAPI
 
-Convert Bruno collections to OpenAPI specifications with ease. This library provides a simple way to transform Bruno collection JSON files into standardized OpenAPI 3.x specifications.
+Convert Bruno collections to OpenAPI specifications with ease. This library provides a simple way to transform Bruno collection directories into standardized OpenAPI 3.x specifications.
 
 ## Installation
 
@@ -14,24 +14,25 @@ npm install @gyeonghokim/bruno-to-openapi
 
 Once installed, you can use the library to convert your Bruno collections to OpenAPI specifications. Below are examples showing how to export to both JSON and YAML formats.
 
-### JSON Export
+### JSON Export (Async)
 
 ```javascript
-import { convertBrunoToOpenAPI } from '@gyeonghokim/bruno-to-openapi';
+import { convertBrunoCollectionToOpenAPI } from '@gyeonghokim/bruno-to-openapi';
 import fs from 'fs';
 
-// Load your Bruno collection JSON file
-import brunoCollection from './path-to-your-bruno-collection.json';
+async function convertCollection() {
+  // Convert Bruno collection directory to OpenAPI specification
+  const result = await convertBrunoCollectionToOpenAPI('./path-to-your-bruno-collection-directory');
 
-// Convert Bruno collection to OpenAPI specification
-const openApiSpec = convertBrunoToOpenAPI(brunoCollection);
+  // Save as JSON file
+  fs.writeFileSync('openapi-spec.json', JSON.stringify(result.openapi, null, 2));
+  console.log('OpenAPI specification saved as openapi-spec.json');
+}
 
-// Save as JSON file
-fs.writeFileSync('openapi-spec.json', JSON.stringify(openApiSpec, null, 2));
-console.log('OpenAPI specification saved as openapi-spec.json');
+convertCollection();
 ```
 
-### YAML Export
+### YAML Export (Async)
 
 To export as YAML, you can use the `js-yaml` library along with this package:
 
@@ -40,20 +41,21 @@ npm install js-yaml
 ```
 
 ```javascript
-import { convertBrunoToOpenAPI } from '@gyeonghokim/bruno-to-openapi';
+import { convertBrunoCollectionToOpenAPI } from '@gyeonghokim/bruno-to-openapi';
 import yaml from 'js-yaml';
 import fs from 'fs';
 
-// Load your Bruno collection JSON file
-import brunoCollection from './path-to-your-bruno-collection.json';
+async function convertCollection() {
+  // Convert Bruno collection directory to OpenAPI specification
+  const result = await convertBrunoCollectionToOpenAPI('./path-to-your-bruno-collection-directory');
 
-// Convert Bruno collection to OpenAPI specification
-const openApiSpec = convertBrunoToOpenAPI(brunoCollection);
+  // Convert to YAML and save
+  const yamlString = yaml.dump(result.openapi, { indent: 2 });
+  fs.writeFileSync('openapi-spec.yaml', yamlString);
+  console.log('OpenAPI specification saved as openapi-spec.yaml');
+}
 
-// Convert to YAML and save
-const yamlString = yaml.dump(openApiSpec, { indent: 2 });
-fs.writeFileSync('openapi-spec.yaml', yamlString);
-console.log('OpenAPI specification saved as openapi-spec.yaml');
+convertCollection();
 ```
 
 ## Features
@@ -64,12 +66,16 @@ console.log('OpenAPI specification saved as openapi-spec.yaml');
 - Preserves request/response examples
 - Maintains folder structures as tags
 - Supports both JSON and YAML output formats
+- Provides synchronous and asynchronous conversion options
+- Includes collection validation utilities
 
 ## API Reference
 
-The library exports a single function:
+The library exports the following functions:
 
-- `convertBrunoToOpenAPI(brunoCollection)`: Takes a Bruno collection object and returns an OpenAPI specification object.
+- `convertBrunoCollectionToOpenAPI(collectionPath)`: Asynchronously takes a Bruno collection directory path and returns a Promise resolving to the conversion result containing the OpenAPI specification.
+- `convertBrunoCollectionToAPISync(collectionPath)`: Synchronously takes a Bruno collection directory path and returns the conversion result containing the OpenAPI specification (Note: The full synchronous implementation has limitations and it's recommended to use the async version).
+- `isValidBrunoCollection(collectionPath)`: Asynchronously validates if a given path contains a valid Bruno collection and returns a Promise resolving to true if valid.
 
 ## Contributing
 

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AAItD;;;;;GAKG;AACH,wBAAsB,+BAA+B,CACnD,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,aAAa,CAAC,CAYxB;AAED;;;;;GAKG;AACH,wBAAgB,mCAAmC,CAAC,cAAc,EAAE,MAAM,GAAG,aAAa,CAqCzF;AAED;;;;GAIG;AACH,wBAAsB,sBAAsB,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAOrF;AAED,YAAY,EACV,UAAU,EACV,eAAe,EACf,aAAa,EACb,eAAe,EACf,eAAe,EACf,cAAc,EACd,iBAAiB,EACjB,cAAc,EACd,eAAe,EACf,YAAY,GACb,MAAM,oBAAoB,CAAA;AAE3B,YAAY,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AAItD;;;;;GAKG;AACH,wBAAsB,+BAA+B,CACnD,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,aAAa,CAAC,CAYxB;AAED;;;;;GAKG;AACH,wBAAgB,mCAAmC,CAAC,cAAc,EAAE,MAAM,GAAG,aAAa,CAYzF;AAED;;;;GAIG;AACH,wBAAsB,sBAAsB,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAOrF;AAED,YAAY,EACV,UAAU,EACV,eAAe,EACf,aAAa,EACb,eAAe,EACf,eAAe,EACf,cAAc,EACd,iBAAiB,EACjB,cAAc,EACd,eAAe,EACf,YAAY,GACb,MAAM,oBAAoB,CAAA;AAE3B,YAAY,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA"}

package/dist/index.js

@@ -26,33 +26,14 @@ export async function convertBrunoCollectionToOpenAPI(collectionPath) {
  */
 export function convertBrunoCollectionToOpenAPISync(collectionPath) {
     try {
-        // For a true synchronous implementation, we would need to implement sync versions
-        // of our file operations. For now, we'll use require instead of import to avoid
-        // top-level await issues, but note that this is still using async operations
-        // which cannot truly be made synchronous without blocking the event loop.
-        // A proper sync implementation would require refactoring our file readers to
-        // have both sync and async versions.
-        // For now, we'll implement a simplified sync version by reading files directly
-        const fs = require('node:fs');
-        const pathModule = require('node:path');
-        // Check if it's a valid collection first
-        if (!(fs.existsSync(collectionPath) && fs.statSync(collectionPath).isDirectory())) {
-            throw new Error(`Collection path does not exist or is not a directory: ${collectionPath}`);
-        }
-        // Look for bruno.json
-        const brunoJsonPath = pathModule.join(collectionPath, 'bruno.json');
-        let brunoConfig = null;
-        if (fs.existsSync(brunoJsonPath)) {
-            const brunoJsonContent = fs.readFileSync(brunoJsonPath, 'utf-8');
-            brunoConfig = JSON.parse(brunoJsonContent);
-        }
-        // Since the full synchronous implementation requires significant changes
-        // to support sync file operations throughout the pipeline, we'll throw
-        // an error indicating that for full sync functionality, async should be used
-        throw new Error('Full synchronous conversion requires significant architectural changes to support sync file operations throughout the pipeline. Please use the async version: convertBrunoCollectionToOpenAPI()');
+        // Parse the Bruno collection synchronously
+        const collection = BrunoParser.parseCollectionSync(collectionPath);
+        // Generate the OpenAPI specification
+        const result = OpenApiGenerator.generateOpenApiSpec(collection);
+        return result;
     }
     catch (error) {
-        throw new Error(`Failed to convert Bruno collection to OpenAPI synchronously: ${error.message}`);
+        throw new Error(`Failed to convert Bruno collection to OpenAPI: ${error.message}`);
     }
 }
 /**

package/dist/utils/bruno-parser.d.ts

@@ -47,5 +47,21 @@ export declare class BrunoParser {
      * Generates a unique identifier
      */
     private static generateUid;
+    /**
+     * Parses a Bruno collection from a directory path synchronously
+     */
+    static parseCollectionSync(collectionPath: string): BrunoCollection;
+    /**
+     * Parses individual .bru files into BrunoItem structures synchronously
+     */
+    static parseBruFilesSync(bruFilePaths: string[], collectionPath: string): BrunoItem[];
+    /**
+     * Parses the content of a single .bru file into a BrunoItem synchronously
+     */
+    static parseBruContentSync(content: string, relativePath: string): BrunoItem;
+    /**
+     * Validates if a given path contains a valid Bruno collection synchronously
+     */
+    static isValidCollectionSync(collectionPath: string): boolean;
 }
 //# sourceMappingURL=bruno-parser.d.ts.map

package/dist/utils/bruno-parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bruno-parser.d.ts","sourceRoot":"","sources":["../../src/utils/bruno-parser.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAGV,eAAe,EAGf,SAAS,EAMV,MAAM,mBAAmB,CAAA;AAG1B;;GAEG;AACH,qBAAa,WAAW;IACtB;;OAEG;WACU,eAAe,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IA6F9E;;OAEG;WACU,aAAa,CAAC,YAAY,EAAE,MAAM,EAAE,EAAE,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IAiBhG;;OAEG;WACU,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC;IAmGvF;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAkB/B;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,mBAAmB;IAoBlC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,mBAAmB;IA0BlC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,kBAAkB;IA2BjC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAmC/B;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAgD/B;;OAEG;WACU,iBAAiB,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAoBxE;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,WAAW;CAK3B"}
+{"version":3,"file":"bruno-parser.d.ts","sourceRoot":"","sources":["../../src/utils/bruno-parser.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAGV,eAAe,EAGf,SAAS,EAMV,MAAM,mBAAmB,CAAA;AAG1B;;GAEG;AACH,qBAAa,WAAW;IACtB;;OAEG;WACU,eAAe,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IA6F9E;;OAEG;WACU,aAAa,CAAC,YAAY,EAAE,MAAM,EAAE,EAAE,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IAiBhG;;OAEG;WACU,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC;IAmGvF;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAkB/B;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,mBAAmB;IAoBlC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,mBAAmB;IA0BlC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,kBAAkB;IA2BjC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAmC/B;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAgD/B;;OAEG;WACU,iBAAiB,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAoBxE;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,WAAW;IAM1B;;OAEG;IACH,MAAM,CAAC,mBAAmB,CAAC,cAAc,EAAE,MAAM,GAAG,eAAe;IA6FnE;;OAEG;IACH,MAAM,CAAC,iBAAiB,CAAC,YAAY,EAAE,MAAM,EAAE,EAAE,cAAc,EAAE,MAAM,GAAG,SAAS,EAAE;IAiBrF;;OAEG;IACH,MAAM,CAAC,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,SAAS;IAmG5E;;OAEG;IACH,MAAM,CAAC,qBAAqB,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO;CAmB9D"}

package/dist/utils/bruno-parser.js

@@ -387,5 +387,214 @@ export class BrunoParser {
         // 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);
     }
+    /**
+     * Parses a Bruno collection from a directory path synchronously
+     */
+    static parseCollectionSync(collectionPath) {
+        // Check if the path exists and is a directory
+        const isDir = FileReader.isDirectorySync(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 (FileReader.fileExistsSync(brunoJsonPath)) {
+            try {
+                const brunoJsonContent = FileReader.readFileSync(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 (FileReader.fileExistsSync(collectionBruPath)) {
+            try {
+                const collectionBruContent = FileReader.readFileSync(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 = FileReader.getBruFilesSync(collectionPath);
+        if (bruFiles.length === 0) {
+            console.warn(`No .bru files found in collection directory: ${collectionPath}`);
+        }
+        const collectionItems = BrunoParser.parseBruFilesSync(bruFiles, collectionPath);
+        collection = { ...collection, items: collectionItems };
+        return collection;
+    }
+    /**
+     * Parses individual .bru files into BrunoItem structures synchronously
+     */
+    static parseBruFilesSync(bruFilePaths, collectionPath) {
+        const items = [];
+        for (const bruPath of bruFilePaths) {
+            try {
+                const content = FileReader.readFileSync(bruPath);
+                const relativePath = path.relative(collectionPath, bruPath);
+                const parsedItem = BrunoParser.parseBruContentSync(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 synchronously
+     */
+    static parseBruContentSync(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;
+    }
+    /**
+     * Validates if a given path contains a valid Bruno collection synchronously
+     */
+    static isValidCollectionSync(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 = FileReader.fileExistsSync(brunoJsonPath);
+            if (hasBrunoJson) {
+                return true;
+            }
+            // Check for .bru files in the directory
+            const bruFiles = FileReader.getBruFilesSync(collectionPath);
+            return bruFiles.length > 0;
+        }
+        catch (error) {
+            return false;
+        }
+    }
 }
 //# sourceMappingURL=bruno-parser.js.map

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

@@ -30,5 +30,29 @@ export declare class FileReader {
      * Safely resolves a path to prevent path traversal
      */
     static safeResolve(basePath: string, relativePath: string): string;
+    /**
+     * Reads a file synchronously and returns its content as a string
+     */
+    static readFileSync(filePath: string): string;
+    /**
+     * Checks if a file exists synchronously
+     */
+    static fileExistsSync(filePath: string): boolean;
+    /**
+     * Checks if a path is a directory synchronously
+     */
+    static isDirectorySync(dirPath: string): boolean;
+    /**
+     * Reads all files in a directory recursively synchronously
+     */
+    static readDirRecursivelySync(dirPath: string): string[];
+    /**
+     * Gets all JSON files in a directory synchronously
+     */
+    static getJsonFilesSync(dirPath: string): string[];
+    /**
+     * Gets all .bru files in a directory synchronously
+     */
+    static getBruFilesSync(dirPath: string): string[];
 }
 //# sourceMappingURL=file-reader.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"file-reader.d.ts","sourceRoot":"","sources":["../../src/utils/file-reader.ts"],"names":[],"mappings":"AAIA;;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;IAYlE;;OAEG;IACH,MAAM,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAoB7C;;OAEG;IACH,MAAM,CAAC,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAShD;;OAEG;IACH,MAAM,CAAC,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAShD;;OAEG;IACH,MAAM,CAAC,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE;IAsBxD;;OAEG;IACH,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE;IAKlD;;OAEG;IACH,MAAM,CAAC,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE;CAIlD"}

package/dist/utils/file-reader.js

@@ -1,3 +1,4 @@
+import fsSync from 'node:fs';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 /**
@@ -100,5 +101,89 @@ export class FileReader {
         }
         return resolved;
     }
+    /**
+     * Reads a file synchronously and returns its content as a string
+     */
+    static readFileSync(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 fsSync.readFileSync(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 synchronously
+     */
+    static fileExistsSync(filePath) {
+        try {
+            fsSync.accessSync(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Checks if a path is a directory synchronously
+     */
+    static isDirectorySync(dirPath) {
+        try {
+            const stats = fsSync.statSync(dirPath);
+            return stats.isDirectory();
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Reads all files in a directory recursively synchronously
+     */
+    static readDirRecursivelySync(dirPath) {
+        try {
+            const entries = fsSync.readdirSync(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 = FileReader.readDirRecursivelySync(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 synchronously
+     */
+    static getJsonFilesSync(dirPath) {
+        const files = FileReader.readDirRecursivelySync(dirPath);
+        return files.filter(file => path.extname(file) === '.json');
+    }
+    /**
+     * Gets all .bru files in a directory synchronously
+     */
+    static getBruFilesSync(dirPath) {
+        const files = FileReader.readDirRecursivelySync(dirPath);
+        return files.filter(file => path.extname(file) === '.bru');
+    }
 }
 //# sourceMappingURL=file-reader.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gyeonghokim/bruno-to-openapi",
   "private": false,
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "Convert Bruno API collections to OpenAPI 3.0 specification",
   "type": "module",
   "module": "./dist/index.js",