@usebruno/filestore 0.6.0 → 0.7.1

package/src/formats/yml/stringifyCollection.ts

@@ -3,18 +3,20 @@ import type { ProtoFileItem, ProtoFileImportPath } from '@opencollection/types/c
 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?.protoFiles?.length > 0
     || brunoConfig.protobuf?.importPaths?.length > 0
   );
 
@@ -39,18 +41,22 @@ const hasRequestDefaults = (collectionRoot: any): boolean => {
 
   return Boolean((requestRoot?.headers?.length)
     || (requestRoot?.vars?.req?.length)
+    || (requestRoot?.vars?.res?.length)
     || hasRequestScripts(collectionRoot)
     || hasRequestAuth(collectionRoot));
 };
 
 const hasRequestAuth = (collectionRoot: any): boolean => {
-  return Boolean((collectionRoot.request?.auth?.mode !== 'none'));
+  const reqAuthMode = collectionRoot?.request?.auth?.mode;
+  return Boolean(reqAuthMode && reqAuthMode !== 'none');
 };
 
 const hasRequestScripts = (collectionRoot: any): boolean => {
-  return (collectionRoot.request?.script?.req)
-    || (collectionRoot.request?.script?.res)
-    || (collectionRoot.request?.tests);
+  if (!collectionRoot?.request) return false;
+
+  return (collectionRoot.request.script?.req)
+    || (collectionRoot.request.script?.res)
+    || (collectionRoot.request.tests);
 };
 
 const hasPresets = (brunoConfig: any): boolean => {
@@ -71,17 +77,25 @@ const stringifyCollection = (collectionRoot: any, brunoConfig: any): string => {
     if (hasCollectionConfig(brunoConfig)) {
       oc.config = {};
 
-      if (brunoConfig.protobuf?.protofFiles?.length) {
-        oc.config.protobuf = {
-          protoFiles: brunoConfig.protobuf.protofFiles.map((protoFile: any): ProtoFileItem => ({
+      if (brunoConfig.protobuf?.protoFiles?.length || brunoConfig.protobuf?.importPaths?.length) {
+        oc.config.protobuf = {};
+
+        if (brunoConfig.protobuf.protoFiles?.length) {
+          oc.config.protobuf.protoFiles = brunoConfig.protobuf.protoFiles.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
-          }))
-        };
+          }));
+        }
+
+        if (brunoConfig.protobuf.importPaths?.length) {
+          oc.config.protobuf.importPaths = brunoConfig.protobuf.importPaths.map((importPath: any): ProtoFileImportPath => {
+            const item: ProtoFileImportPath = { path: importPath.path };
+            if (importPath.enabled === false) {
+              item.disabled = true;
+            }
+            return item;
+          });
+        }
       }
 
       // proxy - only write newer format
@@ -124,7 +138,7 @@ const stringifyCollection = (collectionRoot: any, brunoConfig: any): string => {
       if (brunoConfig.clientCertificates?.certs?.length) {
         oc.config.clientCertificates = brunoConfig.clientCertificates.certs
           .map((cert: any): ClientCertificate | null => {
-            if (cert.type === 'pem') {
+            if (cert.type === 'cert') {
               const pemCert: PemCertificate = {
                 domain: cert.domain,
                 type: 'pem',
@@ -133,7 +147,7 @@ const stringifyCollection = (collectionRoot: any, brunoConfig: any): string => {
                 ...(cert.passphrase && { passphrase: cert.passphrase })
               };
               return pemCert;
-            } else if (cert.type === 'pkcs12') {
+            } else if (cert.type === 'pfx') {
               const pkcs12Cert: Pkcs12Certificate = {
                 domain: cert.domain,
                 type: 'pkcs12',
@@ -178,6 +192,14 @@ const stringifyCollection = (collectionRoot: any, brunoConfig: any): string => {
         }
       }
 
+      // 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);
@@ -188,7 +210,7 @@ const stringifyCollection = (collectionRoot: any, brunoConfig: any): string => {
     }
 
     // docs
-    if (collectionRoot.docs?.trim().length) {
+    if (collectionRoot?.docs?.trim().length) {
       oc.docs = {
         content: collectionRoot.docs,
         type: 'text/markdown'
@@ -200,24 +222,44 @@ const stringifyCollection = (collectionRoot: any, brunoConfig: any): string => {
 
     // extensions
     oc.extensions = {};
-    if (brunoConfig.ignore?.length) {
-      const ignoreList: string[] = [];
-      brunoConfig.ignore.forEach((ignore: string) => {
-        ignoreList.push(ignore);
-      });
-      oc.extensions.ignore = ignoreList;
-    }
-    if (hasPresets(brunoConfig)) {
-      const presetsRequest: any = {};
-      if (brunoConfig.presets.requestType?.length) {
-        presetsRequest.type = brunoConfig.presets.requestType;
+
+    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 (brunoConfig.presets.requestUrl?.length) {
-        presetsRequest.url = brunoConfig.presets.requestUrl;
+
+      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.presets = {
-        request: presetsRequest
-      } as any;
+
+      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);

package/src/formats/yml/stringifyEnvironment.ts

@@ -47,7 +47,10 @@ const stringifyEnvironment = (environment: BrunoEnvironment): string => {
       name: environment.name
     };
 
-    // Convert variables if they exist
+    if (environment.color) {
+      ocEnvironment.color = environment.color;
+    }
+
     if (environment.variables?.length) {
       const ocVariables = toOpenCollectionEnvironmentVariables(environment.variables);
       if (ocVariables) {

package/src/formats/yml/stringifyFolder.ts

@@ -1,6 +1,7 @@
 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';
@@ -8,6 +9,7 @@ import type { RequestDefaults } from '@opencollection/types/common/request-defau
 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';
 
@@ -16,6 +18,7 @@ const hasRequestDefaults = (folderRoot: FolderRoot): boolean => {
 
   return Boolean((requestDefaults?.headers?.length)
     || (requestDefaults?.vars?.req?.length)
+    || (requestDefaults?.vars?.res?.length)
     || hasRequestScripts(folderRoot)
     || hasRequestAuth(folderRoot));
 };
@@ -70,6 +73,14 @@ const stringifyFolder = (folderRoot: FolderRoot): string => {
         }
       }
 
+      // 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);

package/src/index.ts

@@ -25,10 +25,11 @@ import {
   StringifyOptions,
   CollectionFormat
 } from './types';
+import { DEFAULT_COLLECTION_FORMAT } from './constants';
 import { bruRequestParseAndRedactBodyData } from './formats/bru/utils/request-parse-and-redact-body-data';
 
 // request
-export const parseRequest = (content: string, options: ParseOptions = { format: 'bru' }): any => {
+export const parseRequest = (content: string, options: ParseOptions = { format: DEFAULT_COLLECTION_FORMAT }): any => {
   if (options.format === 'bru') {
     return parseBruRequest(content);
   } else if (options.format === 'yml') {
@@ -44,7 +45,7 @@ export const parseRequestAndRedactBody = (content: string, options: ParseOptions
   throw new Error(`Unsupported format: ${options.format}`);
 };
 
-export const stringifyRequest = (requestObj: BrunoItem, options: StringifyOptions = { format: 'bru' }): string => {
+export const stringifyRequest = (requestObj: BrunoItem, options: StringifyOptions = { format: DEFAULT_COLLECTION_FORMAT }): string => {
   if (options.format === 'bru') {
     return stringifyBruRequest(requestObj);
   } else if (options.format === 'yml') {
@@ -74,7 +75,7 @@ export const stringifyRequestViaWorker = async (requestObj: any, options: { form
 };
 
 // collection
-export const parseCollection = (content: string, options: ParseOptions = { format: 'bru' }): any => {
+export const parseCollection = (content: string, options: ParseOptions = { format: DEFAULT_COLLECTION_FORMAT }): any => {
   if (options.format === 'bru') {
     return parseBruCollection(content);
   } else if (options.format === 'yml') {
@@ -83,7 +84,7 @@ export const parseCollection = (content: string, options: ParseOptions = { forma
   throw new Error(`Unsupported format: ${options.format}`);
 };
 
-export const stringifyCollection = (collectionObj: BrunoCollection, brunoConfig: any, options: StringifyOptions = { format: 'bru' }): string => {
+export const stringifyCollection = (collectionObj: BrunoCollection, brunoConfig: any, options: StringifyOptions = { format: DEFAULT_COLLECTION_FORMAT }): string => {
   if (options.format === 'bru') {
     return stringifyBruCollection(collectionObj, false);
   } else if (options.format === 'yml') {
@@ -93,7 +94,7 @@ export const stringifyCollection = (collectionObj: BrunoCollection, brunoConfig:
 };
 
 // folder
-export const parseFolder = (content: string, options: ParseOptions = { format: 'bru' }): any => {
+export const parseFolder = (content: string, options: ParseOptions = { format: DEFAULT_COLLECTION_FORMAT }): any => {
   if (options.format === 'bru') {
     return parseBruCollection(content);
   } else if (options.format === 'yml') {
@@ -102,7 +103,7 @@ export const parseFolder = (content: string, options: ParseOptions = { format: '
   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 stringifyBruCollection(folderObj, true);
   } else if (options.format === 'yml') {
@@ -112,7 +113,7 @@ export const stringifyFolder = (folderObj: any, options: StringifyOptions = { fo
 };
 
 // environment
-export const parseEnvironment = (content: string, options: ParseOptions = { format: 'bru' }): any => {
+export const parseEnvironment = (content: string, options: ParseOptions = { format: DEFAULT_COLLECTION_FORMAT }): any => {
   if (options.format === 'bru') {
     return parseBruEnvironment(content);
   } else if (options.format === 'yml') {
@@ -121,7 +122,7 @@ export const parseEnvironment = (content: string, options: ParseOptions = { form
   throw new Error(`Unsupported format: ${options.format}`);
 };
 
-export const stringifyEnvironment = (envObj: BrunoEnvironment, options: StringifyOptions = { format: 'bru' }): string => {
+export const stringifyEnvironment = (envObj: BrunoEnvironment, options: StringifyOptions = { format: DEFAULT_COLLECTION_FORMAT }): string => {
   if (options.format === 'bru') {
     return stringifyBruEnvironment(envObj);
   } else if (options.format === 'yml') {
@@ -136,3 +137,4 @@ export const parseDotEnv = (content: string): Record<string, string> => {
 
 export { BruParserWorker };
 export * from './types';
+export * from './constants';

package/src/utils/index.ts

@@ -6,6 +6,16 @@ export const isNumber = (value: unknown): value is number => typeof value === 'n
 
 export const isNonEmptyString = (value: unknown): value is string => isString(value) && value.trim().length > 0;
 
+export const ensureString = (value: unknown, fallback: string = ''): string => {
+  if (value === null || value === undefined) {
+    return fallback;
+  }
+  if (typeof value === 'string') {
+    return value;
+  }
+  return String(value);
+};
+
 export const uuid = () => {
   // https://github.com/ai/nanoid/blob/main/url-alphabet/index.js
   const urlAlphabet = 'useandom26T198340PX75pxJACKVERYMINDBUSHWOLFGQZbfghjklqvwyzrict';

package/src/workers/index.ts

@@ -1,5 +1,6 @@
 import WorkerQueue from './WorkerQueue';
 import { Lane, CollectionFormat } from '../types';
+import { DEFAULT_COLLECTION_FORMAT } from '../constants';
 import path from 'node:path';
 
 const sizeInMB = (size: number): number => {
@@ -54,7 +55,7 @@ class BruParserWorker {
     return queueForSize?.workerQueue ?? this.workerQueues[this.workerQueues.length - 1].workerQueue;
   }
 
-  private async enqueueTask({ data, taskType, format = 'bru' }: { data: any; taskType: 'parse' | 'stringify'; format?: CollectionFormat }): Promise<any> {
+  private async enqueueTask({ data, taskType, format = DEFAULT_COLLECTION_FORMAT }: { data: any; taskType: 'parse' | 'stringify'; format?: CollectionFormat }): Promise<any> {
     const size = getSize(data);
     const workerQueue = this.getWorkerQueue(size);
     const workerScriptPath = path.join(__dirname, './workers/worker-script.js');
@@ -67,11 +68,11 @@ class BruParserWorker {
     });
   }
 
-  async parseRequest(data: any, format: CollectionFormat = 'bru'): Promise<any> {
+  async parseRequest(data: any, format: CollectionFormat = DEFAULT_COLLECTION_FORMAT): Promise<any> {
     return this.enqueueTask({ data, taskType: 'parse', format });
   }
 
-  async stringifyRequest(data: any, format: CollectionFormat = 'bru'): Promise<any> {
+  async stringifyRequest(data: any, format: CollectionFormat = DEFAULT_COLLECTION_FORMAT): Promise<any> {
     return this.enqueueTask({ data, taskType: 'stringify', format });
   }
 

package/src/workers/worker-script.ts

@@ -2,6 +2,7 @@ import { parentPort } from 'node:worker_threads';
 import { parseBruRequest, stringifyBruRequest } from '../formats/bru';
 import { parseYmlItem, stringifyYmlItem } from '../formats/yml';
 import { CollectionFormat } from '../types';
+import { DEFAULT_COLLECTION_FORMAT } from '../constants';
 
 interface WorkerMessage {
   taskType: 'parse' | 'stringify';
@@ -14,7 +15,7 @@ interface WorkerMessage {
 parentPort?.on('message', async (message: WorkerMessage) => {
   try {
     const { taskType, data: messageData } = message;
-    const { data, format = 'bru' } = messageData;
+    const { data, format = DEFAULT_COLLECTION_FORMAT } = messageData;
     let result: any;
 
     if (taskType === 'parse') {