@usebruno/filestore 0.11.0 → 0.12.0

package/src/formats/yml/tests/defaultEnvironment.spec.js

@@ -0,0 +1,50 @@
+import parseCollection from '../parseCollection';
+import stringifyCollection from '../stringifyCollection';
+
+const collectionRoot = { meta: null, request: null, docs: null };
+
+describe('yml collection - presets.defaultEnvironment round-trip', () => {
+  it('writes and reads back defaultEnvironment via extensions.bruno.presets', () => {
+    const brunoConfig = {
+      name: 'My API',
+      type: 'collection',
+      ignore: ['node_modules'],
+      presets: { requestType: 'http', requestUrl: 'https://example.com', defaultEnvironment: 'prod' }
+    };
+
+    const yml = stringifyCollection(collectionRoot, brunoConfig);
+    expect(yml).toContain('defaultEnvironment: prod');
+
+    const { brunoConfig: parsed } = parseCollection(yml);
+    expect(parsed.presets).toEqual({
+      requestType: 'http',
+      requestUrl: 'https://example.com',
+      defaultEnvironment: 'prod'
+    });
+  });
+
+  it('persists defaultEnvironment even when no request presets are set', () => {
+    const brunoConfig = {
+      name: 'My API',
+      type: 'collection',
+      ignore: [],
+      presets: { defaultEnvironment: 'staging' }
+    };
+
+    const yml = stringifyCollection(collectionRoot, brunoConfig);
+    expect(yml).toContain('defaultEnvironment: staging');
+
+    const { brunoConfig: parsed } = parseCollection(yml);
+    expect(parsed.presets.defaultEnvironment).toBe('staging');
+  });
+
+  it('does not emit defaultEnvironment when it is not configured', () => {
+    const brunoConfig = { name: 'My API', type: 'collection', ignore: [] };
+
+    const yml = stringifyCollection(collectionRoot, brunoConfig);
+    expect(yml).not.toContain('defaultEnvironment');
+
+    const { brunoConfig: parsed } = parseCollection(yml);
+    expect(parsed.presets).toBeUndefined();
+  });
+});

package/src/formats/yml/tests/stringifyEnvironment.spec.ts

