@usebruno/filestore 0.1.0 → 0.2.0

package/src/formats/bru/tests/fixtures/oauth2-additional-params.js

@@ -0,0 +1,116 @@
+const getBruJsonWithAdditionalParams = (grantType) => ({
+  "meta": {
+    "name": "OAuth2 Additional Params Test",
+    "type": "http",
+    "seq": 1
+  },
+  "http": {
+    "method": "get",
+    "url": "https://api.usebruno.com/protected"
+  },
+  "auth": {
+    "oauth2": {
+      "grantType": grantType,
+    },
+  },
+  "oauth2_additional_parameters_auth_req_headers": [
+    {
+      "name": "auth-header",
+      "value": "auth-header-value",
+      "enabled": true
+    },
+    {
+      "name": "disabled-auth-header",
+      "value": "disabled-auth-header-value",
+      "enabled": false
+    }
+  ],
+  "oauth2_additional_parameters_auth_req_queryparams": [
+    {
+      "name": "auth-query-param",
+      "value": "auth-query-param-value",
+      "enabled": true
+    },
+    {
+      "name": "disabled-auth-query-param",
+      "value": "disabled-auth-query-param-value",
+      "enabled": false
+    }
+  ],
+  "oauth2_additional_parameters_access_token_req_headers": [
+    {
+      "name": "token-header",
+      "value": "token-header-value",
+      "enabled": true
+    },
+    {
+      "name": "disabled-token-header",
+      "value": "disabled-token-header-value",
+      "enabled": false
+    }
+  ],
+  "oauth2_additional_parameters_access_token_req_queryparams": [
+    {
+      "name": "token-query-param",
+      "value": "token-query-param-value",
+      "enabled": true
+    },
+    {
+      "name": "disabled-token-query-param",
+      "value": "disabled-token-query-param-value",
+      "enabled": false
+    }
+  ],
+  "oauth2_additional_parameters_access_token_req_bodyvalues": [
+    {
+      "name": "token-body",
+      "value": "token-body-value",
+      "enabled": true
+    },
+    {
+      "name": "disabled-token-body",
+      "value": "disabled-token-body-value",
+      "enabled": false
+    }
+  ],
+  "oauth2_additional_parameters_refresh_token_req_headers": [
+    {
+      "name": "refresh-header",
+      "value": "refresh-header-value",
+      "enabled": true
+    },
+    {
+      "name": "disabled-refresh-header",
+      "value": "disabled-refresh-header-value",
+      "enabled": false
+    }
+  ],
+  "oauth2_additional_parameters_refresh_token_req_queryparams": [
+    {
+      "name": "refresh-query-param",
+      "value": "refresh-query-param-value",
+      "enabled": true
+    },
+    {
+      "name": "disabled-refresh-query-param",
+      "value": "disabled-refresh-query-param-value",
+      "enabled": false
+    }
+  ],
+  "oauth2_additional_parameters_refresh_token_req_bodyvalues": [
+    {
+      "name": "refresh-body",
+      "value": "refresh-body-value",
+      "enabled": true
+    },
+    {
+      "name": "disabled-refresh-body",
+      "value": "disabled-refresh-body-value",
+      "enabled": false
+    }
+  ]
+})
+
+export {
+  getBruJsonWithAdditionalParams
+};

package/src/formats/bru/tests/fixtures/request-parse-and-redact-body-data/input.bru

@@ -0,0 +1,66 @@
+meta {
+  name: echo request
+  type: http
+  seq: 1
+}
+
+post {
+  url: https://echo.usebruno.com
+  body: json
+  auth: none
+}
+body:json {
+  {
+    "hello": "world"
+  }
+}
+
+body:text {
+  This is a text body
+}
+body:xml {
+  <xml>
+    <name>John</name>
+    <age>30</age>
+  </xml>
+}
+
+body:sparql {
+  SELECT * WHERE {
+    ?subject ?predicate ?object .
+  }
+  LIMIT 10
+}
+body:graphql {
+  {
+    launchesPast {
+      launch_site {
+        site_name
+      }
+      launch_success
+    }
+  }
+}
+
+body:form-urlencoded {
+  apikey: secret
+  numbers: +91998877665
+  ~message: hello
+}
+
+body:multipart-form {
+  apikey: secret
+  numbers: +91998877665
+  ~message: hello
+}
+body:file {
+  file: @file(path/to/file.json) @contentType(application/json)
+  file: @file(path/to/file.json) @contentType(application/json)
+  ~file: @file(path/to/file2.json) @contentType(application/json)
+}
+
+body:graphql:vars {
+  {
+    "limit": 5
+  }
+}

