@usebruno/filestore 0.11.0 → 0.13.0

package/src/formats/yml/parseCollection.ts

@@ -1,5 +1,6 @@
 import type { OpenCollection } from '@opencollection/types';
 import type { FolderRoot } from '@usebruno/schema-types/collection/folder';
+import { normalizeOpenApiSyncConfigs } from '@usebruno/common';
 import { parseYml } from './utils';
 import { toBrunoAuth } from './common/auth';
 import { toBrunoHttpHeaders } from './common/headers';
@@ -38,11 +39,14 @@ const parseCollection = (ymlString: string): ParsedCollection => {
     // presets
     if (brunoExtension?.presets) {
       const presets = brunoExtension.presets as BrunoPresetsExtension;
-      if (presets.request) {
+      if (presets.request || presets.defaultEnvironment) {
         brunoConfig.presets = {
-          requestType: presets.request.type || '',
-          requestUrl: presets.request.url || ''
+          requestType: presets.request?.type || '',
+          requestUrl: presets.request?.url || ''
         };
+        if (presets.defaultEnvironment) {
+          brunoConfig.presets.defaultEnvironment = presets.defaultEnvironment;
+        }
       }
     }
 
@@ -59,15 +63,18 @@ const parseCollection = (ymlString: string): ParsedCollection => {
         };
       }
     }
-    if (Array.isArray(brunoExtensions?.openapi) && brunoExtensions.openapi.length > 0) {
-      brunoConfig.openapi = brunoExtensions.openapi.map((entry: any) => ({
-        sourceUrl: entry.sourceUrl,
-        groupBy: entry.groupBy,
-        ...(entry.lastSyncDate && { lastSyncDate: entry.lastSyncDate }),
-        ...(entry.specHash && { specHash: entry.specHash }),
-        autoCheck: entry.autoCheck !== false,
-        autoCheckInterval: entry.autoCheckInterval || 5
-      }));
+    // scripts.flow controls collection/folder/request script execution order
+    // ('sandwich' | 'sequential'); unrecognized values fall back to the runtime default.
+    if (brunoExtensions?.scripts?.flow === 'sandwich' || brunoExtensions?.scripts?.flow === 'sequential') {
+      brunoConfig.scripts = {
+        ...brunoConfig.scripts,
+        flow: brunoExtensions.scripts.flow
+      };
+    }
+
+    const openApiEntries = normalizeOpenApiSyncConfigs(brunoExtensions?.openapi);
+    if (openApiEntries.length > 0) {
+      brunoConfig.openapi = openApiEntries;
     }
 
     // protobuf
@@ -142,14 +149,16 @@ const parseCollection = (ymlString: string): ParsedCollection => {
               type: 'cert',
               certFilePath: cert.certificateFilePath,
               keyFilePath: cert.privateKeyFilePath,
-              passphrase: cert.passphrase || ''
+              passphrase: cert.passphrase || '',
+              ...(cert.disabled === true && { disabled: true })
             };
           } else if (cert.type === 'pkcs12') {
             return {
               domain: cert.domain,
               type: 'pfx',
               pfxFilePath: cert.pkcs12FilePath,
-              passphrase: cert.passphrase || ''
+              passphrase: cert.passphrase || '',
+              ...(cert.disabled === true && { disabled: true })
             };
           }
           return null;

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

@@ -96,4 +96,53 @@ variables:
     expect(env.name).toBe('Untitled Environment');
     expect(env.variables).toEqual([]);
   });
+
+  describe('extends', () => {
+    it('parses the parent environment name', () => {
+      const env = parseEnvironment(`name: prod
+extends: base
+variables: []
+`);
+
+      expect(env.extends).toBe('base');
+    });
+
+    it('leaves extends absent for an environment that does not declare it', () => {
+      const env = parseEnvironment(`name: prod
+variables: []
+`);
+
+      expect(env).not.toHaveProperty('extends');
+    });
+
+    it('ignores a parent reference that names nothing', () => {
+      const env = parseEnvironment(`name: prod
+extends: "   "
+variables: []
+`);
+
+      expect(env).not.toHaveProperty('extends');
+    });
+
+    it('parses a list of parents unresolved so that a save does not delete it', () => {
+      const env = parseEnvironment(`name: prod
+extends:
+  - base
+  - shared
+variables: []
+`);
+
+      expect(env.extends).toEqual(['base', 'shared']);
+    });
+
+    it('ignores a parent reference that is neither a name nor a list', () => {
+      const env = parseEnvironment(`name: prod
+extends:
+  parent: base
+variables: []
+`);
+
+      expect(env).not.toHaveProperty('extends');
+    });
+  });
 });

