@usebruno/filestore 0.11.0 → 0.13.0

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

@@ -48,6 +48,152 @@ describe('stringifyCollection — typed request.variables', () => {
   });
 });
 
+describe('stringifyCollection — script execution flow', () => {
+  const baseRoot = {
+    meta: null,
+    request: { headers: [], auth: { mode: 'none' }, script: { req: null, res: null }, tests: null, vars: { req: [], res: [] } },
+    docs: null
+  } as any;
+
+  it('round-trips flow: sequential through the bruno extension', () => {
+    const yml = stringifyCollection(baseRoot, { name: 'c', scripts: { flow: 'sequential' } });
+    expect(yml).toMatch(/flow:\s*sequential/);
+    expect(parseCollection(yml).brunoConfig.scripts?.flow).toBe('sequential');
+  });
+
+  it('round-trips flow: sandwich through the bruno extension', () => {
+    const yml = stringifyCollection(baseRoot, { name: 'c', scripts: { flow: 'sandwich' } });
+    expect(parseCollection(yml).brunoConfig.scripts?.flow).toBe('sandwich');
+  });
+
+  it('writes no flow when the collection has none', () => {
+    const yml = stringifyCollection(baseRoot, { name: 'c' });
+    expect(yml).not.toMatch(/flow:/);
+    expect(parseCollection(yml).brunoConfig.scripts?.flow).toBeUndefined();
+  });
+
+  it('drops an unrecognized flow value on write', () => {
+    const yml = stringifyCollection(baseRoot, { name: 'c', scripts: { flow: 'parallel' } });
+    expect(yml).not.toMatch(/flow:/);
+  });
+
+  it('preserves additionalContextRoots alongside a written flow value', () => {
+    const yml = stringifyCollection(baseRoot, {
+      name: 'c',
+      scripts: { flow: 'sequential', additionalContextRoots: ['../libs'] }
+    });
+    const { brunoConfig } = parseCollection(yml);
+    expect(brunoConfig.scripts?.flow).toBe('sequential');
+    expect(brunoConfig.scripts?.additionalContextRoots).toEqual(['../libs']);
+  });
+});
+
+describe('stringifyCollection — client certificates', () => {
+  const baseRoot = {
+    meta: null,
+    request: { headers: [], auth: { mode: 'none' }, script: { req: null, res: null }, tests: null, vars: { req: [], res: [] } },
+    docs: null
+  } as any;
+
+  it('round-trips cert/pfx certificates', () => {
+    const brunoConfig = {
+      name: 'c',
+      clientCertificates: {
+        certs: [
+          {
+            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: ''
+          }
+        ]
+      }
+    };
+
+    const yml = stringifyCollection(baseRoot, brunoConfig);
+    const { brunoConfig: reparsed } = parseCollection(yml);
+
+    expect(reparsed.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('writes disabled: true for disabled certs and round-trips it', () => {
+    const brunoConfig = {
+      name: 'c',
+      clientCertificates: {
+        certs: [
+          {
+            domain: 'localhost',
+            type: 'cert',
+            certFilePath: './certs/client-cert.pem',
+            keyFilePath: './certs/client-key.pem',
+            passphrase: 'secret',
+            disabled: true
+          },
+          {
+            domain: 'example.com',
+            type: 'pfx',
+            pfxFilePath: './certs/client.pfx',
+            passphrase: '',
+            disabled: true
+          }
+        ]
+      }
+    };
+
+    const yml = stringifyCollection(baseRoot, brunoConfig);
+
+    expect(yml).toMatch(/disabled:\s*true/);
+
+    const { brunoConfig: reparsed } = parseCollection(yml);
+    expect(reparsed.clientCertificates.certs[0].disabled).toBe(true);
+    expect(reparsed.clientCertificates.certs[1].disabled).toBe(true);
+  });
+
+  it('does not write disabled for enabled certs', () => {
+    const brunoConfig = {
+      name: 'c',
+      clientCertificates: {
+        certs: [
+          {
+            domain: 'example.com',
+            type: 'pfx',
+            pfxFilePath: './certs/client.pfx',
+            passphrase: ''
+          }
+        ]
+      }
+    };
+
+    const yml = stringifyCollection(baseRoot, brunoConfig);
+
+    expect(yml).not.toMatch(/disabled:/);
+
+    const { brunoConfig: reparsed } = parseCollection(yml);
+    expect(reparsed.clientCertificates.certs[0]).not.toHaveProperty('disabled');
+  });
+});
+
 describe('stringifyCollection — writing the collection version', () => {
   const baseRoot = {
     meta: null,

package/src/formats/yml/stringifyCollection.ts

@@ -5,6 +5,7 @@ import type { ClientCertificate, PemCertificate, Pkcs12Certificate } from '@open
 import type { Variable } from '@opencollection/types/common/variables';
 import type { Action } from '@opencollection/types/common/actions';
 import type { Scripts } from '@opencollection/types/common/scripts';
+import { normalizeOpenApiSyncConfigs } from '@usebruno/common';
 import { stringifyYml } from './utils';
 import { toOpenCollectionAuth } from './common/auth';
 import { toOpenCollectionHttpHeaders } from './common/headers';
@@ -12,6 +13,7 @@ import { toOpenCollectionVariables } from './common/variables';
 import { toOpenCollectionActions } from './common/actions';
 import { toOpenCollectionScripts } from './common/scripts';
 import type { Auth } from '@opencollection/types/common/auth';
+import { HTTP_SCRIPT_KEYS } from '@usebruno/common';
 
 const hasCollectionConfig = (brunoConfig: any): boolean => {
   // protobuf
@@ -61,7 +63,8 @@ const hasRequestScripts = (collectionRoot: any): boolean => {
 
 const hasPresets = (brunoConfig: any): boolean => {
   return brunoConfig?.presets?.requestType?.length
-    || brunoConfig?.presets?.requestUrl?.length;
+    || brunoConfig?.presets?.requestUrl?.length
+    || brunoConfig?.presets?.defaultEnvironment?.length;
 };
 
 const stringifyCollection = (collectionRoot: any, brunoConfig: any): string => {
@@ -148,7 +151,8 @@ const stringifyCollection = (collectionRoot: any, brunoConfig: any): string => {
                 type: 'pem',
                 certificateFilePath: cert.certFilePath,
                 privateKeyFilePath: cert.keyFilePath,
-                ...(cert.passphrase && { passphrase: cert.passphrase })
+                ...(cert.passphrase && { passphrase: cert.passphrase }),
+                ...(cert.disabled === true && { disabled: true })
               };
               return pemCert;
             } else if (cert.type === 'pfx') {
@@ -156,7 +160,8 @@ const stringifyCollection = (collectionRoot: any, brunoConfig: any): string => {
                 domain: cert.domain,
                 type: 'pkcs12',
                 pkcs12FilePath: cert.pfxFilePath,
-                ...(cert.passphrase && { passphrase: cert.passphrase })
+                ...(cert.passphrase && { passphrase: cert.passphrase }),
+                ...(cert.disabled === true && { disabled: true })
               };
               return pkcs12Cert;
             } else {
@@ -206,7 +211,8 @@ const stringifyCollection = (collectionRoot: any, brunoConfig: any): string => {
 
       // scripts
       if (hasRequestScripts(collectionRoot)) {
-        const ocScripts: Scripts | undefined = toOpenCollectionScripts(collectionRoot.request);
+        // TODO: Widen scope to include GRPC scripts once Collection/Folder level inheritance is added to gRPC.
+        const ocScripts: Scripts | undefined = toOpenCollectionScripts(collectionRoot.request, HTTP_SCRIPT_KEYS);
         if (ocScripts) {
           oc.request.scripts = ocScripts;
         }
@@ -241,6 +247,7 @@ const stringifyCollection = (collectionRoot: any, brunoConfig: any): string => {
       }
 
       if (hasPresets(brunoConfig)) {
+        const presetsExtension: any = {};
         const presetsRequest: any = {};
         if (brunoConfig.presets.requestType?.length) {
           presetsRequest.type = brunoConfig.presets.requestType;
@@ -248,37 +255,40 @@ const stringifyCollection = (collectionRoot: any, brunoConfig: any): string => {
         if (brunoConfig.presets.requestUrl?.length) {
           presetsRequest.url = brunoConfig.presets.requestUrl;
         }
-        brunoExtension.presets = {
-          request: presetsRequest
-        };
+        if (Object.keys(presetsRequest).length) {
+          presetsExtension.request = presetsRequest;
+        }
+        if (brunoConfig.presets.defaultEnvironment?.length) {
+          presetsExtension.defaultEnvironment = brunoConfig.presets.defaultEnvironment;
+        }
+        brunoExtension.presets = presetsExtension;
       }
 
       oc.extensions.bruno = brunoExtension;
     }
 
     // bruno-specific script extensions
+    const brunoScripts: Record<string, unknown> = {};
     if (brunoConfig.scripts?.additionalContextRoots?.length) {
+      brunoScripts.additionalContextRoots = brunoConfig.scripts.additionalContextRoots;
+    }
+    if (brunoConfig.scripts?.flow === 'sandwich' || brunoConfig.scripts?.flow === 'sequential') {
+      brunoScripts.flow = brunoConfig.scripts.flow;
+    }
+    if (Object.keys(brunoScripts).length > 0) {
       if (!oc.extensions.bruno) {
         oc.extensions.bruno = {};
       }
-      (oc.extensions.bruno as any).scripts = {
-        additionalContextRoots: brunoConfig.scripts.additionalContextRoots
-      };
+      (oc.extensions.bruno as any).scripts = brunoScripts;
     }
 
     // bruno-specific extensions
-    if (Array.isArray(brunoConfig.openapi) && brunoConfig.openapi.length > 0) {
+    const openApiEntries = normalizeOpenApiSyncConfigs(brunoConfig.openapi);
+    if (openApiEntries.length > 0) {
       if (!oc.extensions.bruno) {
         oc.extensions.bruno = {};
       }
-      (oc.extensions.bruno as any).openapi = brunoConfig.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
-      }));
+      (oc.extensions.bruno as any).openapi = openApiEntries;
     }
 
     return stringifyYml(oc);

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

@@ -88,4 +88,62 @@ describe('stringifyEnvironment', () => {
     const reparsed = parseEnvironment(stringifyEnvironment(env));
     expect(reparsed.color).toBe('#ff0000');
   });
+
+  describe('extends', () => {
+    it('round-trips the parent environment name', () => {
+      const env = {
+        uid: 'env-uid',
+        name: 'prod',
+        extends: 'base',
+        variables: [{ uid: 'u1', name: 'host', value: 'prod.example.com', type: 'text', enabled: true, secret: false }]
+      } as any;
+
+      const reparsed = parseEnvironment(stringifyEnvironment(env));
+
+      expect(reparsed.extends).toBe('base');
+      expect(reparsed.variables[0]).toMatchObject({ name: 'host', value: 'prod.example.com' });
+    });
+
+    it('omits extends when no parent is set', () => {
+      const env = { uid: 'env-uid', name: 'prod', variables: [] } as any;
+
+      expect(stringifyEnvironment(env)).not.toContain('extends');
+    });
+
+    it('omits extends when the parent names nothing', () => {
+      const env = { uid: 'env-uid', name: 'prod', extends: '  ', variables: [] } as any;
+
+      expect(stringifyEnvironment(env)).not.toContain('extends');
+    });
+
+    it('round-trips a list of parents', () => {
+      const env = { uid: 'env-uid', name: 'prod', extends: ['base', 'shared'], variables: [] } as any;
+
+      const reparsed = parseEnvironment(stringifyEnvironment(env));
+
+      expect(reparsed.extends).toEqual(['base', 'shared']);
+    });
+
+    it('omits extends when the list of parents is empty', () => {
+      const env = { uid: 'env-uid', name: 'prod', extends: [], variables: [] } as any;
+
+      expect(stringifyEnvironment(env)).not.toContain('extends');
+    });
+
+    it('never writes the inheritedFrom provenance of a resolved variable', () => {
+      const env = {
+        uid: 'env-uid',
+        name: 'prod',
+        extends: 'base',
+        variables: [
+          { uid: 'u1', name: 'host', value: 'base.example.com', type: 'text', enabled: true, secret: false, inheritedFrom: 'base' }
+        ]
+      } as any;
+
+      const yml = stringifyEnvironment(env);
+
+      expect(yml).not.toContain('inheritedFrom');
+      expect(parseEnvironment(yml).variables[0]).not.toHaveProperty('inheritedFrom');
+    });
+  });
 });

package/src/formats/yml/stringifyEnvironment.ts

@@ -10,6 +10,7 @@ import { stringifyYml } from './utils';
 import { ensureString } from '../../utils';
 import { SECRET_PROVIDER_IDENTIFIER_FIELDS } from '../../constants';
 import { hasTypedMetadata, toOpenCollectionTypedValue, serializeVariableValue } from './common/datatype';
+import { validatedEnvironmentExtendsFrom } from '@usebruno/common/utils';
 
 export const toOpenCollectionEnvironmentVariables = (variables: (BrunoEnvironmentVariable | BrunoSecretEnvironmentVariable)[]): (Variable | SecretVariable)[] | undefined => {
   if (!variables?.length) {
@@ -90,6 +91,11 @@ const stringifyEnvironment = (environment: BrunoEnvironment): string => {
       name: environment.name
     };
 
+    const environmentExtendsFrom = validatedEnvironmentExtendsFrom(environment.extends);
+    if (environmentExtendsFrom) {
+      (ocEnvironment as any).extends = environmentExtendsFrom;
+    }
+
     if (environment.color) {
       ocEnvironment.color = environment.color;
     }

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

@@ -45,3 +45,26 @@ describe('stringifyFolder — typed request.variables', () => {
     expect(reqVars[4].dataType).toBeUndefined();
   });
 });
+
+describe('stringifyFolder — seq', () => {
+  it('omits seq when the folder has none', () => {
+    const folderRoot = { meta: { name: 'no-seq-folder' }, docs: null } as any;
+
+    const yml = stringifyFolder(folderRoot);
+    const { meta } = parseFolder(yml);
+
+    expect(yml).not.toMatch(/seq:/);
+    expect(meta).toEqual(expect.objectContaining({ name: 'no-seq-folder' }));
+    expect(meta!.seq).toBeUndefined();
+  });
+
+  it('preserves an explicit numeric seq', () => {
+    const folderRoot = { meta: { name: 'ordered-folder', seq: 3 }, docs: null } as any;
+
+    const yml = stringifyFolder(folderRoot);
+    const { meta } = parseFolder(yml);
+
+    expect(meta).toEqual(expect.objectContaining({ name: 'ordered-folder' }));
+    expect(meta!.seq).toBe(3);
+  });
+});

package/src/formats/yml/stringifyFolder.ts

@@ -12,6 +12,7 @@ import { toOpenCollectionVariables } from './common/variables';
 import { toOpenCollectionActions } from './common/actions';
 import { toOpenCollectionScripts } from './common/scripts';
 import { stringifyYml } from './utils';
+import { HTTP_SCRIPT_KEYS } from '@usebruno/common';
 
 const hasRequestDefaults = (folderRoot: FolderRoot): boolean => {
   const requestDefaults = folderRoot?.request;
@@ -40,9 +41,14 @@ const stringifyFolder = (folderRoot: FolderRoot): string => {
     // info block
     const info: FolderInfo = {
       name: folderRoot.meta?.name || 'Untitled Folder',
-      type: 'folder',
-      seq: folderRoot.meta?.seq || 1
+      type: 'folder'
     };
+    // Only write seq when the folder actually has a numeric one. Defaulting to 1 would
+    // force every seq-less folder into position 1 on disk and break alphabetical fallback.
+    const seq = folderRoot.meta?.seq;
+    if (typeof seq === 'number' && Number.isFinite(seq)) {
+      info.seq = seq;
+    }
     ocFolder.info = info;
 
     // request defaults
@@ -83,7 +89,8 @@ const stringifyFolder = (folderRoot: FolderRoot): string => {
 
       // scripts
       if (hasRequestScripts(folderRoot)) {
-        const ocScripts: Scripts | undefined = toOpenCollectionScripts(folderRoot?.request);
+        // TODO: Widen scope to include GRPC scripts once Collection/Folder level inheritance is added to GRPC.
+        const ocScripts: Scripts | undefined = toOpenCollectionScripts(folderRoot?.request, HTTP_SCRIPT_KEYS);
         if (ocScripts) {
           ocFolder.request.scripts = ocScripts;
         }

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