package/src/formats/bru/tests/fixtures/request-parse-and-redact-body-data/output.bru

@@ -0,0 +1,35 @@
+meta {
+  name: echo request
+  type: http
+  seq: 1
+}
+
+post {
+  url: https://echo.usebruno.com
+  body: json
+  auth: none
+}
+
+body:form-urlencoded {
+  apikey: secret
+  numbers: +91998877665
+  ~message: hello
+}
+
+body:multipart-form {
+  apikey: secret
+  numbers: +91998877665
+  ~message: hello
+}
+
+body:file {
+  file: @file(path/to/file.json) @contentType(application/json)
+  file: @file(path/to/file.json) @contentType(application/json)
+  ~file: @file(path/to/file2.json) @contentType(application/json)
+}
+
+body:graphql:vars {
+  {
+    "limit": 5
+  }
+}

package/src/formats/bru/tests/oauth2-additional-params.spec.js

@@ -0,0 +1,45 @@
+const { getOauth2AdditionalParameters } = require('../utils/oauth2-additional-params');
+const { bruRequestToJson, bruCollectionToJson } = require('../index');
+const { getBruJsonWithAdditionalParams } = require('./fixtures/oauth2-additional-params');
+
+describe('getOauth2AdditionalParameters', () => {
+  it('authorization_code', () => {
+    const additionalParameters = getOauth2AdditionalParameters(getBruJsonWithAdditionalParams('authorization_code'));
+    expect(additionalParameters.authorization).toHaveLength(4);
+    expect(additionalParameters.token).toHaveLength(6);
+    expect(additionalParameters.refresh).toHaveLength(6);
+
+    expect(additionalParameters.authorization.map(p => p.sendIn).sort()).toEqual(['headers', 'headers', 'queryparams', 'queryparams']);
+    expect(additionalParameters.token.map(p => p.sendIn).sort()).toEqual(['body', 'body', 'headers', 'headers', 'queryparams', 'queryparams']);
+    expect(additionalParameters.refresh.map(p => p.sendIn).sort()).toEqual(['body', 'body', 'headers', 'headers', 'queryparams', 'queryparams']);
+  });
+
+  it('client_credentials', () => {
+    const additionalParameters = getOauth2AdditionalParameters(getBruJsonWithAdditionalParams('client_credentials'));
+    expect(additionalParameters.authorization).toBeUndefined();
+    expect(additionalParameters.token).toHaveLength(6);
+    expect(additionalParameters.refresh).toHaveLength(6);
+
+    expect(additionalParameters.token.map(p => p.sendIn).sort()).toEqual(['body', 'body', 'headers', 'headers', 'queryparams', 'queryparams']);
+    expect(additionalParameters.refresh.map(p => p.sendIn).sort()).toEqual(['body', 'body', 'headers', 'headers', 'queryparams', 'queryparams']);
+  });
+
+  it('password', () => {
+    const additionalParameters = getOauth2AdditionalParameters(getBruJsonWithAdditionalParams('password'));
+    expect(additionalParameters.authorization).toBeUndefined();
+    expect(additionalParameters.token).toHaveLength(6);
+    expect(additionalParameters.refresh).toHaveLength(6);
+
+    expect(additionalParameters.token.map(p => p.sendIn).sort()).toEqual(['body', 'body', 'headers', 'headers', 'queryparams', 'queryparams']);
+    expect(additionalParameters.refresh.map(p => p.sendIn).sort()).toEqual(['body', 'body', 'headers', 'headers', 'queryparams', 'queryparams']);
+  });
+
+  it('implicit', () => {
+    const additionalParameters = getOauth2AdditionalParameters(getBruJsonWithAdditionalParams('implicit'));
+    expect(additionalParameters.authorization).toHaveLength(4);
+    expect(additionalParameters.token).toBeUndefined();
+    expect(additionalParameters.refresh).toBeUndefined();
+
+    expect(additionalParameters.authorization.map(p => p.sendIn).sort()).toEqual(['headers', 'headers', 'queryparams', 'queryparams']);
+  });
+});

