@usebruno/filestore 0.4.0 → 0.6.0

package/src/formats/yml/stringifyEnvironment.ts

@@ -0,0 +1,64 @@
+import type { Environment as BrunoEnvironment, EnvironmentVariable as BrunoEnvironmentVariable } from '@usebruno/schema-types/collection/environment';
+import type { Environment } from '@opencollection/types/config/environments';
+import type { Variable, SecretVariable } from '@opencollection/types/common/variables';
+import { stringifyYml } from './utils';
+
+const toOpenCollectionEnvironmentVariables = (variables: BrunoEnvironmentVariable[]): (Variable | SecretVariable)[] | undefined => {
+  if (!variables?.length) {
+    return undefined;
+  }
+
+  const ocVariables: (Variable | SecretVariable)[] = variables
+    .filter((v: BrunoEnvironmentVariable) => {
+      // todo: currently neither bru lang nor bruno app supports non-string values
+      // update this when bruno app supports non-string values
+      return typeof v.value === 'string';
+    })
+    .map((v: BrunoEnvironmentVariable): Variable | SecretVariable => {
+      if (v.secret === true) {
+        const secretVar: SecretVariable = {
+          secret: true,
+          name: v.name || ''
+        };
+        if (v.enabled === false) {
+          secretVar.disabled = true;
+        }
+        return secretVar;
+      }
+
+      const variable: Variable = {
+        name: v.name || '',
+        value: v.value as string
+      };
+
+      if (v.enabled === false) {
+        variable.disabled = true;
+      }
+
+      return variable;
+    });
+
+  return ocVariables.length > 0 ? ocVariables : undefined;
+};
+
+const stringifyEnvironment = (environment: BrunoEnvironment): string => {
+  try {
+    const ocEnvironment: Environment = {
+      name: environment.name
+    };
+
+    // Convert variables if they exist
+    if (environment.variables?.length) {
+      const ocVariables = toOpenCollectionEnvironmentVariables(environment.variables);
+      if (ocVariables) {
+        ocEnvironment.variables = ocVariables;
+      }
+    }
+
+    return stringifyYml(ocEnvironment);
+  } catch (error) {
+    console.error('Error stringifying environment:', error);
+    throw error;
+  }
+};
+export default stringifyEnvironment;

package/src/formats/yml/stringifyFolder.ts

@@ -0,0 +1,96 @@
+import type { FolderRoot } from '@usebruno/schema-types/collection/folder';
+import type { Folder, FolderInfo } from '@opencollection/types/collection/item';
+import type { Variable } from '@opencollection/types/common/variables';
+import type { Scripts } from '@opencollection/types/common/scripts';
+import type { Auth } from '@opencollection/types/common/auth';
+import type { HttpRequestHeader } from '@opencollection/types/requests/http';
+import type { RequestDefaults } from '@opencollection/types/common/request-defaults';
+import { toOpenCollectionAuth } from './common/auth';
+import { toOpenCollectionHttpHeaders } from './common/headers';
+import { toOpenCollectionVariables } from './common/variables';
+import { toOpenCollectionScripts } from './common/scripts';
+import { stringifyYml } from './utils';
+
+const hasRequestDefaults = (folderRoot: FolderRoot): boolean => {
+  const requestDefaults = folderRoot?.request;
+
+  return Boolean((requestDefaults?.headers?.length)
+    || (requestDefaults?.vars?.req?.length)
+    || hasRequestScripts(folderRoot)
+    || hasRequestAuth(folderRoot));
+};
+
+const hasRequestAuth = (folderRoot: FolderRoot): boolean => {
+  return Boolean((folderRoot.request?.auth?.mode !== 'none'));
+};
+
+const hasRequestScripts = (folderRoot: FolderRoot): boolean => {
+  return Boolean((folderRoot.request?.script?.req)
+    || (folderRoot.request?.script?.res)
+    || (folderRoot.request?.tests));
+};
+
+const stringifyFolder = (folderRoot: FolderRoot): string => {
+  try {
+    const ocFolder: Folder = {};
+
+    // info block
+    const info: FolderInfo = {
+      name: folderRoot.meta?.name || 'Untitled Folder',
+      type: 'folder',
+      seq: folderRoot.meta?.seq || 1
+    };
+    ocFolder.info = info;
+
+    // request defaults
+    if (hasRequestDefaults(folderRoot)) {
+      ocFolder.request = {} as RequestDefaults;
+
+      // headers
+      if (folderRoot.request?.headers?.length) {
+        const ocHeaders: HttpRequestHeader[] | undefined = toOpenCollectionHttpHeaders(folderRoot.request?.headers);
+        if (ocHeaders) {
+          ocFolder.request.headers = ocHeaders;
+        }
+      }
+
+      // auth
+      if (hasRequestAuth(folderRoot)) {
+        const ocAuth: Auth | undefined = toOpenCollectionAuth(folderRoot.request?.auth);
+        if (ocAuth) {
+          ocFolder.request.auth = ocAuth;
+        }
+      }
+
+      // variables
+      if (folderRoot.request?.vars?.req?.length) {
+        const ocVariables: Variable[] | undefined = toOpenCollectionVariables(folderRoot.request?.vars);
+        if (ocVariables) {
+          ocFolder.request.variables = ocVariables;
+        }
+      }
+
+      // scripts
+      if (hasRequestScripts(folderRoot)) {
+        const ocScripts: Scripts | undefined = toOpenCollectionScripts(folderRoot?.request);
+        if (ocScripts) {
+          ocFolder.request.scripts = ocScripts;
+        }
+      }
+    }
+
+    // docs
+    if (folderRoot.docs?.trim().length) {
+      ocFolder.docs = {
+        content: folderRoot.docs,
+        type: 'text/markdown'
+      };
+    }
+
+    return stringifyYml(ocFolder);
+  } catch (error) {
+    console.error('Error stringifying folder.yml:', error);
+    throw error;
+  }
+};
+export default stringifyFolder;

