@usebruno/filestore 0.5.0 → 0.6.0

package/src/formats/bru/index.ts

@@ -9,7 +9,7 @@ import {
 } from '@usebruno/lang';
 import { getOauth2AdditionalParameters } from './utils/oauth2-additional-params';
 
-export const bruRequestToJson = (data: string | any, parsed: boolean = false): any => {
+export const parseBruRequest = (data: string | any, parsed: boolean = false): any => {
   try {
     const json = parsed ? data : bruToJsonV2(data);
 
@@ -109,12 +109,12 @@ export const bruRequestToJson = (data: string | any, parsed: boolean = false): a
     }
     return transformedJson;
   } catch (error) {
-    console.log('bruRequestToJson error', error);
+    console.log('parseBruRequest error', error);
     throw error;
   }
 };
 
-export const jsonRequestToBru = (json: any): string => {
+export const stringifyBruRequest = (json: any): string => {
   try {
     let type = _.get(json, 'type');
     switch (type) {
@@ -160,8 +160,8 @@ export const jsonRequestToBru = (json: any): string => {
         mode: 'json',
         json: '{}'
       });
-    } // For gRPC, add gRPC-specific structure but maintain field names
-    else if (type === 'grpc') {
+    } else if (type === 'grpc') {
+      // For gRPC, add gRPC-specific structure but maintain field names
       bruJson.grpc = {
         url: _.get(json, 'request.url'),
         auth: _.get(json, 'request.auth.mode', 'none'),
@@ -227,7 +227,7 @@ export const jsonRequestToBru = (json: any): string => {
   }
 };
 
-export const bruCollectionToJson = (data: string | any, parsed: boolean = false): any => {
+export const parseBruCollection = (data: string | any, parsed: boolean = false): any => {
   try {
     const json = parsed ? data : _collectionBruToJson(data);
 
@@ -273,7 +273,7 @@ export const bruCollectionToJson = (data: string | any, parsed: boolean = false)
   }
 };
 
-export const jsonCollectionToBru = (json: any, isFolder?: boolean): string => {
+export const stringifyBruCollection = (json: any, isFolder?: boolean): string => {
   try {
     const collectionBruJson: any = {
       headers: _.get(json, 'request.headers', []),
@@ -314,7 +314,7 @@ export const jsonCollectionToBru = (json: any, isFolder?: boolean): string => {
   }
 };
 
-export const bruEnvironmentToJson = (bru: string): any => {
+export const parseBruEnvironment = (bru: string): any => {
   try {
     const json = bruToEnvJsonV2(bru);
 
@@ -331,7 +331,7 @@ export const bruEnvironmentToJson = (bru: string): any => {
   }
 };
 
-export const jsonEnvironmentToBru = (json: any): string => {
+export const stringifyBruEnvironment = (json: any): string => {
   try {
     const bru = envJsonToBruV2(json);
     return bru;

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

@@ -1,5 +1,5 @@
 const { getOauth2AdditionalParameters } = require('../utils/oauth2-additional-params');
-const { bruRequestToJson, bruCollectionToJson } = require('../index');
+const { parseBruRequest, parseBruCollection } = require('../index');
 const { getBruJsonWithAdditionalParams } = require('./fixtures/oauth2-additional-params');
 
 describe('getOauth2AdditionalParameters', () => {

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

@@ -5,7 +5,7 @@ export interface T_OAuth2AdditionalParam {
   name: string;
   value: string;
   enabled: boolean;
-  sendIn: T_Oauth2ParameterSendInType
+  sendIn: T_Oauth2ParameterSendInType;
 }
 
 export interface T_OAuth2AdditionalParameters {
@@ -43,16 +43,16 @@ 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' },
+  { type: 'refresh', sendIn: 'body', source: 'oauth2_additional_parameters_refresh_token_req_bodyvalues' }
 ];
 
 /**
@@ -62,8 +62,8 @@ const mapParametersFromSource = (sourceParams: any[], sendIn: T_Oauth2ParameterS
   if (!sourceParams?.length) {
     return [];
   }
-  
-  return sourceParams.map(param => ({
+
+  return sourceParams.map((param) => ({
     ...param,
     sendIn
   }));
@@ -81,7 +81,7 @@ const shouldIncludeParameterType = (type: T_Oauth2ParameterType, grantType: stri
   if (type === 'token' || type === 'refresh') {
     return grantType !== 'implicit';
   }
-  
+
   // Token and refresh parameters are valid for all grant types
   return true;
 };
@@ -90,15 +90,15 @@ const shouldIncludeParameterType = (type: T_Oauth2ParameterType, grantType: stri
  * Collects all parameters for a specific type (authorization, token, or refresh)
  */
 const collectParametersForType = (
-  json: T_BruJson, 
-  type: T_Oauth2ParameterType, 
+  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 relevantMappings = PARAMETER_MAPPINGS.filter((mapping) => mapping.type === type);
   const allParams: T_OAuth2AdditionalParam[] = [];
 
   for (const mapping of relevantMappings) {
@@ -113,29 +113,28 @@ const collectParametersForType = (
 /**
  * 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  => {
+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) {
+  } catch (error) {
     console.error(error);
-    console.error("Error while getting the oauth2 additional parameters!");
+    console.error('Error while getting the oauth2 additional parameters!');
   }
-  
+
   return additionalParameters;
-};
+};

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

@@ -7,11 +7,11 @@ 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 {"
+      'body:json {',
+      'body:text {',
+      'body:xml {',
+      'body:sparql {',
+      'body:graphql {'
     ];
 
     // Normalize line endings to LF
@@ -37,30 +37,30 @@ export const bruRequestParseAndRedactBodyData = (bruFileContent: string) => {
 
     // Split the file content into blocks
     let fileContentBlocks = bruFileContent.split(`${EOL}}${EOL}`);
-    fileContentBlocks = fileContentBlocks.filter(Boolean).map(_ => _.trim());
+    fileContentBlocks = fileContentBlocks.filter(Boolean).map((_) => _.trim());
 
     // Extract body blocks and their content
     const extractedBodyBlocks = fileContentBlocks
-      .filter(block => bodyTypePatterns.some(pattern => block.startsWith(pattern)))
+      .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))
+    const fileContentWithoutBodyBlocks = fileContentBlocks.filter((block) =>
+      !bodyTypePatterns.some((pattern) => block.startsWith(pattern))
     );
 
     return {
@@ -74,4 +74,4 @@ export const bruRequestParseAndRedactBodyData = (bruFileContent: string) => {
       extractedBodyContent: {}
     };
   }
-};
+};

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

@@ -0,0 +1,78 @@
+import type { Action, ActionSetVariable, ActionVariableScope } from '@opencollection/types/common/actions';
+import type { Variable as BrunoVariable, Variables as BrunoVariables } from '@usebruno/schema-types/common/variables';
+import { uuid } from '../../../utils';
+
+/**
+ * Convert Bruno post-response variables to OpenCollection actions.
+ * Post-response variables in Bruno are converted to 'set-variable' actions
+ * with phase 'after-response'.
+ */
+export const toOpenCollectionActions = (resVariables: BrunoVariables | null | undefined): Action[] | undefined => {
+  if (!resVariables?.length) {
+    return undefined;
+  }
+
+  const actions: Action[] = resVariables.map((v: BrunoVariable): ActionSetVariable => {
+    const action: ActionSetVariable = {
+      type: 'set-variable',
+      phase: 'after-response',
+      selector: {
+        expression: v.value || '',
+        method: 'jsonq'
+      },
+      variable: {
+        name: v.name || '',
+        scope: v.local ? 'request' : 'runtime' as ActionVariableScope
+      }
+    };
+
+    if (v.description?.trim().length) {
+      action.description = v.description;
+    }
+
+    if (v.enabled === false) {
+      action.disabled = true;
+    }
+
+    return action;
+  });
+
+  return actions.length > 0 ? actions : undefined;
+};
+
+/**
+ * Convert OpenCollection actions to Bruno post-response variables.
+ * Only 'set-variable' actions with phase 'after-response' are converted.
+ */
+export const toBrunoPostResponseVariables = (actions: Action[] | null | undefined): BrunoVariables => {
+  if (!actions?.length) {
+    return [];
+  }
+
+  const resVars: BrunoVariables = [];
+
+  actions.forEach((action: Action) => {
+    // Only process 'set-variable' actions with 'after-response' phase
+    if (action.type === 'set-variable' && action.phase === 'after-response') {
+      const setVarAction = action as ActionSetVariable;
+
+      const variable: BrunoVariable = {
+        uid: uuid(),
+        name: setVarAction.variable?.name || '',
+        value: setVarAction.selector?.expression || '',
+        enabled: setVarAction.disabled !== true,
+        local: false
+      };
+
+      if (setVarAction.description) {
+        variable.description = typeof setVarAction.description === 'string'
+          ? setVarAction.description
+          : (setVarAction.description as any)?.content || '';
+      }
+
+      resVars.push(variable);
+    }
+  });
+
+  return resVars;
+};

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

@@ -0,0 +1,146 @@
+import type { KeyValue as BrunoKeyValue } from '@usebruno/schema-types/common/key-value';
+import type { Assertion } from '@opencollection/types/common/assertions';
+import { uuid } from '../../../utils';
+
+const OPERATORS = [
+  'eq',
+  'neq',
+  'gt',
+  'gte',
+  'lt',
+  'lte',
+  'in',
+  'notIn',
+  'contains',
+  'notContains',
+  'length',
+  'matches',
+  'notMatches',
+  'startsWith',
+  'endsWith',
+  'between',
+  'isEmpty',
+  'isNotEmpty',
+  'isNull',
+  'isUndefined',
+  'isDefined',
+  'isTruthy',
+  'isFalsy',
+  'isJson',
+  'isNumber',
+  'isString',
+  'isBoolean',
+  'isArray'
+] as const;
+
+const UNARY_OPERATORS = [
+  'isEmpty',
+  'isNotEmpty',
+  'isNull',
+  'isUndefined',
+  'isDefined',
+  'isTruthy',
+  'isFalsy',
+  'isJson',
+  'isNumber',
+  'isString',
+  'isBoolean',
+  'isArray'
+] as const;
+
+type Operator = typeof OPERATORS[number];
+
+const parseAssertionOperator = (str: string = ''): { operator: Operator; value: string | undefined } => {
+  if (!str || typeof str !== 'string' || !str.length) {
+    return {
+      operator: 'eq',
+      value: str
+    };
+  }
+
+  const [firstWord, ...rest] = str.trim().split(' ');
+  const remainingValue = rest.join(' ');
+
+  // Check if first word is a unary operator
+  if (UNARY_OPERATORS.includes(firstWord as any)) {
+    return {
+      operator: firstWord as Operator,
+      value: undefined
+    };
+  }
+
+  // Check if first word is any recognized operator
+  if (OPERATORS.includes(firstWord as any)) {
+    return {
+      operator: firstWord as Operator,
+      value: remainingValue
+    };
+  }
+
+  // If not a recognized operator, treat the whole string as value with 'eq' operator
+  return {
+    operator: 'eq',
+    value: str
+  };
+};
+
+export const toOpenCollectionAssertions = (assertions: BrunoKeyValue[] | null | undefined): Assertion[] | undefined => {
+  if (!assertions?.length) {
+    return undefined;
+  }
+
+  const ocAssertions: Assertion[] = assertions.map((assertion: BrunoKeyValue): Assertion => {
+    const { operator, value } = parseAssertionOperator(assertion.value || '');
+
+    const ocAssertion: Assertion = {
+      expression: assertion.name || '',
+      operator,
+      ...(value !== undefined && { value })
+    };
+
+    if (assertion?.description?.trim().length) {
+      ocAssertion.description = assertion.description;
+    }
+
+    if (assertion.enabled === false) {
+      ocAssertion.disabled = true;
+    }
+
+    return ocAssertion;
+  });
+
+  return ocAssertions.length > 0 ? ocAssertions : undefined;
+};
+
+export const toBrunoAssertions = (assertions: Assertion[] | null | undefined): BrunoKeyValue[] | undefined => {
+  if (!assertions?.length) {
+    return undefined;
+  }
+
+  const brunoAssertions: BrunoKeyValue[] = assertions.map((assertion: Assertion): BrunoKeyValue => {
+    // Reconstruct the "operator value" format that Bruno uses
+    let valueString = assertion.operator;
+    if (assertion.value !== undefined && assertion.value !== null) {
+      valueString = `${assertion.operator} ${assertion.value}`;
+    }
+
+    const brunoAssertion: BrunoKeyValue = {
+      uid: uuid(),
+      name: assertion.expression || '',
+      value: valueString,
+      enabled: assertion.disabled !== true
+    };
+
+    if (assertion.description) {
+      if (typeof assertion.description === 'string' && assertion.description.trim().length) {
+        brunoAssertion.description = assertion.description;
+      } else if (typeof assertion.description === 'object' && assertion.description.content?.trim().length) {
+        brunoAssertion.description = assertion.description.content;
+      }
+    }
+
+    return brunoAssertion;
+  });
+
+  return brunoAssertions.length > 0 ? brunoAssertions : undefined;
+};