@usebruno/filestore 0.9.0 → 0.11.0

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

@@ -8,6 +8,7 @@ import type { Assertion } from '@opencollection/types/common/assertions';
 import type { Action } from '@opencollection/types/common/actions';
 import type { HttpRequestParam, HttpRequestBody } from '@opencollection/types/requests/http';
 import { stringifyYml } from '../utils';
+import { toOpenCollectionApp, OpenCollectionApp } from '../common/app';
 import { toOpenCollectionAuth } from '../common/auth';
 import { toOpenCollectionHttpHeaders, toOpenCollectionResponseHeaders } from '../common/headers';
 import { toOpenCollectionParams } from '../common/params';
@@ -34,6 +35,9 @@ const stringifyHttpRequest = (item: BrunoItem): string => {
     if (item.tags?.length) {
       info.tags = item.tags;
     }
+    if (isNonEmptyString(item.description)) {
+      info.description = item.description;
+    }
     ocRequest.info = info;
 
     // http block
@@ -212,6 +216,12 @@ const stringifyHttpRequest = (item: BrunoItem): string => {
       ocRequest.docs = brunoRequest.docs;
     }
 
+    // app
+    const app: OpenCollectionApp | undefined = toOpenCollectionApp(item.app);
+    if (app) {
+      (ocRequest as any).app = app;
+    }
+
     return stringifyYml(ocRequest);
   } catch (error) {
     console.error('Error stringifying HTTP request:', error);

package/src/formats/yml/items/stringifyWebsocketRequest.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, WebSocketRequestInfo, WebSocketRequestDetails, WebSocketRequestRuntime } from '@opencollection/types/requests/websocket';
+import type { WebSocketRequest, WebSocketRequestInfo, WebSocketRequestDetails, WebSocketRequestRuntime, WebSocketMessage, WebSocketMessageVariant } from '@opencollection/types/requests/websocket';
 import type { Auth } from '@opencollection/types/common/auth';
 import type { Scripts } from '@opencollection/types/common/scripts';
 import type { Variable } from '@opencollection/types/common/variables';
@@ -28,6 +28,9 @@ const stringifyWebsocketRequest = (item: BrunoItem): string => {
     if (item.tags?.length) {
       info.tags = item.tags;
     }
+    if (isNonEmptyString(item.description)) {
+      info.description = item.description;
+    }
     ocRequest.info = info;
 
     // websocket block
@@ -41,21 +44,31 @@ const stringifyWebsocketRequest = (item: BrunoItem): string => {
       websocket.headers = headers;
     }
 
-    // message
+    // message: single message without a custom name uses flat WebSocketMessage (backward compatible),
+    // otherwise uses WebSocketMessageVariant[] to preserve names
     if (brunoRequest.body?.mode === 'ws' && brunoRequest.body.ws?.length) {
       const messages = brunoRequest.body.ws;
+      const hasCustomName = messages.length === 1 && messages[0].name && messages[0].name.trim().length > 0;
+
+      const hasContent = messages.length === 1 && (messages[0].content || '').trim().length > 0;
 
-      // todo: bruno app supports only one message for now
-      // update this when bruno app supports multiple messages
-      if (messages.length) {
+      if (messages.length === 1 && !hasCustomName && hasContent) {
         const msg = messages[0];
         const message: WebSocketMessage = {
-          type: (msg.type as 'text' | 'json' | 'xml' | 'binary') || 'text',
+          type: (msg.type as WebSocketMessage['type']) || 'text',
           data: msg.content || ''
         };
-        if (message.data.trim().length) {
-          websocket.message = message;
-        }
+        websocket.message = message;
+      } else {
+        const variants: WebSocketMessageVariant[] = messages.map((msg, index) => ({
+          title: msg.name || `message ${index + 1}`,
+          selected: msg.selected || false,
+          message: {
+            type: (msg.type as WebSocketMessage['type']) || 'text',
+            data: msg.content || ''
+          }
+        }));
+        websocket.message = variants;
       }
     }
 

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

@@ -0,0 +1,70 @@
+import parseCollection from './parseCollection';
+
+// Typed `request.variables` propagate through parseCollection into the
+// collectionRoot's vars.req with their dataType + coerced value.
+
+describe('parseCollection — typed request.variables', () => {
+  it('coerces typed values, preserves raw value on un-coercible input, and treats explicit string as the implicit default', () => {
+    const yml = `opencollection: "1.0.0"
+info:
+  name: c
+
+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: cfg
+      value:
+        type: object
+        data: 'not-json'
+`;
+
+    const { collectionRoot } = parseCollection(yml);
+    const reqVars = collectionRoot.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: 'cfg', value: 'not-json', dataType: 'object' });
+  });
+});
+
+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');
+    expect(brunoConfig.version).toBe('v1.0.0');
+  });
+
+  it('turns a number version into text (2 becomes "2")', () => {
+    const { brunoConfig } = parseCollection('opencollection: "1.0.0"\ninfo:\n  name: c\n  version: 2\n');
+    expect(brunoConfig.version).toBe('2');
+  });
+
+  it('has no version when the file does not have one', () => {
+    const { brunoConfig } = parseCollection('opencollection: "1.0.0"\ninfo:\n  name: c\n');
+    expect(brunoConfig.version).toBeUndefined();
+  });
+});

