@usebruno/filestore 0.10.0 → 0.12.0

package/src/formats/yml/stringifyItem.ts

@@ -4,6 +4,7 @@ import stringifyGraphqlRequest from './items/stringifyGraphQLRequest';
 import stringifyGrpcRequest from './items/stringifyGrpcRequest';
 import stringifyWebsocketRequest from './items/stringifyWebsocketRequest';
 import stringifyScript from './items/stringifyScript';
+import stringifyApp from './items/stringifyApp';
 
 const stringifyItem = (item: BrunoItem): string => {
   try {
@@ -23,6 +24,9 @@ const stringifyItem = (item: BrunoItem): string => {
       case 'js':
         return stringifyScript(item);
 
+      case 'app':
+        return stringifyApp(item);
+
       case 'folder':
         throw new Error('Folder items should be handled separately using stringifyFolder');
 

package/src/formats/yml/stringifyMockServer.spec.ts

@@ -0,0 +1,177 @@
+import stringifyMockServer from './stringifyMockServer';
+import parseMockServer from './parseMockServer';
+import type { BrunoMockServer } from './mockServerTypes';
+
+const fullMockServer: BrunoMockServer = {
+  name: 'Dog API Mock',
+  port: 4001,
+  delay: 500,
+  source: {
+    type: 'collection',
+    path: '/Users/x/collections/dog-api'
+  },
+  routes: [
+    {
+      name: 'Get user 200',
+      description: 'Returns a user',
+      request: {
+        url: '/users/:id',
+        method: 'GET',
+        headers: [{ uid: 'h1', name: 'X-Client', value: 'bruno', enabled: true }],
+        params: [{ uid: 'p1', name: 'id', value: '1', type: 'path', enabled: true }],
+        body: { mode: 'json', json: '{"filter": true}' }
+      },
+      response: {
+        status: 200,
+        statusText: 'OK',
+        headers: [{ uid: 'rh1', name: 'Content-Type', value: 'application/json', enabled: true }],
+        body: {
+          type: 'json',
+          content: '{"id": 1}'
+        }
+      },
+      rules: {
+        operator: 'AND',
+        conditions: [
+          { target: 'header', key: 'Authorization', operator: 'equals', value: 'token' }
+        ]
+      },
+      copiedFrom: {
+        exampleName: 'Success',
+        requestPathname: '/Users/x/collections/dog-api/get-user.yml'
+      }
+    }
+  ]
+};
+
+describe('stringifyMockServer', () => {
+  it('writes the info block with type mock', () => {
+    const content = stringifyMockServer(fullMockServer);
+
+    expect(content).toContain('info:');
+    expect(content).toContain('name: Dog API Mock');
+    expect(content).toContain('type: mock');
+  });
+
+  it('writes port, delay and source under the mock block', () => {
+    const content = stringifyMockServer(fullMockServer);
+
+    expect(content).toContain('mock:');
+    expect(content).toContain('port: 4001');
+    expect(content).toContain('delay: 500');
+    expect(content).toContain('type: collection');
+    expect(content).toContain('path: /Users/x/collections/dog-api');
+  });
+
+  it('omits delay when zero and source when manual', () => {
+    const content = stringifyMockServer({
+      name: 'Manual Mock',
+      port: 4000,
+      delay: 0,
+      source: null,
+      routes: []
+    });
+
+    expect(content).not.toContain('delay:');
+    expect(content).not.toContain('source:');
+    expect(content).not.toContain('routes:');
+  });
+
+  it('omits rules when there are no conditions', () => {
+    const content = stringifyMockServer({
+      name: 'Mock',
+      port: 4000,
+      delay: 0,
+      source: null,
+      routes: [
+        {
+          name: 'Ping',
+          description: '',
+          request: { url: '/ping', method: 'GET', headers: [], params: [], body: { mode: 'none' } },
+          response: { status: 204, statusText: 'No Content', headers: [], body: { type: 'text', content: '' } },
+          rules: { operator: 'AND', conditions: [] }
+        }
+      ]
+    });
+
+    expect(content).not.toContain('rules:');
+  });
+
+  it('does not write uids anywhere', () => {
+    const content = stringifyMockServer(fullMockServer);
+    expect(content).not.toContain('uid');
+  });
+});
+
+describe('mock server round-trip', () => {
+  it('parse(stringify(x)) preserves all fields', () => {
+    const parsed = parseMockServer(stringifyMockServer(fullMockServer));
+
+    expect(parsed.name).toBe('Dog API Mock');
+    expect(parsed.port).toBe(4001);
+    expect(parsed.delay).toBe(500);
+    expect(parsed.source).toEqual({ type: 'collection', path: '/Users/x/collections/dog-api' });
+
+    expect(parsed.routes).toHaveLength(1);
+    const route = parsed.routes[0];
+    expect(route.name).toBe('Get user 200');
+    expect(route.description).toBe('Returns a user');
+    expect(route.request.url).toBe('/users/:id');
+    expect(route.request.method).toBe('GET');
+    expect(route.request.headers).toEqual([
+      expect.objectContaining({ name: 'X-Client', value: 'bruno', enabled: true })
+    ]);
+    expect(route.request.params).toEqual([
+      expect.objectContaining({ name: 'id', value: '1', type: 'path', enabled: true })
+    ]);
+    expect(route.request.body).toEqual(expect.objectContaining({ mode: 'json', json: '{"filter": true}' }));
+    expect(route.response.status).toBe(200);
+    expect(route.response.statusText).toBe('OK');
+    expect(route.response.headers).toEqual([
+      expect.objectContaining({ name: 'Content-Type', value: 'application/json' })
+    ]);
+    expect(route.response.body).toEqual({ type: 'json', content: '{"id": 1}' });
+    expect(route.rules).toEqual({
+      operator: 'AND',
+      conditions: [{ target: 'header', key: 'Authorization', operator: 'equals', value: 'token' }]
+    });
+    expect(route.copiedFrom).toEqual({
+      exampleName: 'Success',
+      requestPathname: '/Users/x/collections/dog-api/get-user.yml'
+    });
+  });
+
+  it('round-trips a spec-sourced server', () => {
+    const parsed = parseMockServer(stringifyMockServer({
+      name: 'Spec Mock',
+      port: 4002,
+      delay: 0,
+      source: { type: 'spec', path: '/Users/x/specs/petstore.yml' },
+      routes: []
+    }));
+
+    expect(parsed.source).toEqual({ type: 'spec', path: '/Users/x/specs/petstore.yml' });
+    expect(parsed.routes).toEqual([]);
+  });
+
+  it('round-trips multiline json response bodies byte-safely', () => {
+    const content = '{\n  "id": 1,\n  "name": "rex: \'good\' dog"\n}';
+    const parsed = parseMockServer(stringifyMockServer({
+      name: 'Mock',
+      port: 4000,
+      delay: 0,
+      source: null,
+      routes: [
+        {
+          name: 'Get dog',
+          description: '',
+          request: { url: '/dogs/1', method: 'GET', headers: [], params: [], body: { mode: 'none' } },
+          response: { status: 200, statusText: 'OK', headers: [], body: { type: 'json', content } },
+          rules: { operator: 'AND', conditions: [] }
+        }
+      ]
+    }));
+
+    expect(parsed.routes[0].response.body.content).toBe(content);
+  });
+});

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/fixtures/presets/empty-request.yml

@@ -0,0 +1,7 @@
+opencollection: 1.0.0
+info:
+  name: My Collection
+extensions:
+  bruno:
+    presets:
+      request: {}

package/src/formats/yml/tests/fixtures/presets/no-presets.yml

@@ -0,0 +1,3 @@
+opencollection: 1.0.0
+info:
+  name: My Collection

package/src/formats/yml/tests/fixtures/presets/no-request-key.yml

@@ -0,0 +1,6 @@
+opencollection: 1.0.0
+info:
+  name: My Collection
+extensions:
+  bruno:
+    presets: {}

package/src/formats/yml/tests/fixtures/presets/type-only-realistic.yml

@@ -0,0 +1,24 @@
+opencollection: 1.0.0
+
+info:
+  name: md8
+config:
+  proxy:
+    inherit: true
+    config:
+      protocol: http
+      hostname: ""
+      port: ""
+      auth:
+        username: ""
+        password: ""
+      bypassProxy: ""
+bundled: false
+extensions:
+  bruno:
+    ignore:
+      - node_modules
+      - .git
+    presets:
+      request:
+        type: graphql

package/src/formats/yml/tests/fixtures/presets/url-only-realistic.yml

@@ -0,0 +1,25 @@
+opencollection: 1.0.0
+
+info:
+  name: md8
+config:
+  proxy:
+    inherit: true
+    config:
+      protocol: http
+      hostname: ""
+      port: ""
+      auth:
+        username: ""
+        password: ""
+      bypassProxy: ""
+bundled: false
+extensions:
+  bruno:
+    ignore:
+      - node_modules
+      - .git
+    presets:
+      request:
+        type: http
+        url: https://example.com/graphql

package/src/formats/yml/tests/fixtures/presets/with-type-and-url.yml

@@ -0,0 +1,9 @@
+opencollection: 1.0.0
+info:
+  name: My Collection
+extensions:
+  bruno:
+    presets:
+      request:
+        type: graphql
+        url: https://example.com/graphql

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

@@ -0,0 +1,63 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import parseCollection from '../parseCollection';
+
+const loadFixture = (name) =>
+  fs.readFileSync(path.join(__dirname, 'fixtures', 'presets', `${name}.yml`), 'utf8');
+
+describe('yml parseCollection - presets', () => {
+  it('parses presets when request.type and request.url are present', () => {
+    const { brunoConfig } = parseCollection(loadFixture('with-type-and-url'));
+
+    expect(brunoConfig.presets).toEqual({
+      requestType: 'graphql',
+      requestUrl: 'https://example.com/graphql'
+    });
+  });
+
+  it('defaults requestType and requestUrl to empty strings (not arrays) when request fields are missing', () => {
+    const { brunoConfig } = parseCollection(loadFixture('empty-request'));
+
+    expect(brunoConfig.presets).toEqual({
+      requestType: '',
+      requestUrl: ''
+    });
+    expect(Array.isArray(brunoConfig.presets.requestType)).toBe(false);
+    expect(Array.isArray(brunoConfig.presets.requestUrl)).toBe(false);
+  });
+
+  it('does not set presets when the extension has no presets block', () => {
+    const { brunoConfig } = parseCollection(loadFixture('no-presets'));
+
+    expect(brunoConfig.presets).toBeUndefined();
+  });
+
+  it('does not set presets when presets exists but request key is absent', () => {
+    const { brunoConfig } = parseCollection(loadFixture('no-request-key'));
+
+    expect(brunoConfig.presets).toBeUndefined();
+  });
+
+  it('parses a realistic collection with only request.type set (no url) — defaults url to empty string', () => {
+    const { brunoConfig } = parseCollection(loadFixture('type-only-realistic'));
+
+    expect(brunoConfig.presets).toEqual({
+      requestType: 'graphql',
+      requestUrl: ''
+    });
+    expect(Array.isArray(brunoConfig.presets.requestUrl)).toBe(false);
+    expect(brunoConfig.ignore).toEqual(['node_modules', '.git']);
+  });
+
+  it('parses a realistic collection with request.type http and request.url set', () => {
+    const { brunoConfig } = parseCollection(loadFixture('url-only-realistic'));
+
+    expect(brunoConfig.presets).toEqual({
+      requestType: 'http',
+      requestUrl: 'https://example.com/graphql'
+    });
+    expect(Array.isArray(brunoConfig.presets.requestType)).toBe(false);
+    expect(Array.isArray(brunoConfig.presets.requestUrl)).toBe(false);
+    expect(brunoConfig.ignore).toEqual(['node_modules', '.git']);
+  });
+});

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

@@ -48,46 +48,46 @@ variables:
 const byName = (env) => Object.fromEntries(env.variables.map((v) => [v.name, v]));
 
 describe('yml parseEnvironment - typed values', () => {
-  it('keeps the value as a string and preserves the type via datatype', () => {
+  it('coerces the value to its native JS type and preserves the type via dataType', () => {
     const variables = byName(parseEnvironment(ENV_YML));
 
-    expect(variables.env_num).toMatchObject({ value: '300', type: 'text', datatype: 'number' });
-    expect(typeof variables.env_num.value).toBe('string');
+    expect(variables.env_num).toMatchObject({ value: 300, type: 'text', dataType: 'number' });
+    expect(typeof variables.env_num.value).toBe('number');
 
-    expect(variables.env_bool).toMatchObject({ value: 'true', datatype: 'boolean' });
-    expect(variables.falsy_num).toMatchObject({ value: '0', datatype: 'number' });
-    expect(variables.falsy_bool).toMatchObject({ value: 'false', datatype: 'boolean' });
+    expect(variables.env_bool).toMatchObject({ value: true, dataType: 'boolean' });
+    expect(variables.falsy_num).toMatchObject({ value: 0, dataType: 'number' });
+    expect(variables.falsy_bool).toMatchObject({ value: false, dataType: 'boolean' });
 
-    expect(variables.env_obj.datatype).toBe('object');
-    expect(typeof variables.env_obj.value).toBe('string');
-    expect(variables.env_obj.value).toContain('"scope": "env"');
+    expect(variables.env_obj.dataType).toBe('object');
+    expect(typeof variables.env_obj.value).toBe('object');
+    expect(variables.env_obj.value).toMatchObject({ scope: 'env' });
 
-    expect(variables.env_array_obj).toMatchObject({ value: '[1,2,3,4]', datatype: 'object' });
+    expect(variables.env_array_obj).toMatchObject({ value: [1, 2, 3, 4], dataType: 'object' });
   });
 
-  it('does not set datatype for plain string values', () => {
+  it('does not set dataType for plain string values', () => {
     const variables = byName(parseEnvironment(ENV_YML));
 
     expect(variables.env_str).toMatchObject({ value: 'env_string', type: 'text', secret: false });
-    expect(variables.env_str).not.toHaveProperty('datatype');
+    expect(variables.env_str).not.toHaveProperty('dataType');
   });
 
-  it('parses secret variables with no value or datatype', () => {
+  it('parses secret variables with no value or dataType', () => {
     const variables = byName(parseEnvironment(ENV_YML));
 
     expect(variables.env_secret_str).toMatchObject({ name: 'env_secret_str', value: '', secret: true });
-    expect(variables.env_secret_str).not.toHaveProperty('datatype');
+    expect(variables.env_secret_str).not.toHaveProperty('dataType');
   });
 
-  it('parses secret variables with a type, keeping the value empty and the type in datatype', () => {
+  it('parses secret variables with a type, keeping the value empty and the type in dataType', () => {
     const variables = byName(parseEnvironment(ENV_YML));
 
-    expect(variables.env_secret_num).toMatchObject({ value: '', secret: true, datatype: 'number' });
-    expect(variables.env_secret_bool).toMatchObject({ value: '', secret: true, datatype: 'boolean' });
-    expect(variables.env_secret_obj).toMatchObject({ value: '', secret: true, datatype: 'object' });
+    expect(variables.env_secret_num).toMatchObject({ value: '', secret: true, dataType: 'number' });
+    expect(variables.env_secret_bool).toMatchObject({ value: '', secret: true, dataType: 'boolean' });
+    expect(variables.env_secret_obj).toMatchObject({ value: '', secret: true, dataType: 'object' });
   });
 
-  it('serializes secret variable datatype back to a type field, omitting it for plain secrets', () => {
+  it('serializes secret variable dataType back to a type field, omitting it for plain secrets', () => {
     const yml = stringifyEnvironment(parseEnvironment(ENV_YML));
 
     expect(yml).toContain('- secret: true\n    name: env_secret_num\n    type: number');
@@ -97,19 +97,19 @@ describe('yml parseEnvironment - typed values', () => {
     expect(yml).not.toContain('name: env_secret_str\n    type:');
   });
 
-  it('serializes datatype back to an OpenCollection { type, data } value', () => {
+  it('serializes dataType back to an OpenCollection { type, data } value', () => {
     const yml = stringifyEnvironment(parseEnvironment(ENV_YML));
 
     expect(yml).toContain('type: number');
     expect(yml).toContain('data: "300"');
     expect(yml).toContain('type: boolean');
     expect(yml).toContain('type: object');
-    // plain strings stay plain, never wrapped as a string datatype
+    // plain strings stay plain, never wrapped as a string dataType
     expect(yml).toContain('value: env_string');
     expect(yml).not.toContain('type: string');
   });
 
-  it('round-trips value and datatype through parse -> stringify -> parse', () => {
+  it('round-trips value and dataType through parse -> stringify -> parse', () => {
     const env = parseEnvironment(ENV_YML);
     const reparsed = parseEnvironment(stringifyEnvironment(env));
 
@@ -118,44 +118,5 @@ describe('yml parseEnvironment - typed values', () => {
   });
 });
 
-const EXTERNAL_SECRETS_YML = `name: test_env
-variables:
-  - name: env_str
-    value: env_string
-externalSecrets:
-  type: my-vault
-  variables:
-    - name: by_path
-      path: secret/data/secret
-    - name: by_secret_name
-      secretName: secret
-    - name: by_vault_name
-      vaultName: secret
-`;
-
-describe('yml parseEnvironment - external secrets', () => {
-  it('parses externalSecrets, preserving the type and arbitrary variable keys', () => {
-    const env = parseEnvironment(EXTERNAL_SECRETS_YML);
-
-    expect(env.externalSecrets).toEqual({
-      type: 'my-vault',
-      variables: [
-        { name: 'by_path', path: 'secret/data/secret' },
-        { name: 'by_secret_name', secretName: 'secret' },
-        { name: 'by_vault_name', vaultName: 'secret' }
-      ]
-    });
-  });
-
-  it('does not set externalSecrets when the yml has none', () => {
-    const env = parseEnvironment('name: test_env\nvariables: []\n');
-    expect(env.externalSecrets).toBeUndefined();
-  });
-
-  it('round-trips externalSecrets through parse -> stringify -> parse', () => {
-    const env = parseEnvironment(EXTERNAL_SECRETS_YML);
-    const reparsed = parseEnvironment(stringifyEnvironment(env));
-
-    expect(reparsed.externalSecrets).toEqual(env.externalSecrets);
-  });
-});
+// External-secrets parsing/serialization is covered in parseEnvironment.spec.ts and
+// stringifyEnvironment.spec.ts against the strict { type, variables } model.