@usebruno/filestore 0.5.0 → 0.7.0

package/src/formats/yml/stringifyCollection.ts

@@ -0,0 +1,264 @@
+import type { OpenCollection } from '@opencollection/types';
+import type { ProtoFileItem, ProtoFileImportPath } from '@opencollection/types/config/protobuf';
+import type { HttpRequestHeader } from '@opencollection/types/requests/http';
+import type { ClientCertificate, PemCertificate, Pkcs12Certificate } from '@opencollection/types/config/certificates';
+import type { Variable } from '@opencollection/types/common/variables';
+import type { Action } from '@opencollection/types/common/actions';
+import type { Scripts } from '@opencollection/types/common/scripts';
+import { stringifyYml } from './utils';
+import { toOpenCollectionAuth } from './common/auth';
+import { toOpenCollectionHttpHeaders } from './common/headers';
+import { toOpenCollectionVariables } from './common/variables';
+import { toOpenCollectionActions } from './common/actions';
+import { toOpenCollectionScripts } from './common/scripts';
+import type { Auth } from '@opencollection/types/common/auth';
+
+const hasCollectionConfig = (brunoConfig: any): boolean => {
+  // protobuf
+  const hasProtobuf = (
+    brunoConfig.protobuf?.protofFiles?.length > 0
+    || brunoConfig.protobuf?.importPaths?.length > 0
+  );
+
+  // proxy - check if proxy is configured in newer format
+  // Valid newer format: has 'inherit' property and 'config' object
+  const isValidProxyFormat = brunoConfig.proxy
+    && typeof brunoConfig.proxy === 'object'
+    && 'inherit' in brunoConfig.proxy
+    && brunoConfig.proxy.config
+    && typeof brunoConfig.proxy.config === 'object';
+
+  const hasProxy = isValidProxyFormat;
+
+  // client certificates
+  const hasClientCertificates = brunoConfig.clientCertificates?.certs?.length > 0;
+
+  return hasProtobuf || hasProxy || hasClientCertificates;
+};
+
+const hasRequestDefaults = (collectionRoot: any): boolean => {
+  const requestRoot = collectionRoot?.request;
+
+  return Boolean((requestRoot?.headers?.length)
+    || (requestRoot?.vars?.req?.length)
+    || (requestRoot?.vars?.res?.length)
+    || hasRequestScripts(collectionRoot)
+    || hasRequestAuth(collectionRoot));
+};
+
+const hasRequestAuth = (collectionRoot: any): boolean => {
+  const reqAuthMode = collectionRoot?.request?.auth?.mode;
+  return Boolean(reqAuthMode && reqAuthMode !== 'none');
+};
+
+const hasRequestScripts = (collectionRoot: any): boolean => {
+  if (!collectionRoot?.request) return false;
+
+  return (collectionRoot.request.script?.req)
+    || (collectionRoot.request.script?.res)
+    || (collectionRoot.request.tests);
+};
+
+const hasPresets = (brunoConfig: any): boolean => {
+  return brunoConfig?.presets?.requestType?.length
+    || brunoConfig?.presets?.requestUrl?.length;
+};
+
+const stringifyCollection = (collectionRoot: any, brunoConfig: any): string => {
+  try {
+    const oc: OpenCollection = {};
+
+    oc.opencollection = '1.0.0';
+    oc.info = {
+      name: brunoConfig.name || 'Untitled Collection'
+    };
+
+    // collection config
+    if (hasCollectionConfig(brunoConfig)) {
+      oc.config = {};
+
+      if (brunoConfig.protobuf?.protofFiles?.length) {
+        oc.config.protobuf = {
+          protoFiles: brunoConfig.protobuf.protofFiles.map((protoFile: any): ProtoFileItem => ({
+            type: 'file' as const,
+            path: protoFile.path
+          })),
+          importPaths: brunoConfig.protobuf.importPaths.map((importPath: any): ProtoFileImportPath => ({
+            path: importPath.path,
+            disabled: importPath.disabled
+          }))
+        };
+      }
+
+      // proxy - only write newer format
+      // Validate that brunoConfig.proxy is in newer format before writing
+      const isValidProxyFormat = brunoConfig.proxy
+        && typeof brunoConfig.proxy === 'object'
+        && 'inherit' in brunoConfig.proxy
+        && brunoConfig.proxy.config
+        && typeof brunoConfig.proxy.config === 'object';
+
+      if (isValidProxyFormat) {
+        oc.config.proxy = {
+          inherit: brunoConfig.proxy.inherit,
+          config: {
+            protocol: brunoConfig.proxy.config.protocol || 'http',
+            hostname: brunoConfig.proxy.config.hostname || '',
+            port: brunoConfig.proxy.config.port || '',
+            auth: {
+              username: brunoConfig.proxy.config.auth?.username || '',
+              password: brunoConfig.proxy.config.auth?.password || ''
+            },
+            bypassProxy: brunoConfig.proxy.config.bypassProxy || ''
+          }
+        };
+
+        // Add optional disabled field if true
+        if (brunoConfig.proxy.disabled === true) {
+          oc.config.proxy.disabled = true;
+        }
+
+        // Add optional auth.disabled field if true
+        if (brunoConfig.proxy.config?.auth?.disabled === true) {
+          if (oc.config.proxy.config && oc.config.proxy.config.auth) {
+            oc.config.proxy.config.auth.disabled = true;
+          }
+        }
+      }
+
+      // client certificates
+      if (brunoConfig.clientCertificates?.certs?.length) {
+        oc.config.clientCertificates = brunoConfig.clientCertificates.certs
+          .map((cert: any): ClientCertificate | null => {
+            if (cert.type === 'cert') {
+              const pemCert: PemCertificate = {
+                domain: cert.domain,
+                type: 'pem',
+                certificateFilePath: cert.certFilePath,
+                privateKeyFilePath: cert.keyFilePath,
+                ...(cert.passphrase && { passphrase: cert.passphrase })
+              };
+              return pemCert;
+            } else if (cert.type === 'pfx') {
+              const pkcs12Cert: Pkcs12Certificate = {
+                domain: cert.domain,
+                type: 'pkcs12',
+                pkcs12FilePath: cert.pfxFilePath,
+                ...(cert.passphrase && { passphrase: cert.passphrase })
+              };
+              return pkcs12Cert;
+            } else {
+              // Unsupported certificate type - ignore silently
+              return null;
+            }
+          })
+          .filter((cert: ClientCertificate | null): cert is ClientCertificate => cert !== null);
+      }
+    }
+
+    // request defaults
+    if (hasRequestDefaults(collectionRoot)) {
+      oc.request = {};
+
+      // headers
+      if (collectionRoot.request?.headers?.length) {
+        const ocHeaders: HttpRequestHeader[] | undefined = toOpenCollectionHttpHeaders(collectionRoot.request?.headers);
+        if (ocHeaders) {
+          oc.request.headers = ocHeaders;
+        }
+      }
+
+      // auth
+      if (hasRequestAuth(collectionRoot)) {
+        const ocAuth: Auth | undefined = toOpenCollectionAuth(collectionRoot.request?.auth);
+        if (ocAuth) {
+          oc.request.auth = ocAuth;
+        }
+      }
+
+      // variables
+      if (collectionRoot.request?.vars?.req?.length) {
+        const ocVariables: Variable[] | undefined = toOpenCollectionVariables(collectionRoot.request?.vars);
+        if (ocVariables) {
+          oc.request.variables = ocVariables;
+        }
+      }
+
+      // actions (post-response variables)
+      if (collectionRoot.request?.vars?.res?.length) {
+        const ocActions: Action[] | undefined = toOpenCollectionActions(collectionRoot.request?.vars?.res);
+        if (ocActions) {
+          (oc.request as any).actions = ocActions;
+        }
+      }
+
+      // scripts
+      if (hasRequestScripts(collectionRoot)) {
+        const ocScripts: Scripts | undefined = toOpenCollectionScripts(collectionRoot.request);
+        if (ocScripts) {
+          oc.request.scripts = ocScripts;
+        }
+      }
+    }
+
+    // docs
+    if (collectionRoot?.docs?.trim().length) {
+      oc.docs = {
+        content: collectionRoot.docs,
+        type: 'text/markdown'
+      };
+    }
+
+    // bundled
+    oc.bundled = false;
+
+    // extensions
+    oc.extensions = {};
+
+    const hasBrunoExtensions = brunoConfig.ignore?.length || hasPresets(brunoConfig);
+
+    if (hasBrunoExtensions) {
+      const brunoExtension: any = {};
+
+      if (brunoConfig.ignore?.length) {
+        const ignoreList: string[] = [];
+        brunoConfig.ignore.forEach((ignore: string) => {
+          ignoreList.push(ignore);
+        });
+        brunoExtension.ignore = ignoreList;
+      }
+
+      if (hasPresets(brunoConfig)) {
+        const presetsRequest: any = {};
+        if (brunoConfig.presets.requestType?.length) {
+          presetsRequest.type = brunoConfig.presets.requestType;
+        }
+        if (brunoConfig.presets.requestUrl?.length) {
+          presetsRequest.url = brunoConfig.presets.requestUrl;
+        }
+        brunoExtension.presets = {
+          request: presetsRequest
+        };
+      }
+
+      oc.extensions.bruno = brunoExtension;
+    }
+
+    // bruno-specific script extensions
+    if (brunoConfig.scripts?.additionalContextRoots?.length) {
+      if (!oc.extensions.bruno) {
+        oc.extensions.bruno = {};
+      }
+      (oc.extensions.bruno as any).scripts = {
+        additionalContextRoots: brunoConfig.scripts.additionalContextRoots
+      };
+    }
+
+    return stringifyYml(oc);
+  } catch (error) {
+    console.error('Error stringifying opencollection.yml:', error);
+    throw error;
+  }
+};
+
+export default stringifyCollection;

