@usebruno/filestore 0.10.0 → 0.11.0

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/stringifyCollection.spec.ts

@@ -0,0 +1,77 @@
+import stringifyCollection from './stringifyCollection';
+import parseCollection from './parseCollection';
+
+// Typed collection-root vars serialize to OC's `{ type, data }` struct.
+// `dataType: 'string'` is the implicit default and stays a raw string.
+
+describe('stringifyCollection — typed request.variables', () => {
+  it('round-trips typed values and omits a typed struct for the implicit string default', () => {
+    const collectionRoot = {
+      meta: null,
+      request: {
+        headers: [],
+        auth: { mode: 'none' },
+        script: { req: null, res: null },
+        tests: null,
+        vars: {
+          req: [
+            { uid: 'v1', name: 'count', value: 42, enabled: true, dataType: 'number' },
+            { uid: 'v2', name: 'enabled', value: true, enabled: true, dataType: 'boolean' },
+            { uid: 'v3', name: 'config', value: { a: 1 }, enabled: true, dataType: 'object' },
+            { uid: 'v4', name: 'greeting', value: 'hi', enabled: true, dataType: 'string' },
+            { uid: 'v5', name: 'plain', value: 'hello', enabled: true }
+          ],
+          res: []
+        }
+      },
+      docs: null
+    } as any;
+
+    const brunoConfig = { name: 'c' };
+
+    const yml = stringifyCollection(collectionRoot, brunoConfig);
+
+    // `type: string` is never written out.
+    expect(yml).not.toMatch(/type:\s*string/);
+
+    const { collectionRoot: reparsed } = parseCollection(yml);
+    const reqVars = reparsed.request!.vars!.req!;
+
+    expect(reqVars).toHaveLength(5);
+    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' });
+    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();
+  });
+});
+
+describe('stringifyCollection — writing the collection version', () => {
+  const baseRoot = {
+    meta: null,
+    request: { headers: [], auth: { mode: 'none' }, script: { req: null, res: null }, tests: null, vars: { req: [], res: [] } },
+    docs: null
+  } as any;
+
+  it('writes the version as-is and reads back the same value', () => {
+    const yml = stringifyCollection(baseRoot, { name: 'c', version: '2' });
+    expect(yml).toMatch(/version:\s*['"]?2['"]?/);
+    expect(parseCollection(yml).brunoConfig.version).toBe('2');
+  });
+
+  it('writes no version when the collection has none', () => {
+    const yml = stringifyCollection(baseRoot, { name: 'c' });
+    expect(parseCollection(yml).brunoConfig.version).toBeUndefined();
+  });
+
+  it('accepts any version text — there is no check on the format', () => {
+    // The version is free-form: users can set whatever they like. Each of these should be
+    // saved and read back exactly the same, without changing the format or rejecting it.
+    ['v1.0.0', '2', '1.2.3-beta', '2024.01.15', 'release-2024-Q3', 'anything-goes'].forEach((version) => {
+      const yml = stringifyCollection(baseRoot, { name: 'c', version });
+      expect(parseCollection(yml).brunoConfig.version).toBe(version);
+    });
+  });
+});

package/src/formats/yml/stringifyCollection.ts

@@ -73,6 +73,10 @@ const stringifyCollection = (collectionRoot: any, brunoConfig: any): string => {
       name: brunoConfig.name || 'Untitled Collection'
     };
 
+    if (brunoConfig.version != null && brunoConfig.version !== '') {
+      oc.info.version = String(brunoConfig.version);
+    }
+
     // collection config
     if (hasCollectionConfig(brunoConfig)) {
       oc.config = {};

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

@@ -0,0 +1,91 @@
+import stringifyEnvironment, { toOpenCollectionEnvironmentVariables } from './stringifyEnvironment';
+import parseEnvironment from './parseEnvironment';
+
+describe('toOpenCollectionEnvironmentVariables', () => {
+  it('returns undefined for null / empty input', () => {
+    expect(toOpenCollectionEnvironmentVariables([])).toBeUndefined();
+  });
+
+  it('serializes plain string variables as raw strings', () => {
+    const out = toOpenCollectionEnvironmentVariables([
+      { uid: 'u1', name: 'apiKey', value: 'abc', type: 'text', enabled: true, secret: false } as any
+    ]);
+
+    expect(out).toEqual([{ name: 'apiKey', value: 'abc' }]);
+  });
+
+  it('serializes typed variables as a {type, data} struct', () => {
+    const out = toOpenCollectionEnvironmentVariables([
+      { uid: 'u1', name: 'port', value: 300, type: 'text', enabled: true, secret: false, dataType: 'number' } as any,
+      { uid: 'u2', name: 'flag', value: true, type: 'text', enabled: true, secret: false, dataType: 'boolean' } as any,
+      { uid: 'u3', name: 'config', value: { a: 1 }, type: 'text', enabled: true, secret: false, dataType: 'object' } as any
+    ]);
+
+    expect(out).toEqual([
+      { name: 'port', value: { type: 'number', data: '300' } },
+      { name: 'flag', value: { type: 'boolean', data: 'true' } },
+      { name: 'config', value: { type: 'object', data: '{\n  "a": 1\n}' } }
+    ]);
+  });
+
+  it('serializes secret variables without a value but preserves the dataType as `type`', () => {
+    const out = toOpenCollectionEnvironmentVariables([
+      { uid: 'u1', name: 'apiKey', value: '', type: 'text', enabled: true, secret: true } as any,
+      { uid: 'u2', name: 'flag', value: '', type: 'text', enabled: false, secret: true, dataType: 'number' } as any
+    ]);
+
+    expect(out).toEqual([
+      { secret: true, name: 'apiKey' },
+      { secret: true, name: 'flag', type: 'number', disabled: true }
+    ]);
+  });
+
+  it('marks disabled non-secret variables', () => {
+    const out = toOpenCollectionEnvironmentVariables([
+      { uid: 'u1', name: 'apiKey', value: 'abc', type: 'text', enabled: false, secret: false } as any
+    ]);
+
+    expect(out).toEqual([{ name: 'apiKey', value: 'abc', disabled: true }]);
+  });
+});
+
+describe('stringifyEnvironment', () => {
+  it('round-trips through parseEnvironment for typed and secret variables', () => {
+    const env = {
+      uid: 'env-uid',
+      name: 'test_env',
+      variables: [
+        { uid: 'u1', name: 'env_str', value: 'hello', type: 'text', enabled: true, secret: false },
+        { uid: 'u2', name: 'env_num', value: 300, type: 'text', enabled: true, secret: false, dataType: 'number' as const },
+        { uid: 'u3', name: 'env_bool', value: true, type: 'text', enabled: true, secret: false, dataType: 'boolean' as const },
+        { uid: 'u4', name: 'env_obj', value: { scope: 'env' }, type: 'text', enabled: true, secret: false, dataType: 'object' as const },
+        { uid: 'u5', name: 'env_secret', value: '', type: 'text', enabled: true, secret: true },
+        { uid: 'u6', name: 'env_secret_num', value: '', type: 'text', enabled: true, secret: true, dataType: 'number' as const }
+      ]
+    } as any;
+
+    const yml = stringifyEnvironment(env);
+    const reparsed = parseEnvironment(yml);
+
+    expect(reparsed.name).toBe('test_env');
+    expect(reparsed.variables[0]).toMatchObject({ name: 'env_str', value: 'hello', secret: false });
+    expect(reparsed.variables[1]).toMatchObject({ name: 'env_num', value: 300, dataType: 'number', secret: false });
+    expect(reparsed.variables[2]).toMatchObject({ name: 'env_bool', value: true, dataType: 'boolean', secret: false });
+    expect(reparsed.variables[3]).toMatchObject({ name: 'env_obj', value: { scope: 'env' }, dataType: 'object', secret: false });
+    expect(reparsed.variables[4]).toMatchObject({ name: 'env_secret', secret: true, value: '' });
+    expect(reparsed.variables[4].dataType).toBeUndefined();
+    expect(reparsed.variables[5]).toMatchObject({ name: 'env_secret_num', secret: true, value: '', dataType: 'number' });
+  });
+
+  it('preserves the color field when present', () => {
+    const env = {
+      uid: 'env-uid',
+      name: 'colorful',
+      color: '#ff0000',
+      variables: []
+    } as any;
+
+    const reparsed = parseEnvironment(stringifyEnvironment(env));
+    expect(reparsed.color).toBe('#ff0000');
+  });
+});

package/src/formats/yml/stringifyEnvironment.ts

@@ -1,53 +1,89 @@
-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 { stringifyYml } from './utils';
 import { ensureString } from '../../utils';
+import { SECRET_PROVIDER_IDENTIFIER_FIELDS } from '../../constants';
+import { hasTypedMetadata, toOpenCollectionTypedValue, serializeVariableValue } from './common/datatype';
 
-const toOpenCollectionEnvironmentVariables = (variables: BrunoEnvironmentVariable[]): (Variable | SecretVariable)[] | undefined => {
+export const toOpenCollectionEnvironmentVariables = (variables: (BrunoEnvironmentVariable | BrunoSecretEnvironmentVariable)[]): (Variable | SecretVariable)[] | undefined => {
   if (!variables?.length) {
     return undefined;
   }
 
   const ocVariables: (Variable | SecretVariable)[] = variables
-    .filter((v: BrunoEnvironmentVariable) => {
-      // todo: currently neither bru lang nor bruno app supports non-string values
-      // update this when bruno app supports non-string values
-      return typeof v.value === 'string';
-    })
-    .map((v: BrunoEnvironmentVariable): Variable | SecretVariable => {
-      if (v.secret === true) {
+    .map((v): Variable | SecretVariable => {
+      if ('secret' in v && v.secret === true) {
         const secretVar: SecretVariable = {
           secret: true,
           name: v.name || ''
         };
-        if (v.datatype && v.datatype !== 'string') {
-          secretVar.type = v.datatype;
+        if (hasTypedMetadata(v)) {
+          secretVar.type = v.dataType;
         }
         if (v.enabled === false) {
           secretVar.disabled = true;
         }
+        if (v.description !== undefined) {
+          secretVar.description = v.description;
+        }
         return secretVar;
       }
 
+      const valueStr = serializeVariableValue(v.value);
+
       const variable: Variable = {
         name: v.name || '',
-        value:
-          v.datatype && v.datatype !== 'string'
-            ? { type: v.datatype, data: ensureString(v.value) }
-            : ensureString(v.value)
+        value: hasTypedMetadata(v) ? toOpenCollectionTypedValue(v, valueStr) : valueStr
       };
 
       if (v.enabled === false) {
         variable.disabled = true;
       }
 
+      if (v.description !== undefined) {
+        variable.description = v.description;
+      }
+
       return variable;
     });
 
   return ocVariables.length > 0 ? ocVariables : undefined;
 };
 
+// Serializes the runtime externalSecrets block to yml `{ type, variables: [{ name,
+// path|secretName|vaultName, disabled? }] }`. Runtime-only fields (uid, value,
+// providerConfig, lastSyncedAt) are never written.
+const toOpenCollectionExternalSecrets = (externalSecrets: BrunoEnvironment['externalSecrets']): { type: string; variables: Record<string, string | boolean>[] } | undefined => {
+  const type = externalSecrets?.type as BrunoExternalSecretProviderType | undefined;
+  const identifierField = type && SECRET_PROVIDER_IDENTIFIER_FIELDS[type];
+  if (!type || !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 = (externalSecrets?.variables || [])
+    .filter((v: any) => v && v.name)
+    .map((v: any) => {
+      const secret: Record<string, string | boolean> = {
+        name: v.name,
+        [identifierField]: ensureString(v[identifierField])
+      };
+      if (v.enabled === false) {
+        secret.disabled = true;
+      }
+      return secret;
+    });
+
+  return { type, variables };
+};
+
 const stringifyEnvironment = (environment: BrunoEnvironment): string => {
   try {
     const ocEnvironment: Environment = {
@@ -65,11 +101,9 @@ const stringifyEnvironment = (environment: BrunoEnvironment): string => {
       }
     }
 
-    if (environment.externalSecrets) {
-      (ocEnvironment as any).externalSecrets = {
-        type: environment.externalSecrets.type,
-        variables: (environment.externalSecrets.variables || []).map((variable) => ({ ...variable }))
-      };
+    const ocExternalSecrets = toOpenCollectionExternalSecrets(environment.externalSecrets);
+    if (ocExternalSecrets) {
+      (ocEnvironment as any).externalSecrets = ocExternalSecrets;
     }
 
     return stringifyYml(ocEnvironment);
@@ -78,4 +112,5 @@ const stringifyEnvironment = (environment: BrunoEnvironment): string => {
     throw error;
   }
 };
+
 export default stringifyEnvironment;

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

@@ -0,0 +1,47 @@
+import stringifyFolder from './stringifyFolder';
+import parseFolder from './parseFolder';
+
+// Typed folder vars serialize to OC's `{ type, data }` struct.
+// `dataType: 'string'` is the implicit default and stays a raw string.
+
+describe('stringifyFolder — typed request.variables', () => {
+  it('round-trips typed values and omits a typed struct for the implicit string default', () => {
+    const folderRoot = {
+      meta: { name: 'my-folder', seq: 1 },
+      request: {
+        headers: [],
+        auth: { mode: 'none' },
+        script: { req: null, res: null },
+        tests: null,
+        vars: {
+          req: [
+            { uid: 'v1', name: 'count', value: 42, enabled: true, dataType: 'number' },
+            { uid: 'v2', name: 'enabled', value: true, enabled: true, dataType: 'boolean' },
+            { uid: 'v3', name: 'config', value: { a: 1 }, enabled: true, dataType: 'object' },
+            { uid: 'v4', name: 'greeting', value: 'hi', enabled: true, dataType: 'string' },
+            { uid: 'v5', name: 'plain', value: 'hello', enabled: true }
+          ],
+          res: []
+        }
+      },
+      docs: null
+    } as any;
+
+    const yml = stringifyFolder(folderRoot);
+
+    // `type: string` is never written out.
+    expect(yml).not.toMatch(/type:\s*string/);
+
+    const reparsed = parseFolder(yml);
+    const reqVars = reparsed.request!.vars!.req!;
+
+    expect(reqVars).toHaveLength(5);
+    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' });
+    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();
+  });
+});

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

@@ -0,0 +1,53 @@
+import stringifyItem from './stringifyItem';
+import parseItem from './parseItem';
+
+// Typed bruno vars on `request.vars.req` serialize to OC's `{ type, data }`
+// struct. `dataType: 'string'` is the implicit default and stays a raw string.
+
+describe('stringifyItem — typed runtime.variables', () => {
+  it('round-trips typed values and omits a typed struct for the implicit string default', () => {
+    const item = {
+      uid: 'i1',
+      type: 'http-request',
+      name: 'r',
+      seq: 1,
+      request: {
+        url: 'https://example.com',
+        method: 'GET',
+        headers: [],
+        params: [],
+        body: { mode: 'none' },
+        auth: { mode: 'none' },
+        script: { req: null, res: null },
+        tests: null,
+        vars: {
+          req: [
+            { uid: 'v1', name: 'count', value: 42, enabled: true, dataType: 'number' },
+            { uid: 'v2', name: 'enabled', value: true, enabled: true, dataType: 'boolean' },
+            { uid: 'v3', name: 'config', value: { a: 1 }, enabled: true, dataType: 'object' },
+            { uid: 'v4', name: 'greeting', value: 'hi', enabled: true, dataType: 'string' },
+            { uid: 'v5', name: 'plain', value: 'hello', enabled: true }
+          ],
+          res: []
+        }
+      }
+    } as any;
+
+    const yml = stringifyItem(item);
+
+    // `type: string` is never written out.
+    expect(yml).not.toMatch(/type:\s*string/);
+
+    const reparsed = parseItem(yml);
+    const reqVars = reparsed.request!.vars!.req!;
+
+    expect(reqVars).toHaveLength(5);
+    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' });
+    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();
+  });
+});

package/src/formats/yml/stringifyItem.ts

@@ -4,6 +4,7 @@ import stringifyGraphqlRequest from './items/stringifyGraphQLRequest';
 import stringifyGrpcRequest from './items/stringifyGrpcRequest';
 import stringifyWebsocketRequest from './items/stringifyWebsocketRequest';
 import stringifyScript from './items/stringifyScript';
+import stringifyApp from './items/stringifyApp';
 
 const stringifyItem = (item: BrunoItem): string => {
   try {
@@ -23,6 +24,9 @@ const stringifyItem = (item: BrunoItem): string => {
       case 'js':
         return stringifyScript(item);
 
+      case 'app':
+        return stringifyApp(item);
+
       case 'folder':
         throw new Error('Folder items should be handled separately using stringifyFolder');
 

package/src/formats/yml/tests/fixtures/presets/empty-request.yml

@@ -0,0 +1,7 @@
+opencollection: 1.0.0
+info:
+  name: My Collection
+extensions:
+  bruno:
+    presets:
+      request: {}

package/src/formats/yml/tests/fixtures/presets/no-presets.yml

@@ -0,0 +1,3 @@
+opencollection: 1.0.0
+info:
+  name: My Collection

package/src/formats/yml/tests/fixtures/presets/no-request-key.yml

@@ -0,0 +1,6 @@
+opencollection: 1.0.0
+info:
+  name: My Collection
+extensions:
+  bruno:
+    presets: {}

package/src/formats/yml/tests/fixtures/presets/type-only-realistic.yml

@@ -0,0 +1,24 @@
+opencollection: 1.0.0
+
+info:
+  name: md8
+config:
+  proxy:
+    inherit: true
+    config:
+      protocol: http
+      hostname: ""
+      port: ""
+      auth:
+        username: ""
+        password: ""
+      bypassProxy: ""
+bundled: false
+extensions:
+  bruno:
+    ignore:
+      - node_modules
+      - .git
+    presets:
+      request:
+        type: graphql

package/src/formats/yml/tests/fixtures/presets/url-only-realistic.yml

@@ -0,0 +1,25 @@
+opencollection: 1.0.0
+
+info:
+  name: md8
+config:
+  proxy:
+    inherit: true
+    config:
+      protocol: http
+      hostname: ""
+      port: ""
+      auth:
+        username: ""
+        password: ""
+      bypassProxy: ""
+bundled: false
+extensions:
+  bruno:
+    ignore:
+      - node_modules
+      - .git
+    presets:
+      request:
+        type: http
+        url: https://example.com/graphql

package/src/formats/yml/tests/fixtures/presets/with-type-and-url.yml

@@ -0,0 +1,9 @@
+opencollection: 1.0.0
+info:
+  name: My Collection
+extensions:
+  bruno:
+    presets:
+      request:
+        type: graphql
+        url: https://example.com/graphql