@usebruno/filestore 0.10.0 → 0.11.0

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']);
+  });
+});

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

@@ -48,46 +48,46 @@ variables:
 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', () => {
+  it('coerces the value to its native JS type 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_num).toMatchObject({ value: 300, type: 'text', dataType: 'number' });
+    expect(typeof variables.env_num.value).toBe('number');
 
-    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_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_obj.dataType).toBe('object');
+    expect(typeof variables.env_obj.value).toBe('object');
+    expect(variables.env_obj.value).toMatchObject({ scope: 'env' });
 
-    expect(variables.env_array_obj).toMatchObject({ value: '[1,2,3,4]', datatype: 'object' });
+    expect(variables.env_array_obj).toMatchObject({ value: [1, 2, 3, 4], dataType: 'object' });
   });
 
-  it('does not set datatype for plain string values', () => {
+  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');
+    expect(variables.env_str).not.toHaveProperty('dataType');
   });
 
-  it('parses secret variables with no value or 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');
+    expect(variables.env_secret_str).not.toHaveProperty('dataType');
   });
 
-  it('parses secret variables with a type, keeping the value empty and the type in 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' });
+    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', () => {
+  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');
@@ -97,19 +97,19 @@ describe('yml parseEnvironment - typed values', () => {
     expect(yml).not.toContain('name: env_secret_str\n    type:');
   });
 
-  it('serializes datatype back to an OpenCollection { type, data } value', () => {
+  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
+    // 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', () => {
+  it('round-trips value and dataType through parse -> stringify -> parse', () => {
     const env = parseEnvironment(ENV_YML);
     const reparsed = parseEnvironment(stringifyEnvironment(env));
 
@@ -118,44 +118,5 @@ describe('yml parseEnvironment - typed values', () => {
   });
 });
 
-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);
-  });
-});
+// External-secrets parsing/serialization is covered in parseEnvironment.spec.ts and
+// stringifyEnvironment.spec.ts against the strict { type, variables } model.

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

@@ -0,0 +1,160 @@
+import parseEnvironment from '../parseEnvironment';
+
+describe('yml env parser', () => {
+  it('should parse empty variables', () => {
+    const input = `name: test\n`;
+
+    const output = parseEnvironment(input);
+
+    expect(output.name).toBe('test');
+    expect(output.variables).toEqual([]);
+    expect(output.externalSecrets).toBeUndefined();
+    expect(output.color).toBeNull();
+  });
+
+  it('should parse multiple regular variables with disabled flag', () => {
+    const input = `name: test
+variables:
+  - name: url
+    value: http://localhost:3000
+  - name: port
+    value: "3000"
+    disabled: true
+`;
+
+    const output = parseEnvironment(input);
+
+    expect(output.variables).toHaveLength(2);
+    expect(output.variables[0]).toMatchObject({ name: 'url', value: 'http://localhost:3000', enabled: true });
+    expect(output.variables[1]).toMatchObject({ name: 'port', value: '3000', enabled: false });
+  });
+
+  it('should parse a secret variable', () => {
+    const input = `name: test
+variables:
+  - secret: true
+    name: token
+`;
+
+    const output = parseEnvironment(input);
+
+    expect(output.variables).toHaveLength(1);
+    expect(output.variables[0]).toMatchObject({
+      name: 'token',
+      value: '',
+      enabled: true,
+      secret: true
+    });
+  });
+
+  it('should parse a hashicorp-vault provider block with disabled entries', () => {
+    const input = `name: test
+variables:
+  - name: url
+    value: http://localhost:3000
+externalSecrets:
+  type: hashicorp-vault-cloud
+  variables:
+    - name: cloudSecret
+      path: secret/data/cloud
+    - name: dbPassword
+      path: secret/data/db-password
+      disabled: true
+`;
+
+    const output = parseEnvironment(input);
+
+    expect(output.variables).toHaveLength(1);
+    expect(output.externalSecrets!.type).toBe('hashicorp-vault-cloud');
+    expect(output.externalSecrets!.variables).toMatchObject([
+      { name: 'cloudSecret', path: 'secret/data/cloud', enabled: true },
+      { name: 'dbPassword', path: 'secret/data/db-password', enabled: false }
+    ]);
+    output.externalSecrets!.variables.forEach((variable: any) => {
+      expect(variable.uid).toMatch(/^[a-zA-Z0-9]{21}$/);
+    });
+  });
+
+  it('should parse an aws-secrets-manager provider block', () => {
+    const input = `name: test
+externalSecrets:
+  type: aws-secrets-manager
+  variables:
+    - name: awsSecret
+      secretName: my-aws-secret
+`;
+
+    const output = parseEnvironment(input);
+
+    expect(output.externalSecrets!.type).toBe('aws-secrets-manager');
+    expect(output.externalSecrets!.variables).toMatchObject([{ name: 'awsSecret', secretName: 'my-aws-secret', enabled: true }]);
+  });
+
+  it('should parse an azure-key-vault provider block', () => {
+    const input = `name: test
+externalSecrets:
+  type: azure-key-vault
+  variables:
+    - name: azureSecret
+      vaultName: my-key-vault
+`;
+
+    const output = parseEnvironment(input);
+
+    expect(output.externalSecrets!.type).toBe('azure-key-vault');
+    expect(output.externalSecrets!.variables).toMatchObject([{ name: 'azureSecret', vaultName: 'my-key-vault', enabled: true }]);
+  });
+
+  it('should keep a half-filled row (a name with an empty identifier)', () => {
+    const input = `name: test
+externalSecrets:
+  type: hashicorp-vault-server
+  variables:
+    - name: good
+      path: secret/data/good
+    - name: bad
+      path: ''
+`;
+
+    const output = parseEnvironment(input);
+
+    expect(output.externalSecrets!.type).toBe('hashicorp-vault-server');
+    expect(output.externalSecrets!.variables).toMatchObject([
+      { name: 'good', path: 'secret/data/good', enabled: true },
+      { name: 'bad', path: '', enabled: true }
+    ]);
+  });
+
+  it('should parse a provider block with no variables', () => {
+    const input = `name: test
+externalSecrets:
+  type: aws-secrets-manager
+`;
+
+    const output = parseEnvironment(input);
+
+    expect(output.externalSecrets!.type).toBe('aws-secrets-manager');
+    expect(output.externalSecrets!.variables).toEqual([]);
+  });
+
+  it('should drop the block for an unknown provider type', () => {
+    const input = `name: test
+externalSecrets:
+  type: made-up-provider
+  variables:
+    - name: x
+      path: p/x
+`;
+
+    const output = parseEnvironment(input);
+    expect(output.externalSecrets).toBeUndefined();
+  });
+
+  it('should default name to Untitled Environment when missing', () => {
+    const input = `variables:\n  - name: foo\n    value: bar\n`;
+
+    const output = parseEnvironment(input);
+
+    expect(output.name).toBe('Untitled Environment');
+  });
+});

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

