@usebruno/filestore 0.10.0 → 0.12.0

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,230 @@
+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 stringify a gcp-secrets-manager provider block, one row per project', () => {
+    const output = stringifyEnvironment({
+      uid: 'env1',
+      name: 'test',
+      variables: [],
+      externalSecrets: {
+        type: 'gcp-secrets-manager',
+        variables: [
+          { uid: 'e1', name: 'staging', projectId: 'my-staging-project', enabled: true },
+          { uid: 'e2', name: 'prod', projectId: 'my-prod-project', enabled: true }
+        ]
+      },
+      color: null
+    } as any);
+
+    expect(output).toBe(`name: test
+externalSecrets:
+  type: gcp-secrets-manager
+  variables:
+    - name: staging
+      projectId: my-staging-project
+    - name: prod
+      projectId: my-prod-project
+`);
+  });
+
+  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/formats/yml/utils.ts

@@ -1,7 +1,7 @@
 import * as YAML from 'yaml';
 
 // Top-level keys that should have a blank line before them
-const BLOCK_KEYS = ['info', 'http', 'graphql', 'grpc', 'websocket', 'runtime', 'settings', 'examples', 'docs', 'items', 'request'];
+const BLOCK_KEYS = ['info', 'http', 'graphql', 'grpc', 'websocket', 'mock', 'routes', 'runtime', 'settings', 'examples', 'docs', 'items', 'request'];
 
 export const stringifyYml = (obj: any): string => {
   const yamlStr = YAML.stringify(obj, {

package/src/index.ts

@@ -13,10 +13,12 @@ import {
   parseYmlCollection,
   parseYmlFolder,
   parseYmlEnvironment,
+  parseYmlMockServer,
   stringifyYmlItem,
   stringifyYmlFolder,
   stringifyYmlCollection,
-  stringifyYmlEnvironment
+  stringifyYmlEnvironment,
+  stringifyYmlMockServer
 } from './formats/yml';
 import { dotenvToJson } from '@usebruno/lang';
 import BruParserWorker from './workers';
@@ -27,6 +29,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 => {
@@ -74,6 +77,22 @@ export const stringifyRequestViaWorker = async (requestObj: any, options: { form
   return await fileParserWorker.stringifyRequest(requestObj, options.format);
 };
 
+export const parseFolderViaWorker = async (content: string, options: { format: CollectionFormat }): Promise<any> => {
+  return await getWorkerInstance().parseFolder(content, options.format);
+};
+
+export const stringifyFolderViaWorker = async (folderObj: any, options: { format: CollectionFormat }): Promise<string> => {
+  return await getWorkerInstance().stringifyFolder(folderObj, options.format);
+};
+
+export const parseEnvironmentViaWorker = async (content: string, options: { format: CollectionFormat }): Promise<any> => {
+  return await getWorkerInstance().parseEnvironment(content, options.format);
+};
+
+export const stringifyEnvironmentViaWorker = async (envObj: any, options: { format: CollectionFormat }): Promise<string> => {
+  return await getWorkerInstance().stringifyEnvironment(envObj, options.format);
+};
+
 // collection
 export const parseCollection = (content: string, options: ParseOptions = { format: DEFAULT_COLLECTION_FORMAT }): any => {
   if (options.format === 'bru') {
@@ -131,10 +150,29 @@ export const stringifyEnvironment = (envObj: BrunoEnvironment, options: Stringif
   throw new Error(`Unsupported format: ${options.format}`);
 };
 
+// mock server — workspace-level entity, opencollection yml only
+export const parseMockServer = (content: string, options: ParseOptions = { format: 'yml' }): any => {
+  if (options.format === 'yml') {
+    return parseYmlMockServer(content);
+  }
+  throw new Error(`Unsupported format: ${options.format}`);
+};
+
+export const stringifyMockServer = (mockServerObj: any, options: StringifyOptions = { format: 'yml' }): string => {
+  if (options.format === 'yml') {
+    return stringifyYmlMockServer(mockServerObj);
+  }
+  throw new Error(`Unsupported format: ${options.format}`);
+};
+
 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,11 @@ export interface WorkerTask {
 export interface Lane {
   maxSize: number;
 }
+
+export interface BrunoPresetsExtension {
+  request?: {
+    type?: string;
+    url?: string;
+  };
+  defaultEnvironment?: string;
+}