@usebruno/filestore 0.10.0 → 0.12.0

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

@@ -0,0 +1,70 @@
+import parseFolder from './parseFolder';
+
+// Typed `request.variables` propagate through parseFolder into the folder's
+// vars.req with their dataType + coerced value.
+
+describe('parseFolder — typed request.variables', () => {
+  it('coerces typed values, preserves raw value on un-coercible input, and treats explicit string as the implicit default', () => {
+    const yml = `info:
+  name: my-folder
+
+request:
+  variables:
+    - name: count
+      value:
+        type: number
+        data: "42"
+    - name: enabled
+      value:
+        type: boolean
+        data: "true"
+    - name: config
+      value:
+        type: object
+        data: '{"a":1}'
+    - name: greeting
+      value:
+        type: string
+        data: hi
+    - name: plain
+      value: hello
+    - name: flag
+      value:
+        type: boolean
+        data: 'maybe'
+`;
+
+    const folder = parseFolder(yml);
+    const reqVars = folder.request!.vars!.req!;
+
+    expect(reqVars).toHaveLength(6);
+    expect(reqVars[0]).toMatchObject({ name: 'count', value: 42, dataType: 'number' });
+    expect(reqVars[1]).toMatchObject({ name: 'enabled', value: true, dataType: 'boolean' });
+    expect(reqVars[2]).toMatchObject({ name: 'config', value: { a: 1 }, dataType: 'object' });
+    // Explicit `type: string` is the implicit default — no dataType materialized.
+    expect(reqVars[3]).toMatchObject({ name: 'greeting', value: 'hi' });
+    expect(reqVars[3].dataType).toBeUndefined();
+    expect(reqVars[4]).toMatchObject({ name: 'plain', value: 'hello' });
+    expect(reqVars[4].dataType).toBeUndefined();
+    // Un-coercible: raw value preserved for the UI mismatch warning.
+    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,21 +13,19 @@ 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: null,
-      docs: null
-    };
-
-    // request defaults
-    if (ocFolder.request) {
-      folderRoot.request = {
+      request: {
         headers: [],
-        auth: null,
+        auth: toBrunoAuth(ocFolder.request?.auth),
         script: {
           req: null,
           res: null
@@ -37,40 +35,39 @@ const parseFolder = (ymlString: string): FolderRoot => {
           res: []
         },
         tests: null
-      };
+      },
+      docs: null
+    };
+
+    if (ocFolder.request) {
+      const folderRequest = folderRoot.request!;
 
       // headers
       const headers = toBrunoHttpHeaders(ocFolder.request.headers);
       if (headers) {
-        folderRoot.request.headers = headers;
-      }
-
-      // auth
-      const auth = toBrunoAuth(ocFolder.request.auth);
-      if (auth) {
-        folderRoot.request.auth = auth;
+        folderRequest.headers = headers;
       }
 
       // variables
       const variables = toBrunoVariables(ocFolder.request.variables);
       const postResponseVars = toBrunoPostResponseVariables((ocFolder.request as any).actions);
-      folderRoot.request.vars = {
+      folderRequest.vars = {
         req: variables.req,
         res: postResponseVars
       };
 
       // scripts
       const scripts = toBrunoScripts(ocFolder.request.scripts);
-      if (scripts?.script && folderRoot.request.script) {
+      if (scripts?.script && folderRequest.script) {
         if (scripts.script.req) {
-          folderRoot.request.script.req = scripts.script.req;
+          folderRequest.script.req = scripts.script.req;
         }
         if (scripts.script.res) {
-          folderRoot.request.script.res = scripts.script.res;
+          folderRequest.script.res = scripts.script.res;
         }
       }
       if (scripts?.tests) {
-        folderRoot.request.tests = scripts.tests;
+        folderRequest.tests = scripts.tests;
       }
     }
 

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

@@ -0,0 +1,147 @@
+import parseItem from './parseItem';
+
+// Typed `runtime.variables` propagate through parseItem with their dataType
+// + coerced value. Helper-level coverage lives in the variables/datatype specs.
+
+describe('parseItem — typed runtime.variables', () => {
+  it('coerces typed values, preserves raw value on un-coercible input, and treats explicit string as the implicit default', () => {
+    const yml = `info:
+  name: r
+  type: http
+
+http:
+  url: https://example.com
+  method: GET
+
+runtime:
+  variables:
+    - name: count
+      value:
+        type: number
+        data: "42"
+    - name: enabled
+      value:
+        type: boolean
+        data: "true"
+    - name: config
+      value:
+        type: object
+        data: '{"a":1}'
+    - name: greeting
+      value:
+        type: string
+        data: hi
+    - name: plain
+      value: hello
+    - name: bad
+      value:
+        type: number
+        data: 'not-a-number'
+`;
+
+    const item = parseItem(yml);
+    const reqVars = item.request!.vars!.req!;
+
+    expect(reqVars).toHaveLength(6);
+    expect(reqVars[0]).toMatchObject({ name: 'count', value: 42, dataType: 'number' });
+    expect(reqVars[1]).toMatchObject({ name: 'enabled', value: true, dataType: 'boolean' });
+    expect(reqVars[2]).toMatchObject({ name: 'config', value: { a: 1 }, dataType: 'object' });
+    // Explicit `type: string` is the implicit default — no dataType materialized.
+    expect(reqVars[3]).toMatchObject({ name: 'greeting', value: 'hi' });
+    expect(reqVars[3].dataType).toBeUndefined();
+    expect(reqVars[4]).toMatchObject({ name: 'plain', value: 'hello' });
+    expect(reqVars[4].dataType).toBeUndefined();
+    // Un-coercible: raw value preserved for the UI mismatch warning.
+    expect(reqVars[5]).toMatchObject({ name: 'bad', value: 'not-a-number', dataType: 'number' });
+  });
+
+  it('normalizes raw YAML scalars in `data` to a string before coercing', () => {
+    // YAML parses unquoted scalars per their natural JS type. The `String(... ?? '')`
+    // cast in fromOpenCollectionTypedValue keeps coercion consistent.
+    const yml = `info:
+  name: r
+  type: http
+
+http:
+  url: https://example.com
+  method: GET
+
+runtime:
+  variables:
+    - name: stringy
+      value:
+        type: string
+        data: 42
+    - name: numeric
+      value:
+        type: number
+        data: 42
+    - name: nullish
+      value:
+        type: number
+        data: null
+`;
+
+    const item = parseItem(yml);
+    const reqVars = item.request!.vars!.req!;
+
+    // type=string: raw YAML number → string; no dataType field.
+    expect(reqVars[0]).toMatchObject({ name: 'stringy', value: '42' });
+    expect(reqVars[0].dataType).toBeUndefined();
+    // type=number: '42' → 42.
+    expect(reqVars[1]).toMatchObject({ name: 'numeric', value: 42, dataType: 'number' });
+    // data: null → '' (the `?? ''` arm); coerce bails on empty → raw ''.
+    expect(reqVars[2]).toMatchObject({ name: 'nullish', value: '', dataType: 'number' });
+  });
+
+  it('propagates typed variables for graphql/grpc/websocket requests too', () => {
+    const graphqlYml = `info:
+  name: g
+  type: graphql
+
+graphql:
+  url: https://example.com/graphql
+  method: POST
+
+runtime:
+  variables:
+    - name: count
+      value: { type: number, data: '7' }
+`;
+    expect(parseItem(graphqlYml).request!.vars!.req![0]).toMatchObject({
+      name: 'count', value: 7, dataType: 'number'
+    });
+
+    const grpcYml = `info:
+  name: gr
+  type: grpc
+
+grpc:
+  url: localhost:50051
+
+runtime:
+  variables:
+    - name: flag
+      value: { type: boolean, data: 'false' }
+`;
+    expect(parseItem(grpcYml).request!.vars!.req![0]).toMatchObject({
+      name: 'flag', value: false, dataType: 'boolean'
+    });
+
+    const wsYml = `info:
+  name: ws
+  type: websocket
+
+websocket:
+  url: wss://example.com/socket
+
+runtime:
+  variables:
+    - name: payload
+      value: { type: object, data: '{"k":1}' }
+`;
+    expect(parseItem(wsYml).request!.vars!.req![0]).toMatchObject({
+      name: 'payload', value: { k: 1 }, dataType: 'object'
+    });
+  });
+});

package/src/formats/yml/parseItem.ts

@@ -10,6 +10,7 @@ import parseGraphQLRequest from './items/parseGraphQLRequest';
 import parseGrpcRequest from './items/parseGrpcRequest';
 import parseWebsocketRequest from './items/parseWebsocketRequest';
 import parseScript from './items/parseScript';
+import parseApp, { type AppFile } from './items/parseApp';
 
 // Helper to get the type from an item (now in info block)
 const getItemType = (item: Item): string | undefined => {
@@ -87,6 +88,9 @@ const parseItem = (ymlString: string): BrunoItem => {
       case 'script':
         return parseScript(ocItem as ScriptFile);
 
+      case 'app':
+        return parseApp(ocItem as unknown as AppFile);
+
       case 'folder':
         throw new Error('Folder items should be handled separately using parseFolder');
 

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;