@@ -0,0 +1,204 @@
+import stringifyEnvironment from '../stringifyEnvironment';
+
+describe('yml env stringifier', () => {
+  it('should stringify empty environment', () => {
+    const output = stringifyEnvironment({
+      uid: 'env1',
+      name: 'test',
+      variables: [],
+      color: null
+    } as any);
+
+    expect(output).toBe('name: test\n');
+  });
+
+  it('should stringify multiple regular variables with disabled flag', () => {
+    const output = stringifyEnvironment({
+      uid: 'env1',
+      name: 'test',
+      variables: [
+        { uid: 'v1', name: 'url', value: 'http://localhost:3000', type: 'text', enabled: true },
+        { uid: 'v2', name: 'port', value: '3000', type: 'text', enabled: false }
+      ],
+      color: null
+    } as any);
+
+    expect(output).toBe(`name: test
+variables:
+  - name: url
+    value: http://localhost:3000
+  - name: port
+    value: "3000"
+    disabled: true
+`);
+  });
+
+  it('should stringify secret variables without their values', () => {
+    const output = stringifyEnvironment({
+      uid: 'env1',
+      name: 'test',
+      variables: [
+        { uid: 'v1', name: 'token', value: 'secret-value-not-persisted', type: 'text', enabled: true, secret: true }
+      ],
+      color: null
+    } as any);
+
+    expect(output).toBe(`name: test
+variables:
+  - secret: true
+    name: token
+`);
+  });
+
+  it('should stringify a hashicorp-vault provider block with disabled entries', () => {
+    const output = stringifyEnvironment({
+      uid: 'env1',
+      name: 'test',
+      variables: [
+        { uid: 'v1', name: 'url', value: 'http://localhost:3000', type: 'text', enabled: true }
+      ],
+      externalSecrets: {
+        type: 'hashicorp-vault-cloud',
+        variables: [
+          { uid: 'e1', name: 'cloudSecret', path: 'secret/data/cloud', enabled: true },
+          { uid: 'e2', name: 'dbPassword', path: 'secret/data/db-password', enabled: false }
+        ]
+      },
+      color: null
+    } as any);
+
+    expect(output).toBe(`name: test
+variables:
+  - name: url
+    value: http://localhost:3000
+externalSecrets:
+  type: hashicorp-vault-cloud
+  variables:
+    - name: cloudSecret
+      path: secret/data/cloud
+    - name: dbPassword
+      path: secret/data/db-password
+      disabled: true
+`);
+  });
+
+  it('should stringify an aws-secrets-manager provider block', () => {
+    const output = stringifyEnvironment({
+      uid: 'env1',
+      name: 'test',
+      variables: [],
+      externalSecrets: {
+        type: 'aws-secrets-manager',
+        variables: [
+          { uid: 'e1', name: 'awsSecret', secretName: 'my-aws-secret', enabled: true }
+        ]
+      },
+      color: null
+    } as any);
+
+    expect(output).toBe(`name: test
+externalSecrets:
+  type: aws-secrets-manager
+  variables:
+    - name: awsSecret
+      secretName: my-aws-secret
+`);
+  });
+
+  it('should stringify an azure-key-vault provider block', () => {
+    const output = stringifyEnvironment({
+      uid: 'env1',
+      name: 'test',
+      variables: [],
+      externalSecrets: {
+        type: 'azure-key-vault',
+        variables: [
+          { uid: 'e1', name: 'azureSecret', vaultName: 'my-key-vault', enabled: true }
+        ]
+      },
+      color: null
+    } as any);
+
+    expect(output).toBe(`name: test
+externalSecrets:
+  type: azure-key-vault
+  variables:
+    - name: azureSecret
+      vaultName: my-key-vault
+`);
+  });
+
+  it('should keep a half-filled row (a name with an empty identifier)', () => {
+    const output = stringifyEnvironment({
+      uid: 'env1',
+      name: 'test',
+      variables: [],
+      externalSecrets: {
+        type: 'hashicorp-vault-server',
+        variables: [
+          { uid: 'e1', name: 'good', path: 'secret/data/good', enabled: true },
+          { uid: 'e2', name: 'bad', path: '', enabled: true }
+        ]
+      },
+      color: null
+    } as any);
+
+    // The half-filled 'bad' row is serialized with an explicit empty identifier, not dropped.
+    expect(output).toContain(`    - name: good
+      path: secret/data/good`);
+    expect(output).toContain(`    - name: bad
+      path: ""`);
+  });
+
+  it('coerces a non-string identifier to a string (matching the parser) instead of dropping it', () => {
+    const output = stringifyEnvironment({
+      uid: 'env1',
+      name: 'test',
+      variables: [],
+      externalSecrets: {
+        type: 'hashicorp-vault-server',
+        variables: [{ uid: 'e1', name: 'num', path: 123, enabled: true }]
+      },
+      color: null
+    } as any);
+
+    // 123 is coerced to '123', not dropped to an empty identifier.
+    expect(output).toContain('123');
+    expect(output).not.toContain(`- name: num
+      path: ""`);
+  });
+
+  it('should emit only the provider block when variables is empty', () => {
+    const output = stringifyEnvironment({
+      uid: 'env1',
+      name: 'test',
+      variables: [],
+      externalSecrets: {
+        type: 'aws-secrets-manager',
+        variables: []
+      },
+      color: null
+    } as any);
+
+    expect(output).toBe(`name: test
+externalSecrets:
+  type: aws-secrets-manager
+  variables: []
+`);
+  });
+
+  it('should not emit the external-secret section for an unknown provider type', () => {
+    const output = stringifyEnvironment({
+      uid: 'env1',
+      name: 'test',
+      variables: [],
+      externalSecrets: {
+        type: 'made-up-provider',
+        variables: [{ uid: 'e1', name: 'x', path: 'p/x', enabled: true }]
+      },
+      color: null
+    } as any);
+
+    expect(output).toBe('name: test\n');
+  });
+});

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