@@ -128,6 +128,32 @@ externalSecrets:
 `);
   });
 
+  it('should stringify a gcp-secrets-manager provider block, one row per project', () => {
+    const output = stringifyEnvironment({
+      uid: 'env1',
+      name: 'test',
+      variables: [],
+      externalSecrets: {
+        type: 'gcp-secrets-manager',
+        variables: [
+          { uid: 'e1', name: 'staging', projectId: 'my-staging-project', enabled: true },
+          { uid: 'e2', name: 'prod', projectId: 'my-prod-project', enabled: true }
+        ]
+      },
+      color: null
+    } as any);
+
+    expect(output).toBe(`name: test
+externalSecrets:
+  type: gcp-secrets-manager
+  variables:
+    - name: staging
+      projectId: my-staging-project
+    - name: prod
+      projectId: my-prod-project
+`);
+  });
+
   it('should keep a half-filled row (a name with an empty identifier)', () => {
     const output = stringifyEnvironment({
       uid: 'env1',

package/src/formats/yml/utils.ts

@@ -1,7 +1,7 @@
 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'];
+const BLOCK_KEYS = ['info', 'http', 'graphql', 'grpc', 'websocket', 'mock', 'routes', 'runtime', 'settings', 'examples', 'docs', 'items', 'request'];
 
 export const stringifyYml = (obj: any): string => {
   const yamlStr = YAML.stringify(obj, {

package/src/index.ts

@@ -13,10 +13,12 @@ import {
   parseYmlCollection,
   parseYmlFolder,
   parseYmlEnvironment,
+  parseYmlMockServer,
   stringifyYmlItem,
   stringifyYmlFolder,
   stringifyYmlCollection,
-  stringifyYmlEnvironment
+  stringifyYmlEnvironment,
+  stringifyYmlMockServer
 } from './formats/yml';
 import { dotenvToJson } from '@usebruno/lang';
 import BruParserWorker from './workers';
@@ -75,6 +77,22 @@ export const stringifyRequestViaWorker = async (requestObj: any, options: { form
   return await fileParserWorker.stringifyRequest(requestObj, options.format);
 };
 
+export const parseFolderViaWorker = async (content: string, options: { format: CollectionFormat }): Promise<any> => {
+  return await getWorkerInstance().parseFolder(content, options.format);
+};
+
+export const stringifyFolderViaWorker = async (folderObj: any, options: { format: CollectionFormat }): Promise<string> => {
+  return await getWorkerInstance().stringifyFolder(folderObj, options.format);
+};
+
+export const parseEnvironmentViaWorker = async (content: string, options: { format: CollectionFormat }): Promise<any> => {
+  return await getWorkerInstance().parseEnvironment(content, options.format);
+};
+
+export const stringifyEnvironmentViaWorker = async (envObj: any, options: { format: CollectionFormat }): Promise<string> => {
+  return await getWorkerInstance().stringifyEnvironment(envObj, options.format);
+};
+
 // collection
 export const parseCollection = (content: string, options: ParseOptions = { format: DEFAULT_COLLECTION_FORMAT }): any => {
   if (options.format === 'bru') {
@@ -132,6 +150,21 @@ export const stringifyEnvironment = (envObj: BrunoEnvironment, options: Stringif
   throw new Error(`Unsupported format: ${options.format}`);
 };
 
+// mock server — workspace-level entity, opencollection yml only
+export const parseMockServer = (content: string, options: ParseOptions = { format: 'yml' }): any => {
+  if (options.format === 'yml') {
+    return parseYmlMockServer(content);
+  }
+  throw new Error(`Unsupported format: ${options.format}`);
+};
+
+export const stringifyMockServer = (mockServerObj: any, options: StringifyOptions = { format: 'yml' }): string => {
+  if (options.format === 'yml') {
+    return stringifyYmlMockServer(mockServerObj);
+  }
+  throw new Error(`Unsupported format: ${options.format}`);
+};
+
 export const parseDotEnv = (content: string): Record<string, string> => {
   return dotenvToJson(content);
 };

package/src/types.ts

@@ -26,4 +26,5 @@ export interface BrunoPresetsExtension {
     type?: string;
     url?: string;
   };
+  defaultEnvironment?: string;
 }

package/src/workers/WorkerQueue/index.ts

@@ -1,10 +1,18 @@
 import { Worker } from 'node:worker_threads';
 
+type WorkerTaskType
+  = | 'parse'
+    | 'stringify'
+    | 'parseFolder'
+    | 'stringifyFolder'
+    | 'parseEnvironment'
+    | 'stringifyEnvironment';
+
 interface QueuedTask {
   priority: number;
   scriptPath: string;
   data: any;
-  taskType: 'parse' | 'stringify';
+  taskType: WorkerTaskType;
   resolve?: (value: any) => void;
   reject?: (reason?: any) => void;
 }
@@ -58,7 +66,7 @@ class WorkerQueue {
     }
   }
 
-  async runWorker({ scriptPath, data, taskType }: { scriptPath: string; data: any; taskType: 'parse' | 'stringify' }) {
+  async runWorker({ scriptPath, data, taskType }: { scriptPath: string; data: any; taskType: WorkerTaskType }) {
     return new Promise(async (resolve, reject) => {
       let worker = await this.getWorkerForScriptPath(scriptPath);
 

package/src/workers/index.ts

@@ -55,7 +55,15 @@ class BruParserWorker {
     return queueForSize?.workerQueue ?? this.workerQueues[this.workerQueues.length - 1].workerQueue;
   }
 
-  private async enqueueTask({ data, taskType, format = DEFAULT_COLLECTION_FORMAT }: { data: any; taskType: 'parse' | 'stringify'; format?: CollectionFormat }): Promise<any> {
+  private async enqueueTask({
+    data,
+    taskType,
+    format = DEFAULT_COLLECTION_FORMAT
+  }: {
+    data: any;
+    taskType: 'parse' | 'stringify' | 'parseFolder' | 'stringifyFolder' | 'parseEnvironment' | 'stringifyEnvironment';
+    format?: CollectionFormat;
+  }): Promise<any> {
     const size = getSize(data);
     const workerQueue = this.getWorkerQueue(size);
     const workerScriptPath = path.join(__dirname, './workers/worker-script.js');
@@ -76,6 +84,22 @@ class BruParserWorker {
     return this.enqueueTask({ data, taskType: 'stringify', format });
   }
 
+  async parseFolder(data: any, format: CollectionFormat = DEFAULT_COLLECTION_FORMAT): Promise<any> {
+    return this.enqueueTask({ data, taskType: 'parseFolder', format });
+  }
+
+  async stringifyFolder(data: any, format: CollectionFormat = DEFAULT_COLLECTION_FORMAT): Promise<any> {
+    return this.enqueueTask({ data, taskType: 'stringifyFolder', format });
+  }
+
+  async parseEnvironment(data: any, format: CollectionFormat = DEFAULT_COLLECTION_FORMAT): Promise<any> {
+    return this.enqueueTask({ data, taskType: 'parseEnvironment', format });
+  }
+
+  async stringifyEnvironment(data: any, format: CollectionFormat = DEFAULT_COLLECTION_FORMAT): Promise<any> {
+    return this.enqueueTask({ data, taskType: 'stringifyEnvironment', format });
+  }
+
   async cleanup(): Promise<void> {
     const cleanupPromises = this.workerQueues.map(({ workerQueue }) =>
       workerQueue.cleanup()

package/src/workers/worker-script.ts

@@ -1,39 +1,63 @@
 import { parentPort } from 'node:worker_threads';
-import { parseBruRequest, stringifyBruRequest } from '../formats/bru';
-import { parseYmlItem, stringifyYmlItem } from '../formats/yml';
+import {
+  parseBruRequest,
+  parseBruCollection,
+  parseBruEnvironment,
+  stringifyBruRequest,
+  stringifyBruCollection,
+  stringifyBruEnvironment
+} from '../formats/bru';
+import {
+  parseYmlItem,
+  parseYmlFolder,
+  parseYmlEnvironment,
+  stringifyYmlItem,
+  stringifyYmlFolder,
+  stringifyYmlEnvironment
+} from '../formats/yml';
 import { CollectionFormat } from '../types';
 import { DEFAULT_COLLECTION_FORMAT } from '../constants';
 
+type TaskType
+  = | 'parse'
+    | 'stringify'
+    | 'parseFolder'
+    | 'stringifyFolder'
+    | 'parseEnvironment'
+    | 'stringifyEnvironment';
+
 interface WorkerMessage {
-  taskType: 'parse' | 'stringify';
+  taskType: TaskType;
   data: {
     data: any;
     format?: CollectionFormat;
   };
 }
 
+const runTask = (taskType: TaskType, data: any, format: CollectionFormat): any => {
+  switch (taskType) {
+    case 'parse':
+      return format === 'yml' ? parseYmlItem(data) : parseBruRequest(data);
+    case 'stringify':
+      return format === 'yml' ? stringifyYmlItem(data) : stringifyBruRequest(data);
+    case 'parseFolder':
+      return format === 'yml' ? parseYmlFolder(data) : parseBruCollection(data);
+    case 'stringifyFolder':
+      return format === 'yml' ? stringifyYmlFolder(data) : stringifyBruCollection(data, true);
+    case 'parseEnvironment':
+      return format === 'yml' ? parseYmlEnvironment(data) : parseBruEnvironment(data);
+    case 'stringifyEnvironment':
+      return format === 'yml' ? stringifyYmlEnvironment(data) : stringifyBruEnvironment(data);
+    default:
+      throw new Error(`Unknown task type: ${taskType}`);
+  }
+};
+
 parentPort?.on('message', async (message: WorkerMessage) => {
   try {
     const { taskType, data: messageData } = message;
     const { data, format = DEFAULT_COLLECTION_FORMAT } = messageData;
-    let result: any;
-
-    if (taskType === 'parse') {
-      if (format === 'yml') {
-        result = parseYmlItem(data);
-      } else {
-        result = parseBruRequest(data);
-      }
-    } else if (taskType === 'stringify') {
-      if (format === 'yml') {
-        result = stringifyYmlItem(data);
-      } else {
-        result = stringifyBruRequest(data);
-      }
-    } else {
-      throw new Error(`Unknown task type: ${taskType}`);
-    }
-
+    const result = runTask(taskType, data, format);
     parentPort?.postMessage(result);
   } catch (error: any) {
     console.error('Worker error:', error);