@usebruno/filestore 0.11.0 → 0.13.0

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

@@ -92,6 +92,53 @@ body:graphql:vars {
 }
 `;
 
+const grpcBru = `meta {
+  name: gRPC Test
+  type: grpc
+  seq: 1
+}
+
+grpc {
+  url: grpc://localhost:50051
+  method: /hello.Greeter/SayHello
+  methodType: unary
+}
+
+body:grpc {
+  name: message 1
+  content: '''
+    {
+      "greeting": "hi"
+    }
+  '''
+}
+
+script:grpc:before-call-start {
+  const startedAt = 1;
+  if (startedAt) {
+    bru.setVar("startedAt", startedAt);
+  }
+}
+
+script:grpc:after-call-end {
+  bru.setVar("endedAt", 2);
+}
+
+script:grpc:before-message-send {
+  bru.setVar("sentAt", bru.grpc.request.message.timestamp);
+}
+
+script:grpc:after-message-receive {
+  bru.setVar("receivedAt", bru.grpc.response.message.timestamp);
+}
+
+tests {
+  test("hook ran", function() {
+    expect(bru.getVar("startedAt")).to.equal(1);
+  });
+}
+`;
+
 const xmlSparqlBru = `meta {
   name: Others
   type: http
@@ -169,15 +216,145 @@ body:json {
 }
 `;
 
+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],
+      ['grpc request with lifecycle hooks', grpcBru],
+      ['CRLF grpc request with lifecycle hooks', toCRLF(grpcBru)],
       ['CRLF request', toCRLF(requestBru)],
       ['leading + trailing blank lines in body', blankLinesBru],
-      ['CRLF leading + trailing blank lines', toCRLF(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) => {
@@ -205,6 +382,17 @@ describe('redactLargeBruTextBlocks', () => {
     });
   });
 
+  it('extracts the grpc lifecycle hooks and leaves the dictionary message block in place', () => {
+    const { skeleton, blocks } = redactLargeBruTextBlocks(grpcBru);
+    // all four lifecycle hooks + tests; `body:grpc` is a dictionary and stays in the skeleton
+    expect(blocks.length).toBe(5);
+    expect(skeleton.length).toBeLessThan(grpcBru.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 {
@@ -228,6 +416,37 @@ body:json {
     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

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

@@ -20,6 +20,10 @@ const BLOCK_TAGS = [
   'body:sparql',
   'script:pre-request',
   'script:post-response',
+  'script:grpc:before-call-start',
+  'script:grpc:before-message-send',
+  'script:grpc:after-message-receive',
+  'script:grpc:after-call-end',
   'tests',
   'docs',
   'body'
@@ -41,6 +45,47 @@ const tokenFor = (content: string): string => {
 const blockValue = (content: string[]): string =>
   outdentString(content.join('\n').replace(/^(?:\r?\n)+/, '').replace(/\r$/, ''));
 
+const APP_BLOCK_OPENING = /^app[ \t]*\{\r?$/;
+const MULTILINE_DELIMITER = '\'\'\'';
+const APP_CODE_PAIR = `code: ${MULTILINE_DELIMITER}`;
+
+const appCodeValue = (code: string[]): string =>
+  code.map((line) => line.slice(4)).join('\n').trim();
+
+const redactAppCode = (source: string, blocks: RedactedBlock[]): string => {
+  const lines = source.split('\n');
+
+  const start = lines.findIndex((line) => APP_BLOCK_OPENING.test(line));
+  if (start === -1) {
+    return source;
+  }
+
+  const closingBrace = lines.findIndex((line, index) => index > start && isClosing(line));
+  const end = closingBrace === -1 ? lines.length : closingBrace;
+
+  const opening = lines.findIndex((line, index) => index > start && index < end && line.trim() === APP_CODE_PAIR);
+  if (opening === -1) {
+    return source;
+  }
+
+  const closing = lines.findIndex(
+    (line, index) => index > opening && index < end && line.trim() === MULTILINE_DELIMITER
+  );
+  if (closing === -1) {
+    return source;
+  }
+
+  const code = lines.slice(opening + 1, closing);
+  const value = appCodeValue(code);
+  if (!value.length) {
+    return source;
+  }
+
+  const token = tokenFor(code.join('\n'));
+  blocks.push({ token, value });
+  return [...lines.slice(0, opening + 1), `    ${token}`, ...lines.slice(closing)].join('\n');
+};
+
 export const redactLargeBruTextBlocks = (content: string): RedactionResult => {
   const source = content || '';
   const skeleton: string[] = [];
@@ -49,7 +94,7 @@ export const redactLargeBruTextBlocks = (content: string): RedactionResult => {
   let openTag: string | null = null;
   let openContent: string[] = [];
 
-  for (const line of source.split('\n')) {
+  for (const line of redactAppCode(source, blocks).split('\n')) {
     if (openTag === null && isOpening(line)) {
       openTag = line;
       openContent = [];

package/src/formats/yml/common/omit-headers.spec.ts

@@ -0,0 +1,16 @@
+import { normalizeOmitHeaders } from './omit-headers';
+
+describe('normalizeOmitHeaders', () => {
+  it('normalizes valid omitHeaders lists', () => {
+    expect(normalizeOmitHeaders([' User-Agent ', 'Accept-Encoding'])).toEqual(['User-Agent', 'Accept-Encoding']);
+    expect(normalizeOmitHeaders(['User-Agent', ''])).toEqual(['User-Agent']);
+    expect(normalizeOmitHeaders([null, 42, ' User-Agent '])).toEqual(['User-Agent']);
+  });
+
+  it('returns undefined for empty or invalid input', () => {
+    expect(normalizeOmitHeaders(undefined)).toBeUndefined();
+    expect(normalizeOmitHeaders([])).toBeUndefined();
+    expect(normalizeOmitHeaders(['', '  '])).toBeUndefined();
+    expect(normalizeOmitHeaders(null)).toBeUndefined();
+  });
+});

package/src/formats/yml/common/omit-headers.ts

@@ -0,0 +1,12 @@
+/** Trim omitHeaders; return undefined when there is nothing to save. */
+export const normalizeOmitHeaders = (omitHeaders: unknown): string[] | undefined => {
+  if (!Array.isArray(omitHeaders) || !omitHeaders.length) {
+    return undefined;
+  }
+
+  const names = omitHeaders
+    .map((name) => (typeof name === 'string' ? name.trim() : ''))
+    .filter((name) => name.length > 0);
+
+  return names.length ? names : undefined;
+};

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

@@ -0,0 +1,155 @@
+import { toOpenCollectionScripts, toBrunoScripts } from './scripts';
+import { HTTP_SCRIPT_KEYS, GRPC_SCRIPT_KEYS } from '@usebruno/common';
+
+describe('toOpenCollectionScripts', () => {
+  it('returns undefined when there is nothing to write', () => {
+    expect(toOpenCollectionScripts(null, HTTP_SCRIPT_KEYS)).toBeUndefined();
+    expect(toOpenCollectionScripts(undefined, HTTP_SCRIPT_KEYS)).toBeUndefined();
+    expect(toOpenCollectionScripts({} as any, HTTP_SCRIPT_KEYS)).toBeUndefined();
+    expect(toOpenCollectionScripts({ script: { req: null, res: null }, tests: null } as any, HTTP_SCRIPT_KEYS)).toBeUndefined();
+  });
+
+  it('writes req/res as before-request/after-response for the http keys', () => {
+    const out = toOpenCollectionScripts(
+      { script: { req: 'pre()', res: 'post()' } } as any,
+      HTTP_SCRIPT_KEYS
+    );
+
+    expect(out).toEqual([
+      { type: 'before-request', code: 'pre()' },
+      { type: 'after-response', code: 'post()' }
+    ]);
+  });
+
+  it('writes the grpc lifecycle hooks for the grpc keys', () => {
+    const out = toOpenCollectionScripts(
+      {
+        script: {
+          beforeCallStart: 'before()',
+          beforeMessageSend: 'beforeSend()',
+          afterMessageReceive: 'afterReceive()',
+          afterCallEnd: 'after()'
+        }
+      } as any,
+      GRPC_SCRIPT_KEYS
+    );
+
+    expect(out).toEqual([
+      { type: 'grpc:before-call-start', code: 'before()' },
+      { type: 'grpc:before-message-send', code: 'beforeSend()' },
+      { type: 'grpc:after-message-receive', code: 'afterReceive()' },
+      { type: 'grpc:after-call-end', code: 'after()' }
+    ]);
+  });
+
+  it('drops script slots outside the allowed keys', () => {
+    const script = {
+      req: 'pre()',
+      res: 'post()',
+      beforeCallStart: 'before()',
+      beforeMessageSend: 'beforeSend()',
+      afterMessageReceive: 'afterReceive()',
+      afterCallEnd: 'after()'
+    };
+
+    expect(toOpenCollectionScripts({ script } as any, HTTP_SCRIPT_KEYS)).toEqual([
+      { type: 'before-request', code: 'pre()' },
+      { type: 'after-response', code: 'post()' }
+    ]);
+    expect(toOpenCollectionScripts({ script } as any, GRPC_SCRIPT_KEYS)).toEqual([
+      { type: 'grpc:before-call-start', code: 'before()' },
+      { type: 'grpc:before-message-send', code: 'beforeSend()' },
+      { type: 'grpc:after-message-receive', code: 'afterReceive()' },
+      { type: 'grpc:after-call-end', code: 'after()' }
+    ]);
+  });
+
+  it('returns undefined when every populated slot is gated out', () => {
+    expect(toOpenCollectionScripts({ script: { beforeCallStart: 'before()' } } as any, HTTP_SCRIPT_KEYS)).toBeUndefined();
+    expect(toOpenCollectionScripts({ script: { beforeMessageSend: 'beforeSend()' } } as any, HTTP_SCRIPT_KEYS)).toBeUndefined();
+    expect(toOpenCollectionScripts({ script: { req: 'pre()' } } as any, GRPC_SCRIPT_KEYS)).toBeUndefined();
+  });
+
+  it('trims code and skips whitespace-only scripts', () => {
+    const out = toOpenCollectionScripts(
+      { script: { req: '  pre()  ', res: '   \n  ' }, tests: '  test()  ' } as any,
+      HTTP_SCRIPT_KEYS
+    );
+
+    expect(out).toEqual([
+      { type: 'before-request', code: 'pre()' },
+      { type: 'tests', code: 'test()' }
+    ]);
+  });
+
+  it('writes tests regardless of the allowed keys', () => {
+    expect(toOpenCollectionScripts({ tests: 'test()' } as any, HTTP_SCRIPT_KEYS)).toEqual([
+      { type: 'tests', code: 'test()' }
+    ]);
+    expect(toOpenCollectionScripts({ tests: 'test()' } as any, GRPC_SCRIPT_KEYS)).toEqual([
+      { type: 'tests', code: 'test()' }
+    ]);
+  });
+});
+
+describe('toBrunoScripts', () => {
+  it('returns undefined for null / empty input', () => {
+    expect(toBrunoScripts(null)).toBeUndefined();
+    expect(toBrunoScripts(undefined)).toBeUndefined();
+    expect(toBrunoScripts([])).toBeUndefined();
+  });
+
+  it('maps every known script type to its bruno script slot', () => {
+    expect(
+      toBrunoScripts([
+        { type: 'before-request', code: 'pre()' },
+        { type: 'after-response', code: 'post()' },
+        { type: 'grpc:before-call-start', code: 'before()' },
+        { type: 'grpc:after-call-end', code: 'after()' },
+        { type: 'grpc:before-message-send', code: 'beforeSend()' },
+        { type: 'grpc:after-message-receive', code: 'afterReceive()' },
+        { type: 'tests', code: 'test()' }
+      ])
+    ).toEqual({
+      script: {
+        req: 'pre()',
+        res: 'post()',
+        beforeCallStart: 'before()',
+        afterCallEnd: 'after()',
+        beforeMessageSend: 'beforeSend()',
+        afterMessageReceive: 'afterReceive()'
+      },
+      tests: 'test()'
+    });
+  });
+
+  it('skips entries with no code and returns undefined when none remain', () => {
+    expect(
+      toBrunoScripts([
+        { type: 'before-request', code: '' },
+        { type: 'grpc:before-call-start', code: 'before()' }
+      ])
+    ).toEqual({ script: { beforeCallStart: 'before()' } });
+
+    expect(toBrunoScripts([{ type: 'before-request', code: '' }])).toBeUndefined();
+  });
+
+  it('ignores unrecognized script types', () => {
+    expect(toBrunoScripts([{ type: 'grpc:on-message', code: 'nope()' } as any])).toBeUndefined();
+    expect(
+      toBrunoScripts([
+        { type: 'grpc:on-message', code: 'nope()' } as any,
+        { type: 'before-request', code: 'pre()' }
+      ])
+    ).toEqual({ script: { req: 'pre()' } });
+  });
+
+  it('keeps the last script when a type repeats', () => {
+    expect(
+      toBrunoScripts([
+        { type: 'grpc:before-call-start', code: 'first()' },
+        { type: 'grpc:before-call-start', code: 'second()' }
+      ])
+    ).toEqual({ script: { beforeCallStart: 'second()' } });
+  });
+});

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

@@ -1,24 +1,31 @@
-import type { Scripts, Script } from '@opencollection/types/common/scripts';
+import type { Script as OpenCollectionScript, Scripts } from '@opencollection/types/common/scripts';
 import type { FolderRequest as BrunoFolderRequest } from '@usebruno/schema-types/collection/folder';
 import type { HttpRequest as BrunoHttpRequest } from '@usebruno/schema-types/requests/http';
 import type { WebSocketRequest as BrunoWebSocketRequest } from '@usebruno/schema-types/requests/websocket';
 import type { GrpcRequest as BrunoGrpcRequest } from '@usebruno/schema-types/requests/grpc';
+import type { Script as BrunoScript } from '@usebruno/schema-types/common/scripts';
 
-export const toOpenCollectionScripts = (request: BrunoFolderRequest | BrunoHttpRequest | BrunoWebSocketRequest | BrunoGrpcRequest | null | undefined): Scripts | undefined => {
+export const toOpenCollectionScripts = (request: BrunoFolderRequest | BrunoHttpRequest | BrunoWebSocketRequest | BrunoGrpcRequest | null | undefined, allowedKeys: string[]): Scripts | undefined => {
   const ocScripts: Scripts = [];
+  const script = request?.script as BrunoScript | null | undefined;
+
+  const pushScript = (key: keyof BrunoScript, type: OpenCollectionScript['type'], code: string | null | undefined) => {
+    if (!allowedKeys.includes(key)) {
+      return;
+    }
+    if (!code?.trim().length) {
+      return;
+    }
+    ocScripts.push({ type, code: code.trim() });
+  };
+
+  pushScript('req', 'before-request', script?.req);
+  pushScript('res', 'after-response', script?.res);
+  pushScript('beforeCallStart', 'grpc:before-call-start', script?.beforeCallStart);
+  pushScript('beforeMessageSend', 'grpc:before-message-send', script?.beforeMessageSend);
+  pushScript('afterMessageReceive', 'grpc:after-message-receive', script?.afterMessageReceive);
+  pushScript('afterCallEnd', 'grpc:after-call-end', script?.afterCallEnd);
 
-  if (request?.script?.req?.trim().length) {
-    ocScripts.push({
-      type: 'before-request',
-      code: request.script.req.trim()
-    });
-  }
-  if (request?.script?.res?.trim().length) {
-    ocScripts.push({
-      type: 'after-response',
-      code: request.script.res.trim()
-    });
-  }
   if (request?.tests?.trim().length) {
     ocScripts.push({
       type: 'tests',
@@ -30,7 +37,7 @@ export const toOpenCollectionScripts = (request: BrunoFolderRequest | BrunoHttpR
 };
 
 export const toBrunoScripts = (scripts: Scripts | null | undefined): {
-  script?: { req?: string; res?: string };
+  script?: BrunoScript;
   tests?: string;
 } | undefined => {
   if (!scripts || !Array.isArray(scripts) || scripts.length === 0) {
@@ -38,25 +45,44 @@ export const toBrunoScripts = (scripts: Scripts | null | undefined): {
   }
 
   const brunoScripts: {
-    script?: { req?: string; res?: string };
+    script?: BrunoScript;
     tests?: string;
   } = {};
 
-  for (const script of scripts) {
-    if (script.type === 'before-request' && script.code) {
-      if (!brunoScripts.script) {
-        brunoScripts.script = {};
-      }
-      brunoScripts.script.req = script.code;
+  const setScript = (key: keyof BrunoScript, code: string) => {
+    if (!brunoScripts.script) {
+      brunoScripts.script = {};
     }
-    if (script.type === 'after-response' && script.code) {
-      if (!brunoScripts.script) {
-        brunoScripts.script = {};
-      }
-      brunoScripts.script.res = script.code;
+    brunoScripts.script[key] = code;
+  };
+
+  for (const script of scripts) {
+    if (!script.code) {
+      continue;
     }
-    if (script.type === 'tests' && script.code) {
-      brunoScripts.tests = script.code;
+
+    switch (script.type) {
+      case 'before-request':
+        setScript('req', script.code);
+        break;
+      case 'after-response':
+        setScript('res', script.code);
+        break;
+      case 'grpc:before-call-start':
+        setScript('beforeCallStart', script.code);
+        break;
+      case 'grpc:before-message-send':
+        setScript('beforeMessageSend', script.code);
+        break;
+      case 'grpc:after-message-receive':
+        setScript('afterMessageReceive', script.code);
+        break;
+      case 'grpc:after-call-end':
+        setScript('afterCallEnd', script.code);
+        break;
+      case 'tests':
+        brunoScripts.tests = script.code;
+        break;
     }
   }