package/src/formats/yml/stringifyEnvironment.ts

@@ -0,0 +1,67 @@
+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
+    };
+
+    if (environment.color) {
+      ocEnvironment.color = environment.color;
+    }
+
+    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,107 @@
+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 { Action } from '@opencollection/types/common/actions';
+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 { toOpenCollectionActions } from './common/actions';
+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)
+    || (requestDefaults?.vars?.res?.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;
+        }
+      }
+
+      // actions (post-response variables)
+      if (folderRoot.request?.vars?.res?.length) {
+        const ocActions: Action[] | undefined = toOpenCollectionActions(folderRoot.request?.vars?.res);
+        if (ocActions) {
+          (ocFolder.request as any).actions = ocActions;
+        }
+      }
+
+      // 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,39 @@
+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 { DEFAULT_COLLECTION_FORMAT } from './constants';
 import { bruRequestParseAndRedactBodyData } from './formats/bru/utils/request-parse-and-redact-body-data';
 
-export const parseRequest = (content: string, options: ParseOptions = { format: 'bru' }): any => {
+// request
+export const parseRequest = (content: string, options: ParseOptions = { format: DEFAULT_COLLECTION_FORMAT }): 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 +45,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: DEFAULT_COLLECTION_FORMAT }): 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 +63,78 @@ 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);
 };
 
-export const parseCollection = (content: string, options: ParseOptions = { format: 'bru' }): any => {
+// collection
+export const parseCollection = (content: string, options: ParseOptions = { format: DEFAULT_COLLECTION_FORMAT }): 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: DEFAULT_COLLECTION_FORMAT }): 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}`);
 };
 
-export const parseFolder = (content: string, options: ParseOptions = { format: 'bru' }): any => {
+// folder
+export const parseFolder = (content: string, options: ParseOptions = { format: DEFAULT_COLLECTION_FORMAT }): 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 => {
+export const stringifyFolder = (folderObj: any, options: StringifyOptions = { format: DEFAULT_COLLECTION_FORMAT }): 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}`);
 };
 
-export const parseEnvironment = (content: string, options: ParseOptions = { format: 'bru' }): any => {
+// environment
+export const parseEnvironment = (content: string, options: ParseOptions = { format: DEFAULT_COLLECTION_FORMAT }): 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: DEFAULT_COLLECTION_FORMAT }): 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';
+export * from './constants';

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>;
-} 
+}