@usebruno/filestore 0.10.0 → 0.12.0

package/src/formats/bru/index.ts

@@ -8,11 +8,26 @@ import {
   jsonToCollectionBru as _jsonToCollectionBru
 } from '@usebruno/lang';
 import { getOauth2AdditionalParameters } from './utils/oauth2-additional-params';
+import { uuid } from '../../utils';
 
 export const parseBruRequest = (data: string | any, parsed: boolean = false): any => {
   try {
     const json = parsed ? data : bruToJsonV2(data);
 
+    if (_.get(json, 'meta.type') === 'app') {
+      const seq = _.get(json, 'meta.seq');
+      const tags = _.get(json, 'meta.tags', []);
+      return {
+        type: 'app',
+        name: _.get(json, 'meta.name'),
+        seq: !_.isNaN(seq) ? Number(seq) : 1,
+        tags: Array.isArray(tags) ? tags : [],
+        settings: _.get(json, 'settings', {}),
+        app: { code: _.get(json, 'app.code', null) },
+        request: null
+      };
+    }
+
     let requestType = _.get(json, 'meta.type');
     switch (requestType) {
       case 'http':
@@ -38,11 +53,18 @@ export const parseBruRequest = (data: string | any, parsed: boolean = false): an
       'ws-request': 'ws.url',
       'default': 'http.url'
     };
+
+    const appData = _.get(json, 'app');
+    const app = appData
+      ? { code: _.get(appData, 'code', null), enabled: _.get(appData, 'enabled', false) === true }
+      : null;
+
     const transformedJson = {
       type: requestType,
       name: _.get(json, 'meta.name'),
       seq: !_.isNaN(sequence) ? Number(sequence) : 1,
       settings: _.get(json, 'settings', {}),
+      app,
       tags: Array.isArray(tags) ? tags : [],
       request: {
         // Preserving special characters in custom methods. Using _.upperCase strips special characters.
@@ -117,6 +139,22 @@ export const parseBruRequest = (data: string | any, parsed: boolean = false): an
 
 export const stringifyBruRequest = (json: any): string => {
   try {
+    // Standalone app item — emit only meta + the app code block.
+    if (_.get(json, 'type') === 'app') {
+      const seq = _.get(json, 'seq');
+      const bruJson: any = {
+        meta: {
+          name: _.get(json, 'name'),
+          type: 'app',
+          seq: !_.isNaN(seq) ? Number(seq) : 1,
+          tags: _.get(json, 'tags', [])
+        },
+        settings: _.get(json, 'settings', {}),
+        app: { code: _.get(json, 'app.code', '') }
+      };
+      return jsonToBruV2(bruJson);
+    }
+
     let type = _.get(json, 'type');
     switch (type) {
       case 'http-request':
@@ -221,6 +259,11 @@ export const stringifyBruRequest = (json: any): string => {
     bruJson.docs = _.get(json, 'request.docs', '');
     bruJson.examples = _.get(json, 'examples', []).map((e: any) => jsonExampleToBru(e));
 
+    const app = _.get(json, 'app');
+    if (app && (app.enabled === true || (app.code && app.code.length))) {
+      bruJson.app = { code: app.code || null, enabled: app.enabled === true };
+    }
+
     const bru = jsonToBruV2(bruJson);
     return bru;
   } catch (error) {
@@ -326,6 +369,15 @@ export const parseBruEnvironment = (bru: string): any => {
       _.each(json.variables, (v: any) => (v.type = 'text'));
     }
 
+    // bruToEnvJsonV2 emits the nested `externalSecrets: { type, variables: [{ name,
+    // <identifier>, enabled }] }`. The app/schema additionally expect a `uid` per variable.
+    if (json?.externalSecrets && Array.isArray(json.externalSecrets.variables)) {
+      json.externalSecrets.variables = json.externalSecrets.variables.map((v: any) => ({
+        uid: uuid(),
+        ...v
+      }));
+    }
+
     return json;
   } catch (error) {
     return Promise.reject(error);

package/src/formats/bru/tests/parseBruEnvironment.spec.js

@@ -0,0 +1,63 @@
+const { parseBruEnvironment } = require('../index');
+
+describe('parseBruEnvironment external secrets normalization', () => {
+  it('should normalize the external secrets block to the app shape with uid and enabled', () => {
+    const bru = `vars {
+}
+vars:externalsecrets:hashicorp-vault-server {
+  secret: secret/data/secret
+  password: secret/data/password
+}
+`;
+
+    const output = parseBruEnvironment(bru);
+
+    expect(output.externalSecrets.type).toBe('hashicorp-vault-server');
+    expect(output.externalSecrets.variables).toHaveLength(2);
+
+    output.externalSecrets.variables.forEach((variable) => {
+      expect(typeof variable.uid).toBe('string');
+      expect(variable.uid).toMatch(/^[a-zA-Z0-9]{21}$/);
+      expect(variable.enabled).toBe(true);
+      expect(variable).not.toHaveProperty('disabled');
+    });
+
+    expect(output.externalSecrets.variables.map(({ name, path, enabled }) => ({ name, path, enabled }))).toEqual([
+      { name: 'secret', path: 'secret/data/secret', enabled: true },
+      { name: 'password', path: 'secret/data/password', enabled: true }
+    ]);
+  });
+
+  it('should map a disabled external secret entry to enabled: false', () => {
+    const bru = `vars:externalsecrets:aws-secrets-manager {
+  active: my-active-secret
+  ~inactive: my-inactive-secret
+}
+`;
+
+    const output = parseBruEnvironment(bru);
+
+    expect(output.externalSecrets.type).toBe('aws-secrets-manager');
+    const variables = output.externalSecrets.variables;
+    expect(variables.map(({ name, secretName, enabled }) => ({ name, secretName, enabled }))).toEqual([
+      { name: 'active', secretName: 'my-active-secret', enabled: true },
+      { name: 'inactive', secretName: 'my-inactive-secret', enabled: false }
+    ]);
+    variables.forEach((variable) => {
+      expect(variable).not.toHaveProperty('disabled');
+      expect(variable.uid).toMatch(/^[a-zA-Z0-9]{21}$/);
+    });
+  });
+
+  it('should leave environments without external secrets unchanged', () => {
+    const bru = `vars {
+  host: localhost
+}
+`;
+
+    const output = parseBruEnvironment(bru);
+
+    expect(output.externalSecrets).toBeUndefined();
+    expect(output.variables).toEqual([{ name: 'host', value: 'localhost', enabled: true, secret: false, type: 'text' }]);
+  });
+});

package/src/formats/bru/tests/redact-large-text-blocks.spec.js

@@ -0,0 +1,472 @@
+const { redactLargeBruTextBlocks, restoreRedactedBlocks } = require('../utils/redact-large-text-blocks');
+const { parseBruRequest, parseBruCollection } = require('../index');
+
+const parseViaRedaction = (content, parser) => {
+  const { skeleton, blocks } = redactLargeBruTextBlocks(content);
+  return restoreRedactedBlocks(parser(skeleton), blocks);
+};
+
+const toCRLF = (content) => content.replace(/\n/g, '\r\n');
+
+const requestBru = `meta {
+  name: Redaction Test
+  type: http
+  seq: 1
+}
+
+get {
+  url: https://example.com/api
+  body: json
+}
+
+headers {
+  content-type: application/json
+}
+
+body:json {
+  {
+    "hello": "world",
+    "nested": {
+      "a": 1,
+      "b": [1, 2, 3]
+    }
+  }
+}
+
+body:text {
+  This is a text body
+  spanning multiple lines
+}
+
+script:pre-request {
+  const x = 1;
+  if (x) {
+    console.log("hi");
+  }
+}
+
+script:post-response {
+  bru.setVar("y", 2);
+}
+
+tests {
+  test("ok", function() {
+    expect(1).to.equal(1);
+  });
+}
+
+docs {
+  # Title
+
+  Some **markdown** docs with a fenced block:
+
+      code line stays indented
+}
+`;
+
+const graphqlBru = `meta {
+  name: GraphQL Test
+  type: graphql
+  seq: 1
+}
+
+post {
+  url: https://example.com/graphql
+  body: graphql
+}
+
+body:graphql {
+  {
+    launchesPast {
+      launch_site {
+        site_name
+      }
+    }
+  }
+}
+
+body:graphql:vars {
+  {
+    "limit": 10
+  }
+}
+`;
+
+const xmlSparqlBru = `meta {
+  name: Others
+  type: http
+  seq: 1
+}
+
+post {
+  url: https://example.com
+  body: xml
+}
+
+body:xml {
+  <xml>
+    <name>John</name>
+  </xml>
+}
+
+body:sparql {
+  SELECT * WHERE {
+    ?s ?p ?o .
+  }
+  LIMIT 10
+}
+`;
+
+const collectionBru = `headers {
+  x-trace: enabled
+}
+
+script:pre-request {
+  bru.setEnvVar("base", "https://example.com");
+}
+
+tests {
+  test("collection level", function() {
+    expect(true).to.equal(true);
+  });
+}
+
+docs {
+  # Collection docs
+
+  Notes for the whole collection.
+}
+`;
+
+const folderBru = `meta {
+  name: My Folder
+  seq: 2
+}
+
+docs {
+  # Folder docs
+}
+`;
+
+const blankLinesBru = `meta {
+  name: Blanks
+  type: http
+  seq: 1
+}
+
+post {
+  url: https://example.com
+  body: json
+}
+
+body:json {
+
+  {
+    "a": 1
+  }
+
+
+}
+`;
+
+const appBru = `meta {
+  name: App Request
+  type: http
+  seq: 1
+}
+
+get {
+  url: https://example.com
+  body: none
+  auth: none
+}
+
+app {
+  enabled: true
+  code: '''
+    <div id="x">hi</div>
+    <style>
+    body {
+      color: red;
+    }
+    </style>
+    <script>
+      function go() {
+        return { ok: 1 };
+      }
+    </script>
+  '''
+}
+
+docs {
+  # Docs after the app block
+}
+`;
+
+const standaloneAppBru = `meta {
+  name: Dashboard
+  type: app
+  seq: 2
+}
+
+app {
+  code: '''
+    <div id="app">standalone</div>
+  '''
+}
+`;
+
+const appWithoutCodeBru = `meta {
+  name: No Code
+  type: http
+  seq: 1
+}
+
+get {
+  url: https://example.com
+  body: none
+  auth: none
+}
+
+app {
+  enabled: true
+}
+`;
+
+const appEmptyCodeBru = `meta {
+  name: Empty Code
+  type: http
+  seq: 1
+}
+
+app {
+  enabled: true
+  code: '''
+  '''
+}
+`;
+
+const docsAboutAppCodeBru = `meta {
+  name: Docs About App Code
+  type: http
+  seq: 1
+}
+
+get {
+  url: https://example.com
+}
+
+docs {
+  # How the app block works
+
+  app {
+    code: '''
+      <div>hi</div>
+    '''
+  }
+}
+`;
+
+const appWithoutCodeThenDocsBru = `meta {
+  name: No Code Then Docs
+  type: http
+  seq: 1
+}
+
+get {
+  url: https://example.com
+}
+
+app {
+  enabled: true
+}
+
+docs {
+  Set the code like this:
+
+  code: '''
+    <div>hi</div>
+  '''
+}
+`;
+
+describe('redactLargeBruTextBlocks', () => {
+  describe('matches a normal parse (ohm oracle)', () => {
+    const requestCases = [
+      ['request with bodies, scripts, tests, docs', requestBru],
+      ['graphql query + variables', graphqlBru],
+      ['xml + sparql bodies', xmlSparqlBru],
+      ['CRLF request', toCRLF(requestBru)],
+      ['leading + trailing blank lines in body', blankLinesBru],
+      ['CRLF leading + trailing blank lines', toCRLF(blankLinesBru)],
+      ['request-level app code', appBru],
+      ['CRLF request-level app code', toCRLF(appBru)],
+      ['standalone app item', standaloneAppBru],
+      ['app block without code', appWithoutCodeBru],
+      ['app block with an empty code value', appEmptyCodeBru],
+      ['docs documenting an app code block', docsAboutAppCodeBru],
+      ['app block without code followed by docs holding a code pair', appWithoutCodeThenDocsBru]
+    ];
+
+    it.each(requestCases)('%s', (_name, content) => {
+      expect(parseViaRedaction(content, parseBruRequest)).toEqual(parseBruRequest(content));
+    });
+
+    const collectionCases = [
+      ['collection', collectionBru],
+      ['folder', folderBru],
+      ['CRLF collection', toCRLF(collectionBru)]
+    ];
+
+    it.each(collectionCases)('%s', (_name, content) => {
+      expect(parseViaRedaction(content, parseBruCollection)).toEqual(parseBruCollection(content));
+    });
+  });
+
+  it('extracts each large text block and shrinks the skeleton', () => {
+    const { skeleton, blocks } = redactLargeBruTextBlocks(requestBru);
+    expect(blocks.length).toBe(6);
+    expect(skeleton.length).toBeLessThan(requestBru.length);
+    blocks.forEach((block) => {
+      expect(skeleton).toContain(block.token);
+      expect(skeleton).not.toContain(block.value);
+    });
+  });
+
+  it('keeps the skeleton bounded regardless of block size', () => {
+    const blob = 'x'.repeat(4 * 1024 * 1024);
+    const bru = `meta {
+  name: Huge
+  type: http
+  seq: 1
+}
+
+post {
+  url: https://example.com
+  body: json
+}
+
+body:json {
+  { "blob": "${blob}" }
+}
+`;
+    const { skeleton, blocks } = redactLargeBruTextBlocks(bru);
+    expect(bru.length).toBeGreaterThan(4 * 1024 * 1024);
+    expect(skeleton.length).toBeLessThan(1024);
+    expect(blocks[0].value).toContain(blob);
+  });
+
+  it('keeps huge app code out of the skeleton, pair and delimiters intact', () => {
+    const blob = 'x'.repeat(4 * 1024 * 1024);
+    const bru = appBru.replace('<div id="x">hi</div>', `<div>${blob}</div>`);
+
+    const { skeleton, blocks } = redactLargeBruTextBlocks(bru);
+    expect(skeleton.length).toBeLessThan(1024);
+    expect(skeleton).toMatch(/code: '''\n\s+__BRU_REDACTED_TEXT_BLOCK_\w+__\n\s+'''/);
+    expect(skeleton).toContain('enabled: true');
+    expect(blocks.some((block) => block.value.includes(blob))).toBe(true);
+  });
+
+  it('leaves an app block whose code has no value untouched', () => {
+    const { blocks } = redactLargeBruTextBlocks(appEmptyCodeBru);
+    expect(blocks).toEqual([]);
+  });
+
+  it('leaves a code pair outside the app block untouched', () => {
+    const { blocks } = redactLargeBruTextBlocks(docsAboutAppCodeBru);
+    expect(blocks.length).toBe(1);
+    expect(blocks[0].value).toContain("code: '''");
+    expect(blocks[0].value).toContain('<div>hi</div>');
+    expect(blocks[0].value).not.toContain('__BRU_REDACTED_TEXT_BLOCK_');
+  });
+
+  it('leaves a code pair after an app block that has no code untouched', () => {
+    const { blocks } = redactLargeBruTextBlocks(appWithoutCodeThenDocsBru);
+    expect(blocks.length).toBe(1);
+    expect(blocks[0].value).toContain("code: '''");
+    expect(blocks[0].value).not.toContain('__BRU_REDACTED_TEXT_BLOCK_');
+  });
+
+  it('leaves dictionary body blocks untouched', () => {
+    const multipart = `meta {
+  name: Multipart
+  type: http
+  seq: 1
+}
+
+post {
+  url: https://example.com
+  body: multipartForm
+}
+
+body:multipart-form {
+  field: value
+}
+`;
+    const { blocks } = redactLargeBruTextBlocks(multipart);
+    expect(blocks.length).toBe(0);
+    expect(parseViaRedaction(multipart, parseBruRequest)).toEqual(parseBruRequest(multipart));
+  });
+
+  it('captures nested braces in content without ending the block early', () => {
+    const nested = `body:json {
+  {
+    "a": {
+      "b": [ { "c": 1 } ],
+      "d": {}
+    }
+  }
+}
+
+script:pre-request {
+  function outer() {
+    if (true) {
+      return { ok: 1 };
+    }
+  }
+}
+`;
+    const { blocks } = redactLargeBruTextBlocks(nested);
+    expect(blocks.length).toBe(2);
+    expect(blocks[0].value).toContain('"c": 1');
+    expect(blocks[0].value).toContain('"d": {}');
+    expect(blocks[1].value).toContain('return { ok: 1 };');
+    expect(parseViaRedaction(nested, parseBruRequest)).toEqual(parseBruRequest(nested));
+  });
+
+  it('only redacts blocks at column 0, never indented tags', () => {
+    const indented = `docs {
+  Nested pseudo-block should be treated as content:
+    body:json {
+      { "a": 1 }
+    }
+}
+`;
+    const { blocks } = redactLargeBruTextBlocks(indented);
+    expect(blocks.length).toBe(1);
+    expect(blocks[0].value).toContain('body:json {');
+  });
+
+  it('returns content unchanged when no large text blocks are present', () => {
+    const minimal = `meta {
+  name: Bare
+  type: http
+  seq: 1
+}
+
+get {
+  url: https://example.com
+}
+`;
+    const { skeleton, blocks } = redactLargeBruTextBlocks(minimal);
+    expect(blocks).toEqual([]);
+    expect(skeleton).toBe(minimal);
+  });
+});
+
+describe('restoreRedactedBlocks', () => {
+  it('returns the parsed object unchanged when there are no blocks', () => {
+    const parsed = { request: { body: { json: 'x' } } };
+    expect(restoreRedactedBlocks(parsed, [])).toBe(parsed);
+  });
+});