@usebruno/filestore 0.11.0 → 0.13.0

package/src/formats/yml/stringifyMockServer.ts

@@ -0,0 +1,129 @@
+import { stringifyYml } from './utils';
+import { isNonEmptyString } from '../../utils';
+import { toOpenCollectionHttpHeaders, toOpenCollectionResponseHeaders } from './common/headers';
+import { toOpenCollectionParams } from './common/params';
+import { toOpenCollectionBody } from './common/body';
+import type {
+  MockServerFile,
+  MockRouteEntry,
+  BrunoMockServer,
+  BrunoMockRoute
+} from './mockServerTypes';
+
+const toOcRuleConditions = (conditions: BrunoMockRoute['rules']['conditions']) => (
+  conditions.map((condition) => ({
+    target: condition.target || '',
+    key: condition.key || '',
+    operator: condition.operator || 'equals',
+    value: condition.value || ''
+  }))
+);
+
+const toOcMockRoute = (route: BrunoMockRoute): MockRouteEntry => {
+  const ocRoute: MockRouteEntry = {
+    name: route.name || 'Untitled Mock Response'
+  };
+
+  if (isNonEmptyString(route.description)) {
+    ocRoute.description = route.description;
+  }
+
+  ocRoute.request = {
+    method: route.request?.method || 'GET',
+    url: route.request?.url || '/'
+  };
+
+  const requestHeaders = toOpenCollectionHttpHeaders(route.request?.headers);
+  if (requestHeaders) {
+    ocRoute.request.headers = requestHeaders;
+  }
+
+  const requestParams = toOpenCollectionParams(route.request?.params);
+  if (requestParams) {
+    ocRoute.request.params = requestParams;
+  }
+
+  const requestBody = toOpenCollectionBody(route.request?.body);
+  if (requestBody !== undefined && !Array.isArray(requestBody)) {
+    ocRoute.request.body = requestBody;
+  }
+
+  ocRoute.response = {
+    status: Number(route.response?.status) || 200
+  };
+
+  if (isNonEmptyString(route.response?.statusText)) {
+    ocRoute.response.statusText = route.response.statusText;
+  }
+
+  const responseHeaders = toOpenCollectionResponseHeaders(route.response?.headers);
+  if (responseHeaders) {
+    ocRoute.response.headers = responseHeaders;
+  }
+
+  const responseBody = route.response?.body;
+  if (responseBody && responseBody.type) {
+    const content = responseBody.content;
+    ocRoute.response.body = {
+      type: responseBody.type,
+      data: typeof content === 'string' ? content : JSON.stringify(content, null, 2)
+    };
+  }
+
+  if (route.rules?.conditions?.length) {
+    ocRoute.rules = {
+      operator: route.rules.operator === 'OR' ? 'OR' : 'AND',
+      conditions: toOcRuleConditions(route.rules.conditions)
+    };
+  }
+
+  if (route.copiedFrom && (route.copiedFrom.exampleName || route.copiedFrom.requestPathname)) {
+    ocRoute.copiedFrom = {};
+    if (route.copiedFrom.exampleName) {
+      ocRoute.copiedFrom.example = route.copiedFrom.exampleName;
+    }
+    if (route.copiedFrom.requestPathname) {
+      ocRoute.copiedFrom.requestPath = route.copiedFrom.requestPathname;
+    }
+  }
+
+  return ocRoute;
+};
+
+const stringifyMockServer = (mockServer: BrunoMockServer): string => {
+  try {
+    const ocMockServer: MockServerFile = {
+      info: {
+        name: mockServer.name && mockServer.name.trim().length ? mockServer.name : 'Mock Server',
+        type: 'mock'
+      },
+      mock: {
+        port: Number(mockServer.port) || 4000
+      }
+    };
+
+    const delay = Number(mockServer.delay);
+    if (delay > 0) {
+      ocMockServer.mock!.delay = delay;
+    }
+
+    const source = mockServer.source;
+    if (source && (source.type === 'collection' || source.type === 'spec') && source.path) {
+      ocMockServer.mock!.source = {
+        type: source.type,
+        path: source.path
+      };
+    }
+
+    if (mockServer.routes?.length) {
+      ocMockServer.routes = mockServer.routes.map(toOcMockRoute);
+    }
+
+    return stringifyYml(ocMockServer);
+  } catch (error) {
+    console.error('Error stringifying mock server:', error);
+    throw error;
+  }
+};
+
+export default stringifyMockServer;

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/maxRedirects.spec.ts

