@usebruno/filestore 0.9.0 → 0.11.0

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

@@ -0,0 +1,313 @@
+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
+  }
+
+
+}
+`;
+
+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)]
+    ];
+
+    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('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);
+  });
+});

package/src/formats/bru/utils/redact-large-text-blocks.ts

@@ -0,0 +1,102 @@
+import { createHash } from 'node:crypto';
+import { outdentString } from '@usebruno/lang';
+
+export interface RedactedBlock {
+  token: string;
+  value: string;
+}
+
+export interface RedactionResult {
+  skeleton: string;
+  blocks: RedactedBlock[];
+}
+
+const BLOCK_TAGS = [
+  'body:graphql:vars',
+  'body:graphql',
+  'body:json',
+  'body:text',
+  'body:xml',
+  'body:sparql',
+  'script:pre-request',
+  'script:post-response',
+  'tests',
+  'docs',
+  'body'
+];
+
+const BLOCK_OPENING = new RegExp(`^(${BLOCK_TAGS.join('|')})[ \\t]*\\{\\r?$`);
+
+const isOpening = (line: string): boolean => BLOCK_OPENING.test(line);
+
+// A top-level block's closing brace sits at column 0; braces inside the content are indented, so
+// nested braces are correctly treated as content rather than ending the block early.
+const isClosing = (line: string): boolean => line.startsWith('}');
+
+const tokenFor = (content: string): string => {
+  const hash = createHash('sha256').update(content).digest('hex').slice(0, 16);
+  return `__BRU_REDACTED_TEXT_BLOCK_${hash}__`;
+};
+
+const blockValue = (content: string[]): string =>
+  outdentString(content.join('\n').replace(/^(?:\r?\n)+/, '').replace(/\r$/, ''));
+
+export const redactLargeBruTextBlocks = (content: string): RedactionResult => {
+  const source = content || '';
+  const skeleton: string[] = [];
+  const blocks: RedactedBlock[] = [];
+
+  let openTag: string | null = null;
+  let openContent: string[] = [];
+
+  for (const line of source.split('\n')) {
+    if (openTag === null && isOpening(line)) {
+      openTag = line;
+      openContent = [];
+      continue;
+    }
+
+    if (openTag !== null && isClosing(line)) {
+      const token = tokenFor(openContent.join('\n'));
+      blocks.push({ token, value: blockValue(openContent) });
+      skeleton.push(openTag, `  ${token}`, line);
+      openTag = null;
+      continue;
+    }
+
+    (openTag === null ? skeleton : openContent).push(line);
+  }
+
+  if (openTag !== null) {
+    skeleton.push(openTag, ...openContent);
+  }
+
+  if (blocks.some((block) => source.includes(block.token))) {
+    console.warn('[bruno-filestore] Token collision detected; skipping redaction');
+    return { skeleton: source, blocks: [] };
+  }
+
+  return { skeleton: skeleton.join('\n'), blocks };
+};
+
+export const restoreRedactedBlocks = <T>(parsed: T, blocks: RedactedBlock[]): T => {
+  if (!blocks.length) {
+    return parsed;
+  }
+
+  const valueByToken = new Map(blocks.map((block) => [block.token, block.value]));
+
+  const walk = (node: any): any => {
+    if (typeof node === 'string') {
+      return valueByToken.get(node) ?? node;
+    }
+    if (node && typeof node === 'object') {
+      for (const key of Object.keys(node)) {
+        node[key] = walk(node[key]);
+      }
+    }
+    return node;
+  };
+
+  return walk(parsed);
+};

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

@@ -17,7 +17,7 @@ export const toOpenCollectionActions = (resVariables: BrunoVariables | null | un
       type: 'set-variable',
       phase: 'after-response',
       selector: {
-        expression: v.value || '',
+        expression: ensureString(v.value),
         method: 'jsonq'
       },
       variable: {

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

@@ -0,0 +1,27 @@
+import type { App as BrunoApp } from '@usebruno/schema-types/collection/item';
+
+export interface OpenCollectionApp {
+  enabled?: boolean;
+  code?: string;
+}
+
+export const toOpenCollectionApp = (app: BrunoApp | null | undefined): OpenCollectionApp | undefined => {
+  // The app block persists when enabled even before any code is written.
+  if (!app || (!app.code && app.enabled !== true)) return undefined;
+  const ocApp: OpenCollectionApp = {};
+  if (app.enabled === true) {
+    ocApp.enabled = true;
+  }
+  if (app.code) {
+    ocApp.code = app.code;
+  }
+  return ocApp;
+};
+
+export const toBrunoApp = (app: OpenCollectionApp | null | undefined): BrunoApp | null => {
+  if (!app) return null;
+  return {
+    enabled: app.enabled === true,
+    code: app.code || null
+  };
+};

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

@@ -13,6 +13,20 @@ import type { Auth as BrunoAuth, AuthOauth1 as BrunoAuthOauth1 } from '@usebruno
 import { isString } from '../../../utils';
 import { toOpenCollectionOAuth2, toBrunoOAuth2 } from './auth-oauth2';
 
+// EdgeGrid is a Bruno-specific auth mode that is not part of the OpenCollection spec,
+// so its shape is defined locally and serialized using the same field names as Bruno.
+interface AkamaiEdgeGridAuthValues {
+  type: 'akamai-edgegrid';
+  accessToken?: string;
+  clientToken?: string;
+  clientSecret?: string;
+  baseURL?: string | null;
+  nonce?: string | null;
+  timestamp?: string | null;
+  headersToSign?: string | null;
+  maxBodySize?: number | null;
+}
+
 const buildAwsV4Auth = (config?: BrunoAuth['awsv4']): AuthAwsV4 => {
   const auth: AuthAwsV4 = { type: 'awsv4' };
 
@@ -116,6 +130,25 @@ const buildApiKeyAuth = (config?: BrunoAuth['apikey']): AuthApiKey => {
   return auth;
 };
 
+const buildEdgeGridAuth = (config?: BrunoAuth['akamaiEdgegrid']): AkamaiEdgeGridAuthValues => {
+  const auth: AkamaiEdgeGridAuthValues = { type: 'akamai-edgegrid' };
+
+  if (!config) {
+    return auth;
+  }
+
+  if (isString(config.accessToken)) auth.accessToken = config.accessToken;
+  if (isString(config.clientToken)) auth.clientToken = config.clientToken;
+  if (isString(config.clientSecret)) auth.clientSecret = config.clientSecret;
+  if (isString(config.nonce)) auth.nonce = config.nonce;
+  if (isString(config.timestamp)) auth.timestamp = config.timestamp;
+  if (isString(config.baseURL)) auth.baseURL = config.baseURL;
+  if (isString(config.headersToSign)) auth.headersToSign = config.headersToSign;
+  if (typeof config.maxBodySize === 'number') auth.maxBodySize = config.maxBodySize;
+
+  return auth;
+};
+
 const buildOAuth1Auth = (config?: BrunoAuth['oauth1']): AuthOAuth1 => {
   const auth: AuthOAuth1 = { type: 'oauth1' };
 
@@ -173,6 +206,8 @@ export const toOpenCollectionAuth = (auth?: BrunoAuth | null): Auth | undefined
       return buildOAuth1Auth(auth.oauth1);
     case 'oauth2':
       return toOpenCollectionOAuth2(auth.oauth2);
+    case 'akamai-edgegrid':
+      return buildEdgeGridAuth(auth.akamaiEdgegrid) as unknown as Auth;
     default:
       console.warn(`toOpenCollectionAuth failed: Unsupported auth mode "${auth.mode}".`);
       return undefined;
@@ -189,7 +224,8 @@ export const toBrunoAuth = (auth: Auth | null | undefined): BrunoAuth | null =>
     ntlm: null,
     oauth2: null,
     wsse: null,
-    apikey: null
+    apikey: null,
+    akamaiEdgegrid: null
   };
 
   if (!auth) {
@@ -201,6 +237,22 @@ export const toBrunoAuth = (auth: Auth | null | undefined): BrunoAuth | null =>
     return brunoAuth;
   }
 
+  if ((auth as unknown as AkamaiEdgeGridAuthValues).type === 'akamai-edgegrid') {
+    const edgegrid = auth as unknown as AkamaiEdgeGridAuthValues;
+    brunoAuth.mode = 'akamai-edgegrid';
+    brunoAuth.akamaiEdgegrid = {
+      accessToken: edgegrid.accessToken || '',
+      clientToken: edgegrid.clientToken || '',
+      clientSecret: edgegrid.clientSecret || '',
+      nonce: edgegrid.nonce || '',
+      timestamp: edgegrid.timestamp || '',
+      baseURL: edgegrid.baseURL || '',
+      headersToSign: edgegrid.headersToSign || '',
+      maxBodySize: typeof edgegrid.maxBodySize === 'number' ? edgegrid.maxBodySize : null
+    };
+    return brunoAuth;
+  }
+
   switch (auth.type) {
     case 'awsv4':
       brunoAuth.mode = 'awsv4';

package/src/formats/yml/common/body.spec.ts

@@ -0,0 +1,62 @@
+import { toOpenCollectionBody, toBrunoBody } from './body';
+
+describe('file body description', () => {
+  it('toOpenCollectionBody: preserves description, omits when absent or whitespace-only', () => {
+    const out = toOpenCollectionBody({
+      mode: 'file',
+      file: [
+        { uid: 'f1', filePath: '/tmp/readme.pdf', contentType: 'application/pdf', selected: true, description: 'Upload doc' },
+        { uid: 'f2', filePath: '/tmp/other.bin', contentType: 'application/octet-stream', selected: false },
+        { uid: 'f3', filePath: '/tmp/plain.bin', contentType: 'application/octet-stream', selected: false, description: '   ' }
+      ]
+    } as any);
+
+    expect(out?.type).toBe('file');
+    expect(out?.data).toHaveLength(3);
+    expect(out?.data[0]).toMatchObject({ filePath: '/tmp/readme.pdf', description: 'Upload doc' });
+    expect(out?.data[1]).not.toHaveProperty('description');
+    expect(out?.data[2]).not.toHaveProperty('description');
+  });
+
+  it('toBrunoBody: parses description from file body entries', () => {
+    const out = toBrunoBody({
+      type: 'file',
+      data: [
+        { filePath: '/tmp/readme.pdf', contentType: 'application/pdf', selected: true, description: 'Upload doc' },
+        { filePath: '/tmp/other.bin', contentType: 'application/octet-stream', selected: false }
+      ]
+    } as any);
+
+    expect(out?.mode).toBe('file');
+    expect(out?.file).toHaveLength(2);
+
+    // already fails on the length check above if no bodies are recieved, the if below is just
+    // to satisfy typescript and then validate the content of the files
+    if (out?.file) {
+      expect(out?.file[0]).toMatchObject({ filePath: '/tmp/readme.pdf', description: 'Upload doc' });
+      expect(out?.file[1].description).toBeFalsy();
+    }
+  });
+
+  it('round-trips file body descriptions through OC conversion', () => {
+    const brunoBody = {
+      mode: 'file',
+      file: [
+        { uid: 'f1', filePath: '/tmp/readme.pdf', contentType: 'application/pdf', selected: true, description: 'Upload doc' },
+        { uid: 'f2', filePath: '/tmp/other.bin', contentType: 'application/octet-stream', selected: false }
+      ]
+    } as any;
+
+    const oc = toOpenCollectionBody(brunoBody);
+    const back = toBrunoBody(oc);
+
+    expect(back?.file).toHaveLength(2);
+
+    // already fails on the length check above if no bodies are recieved, the if below is just
+    // to satisfy typescript and then validate the content of the files
+    if (back?.file) {
+      expect(back?.file[0]).toMatchObject({ filePath: '/tmp/readme.pdf', description: 'Upload doc' });
+      expect(back?.file[1].description).toBeFalsy();
+    }
+  });
+});

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

@@ -7,8 +7,10 @@ import type {
   MultipartFormBody,
   MultipartFormEntry,
   FileBody,
-  FileBodyEntry
+  FileBodyVariant
 } from '@opencollection/types/requests/http';
+import type { FileEntry as BrunoFileEntry } from '@usebruno/schema-types/common/file';
+
 import type { KeyValue as BrunoKeyValue } from '@usebruno/schema-types/common/key-value';
 import { uuid, ensureString } from '../../../utils';
 
@@ -103,12 +105,18 @@ export const toOpenCollectionBody = (body: BrunoHttpRequestBody | null | undefin
       return multipartBody;
 
     case 'file':
-      const fileEntries: FileBodyEntry[] = body.file?.map((file): FileBodyEntry => {
-        return {
+      const fileEntries: FileBodyVariant[] = body.file?.map((file): FileBodyVariant => {
+        const fileEntry: FileBodyVariant = {
           filePath: file.filePath || '',
           contentType: file.contentType || '',
           selected: file.selected ?? false
         };
+
+        if (file?.description?.trim().length) {
+          fileEntry.description = file.description;
+        }
+
+        return fileEntry;
       }) || [];
 
       const fileBody: FileBody = {
@@ -222,12 +230,22 @@ export const toBrunoBody = (body: HttpRequestBody | null | undefined): BrunoHttp
 
     case 'file':
       brunoBody.mode = 'file';
-      brunoBody.file = body.data?.map((file): any => ({
-        uid: uuid(),
-        filePath: file.filePath || '',
-        contentType: file.contentType || '',
-        selected: file.selected ?? false
-      })) || [];
+      brunoBody.file = body.data?.map((file): BrunoFileEntry => {
+        const fileEntry: BrunoFileEntry = {
+          uid: uuid(),
+          filePath: file.filePath || '',
+          contentType: file.contentType || '',
+          selected: file.selected ?? false
+        };
+
+        const fileWithDescription = file as FileBodyVariant;
+        const desc = typeof fileWithDescription.description === 'string'
+          ? fileWithDescription.description
+          : (fileWithDescription.description as { content?: string } | undefined)?.content;
+        if (desc && desc.trim().length) fileEntry.description = desc;
+
+        return fileEntry;
+      }) || [];
       break;
 
     default: