@usebruno/filestore 0.9.0 → 0.11.0

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

@@ -0,0 +1,122 @@
+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('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('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_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' });
+  });
+
+  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));
+  });
+});
+
+// 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

@@ -0,0 +1,34 @@
+import { toBrunoVariables, toOpenCollectionVariables } from '../common/variables';
+
+describe('yml variables - typed values (collection / folder / request vars)', () => {
+  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' } },
+      { 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' } }
+    ]);
+  });
+});

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;
+  };
+}