package/src/formats/yml/parseEnvironment.ts

@@ -10,6 +10,7 @@ import { parseYml } from './utils';
 import { uuid, ensureString } from '../../utils';
 import { SECRET_PROVIDER_IDENTIFIER_FIELDS } from '../../constants';
 import { isTypedValue, fromOpenCollectionTypedValue } from './common/datatype';
+import { validatedEnvironmentExtendsFrom } from '@usebruno/common/utils';
 
 const isSecretVariable = (v: Variable | SecretVariable): v is SecretVariable => {
   return 'secret' in v && v.secret === true;
@@ -106,6 +107,11 @@ const parseEnvironment = (ymlString: string): BrunoEnvironment => {
       color: ocEnvironment.color || null
     };
 
+    const ocEnvironmentExtendsFrom = validatedEnvironmentExtendsFrom(ocEnvironment.extends);
+    if (ocEnvironmentExtendsFrom) {
+      brunoEnvironment.extends = ocEnvironmentExtendsFrom;
+    }
+
     const externalSecrets = toBrunoExternalSecrets((ocEnvironment as any).externalSecrets);
     if (externalSecrets) {
       brunoEnvironment.externalSecrets = externalSecrets;

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

@@ -50,3 +50,21 @@ request:
     expect(reqVars[5]).toMatchObject({ name: 'flag', value: 'maybe', dataType: 'boolean' });
   });
 });
+
+describe('parseFolder — seq', () => {
+  it('leaves seq undefined when folder.yml has no seq field', () => {
+    const yml = `info:\n  name: my-folder\n`;
+    const { meta } = parseFolder(yml);
+
+    expect(meta).toEqual(expect.objectContaining({ name: 'my-folder' }));
+    expect(meta!.seq).toBeUndefined();
+  });
+
+  it('preserves an explicit numeric seq from the file', () => {
+    const yml = `info:\n  name: my-folder\n  seq: 3\n`;
+    const { meta } = parseFolder(yml);
+
+    expect(meta).toEqual(expect.objectContaining({ name: 'my-folder' }));
+    expect(meta!.seq).toBe(3);
+  });
+});

package/src/formats/yml/parseFolder.ts