package/src/formats/yml/stringifyItem.ts

@@ -0,0 +1,37 @@
+import type { Item as BrunoItem } from '@usebruno/schema-types/collection/item';
+import stringifyHttpRequest from './items/stringifyHttpRequest';
+import stringifyGraphqlRequest from './items/stringifyGraphQLRequest';
+import stringifyGrpcRequest from './items/stringifyGrpcRequest';
+import stringifyWebsocketRequest from './items/stringifyWebsocketRequest';
+import stringifyScript from './items/stringifyScript';
+
+const stringifyItem = (item: BrunoItem): string => {
+  try {
+    switch (item.type) {
+      case 'http-request':
+        return stringifyHttpRequest(item);
+
+      case 'graphql-request':
+        return stringifyGraphqlRequest(item);
+
+      case 'grpc-request':
+        return stringifyGrpcRequest(item);
+
+      case 'ws-request':
+        return stringifyWebsocketRequest(item);
+
+      case 'js':
+        return stringifyScript(item);
+
+      case 'folder':
+        throw new Error('Folder items should be handled separately using stringifyFolder');
+
+      default:
+        throw new Error(`Unsupported item type: ${item.type}`);
+    }
+  } catch (error) {
+    console.error('Error stringifying item:', error);
+    throw error;
+  }
+};
+export default stringifyItem;

package/src/formats/yml/utils.ts

@@ -0,0 +1,38 @@
+import * as YAML from 'yaml';
+
+// Top-level keys that should have a blank line before them
+const BLOCK_KEYS = ['info', 'http', 'graphql', 'grpc', 'websocket', 'runtime', 'settings', 'examples', 'docs', 'items', 'request'];
+
+export const stringifyYml = (obj: any): string => {
+  const yamlStr = YAML.stringify(obj, {
+    lineWidth: 0,
+    indent: 2,
+    minContentWidth: 0,
+    defaultStringType: 'PLAIN'
+  });
+
+  // Add blank lines before major blocks (only at the top level, not indented)
+  const lines = yamlStr.split('\n');
+  const result: string[] = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    // Check if this is a top-level key (no leading whitespace) that should have a blank line
+    if (i > 0 && !line.startsWith(' ') && !line.startsWith('\t')) {
+      const key = line.split(':')[0];
+      if (BLOCK_KEYS.includes(key)) {
+        // Add blank line before this block (if previous line isn't already blank)
+        if (result.length > 0 && result[result.length - 1].trim() !== '') {
+          result.push('');
+        }
+      }
+    }
+    result.push(line);
+  }
+
+  return result.join('\n');
+};
+
+export const parseYml = (ymlString: string): any => {
+  return YAML.parse(ymlString);
+};

package/src/index.ts