@@ -1,7 +1,7 @@
 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', () => {
+  it('reads a typed value coercing it to its native JS type and records the dataType', () => {
     const ocVariables = [
       { name: 'var_str', value: 'plain' },
       { name: 'var_num', value: { type: 'number', data: '300' } },
@@ -12,16 +12,16 @@ describe('yml variables - typed values (collection / folder / request vars)', ()
     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' });
+    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', () => {
+  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 }
+      { uid: 'u2', name: 'var_num', value: '300', dataType: 'number', enabled: true, local: false }
     ];
 
     const ocVariables = toOpenCollectionVariables(brunoVariables);

package/src/index.ts

@@ -27,6 +27,7 @@ import {
 } from './types';
 import { DEFAULT_COLLECTION_FORMAT } from './constants';
 import { bruRequestParseAndRedactBodyData } from './formats/bru/utils/request-parse-and-redact-body-data';
+import { redactLargeBruTextBlocks, restoreRedactedBlocks } from './formats/bru/utils/redact-large-text-blocks';
 
 // request
 export const parseRequest = (content: string, options: ParseOptions = { format: DEFAULT_COLLECTION_FORMAT }): any => {
@@ -135,6 +136,10 @@ export const parseDotEnv = (content: string): Record<string, string> => {
   return dotenvToJson(content);
 };
 
+export { redactLargeBruTextBlocks, restoreRedactedBlocks };
+export type { RedactedBlock, RedactionResult } from './formats/bru/utils/redact-large-text-blocks';
+export { migrateSecretsJsonToEnvironments } from './utils/secretsJsonToEnvironments';
+
 export { BruParserWorker };
 export * from './types';
 export * from './constants';

package/src/types/bruno-lang.d.ts

@@ -6,4 +6,5 @@ declare module '@usebruno/lang' {
   export function collectionBruToJson(bruContent: string): any;
   export function jsonToCollectionBru(jsonData: any): string;
   export function dotenvToJson(envContent: string): Record<string, string>;
+  export function outdentString(str: string, spaces?: number): string;
 }

package/src/types.ts

@@ -20,3 +20,10 @@ export interface WorkerTask {
 export interface Lane {
   maxSize: number;
 }
+
+export interface BrunoPresetsExtension {
+  request?: {
+    type?: string;
+    url?: string;
+  };
+}