@@ -13,11 +13,15 @@ const parseFolder = (ymlString: string): FolderRoot => {
     const ocFolder: Folder = parseYml(ymlString);
 
     const info = ocFolder.info;
+    const seq = info?.seq;
 
     const folderRoot: FolderRoot = {
       meta: {
         name: ensureString(info?.name, 'Untitled Folder'),
-        seq: info?.seq || 1
+        // Only set seq when the source has a numeric value. Missing seq must stay absent:
+        // defaulting to 1 makes every seq-less folder look "ordered at position 1" to
+        // sortByNameThenSequence, pinning them all to slot 1 instead of alphabetical sort.
+        ...(typeof seq === 'number' && Number.isFinite(seq) ? { seq } : {})
       },
       request: {
         headers: [],

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

@@ -0,0 +1,180 @@
+import parseMockServer from './parseMockServer';
+
+describe('parseMockServer', () => {
+  it('parses a full mock server file', () => {
+    const content = `
+info:
+  name: Dog API Mock
+  type: mock
+
+mock:
+  port: 4001
+  delay: 250
+  source:
+    type: collection
+    path: /Users/x/collections/dog-api
+
+routes:
+  - name: Get user 200
+    description: Returns a user
+    request:
+      method: GET
+      url: /users/:id
+      headers:
+        - name: X-Client
+          value: bruno
+    response:
+      status: 200
+      statusText: OK
+      headers:
+        - name: Content-Type
+          value: application/json
+      body:
+        type: json
+        data: |-
+          {"id": 1}
+    rules:
+      operator: OR
+      conditions:
+        - target: query
+          key: token
+          operator: equals
+          value: abc
+    copiedFrom:
+      example: Success
+      requestPath: /Users/x/collections/dog-api/get-user.yml
+`;
+
+    const mockServer = parseMockServer(content);
+
+    expect(mockServer.name).toBe('Dog API Mock');
+    expect(mockServer.port).toBe(4001);
+    expect(mockServer.delay).toBe(250);
+    expect(mockServer.source).toEqual({ type: 'collection', path: '/Users/x/collections/dog-api' });
+
+    expect(mockServer.routes).toHaveLength(1);
+    const route = mockServer.routes[0];
+    expect(route.name).toBe('Get user 200');
+    expect(route.request.method).toBe('GET');
+    expect(route.request.url).toBe('/users/:id');
+    expect(route.request.headers[0]).toEqual(
+      expect.objectContaining({ name: 'X-Client', value: 'bruno', enabled: true })
+    );
+    expect(route.request.headers[0].uid).toBeTruthy();
+    expect(route.response.status).toBe(200);
+    expect(route.response.body).toEqual({ type: 'json', content: '{"id": 1}' });
+    expect(route.rules.operator).toBe('OR');
+    expect(route.rules.conditions).toEqual([
+      { target: 'query', key: 'token', operator: 'equals', value: 'abc' }
+    ]);
+    expect(route.copiedFrom).toEqual({
+      exampleName: 'Success',
+      requestPathname: '/Users/x/collections/dog-api/get-user.yml'
+    });
+  });
+
+  it('applies safe defaults for a minimal file', () => {
+    const mockServer = parseMockServer('info:\n  name: Tiny Mock\n');
+
+    expect(mockServer).toEqual({
+      name: 'Tiny Mock',
+      port: null,
+      delay: 0,
+      source: null,
+      routes: []
+    });
+  });
+
+  it('defaults route request/response blocks that are missing', () => {
+    const mockServer = parseMockServer(`
+info:
+  name: Mock
+
+routes:
+  - name: Bare route
+`);
+
+    const route = mockServer.routes[0];
+    expect(route.request.url).toBe('/');
+    expect(route.request.method).toBe('GET');
+    expect(route.request.body.mode).toBe('none');
+    expect(route.response.status).toBe(200);
+    expect(route.response.body).toEqual({ type: 'json', content: '' });
+    expect(route.rules).toEqual({ operator: 'AND', conditions: [] });
+    expect(route.copiedFrom).toBeUndefined();
+  });
+
+  it('ignores a source block without a path', () => {
+    const mockServer = parseMockServer(`
+info:
+  name: Mock
+
+mock:
+  source:
+    type: collection
+`);
+
+    expect(mockServer.source).toBeNull();
+  });
+
+  it('rejects non-string source paths', () => {
+    const numericPath = parseMockServer(`
+info:
+  name: Mock
+
+mock:
+  source:
+    type: collection
+    path: 12345
+`);
+    expect(numericPath.source).toBeNull();
+
+    const objectPath = parseMockServer(`
+info:
+  name: Mock
+
+mock:
+  source:
+    type: spec
+    path:
+      nested: value
+`);
+    expect(objectPath.source).toBeNull();
+  });
+
+  it('rejects non-string copiedFrom values', () => {
+    const mockServer = parseMockServer(`
+info:
+  name: Mock
+
+routes:
+  - name: Numeric example
+    copiedFrom:
+      example: 42
+      requestPath: /real/path.yml
+  - name: Object request path
+    copiedFrom:
+      example: Success
+      requestPath:
+        nested: value
+  - name: Fully malformed
+    copiedFrom:
+      example: 1
+      requestPath: 2
+`);
+
+    expect(mockServer.routes[0].copiedFrom).toEqual({
+      exampleName: null,
+      requestPathname: '/real/path.yml'
+    });
+    expect(mockServer.routes[1].copiedFrom).toEqual({
+      exampleName: 'Success',
+      requestPathname: null
+    });
+    expect(mockServer.routes[2].copiedFrom).toBeUndefined();
+  });
+
+  it('throws on non-object content', () => {
+    expect(() => parseMockServer('- a\n- b\n')).toThrow('Invalid mock server file');
+  });
+});

package/src/formats/yml/parseMockServer.ts

@@ -0,0 +1,113 @@
+import { parseYml } from './utils';
+import { ensureString, isNonEmptyString } from '../../utils';
+import { toBrunoHttpHeaders } from './common/headers';
+import { toBrunoParams } from './common/params';
+import { toBrunoBody } from './common/body';
+import type {
+  MockServerFile,
+  MockRouteEntry,
+  BrunoMockServer,
+  BrunoMockRoute,
+  MockRuleCondition
+} from './mockServerTypes';
+
+const emptyRequestBody = () => ({
+  mode: 'none',
+  json: null,
+  text: null,
+  xml: null,
+  sparql: null,
+  formUrlEncoded: null,
+  multipartForm: null,
+  graphql: null,
+  file: null
+});
+
+const toBrunoRuleConditions = (conditions: MockRuleCondition[] | null | undefined) => {
+  if (!Array.isArray(conditions)) {
+    return [];
+  }
+
+  return conditions.map((condition) => ({
+    target: ensureString(condition?.target),
+    key: ensureString(condition?.key),
+    operator: ensureString(condition?.operator, 'equals'),
+    value: ensureString(condition?.value)
+  }));
+};
+
+const toBrunoMockRoute = (route: MockRouteEntry): BrunoMockRoute => {
+  const responseStatus = Number(route?.response?.status) || 200;
+  const responseStatusText = ensureString(route?.response?.statusText);
+
+  const brunoRoute: BrunoMockRoute = {
+    name: ensureString(route?.name, 'Untitled Mock Response'),
+    description: ensureString(route?.description),
+    request: {
+      url: ensureString(route?.request?.url, '/'),
+      method: ensureString(route?.request?.method, 'GET'),
+      headers: toBrunoHttpHeaders(route?.request?.headers) || [],
+      params: toBrunoParams(route?.request?.params) || [],
+      body: toBrunoBody(route?.request?.body) || emptyRequestBody()
+    },
+    response: {
+      status: responseStatus,
+      statusText: responseStatusText === 'OK' && responseStatus !== 200 ? '' : responseStatusText,
+      headers: toBrunoHttpHeaders(route?.response?.headers) || [],
+      body: {
+        type: ensureString(route?.response?.body?.type, 'json'),
+        content: ensureString(route?.response?.body?.data)
+      }
+    },
+    rules: {
+      operator: route?.rules?.operator === 'OR' ? 'OR' : 'AND',
+      conditions: toBrunoRuleConditions(route?.rules?.conditions)
+    }
+  };
+
+  const rawExample = route?.copiedFrom?.example;
+  const rawRequestPath = route?.copiedFrom?.requestPath;
+  const copiedFromExample = isNonEmptyString(rawExample) ? rawExample : null;
+  const copiedFromRequestPath = isNonEmptyString(rawRequestPath) ? rawRequestPath : null;
+
+  if (copiedFromExample || copiedFromRequestPath) {
+    brunoRoute.copiedFrom = {
+      exampleName: copiedFromExample,
+      requestPathname: copiedFromRequestPath
+    };
+  }
+
+  return brunoRoute;
+};
+
+const parseMockServer = (content: string): BrunoMockServer => {
+  const parsed: MockServerFile = parseYml(content);
+
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new Error('Invalid mock server file');
+  }
+
+  const info = parsed.info || ({} as NonNullable<MockServerFile['info']>);
+  const mock = parsed.mock || ({} as NonNullable<MockServerFile['mock']>);
+
+  const brunoMockServer: BrunoMockServer = {
+    name: ensureString(info.name, 'Mock Server'),
+    port: Number(mock.port) || null,
+    delay: Number(mock.delay) || 0,
+    source: null,
+    routes: Array.isArray(parsed.routes) ? parsed.routes.map(toBrunoMockRoute) : []
+  };
+
+  const sourceType = mock.source?.type;
+  const sourcePath = mock.source?.path;
+  if ((sourceType === 'collection' || sourceType === 'spec') && isNonEmptyString(sourcePath)) {
+    brunoMockServer.source = {
+      type: sourceType,
+      path: sourcePath
+    };
+  }
+
+  return brunoMockServer;
+};
+
+export default parseMockServer;

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

@@ -0,0 +1,159 @@
+import stringifyItem from './stringifyItem';
+import parseItem from './parseItem';
+import stringifyCollection from './stringifyCollection';
+import parseCollection from './parseCollection';
+import stringifyFolder from './stringifyFolder';
+import parseFolder from './parseFolder';
+
+const GRPC_SLOTS = {
+  beforeCallStart: 'before()',
+  afterCallEnd: 'after()',
+  beforeMessageSend: 'beforeSend()',
+  afterMessageReceive: 'afterReceive()'
+};
+
+const ALL_SLOTS = {
+  req: 'pre()',
+  res: 'post()',
+  ...GRPC_SLOTS
+};
+
+const HTTP_TYPES = ['before-request', 'after-response'];
+const GRPC_TYPES = [
+  'grpc:before-call-start',
+  'grpc:after-call-end',
+  'grpc:before-message-send',
+  'grpc:after-message-receive'
+];
+
+const expectScriptTypes = (yml: string, written: string[], dropped: string[]) => {
+  written.forEach((type) => expect(yml).toContain(`type: ${type}`));
+  dropped.forEach((type) => expect(yml).not.toContain(`type: ${type}`));
+};
+
+const itemWithAllSlots = (type: string, request: Record<string, any>) => ({
+  uid: 'i1',
+  type,
+  name: 'r',
+  seq: 1,
+  request: {
+    auth: { mode: 'none' },
+    headers: [],
+    script: { ...ALL_SLOTS },
+    tests: null,
+    vars: { req: [], res: [] },
+    ...request
+  }
+}) as any;
+
+const rootWithScript = (script: Record<string, string | null>) => ({
+  meta: { name: 'my-folder', seq: 1 },
+  request: {
+    headers: [],
+    auth: { mode: 'none' },
+    script,
+    tests: null,
+    vars: { req: [], res: [] }
+  },
+  docs: null
+}) as any;
+
+describe('script — request items', () => {
+  const httpFamily = [
+    [
+      'http',
+      itemWithAllSlots('http-request', {
+        url: 'https://example.com',
+        method: 'GET',
+        params: [],
+        body: { mode: 'none' }
+      })
+    ],
+    [
+      'graphql',
+      itemWithAllSlots('graphql-request', {
+        url: 'https://example.com/graphql',
+        method: 'POST',
+        params: [],
+        body: { mode: 'graphql', graphql: { query: '{ hi }', variables: '' } }
+      })
+    ],
+    // TODO: Move it to a separate test block, once ws scripts are added.
+    [
+      'websocket',
+      itemWithAllSlots('ws-request', {
+        url: 'wss://example.com',
+        body: { mode: 'ws', ws: [{ name: 'message 1', content: '{}' }] }
+      })
+    ]
+  ] as [string, any][];
+
+  it.each(httpFamily)('a %s request writes req/res and drops the grpc hooks', (_name, item) => {
+    const yml = stringifyItem(item);
+
+    expectScriptTypes(yml, HTTP_TYPES, GRPC_TYPES);
+    expect(yml).not.toContain('before()');
+    expect(yml).not.toContain('after()');
+    expect(yml).not.toContain('beforeSend()');
+    expect(yml).not.toContain('afterReceive()');
+
+    expect(parseItem(yml).request!.script).toEqual({ req: 'pre()', res: 'post()' });
+  });
+
+  it('a grpc request writes the lifecycle hooks and drops req/res', () => {
+    const item = itemWithAllSlots('grpc-request', {
+      url: 'grpc://localhost:50051',
+      method: '/hello.Greeter/SayHello',
+      methodType: 'unary',
+      body: { mode: 'grpc', grpc: [{ name: 'message 1', content: '{}' }] },
+      assertions: []
+    });
+
+    const yml = stringifyItem(item);
+
+    expectScriptTypes(yml, GRPC_TYPES, HTTP_TYPES);
+    expect(yml).not.toContain('pre()');
+    expect(yml).not.toContain('post()');
+
+    expect(parseItem(yml).request!.script).toEqual({
+      beforeCallStart: 'before()',
+      afterCallEnd: 'after()',
+      beforeMessageSend: 'beforeSend()',
+      afterMessageReceive: 'afterReceive()'
+    });
+  });
+});
+
+describe('script — collection and folder roots', () => {
+  it('a collection root writes req/res and drops the grpc hooks', () => {
+    const yml = stringifyCollection(rootWithScript({ ...ALL_SLOTS }), { name: 'c' });
+
+    expectScriptTypes(yml, HTTP_TYPES, GRPC_TYPES);
+
+    expect(parseCollection(yml).collectionRoot.request!.script).toEqual({ req: 'pre()', res: 'post()' });
+  });
+
+  it('a folder root writes req/res and drops the grpc hooks', () => {
+    const yml = stringifyFolder(rootWithScript({ ...ALL_SLOTS }));
+
+    expectScriptTypes(yml, HTTP_TYPES, GRPC_TYPES);
+
+    expect(parseFolder(yml).request!.script).toEqual({ req: 'pre()', res: 'post()' });
+  });
+
+  it('a collection root carrying only grpc hooks writes no scripts at all', () => {
+    const yml = stringifyCollection(rootWithScript({ ...GRPC_SLOTS }), { name: 'c' });
+
+    expect(yml).not.toContain('scripts:');
+
+    expect(parseCollection(yml).collectionRoot.request?.script).toBeUndefined();
+  });
+
+  it('a folder root carrying only grpc hooks writes no scripts at all', () => {
+    const yml = stringifyFolder(rootWithScript({ ...GRPC_SLOTS }));
+
+    expect(yml).not.toContain('scripts:');
+
+    expect(parseFolder(yml).request!.script).toEqual({ req: null, res: null });
+  });
+});