@usebruno/filestore 0.11.0 → 0.12.0

package/src/formats/yml/items/parseHttpRequest.ts

@@ -11,6 +11,8 @@ import { toBrunoScripts } from '../common/scripts';
 import { toBrunoAssertions } from '../common/assertions';
 import { toBrunoApp } from '../common/app';
 import { uuid, ensureString } from '../../../utils';
+import { utils } from '@usebruno/common';
+const { toBool, toNumber } = utils;
 
 const parseHttpRequest = (ocRequest: HttpRequest): BrunoItem => {
   const info = ocRequest.info;
@@ -113,11 +115,7 @@ const parseHttpRequest = (ocRequest: HttpRequest): BrunoItem => {
   if (ocRequest.settings) {
     const settings: BrunoHttpItemSettings = {};
 
-    if (typeof ocRequest.settings.encodeUrl === 'boolean') {
-      settings.encodeUrl = ocRequest.settings.encodeUrl;
-    } else {
-      settings.encodeUrl = true;
-    }
+    settings.encodeUrl = toBool(ocRequest.settings.encodeUrl, true);
 
     if (typeof ocRequest.settings.timeout === 'number') {
       settings.timeout = ocRequest.settings.timeout;
@@ -127,17 +125,9 @@ const parseHttpRequest = (ocRequest: HttpRequest): BrunoItem => {
       settings.timeout = 0;
     }
 
-    if (typeof ocRequest.settings.followRedirects === 'boolean') {
-      settings.followRedirects = ocRequest.settings.followRedirects;
-    } else {
-      settings.followRedirects = true;
-    }
-
-    if (typeof ocRequest.settings.maxRedirects === 'number') {
-      settings.maxRedirects = ocRequest.settings.maxRedirects;
-    } else {
-      settings.maxRedirects = 5;
-    }
+    settings.followRedirects = toBool(ocRequest.settings.followRedirects, true);
+    settings.maxRedirects = toNumber(ocRequest.settings.maxRedirects, 5);
+    settings.forwardAuthorizationHeader = toBool(ocRequest.settings.forwardAuthorizationHeader, true);
 
     brunoItem.settings = settings;
   }

package/src/formats/yml/items/stringifyGraphQLRequest.ts

@@ -16,6 +16,7 @@ import { toOpenCollectionVariables } from '../common/variables';
 import { toOpenCollectionActions } from '../common/actions';
 import { toOpenCollectionScripts } from '../common/scripts';
 import { toOpenCollectionAssertions } from '../common/assertions';
+import { resolveTimeoutSetting } from '@usebruno/common/utils';
 
 const stringifyGraphQLRequest = (item: BrunoItem): string => {
   try {
@@ -132,12 +133,7 @@ const stringifyGraphQLRequest = (item: BrunoItem): string => {
       settings.encodeUrl = true;
     }
 
-    const timeout = httpSettings?.timeout;
-    if (isNumber(timeout)) {
-      settings.timeout = timeout;
-    } else {
-      settings.timeout = 0;
-    }
+    settings.timeout = resolveTimeoutSetting(httpSettings?.timeout);
 
     if (httpSettings?.followRedirects === true) {
       settings.followRedirects = true;
@@ -154,6 +150,8 @@ const stringifyGraphQLRequest = (item: BrunoItem): string => {
       settings.maxRedirects = 5;
     }
 
+    settings.forwardAuthorizationHeader = httpSettings?.forwardAuthorizationHeader ?? true;
+
     ocRequest.settings = settings;
 
     // docs

package/src/formats/yml/items/stringifyHttpRequest.ts

@@ -18,6 +18,7 @@ import { toOpenCollectionActions } from '../common/actions';
 import { toOpenCollectionScripts } from '../common/scripts';
 import { toOpenCollectionAssertions } from '../common/assertions';
 import { isNumber, isNonEmptyString } from '../../../utils';
+import { resolveTimeoutSetting } from '@usebruno/common/utils';
 
 const stringifyHttpRequest = (item: BrunoItem): string => {
   try {
@@ -120,12 +121,7 @@ const stringifyHttpRequest = (item: BrunoItem): string => {
       settings.encodeUrl = true;
     }
 
-    const timeout = httpSettings?.timeout;
-    if (isNumber(timeout)) {
-      settings.timeout = timeout;
-    } else {
-      settings.timeout = 0;
-    }
+    settings.timeout = resolveTimeoutSetting(httpSettings?.timeout);
 
     if (httpSettings?.followRedirects === true) {
       settings.followRedirects = true;
@@ -142,6 +138,8 @@ const stringifyHttpRequest = (item: BrunoItem): string => {
       settings.maxRedirects = 5;
     }
 
+    settings.forwardAuthorizationHeader = httpSettings?.forwardAuthorizationHeader ?? true;
+
     ocRequest.settings = settings;
 
     // examples

package/src/formats/yml/mockServerTypes.ts

@@ -0,0 +1,95 @@
+import type { HttpRequestHeader, HttpResponseHeader, HttpRequestParam, HttpRequestBody } from '@opencollection/types/requests/http';
+
+export interface MockRuleCondition {
+  target?: string;
+  key?: string;
+  operator?: string;
+  value?: string;
+}
+
+export interface MockRouteRules {
+  operator?: 'AND' | 'OR';
+  conditions?: MockRuleCondition[];
+}
+
+export interface MockRouteEntry {
+  name?: string;
+  description?: string;
+  request?: {
+    method?: string;
+    url?: string;
+    headers?: HttpRequestHeader[];
+    params?: HttpRequestParam[];
+    body?: HttpRequestBody;
+  };
+  response?: {
+    status?: number;
+    statusText?: string;
+    headers?: HttpResponseHeader[];
+    body?: {
+      type?: string;
+      data?: string;
+    };
+  };
+  rules?: MockRouteRules;
+  copiedFrom?: {
+    example?: string | null;
+    requestPath?: string | null;
+  };
+}
+
+export interface MockServerFile {
+  info?: {
+    name?: string;
+    type?: 'mock';
+  };
+  mock?: {
+    port?: number;
+    delay?: number;
+    source?: {
+      type?: 'collection' | 'spec';
+      path?: string;
+    };
+  };
+  routes?: MockRouteEntry[];
+}
+
+export interface BrunoMockRoute {
+  name: string;
+  description: string;
+  request: {
+    url: string;
+    method: string;
+    headers: any[];
+    params: any[];
+    body: any;
+  };
+  response: {
+    status: number;
+    statusText: string;
+    headers: any[];
+    body: {
+      type: string;
+      content: string;
+    };
+  };
+  rules: {
+    operator: 'AND' | 'OR';
+    conditions: Array<{ target: string; key: string; operator: string; value: string }>;
+  };
+  copiedFrom?: {
+    exampleName: string | null;
+    requestPathname: string | null;
+  };
+}
+
+export interface BrunoMockServer {
+  name: string;
+  port: number | null;
+  delay: number;
+  source: {
+    type: 'collection' | 'spec';
+    path: string;
+  } | null;
+  routes: BrunoMockRoute[];
+}

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

@@ -52,6 +52,129 @@ request:
   });
 });
 
+describe('parseCollection — script execution flow', () => {
+  it('reads flow: sequential from the bruno extension', () => {
+    const yml = `opencollection: "1.0.0"
+info:
+  name: c
+extensions:
+  bruno:
+    scripts:
+      flow: sequential
+`;
+    const { brunoConfig } = parseCollection(yml);
+    expect(brunoConfig.scripts?.flow).toBe('sequential');
+  });
+
+  it('reads flow: sandwich from the bruno extension', () => {
+    const yml = `opencollection: "1.0.0"
+info:
+  name: c
+extensions:
+  bruno:
+    scripts:
+      flow: sandwich
+`;
+    const { brunoConfig } = parseCollection(yml);
+    expect(brunoConfig.scripts?.flow).toBe('sandwich');
+  });
+
+  it('ignores an unrecognized flow value', () => {
+    const yml = `opencollection: "1.0.0"
+info:
+  name: c
+extensions:
+  bruno:
+    scripts:
+      flow: parallel
+`;
+    const { brunoConfig } = parseCollection(yml);
+    expect(brunoConfig.scripts?.flow).toBeUndefined();
+  });
+
+  it('has no scripts.flow when the file does not set one', () => {
+    const { brunoConfig } = parseCollection('opencollection: "1.0.0"\ninfo:\n  name: c\n');
+    expect(brunoConfig.scripts?.flow).toBeUndefined();
+  });
+});
+
+describe('parseCollection — client certificates', () => {
+  it('maps pem and pkcs12 certs to Bruno cert/pfx shapes', () => {
+    const yml = `opencollection: "1.0.0"
+info:
+  name: c
+config:
+  clientCertificates:
+    - domain: localhost
+      type: pem
+      certificateFilePath: ./certs/client-cert.pem
+      privateKeyFilePath: ./certs/client-key.pem
+      passphrase: secret
+    - domain: example.com
+      type: pkcs12
+      pkcs12FilePath: ./certs/client.pfx
+`;
+    const { brunoConfig } = parseCollection(yml);
+
+    expect(brunoConfig.clientCertificates.certs).toEqual([
+      {
+        domain: 'localhost',
+        type: 'cert',
+        certFilePath: './certs/client-cert.pem',
+        keyFilePath: './certs/client-key.pem',
+        passphrase: 'secret'
+      },
+      {
+        domain: 'example.com',
+        type: 'pfx',
+        pfxFilePath: './certs/client.pfx',
+        passphrase: ''
+      }
+    ]);
+  });
+
+  it('drops certs with an unrecognized type', () => {
+    const yml = `opencollection: "1.0.0"
+info:
+  name: c
+config:
+  clientCertificates:
+    - domain: localhost
+      type: bogus
+      certificateFilePath: ./certs/client-cert.pem
+`;
+    const { brunoConfig } = parseCollection(yml);
+
+    expect(brunoConfig.clientCertificates.certs).toEqual([]);
+  });
+
+  it('reads a per-cert disabled flag when set to true, otherwise leaves it off', () => {
+    const yml = `opencollection: "1.0.0"
+info:
+  name: c
+config:
+  clientCertificates:
+    - domain: localhost
+      type: pem
+      certificateFilePath: ./certs/client-cert.pem
+      privateKeyFilePath: ./certs/client-key.pem
+      disabled: true
+    - domain: example.com
+      type: pkcs12
+      pkcs12FilePath: ./certs/client.pfx
+      disabled: true
+    - domain: other.com
+      type: pkcs12
+      pkcs12FilePath: ./certs/other.pfx
+`;
+    const { brunoConfig } = parseCollection(yml);
+
+    expect(brunoConfig.clientCertificates.certs[0].disabled).toBe(true);
+    expect(brunoConfig.clientCertificates.certs[1].disabled).toBe(true);
+    expect(brunoConfig.clientCertificates.certs[2]).not.toHaveProperty('disabled');
+  });
+});
+
 describe('parseCollection — reading the collection version', () => {
   it('reads the version from the file as text', () => {
     const { brunoConfig } = parseCollection('opencollection: "1.0.0"\ninfo:\n  name: c\n  version: v1.0.0\n');

package/src/formats/yml/parseCollection.ts

@@ -38,11 +38,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,6 +62,14 @@ const parseCollection = (ymlString: string): ParsedCollection => {
         };
       }
     }
+    // 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
+      };
+    }
     if (Array.isArray(brunoExtensions?.openapi) && brunoExtensions.openapi.length > 0) {
       brunoConfig.openapi = brunoExtensions.openapi.map((entry: any) => ({
         sourceUrl: entry.sourceUrl,
@@ -142,14 +153,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/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');
+  });
+});