package/src/formats/yml/parseCollection.ts

@@ -7,6 +7,7 @@ import { toBrunoVariables } from './common/variables';
 import { toBrunoPostResponseVariables } from './common/actions';
 import { toBrunoScripts } from './common/scripts';
 import { ensureString } from '../../utils';
+import type { BrunoPresetsExtension } from '../../types';
 
 interface ParsedCollection {
   collectionRoot: FolderRoot;
@@ -25,6 +26,10 @@ const parseCollection = (ymlString: string): ParsedCollection => {
       ignore: []
     };
 
+    if (oc.info?.version != null && oc.info.version !== '') {
+      brunoConfig.version = ensureString(oc.info.version, '');
+    }
+
     const brunoExtension = (oc.extensions as any)?.bruno;
     if (brunoExtension?.ignore && Array.isArray(brunoExtension.ignore)) {
       brunoConfig.ignore = brunoExtension.ignore;
@@ -32,11 +37,11 @@ const parseCollection = (ymlString: string): ParsedCollection => {
 
     // presets
     if (brunoExtension?.presets) {
-      const presets = brunoExtension.presets as any;
+      const presets = brunoExtension.presets as BrunoPresetsExtension;
       if (presets.request) {
         brunoConfig.presets = {
-          requestType: presets.request.type || [],
-          requestUrl: presets.request.url || []
+          requestType: presets.request.type || '',
+          requestUrl: presets.request.url || ''
         };
       }
     }

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

@@ -0,0 +1,99 @@
+import parseEnvironment, { toBrunoEnvironmentVariables } from './parseEnvironment';
+
+describe('toBrunoEnvironmentVariables', () => {
+  it('returns an empty array for null / empty input', () => {
+    expect(toBrunoEnvironmentVariables(null)).toEqual([]);
+    expect(toBrunoEnvironmentVariables(undefined)).toEqual([]);
+    expect(toBrunoEnvironmentVariables([])).toEqual([]);
+  });
+
+  it('parses a plain string variable as text with secret=false', () => {
+    const [variable] = toBrunoEnvironmentVariables([{ name: 'apiKey', value: 'abc' } as any]);
+
+    expect(variable).toMatchObject({
+      name: 'apiKey',
+      value: 'abc',
+      type: 'text',
+      enabled: true,
+      secret: false
+    });
+    expect(variable.uid).toEqual(expect.any(String));
+    expect(variable.dataType).toBeUndefined();
+  });
+
+  it('parses typed values and attaches the dataType field', () => {
+    const vars = toBrunoEnvironmentVariables([
+      { name: 'port', value: { type: 'number', data: '300' } } as any,
+      { name: 'flag', value: { type: 'boolean', data: 'true' } } as any,
+      { name: 'config', value: { type: 'object', data: '{"a":1}' } } as any
+    ]);
+
+    expect(vars[0]).toMatchObject({ name: 'port', value: 300, dataType: 'number', secret: false });
+    expect(vars[1]).toMatchObject({ name: 'flag', value: true, dataType: 'boolean', secret: false });
+    expect(vars[2]).toMatchObject({ name: 'config', value: { a: 1 }, dataType: 'object', secret: false });
+  });
+
+  it('parses secret variables with secret=true and attaches the dataType from `type`', () => {
+    const vars = toBrunoEnvironmentVariables([
+      { secret: true, name: 'apiKey' } as any,
+      { secret: true, name: 'port', type: 'number' } as any,
+      { secret: true, name: 'flag', type: 'boolean', disabled: true } as any
+    ]);
+
+    expect(vars[0]).toMatchObject({ name: 'apiKey', secret: true, enabled: true, value: '' });
+    // A bare secret has no `type`, so no dataType materializes.
+    expect(vars[0].dataType).toBeUndefined();
+    expect(vars[1]).toMatchObject({ name: 'port', secret: true, enabled: true, dataType: 'number' });
+    expect(vars[2]).toMatchObject({ name: 'flag', secret: true, enabled: false, dataType: 'boolean' });
+  });
+
+  it('honors the disabled flag on non-secret variables', () => {
+    const [variable] = toBrunoEnvironmentVariables([
+      { name: 'apiKey', value: 'abc', disabled: true } as any
+    ]);
+
+    expect(variable.enabled).toBe(false);
+  });
+});
+
+describe('parseEnvironment (full yml)', () => {
+  it('parses an environment with mixed plain, typed and secret variables', () => {
+    const yml = `name: test_env
+variables:
+  - name: env_str
+    value: hello
+  - name: env_num
+    value:
+      type: number
+      data: "300"
+  - name: env_bool
+    value:
+      type: boolean
+      data: "true"
+  - name: env_obj
+    value:
+      type: object
+      data: '{"scope":"env"}'
+  - secret: true
+    name: env_secret
+`;
+
+    const env = parseEnvironment(yml);
+
+    expect(env.name).toBe('test_env');
+    expect(env.variables).toHaveLength(5);
+
+    expect(env.variables[0]).toMatchObject({ name: 'env_str', value: 'hello', secret: false });
+    expect(env.variables[1]).toMatchObject({ name: 'env_num', value: 300, dataType: 'number', secret: false });
+    expect(env.variables[2]).toMatchObject({ name: 'env_bool', value: true, dataType: 'boolean', secret: false });
+    expect(env.variables[3]).toMatchObject({ name: 'env_obj', value: { scope: 'env' }, dataType: 'object', secret: false });
+    expect(env.variables[4]).toMatchObject({ name: 'env_secret', secret: true, value: '' });
+    expect(env.variables[4].dataType).toBeUndefined();
+  });
+
+  it('defaults environment name when missing', () => {
+    const env = parseEnvironment('variables: []');
+    expect(env.name).toBe('Untitled Environment');
+    expect(env.variables).toEqual([]);
+  });
+});

package/src/formats/yml/parseEnvironment.ts

@@ -1,21 +1,28 @@
-import type { Environment as BrunoEnvironment, EnvironmentVariable as BrunoEnvironmentVariable } from '@usebruno/schema-types/collection/environment';
+import type {
+  Environment as BrunoEnvironment,
+  EnvironmentVariable as BrunoEnvironmentVariable,
+  SecretEnvironmentVariable as BrunoSecretEnvironmentVariable,
+  ExternalSecretProviderType as BrunoExternalSecretProviderType
+} from '@usebruno/schema-types/collection/environment';
 import type { Environment } from '@opencollection/types/config/environments';
 import type { Variable, SecretVariable } from '@opencollection/types/common/variables';
 import { parseYml } from './utils';
 import { uuid, ensureString } from '../../utils';
+import { SECRET_PROVIDER_IDENTIFIER_FIELDS } from '../../constants';
+import { isTypedValue, fromOpenCollectionTypedValue } from './common/datatype';
 
 const isSecretVariable = (v: Variable | SecretVariable): v is SecretVariable => {
   return 'secret' in v && v.secret === true;
 };
 
-const toBrunoEnvironmentVariables = (variables: (Variable | SecretVariable)[] | null | undefined): BrunoEnvironmentVariable[] => {
+export const toBrunoEnvironmentVariables = (variables: (Variable | SecretVariable)[] | null | undefined): (BrunoEnvironmentVariable | BrunoSecretEnvironmentVariable)[] => {
   if (!variables?.length) {
     return [];
   }
 
-  return variables.map((v): BrunoEnvironmentVariable => {
+  return variables.map((v): (BrunoEnvironmentVariable | BrunoSecretEnvironmentVariable) => {
     if (isSecretVariable(v)) {
-      return {
+      const variable: BrunoEnvironmentVariable = {
         uid: uuid(),
         name: ensureString(v.name),
         value: '',
@@ -23,19 +30,71 @@ const toBrunoEnvironmentVariables = (variables: (Variable | SecretVariable)[] |
         enabled: v.disabled !== true,
         secret: true
       };
+
+      if (v.type && v.type !== 'string' && v.type !== 'null') {
+        variable.dataType = v.type;
+      }
+
+      if (v.description) {
+        variable.description = typeof v.description === 'string' ? v.description : (v.description as any)?.content || '';
+      }
+
+      return variable;
     }
+
     const variable: BrunoEnvironmentVariable = {
       uid: uuid(),
       name: ensureString(v.name),
-      value: ensureString(v.value),
+      value: '',
       type: 'text',
       enabled: v.disabled !== true,
       secret: false
     };
+
+    if (isTypedValue(v.value)) {
+      Object.assign(variable, fromOpenCollectionTypedValue(v.value));
+    } else {
+      variable.value = ensureString(v.value);
+    }
+
+    if (v.description) {
+      variable.description = typeof v.description === 'string' ? v.description : (v.description as any)?.content || '';
+    }
+
     return variable;
   });
 };
 
+// Parses the yml `externalSecrets: { type, variables: [{ name, path|secretName|vaultName }] }`
+// block into the runtime shape. `uid` and `enabled` are added here; the fetched `value`,
+// `providerConfig` and `lastSyncedAt` are runtime-only and never present in the file.
+const toBrunoExternalSecrets = (externalSecrets: any): BrunoEnvironment['externalSecrets'] | undefined => {
+  if (!externalSecrets || typeof externalSecrets !== 'object') {
+    return undefined;
+  }
+
+  const type = ensureString(externalSecrets.type) as BrunoExternalSecretProviderType;
+  const identifierField = SECRET_PROVIDER_IDENTIFIER_FIELDS[type];
+  if (!identifierField) {
+    return undefined;
+  }
+
+  // Keep any named entry, even one with an empty identifier — a half-filled secret row is the user's
+  // data; dropping it here would silently delete it on the next save.
+  const variables = Array.isArray(externalSecrets.variables)
+    ? externalSecrets.variables
+        .filter((v: any) => v && v.name)
+        .map((v: any) => ({
+          uid: uuid(),
+          name: ensureString(v.name),
+          enabled: v.disabled !== true,
+          [identifierField]: ensureString(v[identifierField])
+        }))
+    : [];
+
+  return { type, variables } as BrunoEnvironment['externalSecrets'];
+};
+
 const parseEnvironment = (ymlString: string): BrunoEnvironment => {
   try {
     const ocEnvironment: Environment = parseYml(ymlString);
@@ -47,6 +106,11 @@ const parseEnvironment = (ymlString: string): BrunoEnvironment => {
       color: ocEnvironment.color || null
     };
 
+    const externalSecrets = toBrunoExternalSecrets((ocEnvironment as any).externalSecrets);
+    if (externalSecrets) {
+      brunoEnvironment.externalSecrets = externalSecrets;
+    }
+
     return brunoEnvironment;
   } catch (error) {
     console.error('Error parsing environment:', error);

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

@@ -0,0 +1,52 @@
+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' });
+  });
+});

package/src/formats/yml/parseFolder.ts

@@ -19,15 +19,9 @@ const parseFolder = (ymlString: string): FolderRoot => {
         name: ensureString(info?.name, 'Untitled Folder'),
         seq: info?.seq || 1
       },
-      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 +31,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'
+    });
+  });
+});