package/src/formats/bru/tests/request-parse-and-redact-body-data.spec.js

@@ -0,0 +1,44 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const { bruRequestParseAndRedactBodyData } = require("../utils/request-parse-and-redact-body-data");
+
+describe("parse and redact body data", () => {
+  it("should redact body blocks from the bru file string", () => {
+    const fixturesPath = `/fixtures/request-parse-and-redact-body-data`;
+    const inputBruString = fs.readFileSync(path.join(__dirname, fixturesPath, './input.bru'), 'utf8');
+    const expectedOutputBruString = fs.readFileSync(path.join(__dirname, fixturesPath, './output.bru'), 'utf8');
+
+    const res = bruRequestParseAndRedactBodyData(inputBruString);
+    expect(res.bruFileStringWithRedactedBody).toBe(expectedOutputBruString);
+    expect(res.extractedBodyContent).toEqual({
+      graphql: `
+{
+  launchesPast {
+    launch_site {
+      site_name
+    }
+    launch_success
+  }
+}
+      `.trim(),
+      json: `
+{
+  "hello": "world"
+}     
+      `.trim(),
+      sparql: `
+SELECT * WHERE {
+  ?subject ?predicate ?object .
+}
+LIMIT 10
+      `.trim(),
+      text: `This is a text body`, 
+      xml: `
+<xml>
+  <name>John</name>
+  <age>30</age>
+</xml>
+      `.trim()
+    })
+  });
+});

package/src/formats/bru/utils/oauth2-additional-params.ts