@@ -1,25 +1,38 @@
+import type { BrunoCollection, BrunoItem, BrunoEnvironment } from '@usebruno/schema-types';
+
 import {
-  bruRequestToJson,
-  jsonRequestToBru,
-  bruCollectionToJson,
-  jsonCollectionToBru,
-  bruEnvironmentToJson,
-  jsonEnvironmentToBru
+  parseBruRequest,
+  parseBruCollection,
+  parseBruEnvironment,
+  stringifyBruRequest,
+  stringifyBruCollection,
+  stringifyBruEnvironment
 } from './formats/bru';
+import {
+  parseYmlItem,
+  parseYmlCollection,
+  parseYmlFolder,
+  parseYmlEnvironment,
+  stringifyYmlItem,
+  stringifyYmlFolder,
+  stringifyYmlCollection,
+  stringifyYmlEnvironment
+} from './formats/yml';
 import { dotenvToJson } from '@usebruno/lang';
 import BruParserWorker from './workers';
 import {
   ParseOptions,
   StringifyOptions,
-  ParsedRequest,
-  ParsedCollection,
-  ParsedEnvironment
+  CollectionFormat
 } from './types';
 import { bruRequestParseAndRedactBodyData } from './formats/bru/utils/request-parse-and-redact-body-data';
 
+// request
 export const parseRequest = (content: string, options: ParseOptions = { format: 'bru' }): any => {
   if (options.format === 'bru') {
-    return bruRequestToJson(content);
+    return parseBruRequest(content);
+  } else if (options.format === 'yml') {
+    return parseYmlItem(content);
   }
   throw new Error(`Unsupported format: ${options.format}`);
 };
@@ -31,15 +44,17 @@ export const parseRequestAndRedactBody = (content: string, options: ParseOptions
   throw new Error(`Unsupported format: ${options.format}`);
 };
 
