@usebruno/filestore 0.10.0 → 0.12.0

package/src/formats/yml/common/variables.spec.ts

@@ -0,0 +1,127 @@
+import { toOpenCollectionVariables, toBrunoVariables } from './variables';
+
+describe('toOpenCollectionVariables', () => {
+  it('returns undefined for null / empty input', () => {
+    expect(toOpenCollectionVariables(null)).toBeUndefined();
+    expect(toOpenCollectionVariables(undefined)).toBeUndefined();
+    expect(toOpenCollectionVariables([])).toBeUndefined();
+    expect(toOpenCollectionVariables({ req: [], res: [] })).toBeUndefined();
+  });
+
+  it('serializes plain string variables as a raw string value', () => {
+    const out = toOpenCollectionVariables([
+      { uid: 'u1', name: 'apiKey', value: 'abc', enabled: true } as any
+    ]);
+
+    expect(out).toEqual([{ name: 'apiKey', value: 'abc' }]);
+  });
+
+  it('serializes typed variables as a {type, data} struct', () => {
+    const out = toOpenCollectionVariables([
+      { uid: 'u1', name: 'port', value: 3000, enabled: true, dataType: 'number' } as any,
+      { uid: 'u2', name: 'flag', value: true, enabled: true, dataType: 'boolean' } as any,
+      { uid: 'u3', name: 'config', value: { a: 1 }, enabled: true, dataType: 'object' } as any
+    ]);
+
+    expect(out).toEqual([
+      { name: 'port', value: { type: 'number', data: '3000' } },
+      { name: 'flag', value: { type: 'boolean', data: 'true' } },
+      { name: 'config', value: { type: 'object', data: '{\n  "a": 1\n}' } }
+    ]);
+  });
+
+  it('does not emit a typed struct for the string default dataType', () => {
+    const out = toOpenCollectionVariables([
+      { uid: 'u1', name: 'apiKey', value: 'abc', enabled: true, dataType: 'string' } as any
+    ]);
+
+    expect(out).toEqual([{ name: 'apiKey', value: 'abc' }]);
+  });
+
+  it('marks disabled variables and preserves description', () => {
+    const out = toOpenCollectionVariables([
+      { uid: 'u1', name: 'apiKey', value: 'abc', enabled: false, description: 'auth key' } as any
+    ]);
+
+    expect(out).toEqual([
+      { name: 'apiKey', value: 'abc', description: 'auth key', disabled: true }
+    ]);
+  });
+
+  it('accepts the folder { req, res } shape and only emits req vars', () => {
+    const out = toOpenCollectionVariables({
+      req: [{ uid: 'u1', name: 'a', value: '1', enabled: true } as any],
+      res: [{ uid: 'u2', name: 'b', value: '2', enabled: true } as any]
+    });
+
+    expect(out).toEqual([{ name: 'a', value: '1' }]);
+  });
+});
+
+describe('toBrunoVariables', () => {
+  it('returns empty req/res for null / empty input', () => {
+    expect(toBrunoVariables(null)).toEqual({ req: [], res: [] });
+    expect(toBrunoVariables(undefined)).toEqual({ req: [], res: [] });
+    expect(toBrunoVariables([])).toEqual({ req: [], res: [] });
+  });
+
+  it('parses plain string variables into Bruno req vars', () => {
+    const { req } = toBrunoVariables([
+      { name: 'apiKey', value: 'abc' } as any
+    ]);
+
+    expect(req).toHaveLength(1);
+    const v = req![0];
+    expect(v).toMatchObject({
+      name: 'apiKey',
+      value: 'abc',
+      enabled: true,
+      local: false
+    });
+    expect(v.uid).toEqual(expect.any(String));
+    expect(v.dataType).toBeUndefined();
+  });
+
+  it('parses typed-value variables into typed Bruno variables', () => {
+    const { req } = toBrunoVariables([
+      { name: 'port', value: { type: 'number', data: '3000' } } as any,
+      { name: 'flag', value: { type: 'boolean', data: 'true' } } as any,
+      { name: 'config', value: { type: 'object', data: '{"a":1}' } } as any
+    ]);
+
+    expect(req![0]).toMatchObject({ name: 'port', value: 3000, dataType: 'number' });
+    expect(req![1]).toMatchObject({ name: 'flag', value: true, dataType: 'boolean' });
+    expect(req![2]).toMatchObject({ name: 'config', value: { a: 1 }, dataType: 'object' });
+  });
+
+  it('falls back to the raw string when typed data fails to coerce', () => {
+    const { req } = toBrunoVariables([
+      { name: 'port', value: { type: 'number', data: 'not-a-number' } } as any,
+      { name: 'flag', value: { type: 'boolean', data: 'not-a-boolean' } } as any,
+      { name: 'config', value: { type: 'object', data: 'not-a-object' } } as any
+    ]);
+
+    expect(req![0]).toMatchObject({ name: 'port', value: 'not-a-number', dataType: 'number' });
+    expect(typeof req![0].value).toBe('string');
+    expect(req![1]).toMatchObject({ name: 'flag', value: 'not-a-boolean', dataType: 'boolean' });
+    expect(typeof req![1].value).toBe('string');
+    expect(req![2]).toMatchObject({ name: 'config', value: 'not-a-object', dataType: 'object' });
+    expect(typeof req![2].value).toBe('string');
+  });
+
+  it('respects the disabled flag', () => {
+    const { req } = toBrunoVariables([
+      { name: 'a', value: '1', disabled: true } as any
+    ]);
+
+    expect(req![0].enabled).toBe(false);
+  });
+
+  it('extracts description.content when description is a structured object', () => {
+    const { req } = toBrunoVariables([
+      { name: 'a', value: '1', description: { content: 'note' } } as any
+    ]);
+
+    expect(req![0].description).toBe('note');
+  });
+});