@@ -0,0 +1,141 @@
+type T_Oauth2ParameterType = 'authorization' | 'token' | 'refresh';
+type T_Oauth2ParameterSendInType = 'headers' | 'queryparams' | 'body';
+
+export interface T_OAuth2AdditionalParam {
+  name: string;
+  value: string;
+  enabled: boolean;
+  sendIn: T_Oauth2ParameterSendInType
+}
+
+export interface T_OAuth2AdditionalParameters {
+  authorization?: T_OAuth2AdditionalParam[];
+  token?: T_OAuth2AdditionalParam[];
+  refresh?: T_OAuth2AdditionalParam[];
+}
+
+export interface T_Oauth2Auth {
+  grantType: string;
+  additionalParameters?: T_OAuth2AdditionalParameters;
+}
+
+export interface T_BruJson {
+  auth: {
+    oauth2: T_Oauth2Auth;
+  };
+  oauth2_additional_parameters_auth_req_headers?: any[];
+  oauth2_additional_parameters_auth_req_queryparams?: any[];
+  oauth2_additional_parameters_access_token_req_headers?: any[];
+  oauth2_additional_parameters_access_token_req_queryparams?: any[];
+  oauth2_additional_parameters_access_token_req_bodyvalues?: any[];
+  oauth2_additional_parameters_refresh_token_req_headers?: any[];
+  oauth2_additional_parameters_refresh_token_req_queryparams?: any[];
+  oauth2_additional_parameters_refresh_token_req_bodyvalues?: any[];
+}
+
+interface T_Oauth2ParameterMapping {
+  type: T_Oauth2ParameterType;
+  sendIn: T_Oauth2ParameterSendInType;
+  source: keyof T_BruJson;
+}
+
+const PARAMETER_MAPPINGS: T_Oauth2ParameterMapping[] = [
+  // Authorization parameters (only for authorization_code grant type)
+  { type: 'authorization', sendIn: 'headers', source: 'oauth2_additional_parameters_auth_req_headers' },
+  { type: 'authorization', sendIn: 'queryparams', source: 'oauth2_additional_parameters_auth_req_queryparams' },
+  
+  // Token parameters (for all grant types)
+  { type: 'token', sendIn: 'headers', source: 'oauth2_additional_parameters_access_token_req_headers' },
+  { type: 'token', sendIn: 'queryparams', source: 'oauth2_additional_parameters_access_token_req_queryparams' },
+  { type: 'token', sendIn: 'body', source: 'oauth2_additional_parameters_access_token_req_bodyvalues' },
+  
+  // Refresh parameters (for grant types that support refresh)
+  { type: 'refresh', sendIn: 'headers', source: 'oauth2_additional_parameters_refresh_token_req_headers' },
+  { type: 'refresh', sendIn: 'queryparams', source: 'oauth2_additional_parameters_refresh_token_req_queryparams' },
+  { type: 'refresh', sendIn: 'body', source: 'oauth2_additional_parameters_refresh_token_req_bodyvalues' },
+];
+
+/**
+ * Maps source parameters to T_OAuth2AdditionalParam format
+ */
+const mapParametersFromSource = (sourceParams: any[], sendIn: T_Oauth2ParameterSendInType): T_OAuth2AdditionalParam[] => {
+  if (!sourceParams?.length) {
+    return [];
+  }
+  
+  return sourceParams.map(param => ({
+    ...param,
+    sendIn
+  }));
+};
+
+/**
+ * Checks if a parameter type should be included based on grant type
+ */
+const shouldIncludeParameterType = (type: T_Oauth2ParameterType, grantType: string): boolean => {
+  // Authorization parameters are only valid for authorization_code grant type
+  if (type === 'authorization') {
+    return grantType === 'authorization_code' || grantType === 'implicit';
+  }
+
+  if (type === 'token' || type === 'refresh') {
+    return grantType !== 'implicit';
+  }
+  
+  // Token and refresh parameters are valid for all grant types
+  return true;
+};
+
+/**
+ * Collects all parameters for a specific type (authorization, token, or refresh)
+ */
+const collectParametersForType = (
+  json: T_BruJson, 
+  type: T_Oauth2ParameterType, 
+  grantType: string
+): T_OAuth2AdditionalParam[] => {
+  if (!shouldIncludeParameterType(type, grantType)) {
+    return [];
+  }
+
+  const relevantMappings = PARAMETER_MAPPINGS.filter(mapping => mapping.type === type);
+  const allParams: T_OAuth2AdditionalParam[] = [];
+
+  for (const mapping of relevantMappings) {
+    const sourceParams = json[mapping.source] as any[];
+    const mappedParams = mapParametersFromSource(sourceParams, mapping.sendIn);
+    allParams.push(...mappedParams);
+  }
+
+  return allParams;
+};
+
+/**
+ * This function extracts OAuth2 additional parameters from various sources in the bru json data and organizes
+ * them into a structured format based on their usage context (authorization, token, refresh).
+ * 
+ * @param json - json object containing OAuth2 configuration and additional parameters
+ * @returns OAuth2 additional parameters
+ */
+export const getOauth2AdditionalParameters = (json: T_BruJson): T_OAuth2AdditionalParameters  => {
+  const grantType = json.auth.oauth2.grantType;
+  const additionalParameters: T_OAuth2AdditionalParameters = {};
+
+  try {
+    // Collect parameters for each type
+    const parameterTypes: T_Oauth2ParameterType[] = ['authorization', 'token', 'refresh'];
+    
+    for (const type of parameterTypes) {
+      const params = collectParametersForType(json, type, grantType);
+      if (params.length > 0) {
+        additionalParameters[type] = params;
+      }
+    }
+  }
+  catch(error) {
+    console.error(error);
+    console.error("Error while getting the oauth2 additional parameters!");
+  }
+  
+  return additionalParameters;
+};

package/src/formats/bru/utils/request-parse-and-redact-body-data.ts

