@usebruno/filestore 0.10.0 → 0.12.0

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

@@ -0,0 +1,143 @@
+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$/, ''));
+
+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[] = [];
+  const blocks: RedactedBlock[] = [];
+
+  let openTag: string | null = null;
+  let openContent: string[] = [];
+
+  for (const line of redactAppCode(source, blocks).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:

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

@@ -0,0 +1,110 @@
+import {
+  isBrunoVariableDataType,
+  isTypedValue,
+  hasTypedMetadata,
+  toOpenCollectionTypedValue,
+  fromOpenCollectionTypedValue
+} from './datatype';
+
+describe('dataType helpers', () => {
+  describe('isBrunoVariableDataType', () => {
+    it('returns true for supported Bruno datatypes', () => {
+      expect(isBrunoVariableDataType('string')).toBe(true);
+      expect(isBrunoVariableDataType('number')).toBe(true);
+      expect(isBrunoVariableDataType('boolean')).toBe(true);
+      expect(isBrunoVariableDataType('object')).toBe(true);
+    });
+
+    it('returns false for unsupported OpenCollection datatypes (e.g. null)', () => {
+      expect(isBrunoVariableDataType('null')).toBe(false);
+    });
+
+    it('returns false for non-string inputs', () => {
+      expect(isBrunoVariableDataType(undefined)).toBe(false);
+      expect(isBrunoVariableDataType(null)).toBe(false);
+      expect(isBrunoVariableDataType(42)).toBe(false);
+      expect(isBrunoVariableDataType({})).toBe(false);
+    });
+  });
+
+  describe('isTypedValue', () => {
+    it('returns true for OpenCollection typed-value shapes', () => {
+      expect(isTypedValue({ type: 'number', data: '42' })).toBe(true);
+      expect(isTypedValue({ type: 'object', data: '{}' })).toBe(true);
+    });
+
+    it('returns false for plain strings', () => {
+      expect(isTypedValue('hello')).toBe(false);
+      expect(isTypedValue('')).toBe(false);
+    });
+
+    it('returns false for arrays, null, and objects missing type/data', () => {
+      expect(isTypedValue(null)).toBe(false);
+      expect(isTypedValue([])).toBe(false);
+      expect(isTypedValue([{ type: 'number', data: '1' }])).toBe(false);
+      expect(isTypedValue({ type: 'number' })).toBe(false);
+      expect(isTypedValue({ data: '1' })).toBe(false);
+      expect(isTypedValue({})).toBe(false);
+    });
+  });
+
+  describe('hasTypedMetadata', () => {
+    it('returns false when dataType is missing', () => {
+      expect(hasTypedMetadata({})).toBe(false);
+    });
+
+    it('returns false when dataType is the string default', () => {
+      expect(hasTypedMetadata({ dataType: 'string' })).toBe(false);
+    });
+
+    it('returns true for non-string datatypes', () => {
+      expect(hasTypedMetadata({ dataType: 'number' })).toBe(true);
+      expect(hasTypedMetadata({ dataType: 'boolean' })).toBe(true);
+      expect(hasTypedMetadata({ dataType: 'object' })).toBe(true);
+    });
+  });
+
+  describe('toOpenCollectionTypedValue', () => {
+    it('builds a {type, data} struct from dataType + stringified value', () => {
+      expect(toOpenCollectionTypedValue({ dataType: 'number' }, '42'))
+        .toEqual({ type: 'number', data: '42' });
+      expect(toOpenCollectionTypedValue({ dataType: 'boolean' }, 'true'))
+        .toEqual({ type: 'boolean', data: 'true' });
+      expect(toOpenCollectionTypedValue({ dataType: 'object' }, '{"a":1}'))
+        .toEqual({ type: 'object', data: '{"a":1}' });
+    });
+
+    it('falls back to type "string" when dataType is missing', () => {
+      expect(toOpenCollectionTypedValue({}, 'hello'))
+        .toEqual({ type: 'string', data: 'hello' });
+    });
+  });
+
+  describe('fromOpenCollectionTypedValue', () => {
+    it('coerces typed values to their declared dataType', () => {
+      expect(fromOpenCollectionTypedValue({ type: 'number', data: '42' }))
+        .toEqual({ value: 42, dataType: 'number' });
+      expect(fromOpenCollectionTypedValue({ type: 'boolean', data: 'true' }))
+        .toEqual({ value: true, dataType: 'boolean' });
+      expect(fromOpenCollectionTypedValue({ type: 'object', data: '{"a":1}' }))
+        .toEqual({ value: { a: 1 }, dataType: 'object' });
+    });
+
+    it('falls back to string when the declared type is unsupported (e.g. null)', () => {
+      const result = fromOpenCollectionTypedValue({ type: 'null' as any, data: '' });
+      expect(result.dataType).toBeUndefined();
+    });
+
+    it('coerces non-string data to a string before coercing by dataType', () => {
+      const result = fromOpenCollectionTypedValue({ type: 'number', data: 42 as any });
+      expect(result.value).toBe(42);
+      expect(result.dataType).toBe('number');
+    });
+
+    it('returns the raw string when coercion fails (e.g. non-numeric @number)', () => {
+      const result = fromOpenCollectionTypedValue({ type: 'number', data: 'not-a-number' });
+      expect(result.value).toBe('not-a-number');
+      expect(result.dataType).toBe('number');
+    });
+  });
+});

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

@@ -0,0 +1,57 @@
+import type { VariableTypedValue } from '@opencollection/types/common/variables';
+import {
+  parseValueByDataType,
+  BrunoVariableDataType,
+  isBrunoVariableDataType,
+  valueToString
+} from '@usebruno/common/utils';
+
+export { BrunoVariableDataType, isBrunoVariableDataType };
+
+export const serializeVariableValue = (value: unknown): string => {
+  if (value !== null && typeof value === 'object') {
+    return JSON.stringify(value, null, 2);
+  }
+  return valueToString(value);
+};
+
+export const isTypedValue = (value: unknown): value is VariableTypedValue => {
+  return typeof value === 'object'
+    && value !== null
+    && !Array.isArray(value)
+    && 'type' in value
+    && 'data' in value;
+};
+
+export interface TypedVariableFields {
+  dataType?: BrunoVariableDataType;
+}
+
+export const hasTypedMetadata = (v: TypedVariableFields): boolean => {
+  return !!v.dataType && v.dataType !== 'string';
+};
+
+export const toOpenCollectionTypedValue = (
+  v: TypedVariableFields,
+  dataStr: string
+): VariableTypedValue => {
+  return {
+    type: (v.dataType || 'string') as VariableTypedValue['type'],
+    data: dataStr
+  };
+};
+
+// `'string'` is the implicit default — omitted from the result.
+export const fromOpenCollectionTypedValue = (
+  typed: VariableTypedValue
+): { value: any } & TypedVariableFields => {
+  const dataStr = typeof typed.data === 'string' ? typed.data : String(typed.data ?? '');
+  const dataType: BrunoVariableDataType = isBrunoVariableDataType(typed.type) ? typed.type : 'string';
+  const result: { value: any } & TypedVariableFields = {
+    value: parseValueByDataType(dataStr, dataType)
+  };
+  if (dataType !== 'string') {
+    result.dataType = dataType;
+  }
+  return result;
+};

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

@@ -51,6 +51,10 @@ export const toBrunoHttpHeaders = (headers: HttpRequestHeader[] | HttpResponseHe
       enabled: ('disabled' in header) ? header.disabled !== true : true
     };
 
+    if ('description' in header && header.description) {
+      brunoHeader.description = typeof header.description === 'string' ? header.description : (header.description as any)?.content || '';
+    }
+
     return brunoHeader;
   });