@usebruno/filestore 0.11.0 → 0.12.0

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/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

@@ -61,7 +61,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 +149,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 +158,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 {
@@ -241,6 +244,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,22 +252,31 @@ 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

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

@@ -40,9 +40,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

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;