package/src/formats/yml/common/variables.ts

@@ -2,16 +2,13 @@ import { Variable, VariableTypedValue } from '@opencollection/types/common/varia
 import { FolderRequest as BrunoFolderRequest } from '@usebruno/schema-types/collection/folder';
 import { Variable as BrunoVariable, Variables as BrunoVariables } from '@usebruno/schema-types/common/variables';
 import { uuid, ensureString } from '../../../utils';
-
-export const isTypedValue = (value: unknown): value is VariableTypedValue => {
-  return (
-    typeof value === 'object'
-    && value !== null
-    && !Array.isArray(value)
-    && 'type' in value
-    && 'data' in value
-  );
-};
+import {
+  isTypedValue,
+  hasTypedMetadata,
+  toOpenCollectionTypedValue,
+  fromOpenCollectionTypedValue,
+  serializeVariableValue
+} from './datatype';
 
 /**
  * Convert Bruno pre-request variables to OpenCollection variables format.
@@ -29,12 +26,10 @@ export const toOpenCollectionVariables = (variables: BrunoFolderRequest['vars']
   }
 
   const ocVariables: Variable[] = reqVarsArray.map((v: BrunoVariable): Variable => {
+    const valueStr = serializeVariableValue(v.value);
     const variable: Variable = {
       name: v.name || '',
-      value:
-        v.datatype && v.datatype !== 'string'
-          ? { type: v.datatype, data: ensureString(v.value) }
-          : v.value || ''
+      value: hasTypedMetadata(v) ? toOpenCollectionTypedValue(v, valueStr) : valueStr
     };
 
     if (v?.description?.trim().length) {
@@ -62,7 +57,7 @@ export const toBrunoVariables = (variables: Variable[] | null | undefined): { re
   const reqVars: BrunoVariables = [];
 
   variables.forEach((v: Variable) => {
-    const variable: BrunoVariable = {
+    const base: BrunoVariable = {
       uid: uuid(),
       name: ensureString(v.name),
       value: '',
@@ -71,19 +66,16 @@ export const toBrunoVariables = (variables: Variable[] | null | undefined): { re
     };
 
     if (isTypedValue(v.value)) {
-      variable.value = ensureString(v.value.data);
-      if (v.value.type !== 'string' && v.value.type !== 'null') {
-        variable.datatype = v.value.type;
-      }
+      Object.assign(base, fromOpenCollectionTypedValue(v.value));
     } else {
-      variable.value = ensureString(v.value);
+      base.value = ensureString(v.value);
     }
 
     if (v.description) {
-      variable.description = typeof v.description === 'string' ? v.description : (v.description as any)?.content || '';
+      base.description = typeof v.description === 'string' ? v.description : (v.description as any)?.content || '';
     }
 
-    reqVars.push(variable);
+    reqVars.push(base);
   });
 
   return { req: reqVars, res: [] };

package/src/formats/yml/index.ts

@@ -2,19 +2,23 @@ import parseYmlItem from './parseItem';
 import parseYmlFolder from './parseFolder';
 import parseYmlCollection from './parseCollection';
 import parseYmlEnvironment from './parseEnvironment';
+import parseYmlMockServer from './parseMockServer';
 
 import stringifyYmlItem from './stringifyItem';
 import stringifyYmlFolder from './stringifyFolder';
 import stringifyYmlCollection from './stringifyCollection';
 import stringifyYmlEnvironment from './stringifyEnvironment';
+import stringifyYmlMockServer from './stringifyMockServer';
 
 export {
   parseYmlItem,
   parseYmlFolder,
   parseYmlCollection,
   parseYmlEnvironment,
+  parseYmlMockServer,
   stringifyYmlItem,
   stringifyYmlFolder,
   stringifyYmlCollection,
-  stringifyYmlEnvironment
+  stringifyYmlEnvironment,
+  stringifyYmlMockServer
 };

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

@@ -0,0 +1,37 @@
+import type { Item as BrunoItem } from '@usebruno/schema-types/collection/item';
+import { uuid } from '../../../utils';
+
+export interface AppFile {
+  info: {
+    name?: string;
+    type: 'app';
+    seq?: number;
+    tags?: string[];
+  };
+  code?: string;
+}
+
+const parseApp = (ocApp: AppFile): BrunoItem => {
+  const info = ocApp.info || ({} as AppFile['info']);
+
+  const brunoItem: BrunoItem = {
+    uid: uuid(),
+    type: 'app',
+    seq: typeof info.seq === 'number' ? info.seq : 1,
+    name: info.name || 'App',
+    tags: Array.isArray(info.tags) ? info.tags : [],
+    request: null,
+    settings: null,
+    app: { code: ocApp.code || '' },
+    fileContent: null,
+    root: null,
+    items: [],
+    examples: [],
+    filename: null,
+    pathname: null
+  };
+
+  return brunoItem;
+};
+
+export default parseApp;

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

@@ -9,6 +9,8 @@ import { toBrunoPostResponseVariables } from '../common/actions';
 import { toBrunoScripts } from '../common/scripts';
 import { toBrunoAssertions } from '../common/assertions';
 import { uuid, ensureString } from '../../../utils';
+import { utils } from '@usebruno/common';
+const { toBool, toNumber } = utils;
 
 const parseGraphQLRequest = (ocRequest: GraphQLRequest): BrunoItem => {
   const info = ocRequest.info;
@@ -98,15 +100,19 @@ const parseGraphQLRequest = (ocRequest: GraphQLRequest): BrunoItem => {
     pathname: null
   };
 
+  // description
+  if (info?.description) {
+    const desc = typeof info.description === 'string' ? info.description : (info.description as any)?.content || '';
+    if (desc.trim().length) {
+      brunoItem.description = desc;
+    }
+  }
+
   // settings
   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;
@@ -116,17 +122,9 @@ const parseGraphQLRequest = (ocRequest: GraphQLRequest): 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/parseGrpcRequest.ts

@@ -1,6 +1,6 @@
 import type { Item as BrunoItem } from '@usebruno/schema-types/collection/item';
 import type { GrpcRequest as BrunoGrpcRequest } from '@usebruno/schema-types/requests/grpc';
-import type { GrpcRequest, GrpcMetadata } from '@opencollection/types/requests/grpc';
+import type { GrpcRequest, GrpcMetadata, GrpcMessageVariant } from '@opencollection/types/requests/grpc';
 import type { KeyValue as BrunoKeyValue } from '@usebruno/schema-types/common/key-value';
 import { toBrunoAuth } from '../common/auth';
 import { toBrunoVariables } from '../common/variables';
@@ -21,6 +21,13 @@ const toBrunoGrpcMetadata = (metadata: GrpcMetadata[] | null | undefined): Bruno
       enabled: meta.disabled !== true
     };
 
+    if (meta.description) {
+      const desc = typeof meta.description === 'string' ? meta.description : (meta.description as any)?.content || '';
+      if (desc.trim().length) {
+        brunoMeta.description = desc;
+      }
+    }
+
     return brunoMeta;
   });
 
@@ -57,10 +64,16 @@ const parseGrpcRequest = (ocRequest: GrpcRequest): BrunoItem => {
   };
 
   // message
-  if (isNonEmptyString(grpc?.message)) {
+  const rawMessage = grpc?.message;
+  if (Array.isArray(rawMessage)) {
+    brunoRequest.body.grpc = (rawMessage as GrpcMessageVariant[]).map(({ title, message }, index) => ({
+      name: title || `message ${index + 1}`,
+      content: ensureString(message)
+    }));
+  } else if (isNonEmptyString(rawMessage)) {
     brunoRequest.body.grpc = [{
       name: '',
-      content: grpc?.message as string
+      content: rawMessage as string
     }];
   }
 
@@ -110,6 +123,14 @@ const parseGrpcRequest = (ocRequest: GrpcRequest): BrunoItem => {
     pathname: null
   };
 
+  // description
+  if (info?.description) {
+    const desc = typeof info.description === 'string' ? info.description : (info.description as any)?.content || '';
+    if (desc.trim().length) {
+      brunoItem.description = desc;
+    }
+  }
+
   return brunoItem;
 };
 

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

@@ -9,7 +9,10 @@ import { toBrunoVariables } from '../common/variables';
 import { toBrunoPostResponseVariables } from '../common/actions';
 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;
@@ -79,6 +82,9 @@ const parseHttpRequest = (ocRequest: HttpRequest): BrunoItem => {
     brunoRequest.docs = ocRequest.docs;
   }
 
+  // app
+  const app = toBrunoApp((ocRequest as any).app);
+
   // bruno item
   const brunoItem: BrunoItem = {
     uid: uuid(),
@@ -88,6 +94,7 @@ const parseHttpRequest = (ocRequest: HttpRequest): BrunoItem => {
     tags: info?.tags || [],
     request: brunoRequest,
     settings: null,
+    app,
     fileContent: null,
     root: null,
     items: [],
@@ -96,15 +103,19 @@ const parseHttpRequest = (ocRequest: HttpRequest): BrunoItem => {
     pathname: null
   };
 
+  // description
+  if (info?.description) {
+    const desc = typeof info.description === 'string' ? info.description : (info.description as any)?.content || '';
+    if (desc.trim().length) {
+      brunoItem.description = desc;
+    }
+  }
+
   // settings
   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;
@@ -114,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/parseWebsocketRequest.ts

@@ -1,6 +1,6 @@
 import type { Item as BrunoItem } from '@usebruno/schema-types/collection/item';
 import type { WebSocketRequest as BrunoWebSocketRequest } from '@usebruno/schema-types/requests/websocket';
-import type { WebSocketRequest, WebSocketMessage } from '@opencollection/types/requests/websocket';
+import type { WebSocketRequest, WebSocketMessage, WebSocketMessageVariant } from '@opencollection/types/requests/websocket';
 import { toBrunoAuth } from '../common/auth';
 import { toBrunoHttpHeaders } from '../common/headers';
 import { toBrunoVariables } from '../common/variables';
@@ -35,14 +35,26 @@ const parseWebsocketRequest = (ocRequest: WebSocketRequest): BrunoItem => {
 
   // message
   if (websocket?.message) {
-    const message = websocket.message as WebSocketMessage;
-    const messageData = ensureString(message.data);
-    if (messageData.trim().length) {
-      brunoRequest.body.ws = [{
-        name: '',
-        type: message.type || 'text',
-        content: messageData
-      }];
+    if (Array.isArray(websocket.message)) {
+      // multiple messages: WebSocketMessageVariant[]
+      const variants = websocket.message as WebSocketMessageVariant[];
+      brunoRequest.body.ws = variants.map((variant, index) => ({
+        name: variant.title || `message ${index + 1}`,
+        type: variant.message?.type || 'text',
+        content: ensureString(variant.message?.data),
+        selected: variant.selected || false
+      }));
+    } else {
+      // single message uses flat WebSocketMessage
+      const message = websocket.message as WebSocketMessage;
+      const messageData = ensureString(message.data);
+      if (messageData.trim().length) {
+        brunoRequest.body.ws = [{
+          name: '',
+          type: message.type || 'text',
+          content: messageData
+        }];
+      }
     }
   }
 
@@ -101,6 +113,14 @@ const parseWebsocketRequest = (ocRequest: WebSocketRequest): BrunoItem => {
     pathname: null
   };
 
+  // description
+  if (info?.description) {
+    const desc = typeof info.description === 'string' ? info.description : (info.description as any)?.content || '';
+    if (desc.trim().length) {
+      brunoItem.description = desc;
+    }
+  }
+
   return brunoItem;
 };
 

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

@@ -0,0 +1,45 @@
+import type { Item as BrunoItem } from '@usebruno/schema-types/collection/item';
+import { stringifyYml } from '../utils';
+
+interface AppFileInfo {
+  name: string;
+  type: 'app';
+  seq?: number;
+  tags?: string[];
+}
+
+interface AppFile {
+  info: AppFileInfo;
+  code?: string;
+}
+
+// Mirror the request shape (info.name/type/seq/tags + body) so apps round-trip
+// the same fields and can be reordered via seq like every other item.
+const stringifyApp = (item: BrunoItem): string => {
+  try {
+    const info: AppFileInfo = {
+      name: item.name && item.name.trim().length ? item.name : 'App',
+      type: 'app'
+    };
+    if (typeof item.seq === 'number') {
+      info.seq = item.seq;
+    }
+    if (Array.isArray(item.tags) && item.tags.length) {
+      info.tags = item.tags;
+    }
+
+    const ocApp: AppFile = { info };
+
+    const code = item.app?.code;
+    if (code && code.trim().length) {
+      ocApp.code = code;
+    }
+
+    return stringifyYml(ocApp);
+  } catch (error) {
+    console.error('Error stringifying app:', error);
+    throw error;
+  }
+};
+
+export default stringifyApp;

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 {
@@ -33,6 +34,9 @@ const stringifyGraphQLRequest = (item: BrunoItem): string => {
     if (item.tags?.length) {
       info.tags = item.tags;
     }
+    if (isNonEmptyString(item.description)) {
+      info.description = item.description;
+    }
     ocRequest.info = info;
 
     // graphql block
@@ -129,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;
@@ -151,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/stringifyGrpcRequest.ts

@@ -1,7 +1,7 @@
 import type { Item as BrunoItem } from '@usebruno/schema-types/collection/item';
 import type { KeyValue as BrunoKeyValue } from '@usebruno/schema-types/common/key-value';
 import type { GrpcRequest as BrunoGrpcRequest } from '@usebruno/schema-types/requests/grpc';
-import type { GrpcRequest, GrpcMetadata, GrpcMessage, GrpcRequestInfo, GrpcRequestDetails, GrpcRequestRuntime } from '@opencollection/types/requests/grpc';
+import type { GrpcRequest, GrpcMetadata, GrpcMessageVariant, GrpcMessage, GrpcRequestInfo, GrpcRequestDetails, GrpcRequestRuntime } from '@opencollection/types/requests/grpc';
 import type { Auth } from '@opencollection/types/common/auth';
 import type { Scripts } from '@opencollection/types/common/scripts';
 import type { Variable } from '@opencollection/types/common/variables';
@@ -29,6 +29,9 @@ const stringifyGrpcRequest = (item: BrunoItem): string => {
     if (item.tags?.length) {
       info.tags = item.tags;
     }
+    if (isNonEmptyString(item.description)) {
+      info.description = item.description;
+    }
     ocRequest.info = info;
 
     // grpc block
@@ -73,16 +76,11 @@ const stringifyGrpcRequest = (item: BrunoItem): string => {
 
     // message
     if (brunoRequest.body?.mode === 'grpc' && brunoRequest.body.grpc?.length) {
-      const messages = brunoRequest.body.grpc;
-
-      // todo: bruno app supports only one message for now
-      // update this when bruno app supports multiple messages
-      if (messages.length) {
-        const message: GrpcMessage = messages[0].content || '';
-        if (message.trim().length) {
-          grpc.message = message;
-        }
-      }
+      const messages: GrpcMessageVariant[] = brunoRequest.body.grpc.map(({ name, content }, index) => ({
+        title: name || `message ${index + 1}`,
+        message: content || ''
+      }));
+      grpc.message = messages;
     }
 
     // auth