@usebruno/filestore 0.9.0 → 0.10.0

package/dist/formats/yml/common/variables.d.ts

@@ -1,6 +1,7 @@
-import { Variable } from '@opencollection/types/common/variables';
+import { Variable, VariableTypedValue } from '@opencollection/types/common/variables';
 import { FolderRequest as BrunoFolderRequest } from '@usebruno/schema-types/collection/folder';
 import { Variables as BrunoVariables } from '@usebruno/schema-types/common/variables';
+export declare const isTypedValue: (value: unknown) => value is VariableTypedValue;
 /**
  * Convert Bruno pre-request variables to OpenCollection variables format.
  * Note: Post-response variables are now converted to actions (see actions.ts).

package/dist/formats/yml/common/variables.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"variables.d.ts","sourceRoot":"","sources":["../../../../src/formats/yml/common/variables.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,wCAAwC,CAAC;AAClE,OAAO,EAAE,aAAa,IAAI,kBAAkB,EAAE,MAAM,0CAA0C,CAAC;AAC/F,OAAO,EAA6B,SAAS,IAAI,cAAc,EAAE,MAAM,yCAAyC,CAAC;AAGjH;;;GAGG;AACH,eAAO,MAAM,yBAAyB,cAAe,kBAAkB,CAAC,MAAM,CAAC,GAAG,cAAc,GAAG,IAAI,GAAG,SAAS,KAAG,QAAQ,EAAE,GAAG,SA4BlI,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,gBAAgB,cAAe,QAAQ,EAAE,GAAG,IAAI,GAAG,SAAS,KAAG;IAAE,GAAG,EAAE,cAAc,CAAC;IAAC,GAAG,EAAE,cAAc,CAAA;CAwBrH,CAAC"}
+{"version":3,"file":"variables.d.ts","sourceRoot":"","sources":["../../../../src/formats/yml/common/variables.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,kBAAkB,EAAE,MAAM,wCAAwC,CAAC;AACtF,OAAO,EAAE,aAAa,IAAI,kBAAkB,EAAE,MAAM,0CAA0C,CAAC;AAC/F,OAAO,EAA6B,SAAS,IAAI,cAAc,EAAE,MAAM,yCAAyC,CAAC;AAGjH,eAAO,MAAM,YAAY,UAAW,OAAO,gCAQ1C,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,yBAAyB,cAAe,kBAAkB,CAAC,MAAM,CAAC,GAAG,cAAc,GAAG,IAAI,GAAG,SAAS,KAAG,QAAQ,EAAE,GAAG,SA+BlI,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,gBAAgB,cAAe,QAAQ,EAAE,GAAG,IAAI,GAAG,SAAS,KAAG;IAAE,GAAG,EAAE,cAAc,CAAC;IAAC,GAAG,EAAE,cAAc,CAAA;CAiCrH,CAAC"}

package/dist/formats/yml/parseEnvironment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parseEnvironment.d.ts","sourceRoot":"","sources":["../../../src/formats/yml/parseEnvironment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,IAAI,gBAAgB,EAAmD,MAAM,+CAA+C,CAAC;AAsCtJ,QAAA,MAAM,gBAAgB,cAAe,MAAM,KAAG,gBAgB7C,CAAC;AAEF,eAAe,gBAAgB,CAAC"}
+{"version":3,"file":"parseEnvironment.d.ts","sourceRoot":"","sources":["../../../src/formats/yml/parseEnvironment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,IAAI,gBAAgB,EAAmD,MAAM,+CAA+C,CAAC;AA2EtJ,QAAA,MAAM,gBAAgB,cAAe,MAAM,KAAG,gBAqB7C,CAAC;AAEF,eAAe,gBAAgB,CAAC"}

package/dist/formats/yml/stringifyEnvironment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stringifyEnvironment.d.ts","sourceRoot":"","sources":["../../../src/formats/yml/stringifyEnvironment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,IAAI,gBAAgB,EAAmD,MAAM,+CAA+C,CAAC;AA2CtJ,QAAA,MAAM,oBAAoB,gBAAiB,gBAAgB,KAAG,MAsB7D,CAAC;AACF,eAAe,oBAAoB,CAAC"}
+{"version":3,"file":"stringifyEnvironment.d.ts","sourceRoot":"","sources":["../../../src/formats/yml/stringifyEnvironment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,IAAI,gBAAgB,EAAmD,MAAM,+CAA+C,CAAC;AAkDtJ,QAAA,MAAM,oBAAoB,gBAAiB,gBAAgB,KAAG,MA6B7D,CAAC;AACF,eAAe,oBAAoB,CAAC"}

package/dist/formats/yml/tests/parseEnvironment.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=parseEnvironment.spec.d.ts.map

package/dist/formats/yml/tests/parseEnvironment.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseEnvironment.spec.d.ts","sourceRoot":"","sources":["../../../../src/formats/yml/tests/parseEnvironment.spec.js"],"names":[],"mappings":""}

package/dist/formats/yml/tests/variables.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=variables.spec.d.ts.map

package/dist/formats/yml/tests/variables.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"variables.spec.d.ts","sourceRoot":"","sources":["../../../../src/formats/yml/tests/variables.spec.js"],"names":[],"mappings":""}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@usebruno/filestore",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "license": "MIT",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -29,7 +29,7 @@
     "@types/jest": "^29.5.11",
     "@types/lodash": "^4.14.191",
     "@types/node": "^24.1.0",
-    "@usebruno/schema-types": "0.4.0",
+    "@usebruno/schema-types": "0.6.0",
     "babel-jest": "^29.7.0",
     "jest": "^29.2.0",
     "nanoid": "3.3.8",
@@ -45,7 +45,7 @@
   },
   "dependencies": {
     "@types/nanoid": "^2.1.0",
-    "@usebruno/lang": "0.36.0",
+    "@usebruno/lang": "0.37.0",
     "ajv": "^8.17.1",
     "lodash": "^4.17.21",
     "yaml": "^2.3.4"

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

@@ -1,8 +1,18 @@
-import { Variable } from '@opencollection/types/common/variables';
+import { Variable, VariableTypedValue } from '@opencollection/types/common/variables';
 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
+  );
+};
+
 /**
  * Convert Bruno pre-request variables to OpenCollection variables format.
  * Note: Post-response variables are now converted to actions (see actions.ts).
@@ -21,7 +31,10 @@ export const toOpenCollectionVariables = (variables: BrunoFolderRequest['vars']
   const ocVariables: Variable[] = reqVarsArray.map((v: BrunoVariable): Variable => {
     const variable: Variable = {
       name: v.name || '',
-      value: v.value || ''
+      value:
+        v.datatype && v.datatype !== 'string'
+          ? { type: v.datatype, data: ensureString(v.value) }
+          : v.value || ''
     };
 
     if (v?.description?.trim().length) {
@@ -52,11 +65,20 @@ export const toBrunoVariables = (variables: Variable[] | null | undefined): { re
     const variable: BrunoVariable = {
       uid: uuid(),
       name: ensureString(v.name),
-      value: ensureString(v.value),
+      value: '',
       enabled: v.disabled !== true,
       local: false
     };
 
+    if (isTypedValue(v.value)) {
+      variable.value = ensureString(v.value.data);
+      if (v.value.type !== 'string' && v.value.type !== 'null') {
+        variable.datatype = v.value.type;
+      }
+    } else {
+      variable.value = ensureString(v.value);
+    }
+
     if (v.description) {
       variable.description = typeof v.description === 'string' ? v.description : (v.description as any)?.content || '';
     }

package/src/formats/yml/parseEnvironment.ts

@@ -3,6 +3,7 @@ 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 { isTypedValue } from './common/variables';
 
 const isSecretVariable = (v: Variable | SecretVariable): v is SecretVariable => {
   return 'secret' in v && v.secret === true;
@@ -15,7 +16,7 @@ const toBrunoEnvironmentVariables = (variables: (Variable | SecretVariable)[] |
 
   return variables.map((v): BrunoEnvironmentVariable => {
     if (isSecretVariable(v)) {
-      return {
+      const variable: BrunoEnvironmentVariable = {
         uid: uuid(),
         name: ensureString(v.name),
         value: '',
@@ -23,19 +24,55 @@ const toBrunoEnvironmentVariables = (variables: (Variable | SecretVariable)[] |
         enabled: v.disabled !== true,
         secret: true
       };
+
+      if (v.type && v.type !== 'string' && v.type !== 'null') {
+        variable.datatype = v.type;
+      }
+
+      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)) {
+      variable.value = ensureString(v.value.data);
+      if (v.value.type !== 'string' && v.value.type !== 'null') {
+        variable.datatype = v.value.type;
+      }
+    } else {
+      variable.value = ensureString(v.value);
+    }
+
     return variable;
   });
 };
 
+const toBrunoExternalSecrets = (externalSecrets: any): BrunoEnvironment['externalSecrets'] | undefined => {
+  if (!externalSecrets || typeof externalSecrets !== 'object') {
+    return undefined;
+  }
+
+  const variables = Array.isArray(externalSecrets.variables)
+    ? externalSecrets.variables.map((variable: any) => {
+        const result: Record<string, string> = { name: ensureString(variable?.name) };
+        Object.keys(variable || {}).forEach((key) => {
+          if (key !== 'name') {
+            result[key] = ensureString(variable[key]);
+          }
+        });
+        return result;
+      })
+    : [];
+
+  return { type: ensureString(externalSecrets.type), variables } as BrunoEnvironment['externalSecrets'];
+};
+
 const parseEnvironment = (ymlString: string): BrunoEnvironment => {
   try {
     const ocEnvironment: Environment = parseYml(ymlString);
@@ -47,6 +84,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/stringifyEnvironment.ts

@@ -2,6 +2,7 @@ import type { Environment as BrunoEnvironment, EnvironmentVariable as BrunoEnvir
 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';
 
 const toOpenCollectionEnvironmentVariables = (variables: BrunoEnvironmentVariable[]): (Variable | SecretVariable)[] | undefined => {
   if (!variables?.length) {
@@ -20,6 +21,9 @@ const toOpenCollectionEnvironmentVariables = (variables: BrunoEnvironmentVariabl
           secret: true,
           name: v.name || ''
         };
+        if (v.datatype && v.datatype !== 'string') {
+          secretVar.type = v.datatype;
+        }
         if (v.enabled === false) {
           secretVar.disabled = true;
         }
@@ -28,7 +32,10 @@ const toOpenCollectionEnvironmentVariables = (variables: BrunoEnvironmentVariabl
 
       const variable: Variable = {
         name: v.name || '',
-        value: v.value as string
+        value:
+          v.datatype && v.datatype !== 'string'
+            ? { type: v.datatype, data: ensureString(v.value) }
+            : ensureString(v.value)
       };
 
       if (v.enabled === false) {
@@ -58,6 +65,13 @@ const stringifyEnvironment = (environment: BrunoEnvironment): string => {
       }
     }
 
+    if (environment.externalSecrets) {
+      (ocEnvironment as any).externalSecrets = {
+        type: environment.externalSecrets.type,
+        variables: (environment.externalSecrets.variables || []).map((variable) => ({ ...variable }))
+      };
+    }
+
     return stringifyYml(ocEnvironment);
   } catch (error) {
     console.error('Error stringifying environment:', error);

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

@@ -0,0 +1,161 @@
+import parseEnvironment from '../parseEnvironment';
+import stringifyEnvironment from '../stringifyEnvironment';
+
+const ENV_YML = `name: test_env
+variables:
+  - name: env_str
+    value: env_string
+  - 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"
+        }
+  - name: falsy_num
+    value:
+      type: number
+      data: "0"
+  - name: falsy_bool
+    value:
+      type: boolean
+      data: "false"
+  - secret: true
+    name: env_secret_str
+  - secret: true
+    name: env_secret_num
+    type: number
+  - secret: true
+    name: env_secret_bool
+    type: boolean
+  - secret: true
+    name: env_secret_obj
+    type: object
+  - name: env_array_obj
+    value:
+      type: object
+      data: "[1,2,3,4]"
+`;
+
+const byName = (env) => Object.fromEntries(env.variables.map((v) => [v.name, v]));
+
+describe('yml parseEnvironment - typed values', () => {
+  it('keeps the value as a string and preserves the type via datatype', () => {
+    const variables = byName(parseEnvironment(ENV_YML));
+
+    expect(variables.env_num).toMatchObject({ value: '300', type: 'text', datatype: 'number' });
+    expect(typeof variables.env_num.value).toBe('string');
+
+    expect(variables.env_bool).toMatchObject({ value: 'true', datatype: 'boolean' });
+    expect(variables.falsy_num).toMatchObject({ value: '0', datatype: 'number' });
+    expect(variables.falsy_bool).toMatchObject({ value: 'false', datatype: 'boolean' });
+
+    expect(variables.env_obj.datatype).toBe('object');
+    expect(typeof variables.env_obj.value).toBe('string');
+    expect(variables.env_obj.value).toContain('"scope": "env"');
+
+    expect(variables.env_array_obj).toMatchObject({ value: '[1,2,3,4]', datatype: 'object' });
+  });
+
+  it('does not set datatype for plain string values', () => {
+    const variables = byName(parseEnvironment(ENV_YML));
+
+    expect(variables.env_str).toMatchObject({ value: 'env_string', type: 'text', secret: false });
+    expect(variables.env_str).not.toHaveProperty('datatype');
+  });
+
+  it('parses secret variables with no value or datatype', () => {
+    const variables = byName(parseEnvironment(ENV_YML));
+
+    expect(variables.env_secret_str).toMatchObject({ name: 'env_secret_str', value: '', secret: true });
+    expect(variables.env_secret_str).not.toHaveProperty('datatype');
+  });
+
+  it('parses secret variables with a type, keeping the value empty and the type in datatype', () => {
+    const variables = byName(parseEnvironment(ENV_YML));
+
+    expect(variables.env_secret_num).toMatchObject({ value: '', secret: true, datatype: 'number' });
+    expect(variables.env_secret_bool).toMatchObject({ value: '', secret: true, datatype: 'boolean' });
+    expect(variables.env_secret_obj).toMatchObject({ value: '', secret: true, datatype: 'object' });
+  });
+
+  it('serializes secret variable datatype back to a type field, omitting it for plain secrets', () => {
+    const yml = stringifyEnvironment(parseEnvironment(ENV_YML));
+
+    expect(yml).toContain('- secret: true\n    name: env_secret_num\n    type: number');
+    expect(yml).toContain('- secret: true\n    name: env_secret_bool\n    type: boolean');
+    expect(yml).toContain('- secret: true\n    name: env_secret_obj\n    type: object');
+    expect(yml).toContain('- secret: true\n    name: env_secret_str');
+    expect(yml).not.toContain('name: env_secret_str\n    type:');
+  });
+
+  it('serializes datatype back to an OpenCollection { type, data } value', () => {
+    const yml = stringifyEnvironment(parseEnvironment(ENV_YML));
+
+    expect(yml).toContain('type: number');
+    expect(yml).toContain('data: "300"');
+    expect(yml).toContain('type: boolean');
+    expect(yml).toContain('type: object');
+    // plain strings stay plain, never wrapped as a string datatype
+    expect(yml).toContain('value: env_string');
+    expect(yml).not.toContain('type: string');
+  });
+
+  it('round-trips value and datatype through parse -> stringify -> parse', () => {
+    const env = parseEnvironment(ENV_YML);
+    const reparsed = parseEnvironment(stringifyEnvironment(env));
+
+    const withoutUid = (e) => e.variables.map(({ uid, ...rest }) => rest);
+    expect(withoutUid(reparsed)).toEqual(withoutUid(env));
+  });
+});
+
+const EXTERNAL_SECRETS_YML = `name: test_env
+variables:
+  - name: env_str
+    value: env_string
+externalSecrets:
+  type: my-vault
+  variables:
+    - name: by_path
+      path: secret/data/secret
+    - name: by_secret_name
+      secretName: secret
+    - name: by_vault_name
+      vaultName: secret
+`;
+
+describe('yml parseEnvironment - external secrets', () => {
+  it('parses externalSecrets, preserving the type and arbitrary variable keys', () => {
+    const env = parseEnvironment(EXTERNAL_SECRETS_YML);
+
+    expect(env.externalSecrets).toEqual({
+      type: 'my-vault',
+      variables: [
+        { name: 'by_path', path: 'secret/data/secret' },
+        { name: 'by_secret_name', secretName: 'secret' },
+        { name: 'by_vault_name', vaultName: 'secret' }
+      ]
+    });
+  });
+
+  it('does not set externalSecrets when the yml has none', () => {
+    const env = parseEnvironment('name: test_env\nvariables: []\n');
+    expect(env.externalSecrets).toBeUndefined();
+  });
+
+  it('round-trips externalSecrets through parse -> stringify -> parse', () => {
+    const env = parseEnvironment(EXTERNAL_SECRETS_YML);
+    const reparsed = parseEnvironment(stringifyEnvironment(env));
+
+    expect(reparsed.externalSecrets).toEqual(env.externalSecrets);
+  });
+});

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

@@ -0,0 +1,34 @@
+import { toBrunoVariables, toOpenCollectionVariables } from '../common/variables';
+
+describe('yml variables - typed values (collection / folder / request vars)', () => {
+  it('reads a typed value keeping the value as a string and the type in datatype', () => {
+    const ocVariables = [
+      { name: 'var_str', value: 'plain' },
+      { name: 'var_num', value: { type: 'number', data: '300' } },
+      { name: 'var_bool', value: { type: 'boolean', data: 'false' } },
+      { name: 'var_obj', value: { type: 'object', data: '{"scope":"folder"}' } }
+    ];
+
+    const { req } = toBrunoVariables(ocVariables);
+
+    expect(req.find((v) => v.name === 'var_str')).toMatchObject({ value: 'plain' });
+    expect(req.find((v) => v.name === 'var_str')).not.toHaveProperty('datatype');
+    expect(req.find((v) => v.name === 'var_num')).toMatchObject({ value: '300', datatype: 'number' });
+    expect(req.find((v) => v.name === 'var_bool')).toMatchObject({ value: 'false', datatype: 'boolean' });
+    expect(req.find((v) => v.name === 'var_obj')).toMatchObject({ value: '{"scope":"folder"}', datatype: 'object' });
+  });
+
+  it('writes datatype back as a { type, data } value, leaving plain strings untouched', () => {
+    const brunoVariables = [
+      { uid: 'u1', name: 'var_str', value: 'plain', enabled: true, local: false },
+      { uid: 'u2', name: 'var_num', value: '300', datatype: 'number', enabled: true, local: false }
+    ];
+
+    const ocVariables = toOpenCollectionVariables(brunoVariables);
+
+    expect(ocVariables).toEqual([
+      { name: 'var_str', value: 'plain' },
+      { name: 'var_num', value: { type: 'number', data: '300' } }
+    ]);
+  });
+});