@@ -0,0 +1,144 @@
+import { parseRequest, stringifyRequest } from './index';
+import { DEFAULT_MAX_REDIRECTS } from '@usebruno/common/utils';
+import type { CollectionFormat } from './types';
+
+const FORMATS: CollectionFormat[] = ['bru', 'yml'];
+
+const requestWithMaxRedirects = (maxRedirects: number) => ({
+  uid: 'req-uid',
+  name: 'Get Users',
+  type: 'http-request',
+  seq: 1,
+  request: {
+    url: 'https://restcountries.com/v2/alpha/in',
+    method: 'GET',
+    headers: [],
+    params: [],
+    body: { mode: 'none' },
+    auth: { mode: 'none' },
+    script: {},
+    vars: {},
+    assertions: [],
+    tests: ''
+  },
+  settings: { maxRedirects }
+});
+
+// Serializes with Bruno's own writer and reads back, covering the write side too.
+const roundTripRequest = (maxRedirects: number, format: CollectionFormat) =>
+  parseRequest(stringifyRequest(requestWithMaxRedirects(maxRedirects) as any, { format }), { format })
+    .settings.maxRedirects;
+
+const HAND_EDITED_DOCUMENTS: Record<CollectionFormat, (rawValue: string) => string> = {
+  bru: (rawValue) => `meta {
+  name: Get Users
+  type: http
+  seq: 1
+}
+
+get {
+  url: https://restcountries.com/v2/alpha/in
+  body: none
+  auth: none
+}
+
+settings {
+  maxRedirects: ${rawValue}
+}
+`,
+  yml: (rawValue) => `info:
+  name: Get Users
+  type: http
+  seq: 1
+
+http:
+  method: GET
+  url: https://restcountries.com/v2/alpha/in
+
+settings:
+  maxRedirects: ${rawValue}
+`
+};
+
+// Parses a document stated byte-for-byte, for values Bruno's writer would never produce
+// (.inf, blank, quoted). Returns what the parser stored, so assertions can distinguish a
+// dropped value from one the parser replaced with the default.
+const parseHandEditedValue = (rawValue: string, format: CollectionFormat) =>
+  parseRequest(HAND_EDITED_DOCUMENTS[format](rawValue), { format }).settings.maxRedirects;
+
+describe('maxRedirects on-disk round trip', () => {
+  describe.each(FORMATS)('%s format', (format) => {
+    // The formats agree on the enforced ceiling but not on what they store for an unusable value:
+    // bru omits the setting, yml writes the default in its place.
+    const storedWhenUnusable = format === 'bru' ? undefined : DEFAULT_MAX_REDIRECTS;
+
+    it.each([0, 5, 50, 51, 1000, Number.MAX_SAFE_INTEGER])(
+      'preserves a maxRedirects of %p',
+      (maxRedirects) => {
+        expect(roundTripRequest(maxRedirects, format)).toBe(maxRedirects);
+      }
+    );
+
+    // parseInt stops at the exponent, so a ceiling Bruno writes as 1e+31 reads back as 1.
+    it.each([1e21, 1e31, 9.999999999998865e21])(
+      'preserves an exponentially serialized maxRedirects of %p',
+      (maxRedirects) => {
+        expect(roundTripRequest(maxRedirects, format)).toBe(maxRedirects);
+      }
+    );
+
+    // Files written before any change to the writer's number formatting keep these exact bytes,
+    // so the literal exponent form must parse regardless of what the writer emits today.
+    it.each([
+      ['1e+21', 1e21],
+      ['9.999999999998865e+21', 9.999999999998865e21]
+    ])('reads an on-disk exponent literal %s in full', (rawValue, expected) => {
+      expect(parseHandEditedValue(rawValue, format)).toBe(expected);
+    });
+
+    it.each(['1e309', '-1e309', '1' + '0'.repeat(400)])(
+      'does not store an on-disk %s that overflows to a non-finite number',
+      (rawValue) => {
+        expect(parseHandEditedValue(rawValue, format)).toBe(storedWhenUnusable);
+      }
+    );
+
+    it('clamps an on-disk value beyond MAX_SAFE_INTEGER to the nearest representable integer', () => {
+      expect(parseHandEditedValue('9007199254740993', format)).toBe(9007199254740992);
+    });
+
+    it.each(['', ' ', '   '])('does not store a blank on-disk value %p', (rawValue) => {
+      expect(parseHandEditedValue(rawValue, format)).toBe(storedWhenUnusable);
+    });
+
+    it.each(['-1', '-3', '-0.5'])('does not store a negative on-disk value of %s', (rawValue) => {
+      expect(parseHandEditedValue(rawValue, format)).toBe(storedWhenUnusable);
+    });
+  });
+
+  // Copying a request from a bru collection into a yml one adds a maxRedirects the author never
+  // set, since yml materializes the default where bru left the setting out.
+  it('stores an unusable value differently per format', () => {
+    expect(parseHandEditedValue('abc', 'bru')).toBeUndefined();
+    expect(parseHandEditedValue('abc', 'yml')).toBe(DEFAULT_MAX_REDIRECTS);
+  });
+
+  it('truncates a fractional maxRedirects identically in both formats', () => {
+    expect(roundTripRequest(3.5, 'bru')).toBe(3);
+    expect(roundTripRequest(3.5, 'yml')).toBe(3);
+  });
+
+  it.each(['Infinity', '-Infinity', 'NaN'])('does not store a hand-edited bru maxRedirects of %s', (rawValue) => {
+    expect(parseHandEditedValue(rawValue, 'bru')).toBeUndefined();
+  });
+
+  it.each(['.inf', '-.inf', '.nan'])('replaces a hand-edited yml maxRedirects of %s with the default', (rawValue) => {
+    expect(parseHandEditedValue(rawValue, 'yml')).toBe(DEFAULT_MAX_REDIRECTS);
+  });
+
+  it('does not honour a quoted yml count, but reads a plain count in both formats', () => {
+    expect(parseHandEditedValue('"10"', 'yml')).toBe(DEFAULT_MAX_REDIRECTS);
+    expect(parseHandEditedValue('10', 'yml')).toBe(10);
+    expect(parseHandEditedValue('10', 'bru')).toBe(10);
+  });
+});

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);