@@ -0,0 +1,77 @@
+/**
+ * Parses a .bru file and extracts body content while redacting it from the main content
+ * @param {string} bruFileContent - The raw content of the .bru file
+ * @returns {Object} Object containing redacted file content and extracted body data
+ */
+export const bruRequestParseAndRedactBodyData = (bruFileContent: string) => {
+  try {
+    // Define the patterns that indicate the start of different body types
+    const bodyTypePatterns = [
+      "body:json {",
+      "body:text {",
+      "body:xml {",
+      "body:sparql {",
+      "body:graphql {"
+    ];
+
+    // Normalize line endings to LF
+    bruFileContent = (bruFileContent || '').replace(/\r\n/g, '\n');
+
+    const EOL = `\n`;
+
+    /**
+     * Removes the leading 2-space indentation from each line of a string
+     * @param {string} indentedString - The string with leading spaces to remove
+     * @returns {string} The string with indentation removed
+     */
+    const removeLeadingIndentation = (indentedString: string) => {
+      if (!indentedString || !indentedString.length) {
+        return indentedString || '';
+      }
+
+      return indentedString
+        .split(EOL)
+        .map((line) => line.replace(/^  /, ''))
+        .join(EOL);
+    };
+
+    // Split the file content into blocks
+    let fileContentBlocks = bruFileContent.split(`${EOL}}${EOL}`);
+    fileContentBlocks = fileContentBlocks.filter(Boolean).map(_ => _.trim());
+
+    // Extract body blocks and their content
+    const extractedBodyBlocks = fileContentBlocks
+      .filter(block => bodyTypePatterns.some(pattern => block.startsWith(pattern)))
+      .reduce((bodyContentMap: Record<string, string>, bodyBlock) => {
+        // Extract the body type (json, text, xml, etc.) from the first line
+        const firstLine = bodyBlock.split(EOL)[0];
+        const bodyType = firstLine.split(`body:`)[1].split(/\s/)[0];
+        
+        // Extract the body content (everything between the opening and closing braces)
+        const bodyContentLines = bodyBlock.split(EOL).slice(1);
+        const rawBodyContent = bodyContentLines.join(EOL);
+        
+        // Remove indentation from the body content
+        const cleanBodyContent = removeLeadingIndentation(rawBodyContent);
+        
+        bodyContentMap[bodyType] = cleanBodyContent;
+        return bodyContentMap;
+      }, {});
+
+    // Filter out body blocks to get the remaining file content
+    const fileContentWithoutBodyBlocks = fileContentBlocks.filter(block => 
+      !bodyTypePatterns.some(pattern => block.startsWith(pattern))
+    );
+
+    return {
+      bruFileStringWithRedactedBody: fileContentWithoutBodyBlocks.join(`${EOL}}${EOL}${EOL}`).concat(`${EOL}}${EOL}`),
+      extractedBodyContent: extractedBodyBlocks
+    };
+  } catch (error) {
+    console.error('Error parsing and redacting body data:', error);
+    return {
+      bruFileStringWithRedactedBody: bruFileContent,
+      extractedBodyContent: {}
+    };
+  }
+};

package/src/index.ts

@@ -15,6 +15,7 @@ import {
   ParsedCollection,
   ParsedEnvironment
 } from './types';
+import { bruRequestParseAndRedactBodyData } from './formats/bru/utils/request-parse-and-redact-body-data';
 
 export const parseRequest = (content: string, options: ParseOptions = { format: 'bru' }): any => {
   if (options.format === 'bru') {
@@ -23,6 +24,13 @@ export const parseRequest = (content: string, options: ParseOptions = { format:
   throw new Error(`Unsupported format: ${options.format}`);
 };
 
+export const parseRequestAndRedactBody = (content: string, options: ParseOptions = { format: 'bru' }): any => {
+  if (options.format === 'bru') {
+    return bruRequestParseAndRedactBodyData(content);
+  }
+  throw new Error(`Unsupported format: ${options.format}`);
+};
+
 export const stringifyRequest = (requestObj: ParsedRequest, options: StringifyOptions = { format: 'bru' }): string => {
   if (options.format === 'bru') {
     return jsonRequestToBru(requestObj);