-export const stringifyRequest = (requestObj: ParsedRequest, options: StringifyOptions = { format: 'bru' }): string => {
+export const stringifyRequest = (requestObj: BrunoItem, options: StringifyOptions = { format: 'bru' }): string => {
   if (options.format === 'bru') {
-    return jsonRequestToBru(requestObj);
+    return stringifyBruRequest(requestObj);
+  } else if (options.format === 'yml') {
+    return stringifyYmlItem(requestObj);
   }
   throw new Error(`Unsupported format: ${options.format}`);
 };
 
+// request via worker
 let globalWorkerInstance: BruParserWorker | null = null;
-
 const getWorkerInstance = (): BruParserWorker => {
   if (!globalWorkerInstance) {
     globalWorkerInstance = new BruParserWorker();
@@ -47,62 +62,77 @@ const getWorkerInstance = (): BruParserWorker => {
   return globalWorkerInstance;
 };
 
-export const parseRequestViaWorker = async (content: string): Promise<any> => {
+export const parseRequestViaWorker = async (content: string, options: { format: CollectionFormat; filename?: string }): Promise<any> => {
   const fileParserWorker = getWorkerInstance();
-  return await fileParserWorker.parseRequest(content);
+
+  return await fileParserWorker.parseRequest(content, options.format);
 };
 
-export const stringifyRequestViaWorker = async (requestObj: any): Promise<string> => {
+export const stringifyRequestViaWorker = async (requestObj: any, options: { format: CollectionFormat }): Promise<string> => {
   const fileParserWorker = getWorkerInstance();
-  return await fileParserWorker.stringifyRequest(requestObj);
+  return await fileParserWorker.stringifyRequest(requestObj, options.format);
 };
 
+// collection
 export const parseCollection = (content: string, options: ParseOptions = { format: 'bru' }): any => {
   if (options.format === 'bru') {
-    return bruCollectionToJson(content);
+    return parseBruCollection(content);
+  } else if (options.format === 'yml') {
+    return parseYmlCollection(content);
   }
   throw new Error(`Unsupported format: ${options.format}`);
 };
 
-export const stringifyCollection = (collectionObj: ParsedCollection, options: StringifyOptions = { format: 'bru' }): string => {
+export const stringifyCollection = (collectionObj: BrunoCollection, brunoConfig: any, options: StringifyOptions = { format: 'bru' }): string => {
   if (options.format === 'bru') {
-    return jsonCollectionToBru(collectionObj, false);
+    return stringifyBruCollection(collectionObj, false);
+  } else if (options.format === 'yml') {
+    return stringifyYmlCollection(collectionObj, brunoConfig);
   }
   throw new Error(`Unsupported format: ${options.format}`);
 };
 
+// folder
 export const parseFolder = (content: string, options: ParseOptions = { format: 'bru' }): any => {
   if (options.format === 'bru') {
-    return bruCollectionToJson(content);
+    return parseBruCollection(content);
+  } else if (options.format === 'yml') {
+    return parseYmlFolder(content);
   }
   throw new Error(`Unsupported format: ${options.format}`);
 };
 
 export const stringifyFolder = (folderObj: any, options: StringifyOptions = { format: 'bru' }): string => {
   if (options.format === 'bru') {
-    return jsonCollectionToBru(folderObj, true);
+    return stringifyBruCollection(folderObj, true);
+  } else if (options.format === 'yml') {
+    return stringifyYmlFolder(folderObj);
   }
   throw new Error(`Unsupported format: ${options.format}`);
 };
 
+// environment
 export const parseEnvironment = (content: string, options: ParseOptions = { format: 'bru' }): any => {
   if (options.format === 'bru') {
-    return bruEnvironmentToJson(content);
+    return parseBruEnvironment(content);
+  } else if (options.format === 'yml') {
+    return parseYmlEnvironment(content);
   }
   throw new Error(`Unsupported format: ${options.format}`);
 };
 
-export const stringifyEnvironment = (envObj: ParsedEnvironment, options: StringifyOptions = { format: 'bru' }): string => {
+export const stringifyEnvironment = (envObj: BrunoEnvironment, options: StringifyOptions = { format: 'bru' }): string => {
   if (options.format === 'bru') {
-    return jsonEnvironmentToBru(envObj);
+    return stringifyBruEnvironment(envObj);
+  } else if (options.format === 'yml') {
+    return stringifyYmlEnvironment(envObj);
   }
   throw new Error(`Unsupported format: ${options.format}`);
 };
 
-
 export const parseDotEnv = (content: string): Record<string, string> => {
   return dotenvToJson(content);
 };
 
 export { BruParserWorker };
-export * from './types';
+export * from './types';

package/src/types/bruno-lang.d.ts

@@ -6,4 +6,4 @@ declare module '@usebruno/lang' {
   export function collectionBruToJson(bruContent: string): any;
   export function jsonToCollectionBru(jsonData: any): string;
   export function dotenvToJson(envContent: string): Record<string, string>;
-} 
+}

package/src/types.ts

@@ -1,130 +1,11 @@
+export type CollectionFormat = 'bru' | 'yml';
+
 export interface ParseOptions {
-  format?: 'bru' | 'yaml';
+  format?: CollectionFormat;
 }
 
 export interface StringifyOptions {
-  format?: 'bru' | 'yaml';
-}
-
-export interface RequestBody {
-  mode?: string;
-  raw?: string;
-  formUrlEncoded?: Array<{ name: string; value: string; enabled: boolean }>;
-  multipartForm?: Array<{ name: string; value: string; type: string; enabled: boolean }>;
-  json?: string;
-  xml?: string;
-  sparql?: string;
-  graphql?: {
-    query?: string;
-    variables?: string;
-  };
-}
-
-export interface AuthConfig {
-  mode?: string;
-  basic?: {
-    username?: string;
-    password?: string;
-  };
-  bearer?: {
-    token?: string;
-  };
-  apikey?: {
-    key?: string;
-    value?: string;
-    placement?: string;
-  };
-  awsv4?: {
-    accessKeyId?: string;
-    secretAccessKey?: string;
-    sessionToken?: string;
-    service?: string;
-    region?: string;
-    profileName?: string;
-  };
-  oauth2?: {
-    grantType?: string;
-    callbackUrl?: string;
-    authorizationUrl?: string;
-    accessTokenUrl?: string;
-    clientId?: string;
-    clientSecret?: string;
-    scope?: string;
-    state?: string;
-    pkce?: boolean;
-  };
-}
-
-export interface RequestParam {
-  name: string;
-  value: string;
-  enabled: boolean;
-}
-
-export interface RequestHeader {
-  name: string;
-  value: string;
-  enabled: boolean;
-}
-
-export interface RequestAssertion {
-  name: string;
-  value: string;
-  enabled: boolean;
-}
-
-export interface RequestVars {
-  req?: Array<{ name: string; value: string; enabled: boolean }>;
-  res?: Array<{ name: string; value: string; enabled: boolean }>;
-}
-
-export interface RequestScript {
-  req?: string;
-  res?: string;
-}
-
-export interface RequestSettings {
-  [key: string]: any;
-}
-
-export interface RequestData {
-  method: string;
-  url: string;
-  params: RequestParam[];
-  headers: RequestHeader[];
-  auth: AuthConfig;
-  body: RequestBody;
-  script: RequestScript;
-  vars: RequestVars;
-  assertions: RequestAssertion[];
-  tests: string;
-  docs: string;
-}
-
-export interface ParsedRequest {
-  type: 'http-request' | 'graphql-request';
-  name: string;
-  seq: number;
-  settings: RequestSettings;
-  tags: string[];
-  request: RequestData;
-}
-
-export interface ParsedCollection {
-  name: string;
-  type?: string;
-  version?: string;
-  [key: string]: any;
-}
-
-export interface EnvironmentVariable {
-  name: string;
-  value: string;
-  enabled: boolean;
-}
-
-export interface ParsedEnvironment {
-  variables: EnvironmentVariable[];
+  format?: CollectionFormat;
 }
 
 export interface WorkerTask {
@@ -138,4 +19,4 @@ export interface WorkerTask {
 
 export interface Lane {
   maxSize: number;
-} 
+}

package/src/utils/index.ts

@@ -0,0 +1,15 @@
+const { customAlphabet } = require('nanoid');
+
+export const isString = (value: unknown): value is string => typeof value === 'string';
+
+export const isNumber = (value: unknown): value is number => typeof value === 'number';
+
+export const isNonEmptyString = (value: unknown): value is string => isString(value) && value.trim().length > 0;
+
+export const uuid = () => {
+  // https://github.com/ai/nanoid/blob/main/url-alphabet/index.js
+  const urlAlphabet = 'useandom26T198340PX75pxJACKVERYMINDBUSHWOLFGQZbfghjklqvwyzrict';
+  const customNanoId = customAlphabet(urlAlphabet, 21);
+
+  return customNanoId();
+};

package/src/workers/WorkerQueue/index.ts

@@ -21,14 +21,14 @@ class WorkerQueue {
   }
 
   async getWorkerForScriptPath(scriptPath: string) {
-    if (!this.workers) this.workers = {}; 
+    if (!this.workers) this.workers = {};
     let worker = this.workers[scriptPath];
     if (!worker || worker.threadId === -1) {
       this.workers[scriptPath] = worker = new Worker(scriptPath);
     }
     return worker;
   }
-  
+
   async enqueue(task: QueuedTask) {
     const { priority, scriptPath, data, taskType } = task;
 
@@ -40,9 +40,9 @@ class WorkerQueue {
   }
 
   async processQueue() {
-    if (this.isProcessing || this.queue.length === 0){
+    if (this.isProcessing || this.queue.length === 0) {
       return;
-    } 
+    }
 
     this.isProcessing = true;
     const { scriptPath, data, taskType, resolve, reject } = this.queue.shift() as QueuedTask;
@@ -61,12 +61,12 @@ class WorkerQueue {
   async runWorker({ scriptPath, data, taskType }: { scriptPath: string; data: any; taskType: 'parse' | 'stringify' }) {
     return new Promise(async (resolve, reject) => {
       let worker = await this.getWorkerForScriptPath(scriptPath);
-      
+
       const messageHandler = (data: any) => {
         worker.off('message', messageHandler);
         worker.off('error', errorHandler);
         worker.off('exit', exitHandler);
-        
+
         if (data?.error) {
           reject(new Error(data?.error));
         } else {
@@ -89,7 +89,7 @@ class WorkerQueue {
         delete this.workers[scriptPath];
         reject(new Error(`Worker stopped with exit code ${code}`));
       };
-      
+
       worker.on('message', messageHandler);
       worker.on('error', errorHandler);
       worker.on('exit', exitHandler);
@@ -99,16 +99,16 @@ class WorkerQueue {
   }
 
   async cleanup() {
-    const promises = Object.values(this.workers).map(worker => {
+    const promises = Object.values(this.workers).map((worker) => {
       if (worker.threadId !== -1) {
         return worker.terminate();
       }
       return Promise.resolve();
     });
-    
+
     await Promise.allSettled(promises);
     this.workers = {};
   }
 }
 
-export default WorkerQueue;
+export default WorkerQueue;