@usebruno/filestore 0.9.0 → 0.11.0

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,46 +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 (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.value as string
+        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 = {
@@ -58,10 +101,16 @@ const stringifyEnvironment = (environment: BrunoEnvironment): string => {
       }
     }
 
+    const ocExternalSecrets = toOpenCollectionExternalSecrets(environment.externalSecrets);
+    if (ocExternalSecrets) {
+      (ocEnvironment as any).externalSecrets = ocExternalSecrets;
+    }
+
     return stringifyYml(ocEnvironment);
   } catch (error) {
     console.error('Error stringifying environment:', error);
     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

package/src/formats/yml/tests/parseCollection.spec.js

@@ -0,0 +1,63 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import parseCollection from '../parseCollection';
+
+const loadFixture = (name) =>
+  fs.readFileSync(path.join(__dirname, 'fixtures', 'presets', `${name}.yml`), 'utf8');
+
+describe('yml parseCollection - presets', () => {
+  it('parses presets when request.type and request.url are present', () => {
+    const { brunoConfig } = parseCollection(loadFixture('with-type-and-url'));
+
+    expect(brunoConfig.presets).toEqual({
+      requestType: 'graphql',
+      requestUrl: 'https://example.com/graphql'
+    });
+  });
+
+  it('defaults requestType and requestUrl to empty strings (not arrays) when request fields are missing', () => {
+    const { brunoConfig } = parseCollection(loadFixture('empty-request'));
+
+    expect(brunoConfig.presets).toEqual({
+      requestType: '',
+      requestUrl: ''
+    });
+    expect(Array.isArray(brunoConfig.presets.requestType)).toBe(false);
+    expect(Array.isArray(brunoConfig.presets.requestUrl)).toBe(false);
+  });
+
+  it('does not set presets when the extension has no presets block', () => {
+    const { brunoConfig } = parseCollection(loadFixture('no-presets'));
+
+    expect(brunoConfig.presets).toBeUndefined();
+  });
+
+  it('does not set presets when presets exists but request key is absent', () => {
+    const { brunoConfig } = parseCollection(loadFixture('no-request-key'));
+
+    expect(brunoConfig.presets).toBeUndefined();
+  });
+
+  it('parses a realistic collection with only request.type set (no url) — defaults url to empty string', () => {
+    const { brunoConfig } = parseCollection(loadFixture('type-only-realistic'));
+
+    expect(brunoConfig.presets).toEqual({
+      requestType: 'graphql',
+      requestUrl: ''
+    });
+    expect(Array.isArray(brunoConfig.presets.requestUrl)).toBe(false);
+    expect(brunoConfig.ignore).toEqual(['node_modules', '.git']);
+  });
+
+  it('parses a realistic collection with request.type http and request.url set', () => {
+    const { brunoConfig } = parseCollection(loadFixture('url-only-realistic'));
+
+    expect(brunoConfig.presets).toEqual({
+      requestType: 'http',
+      requestUrl: 'https://example.com/graphql'
+    });
+    expect(Array.isArray(brunoConfig.presets.requestType)).toBe(false);
+    expect(Array.isArray(brunoConfig.presets.requestUrl)).toBe(false);
+    expect(brunoConfig.ignore).toEqual(['node_modules', '.git']);
+  });
+});