@bigid/apps-infrastructure-node-js 1.218.1 → 1.220.1

package/lib/services/bigidProxyService.d.ts

@@ -8,7 +8,7 @@ export declare enum RequestMethod {
     DELETE = "delete"
 }
 export declare const getTenantRegistrations: (bigidToken: string) => Promise<TenantRegistration[]>;
-export declare const doCallToUrl: (bigidToken: string, requestMethod: RequestMethod, endpoint: string, bodyJson?: Record<string, any>) => Promise<any>;
+export declare const doCallToUrl: (bigidToken: string, requestMethod: RequestMethod, endpoint: string, bodyJson?: Record<string, any>, additionalHeaderFields?: Record<string, any>) => Promise<any>;
 /**
  * This method receives a message object to update BigID regarding the current state of the action execution
  * (should be used in case of an async actions)
@@ -22,20 +22,20 @@ export declare const updateActionStatusToBigID: (executionContext: ExecutionCont
  * @param endpoint - the endpoint in BigID, used for GET request. e.g - {BigIDBaseUrl}/ds_connections
  * @return - String containing the response from BigID
  */
-export declare const executeHttpGet: (executionContext: ExecutionContext, endpoint: string) => Promise<any>;
+export declare const executeHttpGet: (executionContext: ExecutionContext, endpoint: string, additionalHeaderFields?: Record<string, any>) => Promise<any>;
 /**
  * the endpoint in BigID, used for POST requests. e.g - {BigIDBaseUrl}/scan
  */
-export declare const executeHttpPost: (executionContext: ExecutionContext, endpoint: string, obj: any) => Promise<any>;
+export declare const executeHttpPost: (executionContext: ExecutionContext, endpoint: string, obj: any, additionalHeaderFields?: Record<string, any>) => Promise<any>;
 /**
  * the endpoint in BigID, used for POST requests. e.g - {BigIDBaseUrl}/scan
  */
-export declare const executeHttpPut: (executionContext: ExecutionContext, endpoint: string, obj: any) => Promise<any>;
+export declare const executeHttpPut: (executionContext: ExecutionContext, endpoint: string, obj: any, additionalHeaderFields?: Record<string, any>) => Promise<any>;
 /**
  * the endpoint in BigID, used for DELETE requests.
  */
-export declare const executeHttpDelete: (executionContext: ExecutionContext, endpoint: string) => Promise<any>;
-export declare const executePost: (requestMethod: RequestMethod, baseUrl: string | undefined, bodyJson: Record<string, any>) => Promise<any>;
+export declare const executeHttpDelete: (executionContext: ExecutionContext, endpoint: string, additionalHeaderFields?: Record<string, any>) => Promise<any>;
+export declare const executePost: (requestMethod: RequestMethod, baseUrl: string | undefined, bodyJson: Record<string, any>, additionalHeaderFields?: Record<string, any>) => Promise<any>;
 export declare const uploadAttachment: (executionContext: ExecutionContext, filePathToUpload: string) => Promise<import("axios").AxiosResponse<any, any>>;
 export declare const getAppStorage: (executionContext: ExecutionContext) => Promise<any>;
 export declare const getValueFromAppStorage: (executionContext: ExecutionContext, key: string) => Promise<string>;

package/lib/services/bigidProxyService.js

@@ -31,14 +31,10 @@ const getTenantRegistrations = (bigidToken) => __awaiter(void 0, void 0, void 0,
     return tenants;
 });
 exports.getTenantRegistrations = getTenantRegistrations;
-const doCallToUrl = (bigidToken, requestMethod, endpoint, bodyJson) => __awaiter(void 0, void 0, void 0, function* () {
+const doCallToUrl = (bigidToken, requestMethod, endpoint, bodyJson, additionalHeaderFields) => __awaiter(void 0, void 0, void 0, function* () {
     (0, utils_1.logInfo)(`--> bigid-proxy::callBigIdApi: [${requestMethod}] endpoint: ${endpoint}`);
     try {
-        const headers = {
-            Accept: 'application/json, text/plain, */*',
-            'Content-Type': 'application/json',
-            Authorization: bigidToken,
-        };
+        const headers = Object.assign({ Accept: 'application/json, text/plain, */*', 'Content-Type': 'application/json', Authorization: bigidToken }, (additionalHeaderFields || {}));
         const parsedUrl = new URL(endpoint);
         parsedUrl.pathname = parsedUrl.pathname.replace(/\/+/g, '/');
         const requestObj = {
@@ -63,10 +59,10 @@ const doCallToUrl = (bigidToken, requestMethod, endpoint, bodyJson) => __awaiter
     }
 });
 exports.doCallToUrl = doCallToUrl;
-function callBigIdApi(executionContext, requestMethod, endpoint, bodyJson, useEndpointWithoutBigIdBasePath) {
+function callBigIdApi(executionContext, requestMethod, endpoint, options) {
     return __awaiter(this, void 0, void 0, function* () {
-        const url = useEndpointWithoutBigIdBasePath ? endpoint : executionContext.bigidBaseUrl + endpoint;
-        return yield (0, exports.doCallToUrl)(executionContext.bigidToken, requestMethod, url, bodyJson);
+        const url = (options === null || options === void 0 ? void 0 : options.useEndpointWithoutBigIdBasePath) ? endpoint : executionContext.bigidBaseUrl + endpoint;
+        return yield (0, exports.doCallToUrl)(executionContext.bigidToken, requestMethod, url, options === null || options === void 0 ? void 0 : options.bodyJson, options === null || options === void 0 ? void 0 : options.additionalHeaderFields);
     });
 }
 /**
@@ -76,7 +72,10 @@ function callBigIdApi(executionContext, requestMethod, endpoint, bodyJson, useEn
  * @param actionResponseDetails
  */
 const updateActionStatusToBigID = (executionContext, actionResponseDetails) => __awaiter(void 0, void 0, void 0, function* () {
-    return yield callBigIdApi(executionContext, RequestMethod.PUT, executionContext.updateResultCallback, actionResponseDetails, true);
+    return yield callBigIdApi(executionContext, RequestMethod.PUT, executionContext.updateResultCallback, {
+        bodyJson: actionResponseDetails,
+        useEndpointWithoutBigIdBasePath: true
+    });
 });
 exports.updateActionStatusToBigID = updateActionStatusToBigID;
 /**
@@ -85,31 +84,28 @@ exports.updateActionStatusToBigID = updateActionStatusToBigID;
  * @param endpoint - the endpoint in BigID, used for GET request. e.g - {BigIDBaseUrl}/ds_connections
  * @return - String containing the response from BigID
  */
-const executeHttpGet = (executionContext, endpoint) => __awaiter(void 0, void 0, void 0, function* () { return yield callBigIdApi(executionContext, RequestMethod.GET, endpoint); });
+const executeHttpGet = (executionContext, endpoint, additionalHeaderFields) => __awaiter(void 0, void 0, void 0, function* () { return yield callBigIdApi(executionContext, RequestMethod.GET, endpoint, { additionalHeaderFields }); });
 exports.executeHttpGet = executeHttpGet;
 /**
  * the endpoint in BigID, used for POST requests. e.g - {BigIDBaseUrl}/scan
  */
-const executeHttpPost = (executionContext, endpoint, obj) => __awaiter(void 0, void 0, void 0, function* () { return yield callBigIdApi(executionContext, RequestMethod.POST, endpoint, obj); });
+const executeHttpPost = (executionContext, endpoint, obj, additionalHeaderFields) => __awaiter(void 0, void 0, void 0, function* () { return yield callBigIdApi(executionContext, RequestMethod.POST, endpoint, { bodyJson: obj, additionalHeaderFields }); });
 exports.executeHttpPost = executeHttpPost;
 /**
  * the endpoint in BigID, used for POST requests. e.g - {BigIDBaseUrl}/scan
  */
-const executeHttpPut = (executionContext, endpoint, obj) => __awaiter(void 0, void 0, void 0, function* () { return yield callBigIdApi(executionContext, RequestMethod.PUT, endpoint, obj); });
+const executeHttpPut = (executionContext, endpoint, obj, additionalHeaderFields) => __awaiter(void 0, void 0, void 0, function* () { return yield callBigIdApi(executionContext, RequestMethod.PUT, endpoint, { bodyJson: obj, additionalHeaderFields }); });
 exports.executeHttpPut = executeHttpPut;
 /**
  * the endpoint in BigID, used for DELETE requests.
  */
-const executeHttpDelete = (executionContext, endpoint) => __awaiter(void 0, void 0, void 0, function* () { return yield callBigIdApi(executionContext, RequestMethod.DELETE, endpoint); });
+const executeHttpDelete = (executionContext, endpoint, additionalHeaderFields) => __awaiter(void 0, void 0, void 0, function* () { return yield callBigIdApi(executionContext, RequestMethod.DELETE, endpoint, { additionalHeaderFields }); });
 exports.executeHttpDelete = executeHttpDelete;
-const executePost = (requestMethod, baseUrl, bodyJson) => __awaiter(void 0, void 0, void 0, function* () {
+const executePost = (requestMethod, baseUrl, bodyJson, additionalHeaderFields) => __awaiter(void 0, void 0, void 0, function* () {
     var _a, _b, _c, _d, _e, _f;
     try {
         const url = baseUrl + 'api/v1/sessions';
-        const headers = {
-            Accept: 'application/json',
-            'Content-type': 'application/json',
-        };
+        const headers = Object.assign({ Accept: 'application/json', 'Content-type': 'application/json' }, (additionalHeaderFields || {}));
         const requestObj = {
             method: requestMethod,
             url: url,

package/log/app.log

@@ -0,0 +1,8 @@
+[2025-01-23T09:45:58.982] [INFO] default - --> bigid-proxy::callBigIdApi: [get] endpoint: https://bigid-ui:9090/api/v1/id_connections
+[2025-01-23T09:45:58.995] [INFO] default - <-- bigid-proxy::callBigIdApi: https://bigid-ui:9090/api/v1/id_connections success
+[2025-01-23T09:45:58.998] [INFO] default - --> bigid-proxy::callBigIdApi: [post] endpoint: https://bigid-ui:9090/api/v1/id_connections
+[2025-01-23T09:45:59.002] [INFO] default - <-- bigid-proxy::callBigIdApi: https://bigid-ui:9090/api/v1/id_connections success
+[2025-01-23T09:45:59.003] [INFO] default - --> bigid-proxy::callBigIdApi: [put] endpoint: https://bigid-ui:9090/api/v1/id_connections
+[2025-01-23T09:45:59.006] [INFO] default - <-- bigid-proxy::callBigIdApi: https://bigid-ui:9090/api/v1/id_connections success
+[2025-01-23T09:45:59.007] [INFO] default - --> bigid-proxy::callBigIdApi: [delete] endpoint: https://bigid-ui:9090/api/v1/id_connections
+[2025-01-23T09:45:59.011] [INFO] default - <-- bigid-proxy::callBigIdApi: https://bigid-ui:9090/api/v1/id_connections success

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@bigid/apps-infrastructure-node-js",
-  "version": "1.218.1",
+  "version": "1.220.1",
   "description": "",
   "main": "lib/index.js",
   "scripts": {
     "docs": "npx tsc && ./node_modules/.bin/jsdoc -c jsdoc.json",
-    "test": "mocha 'test/**/*.ts'"
+    "test": "mocha --require ts-node/register --require source-map-support/register 'test/**/*.ts'"
   },
   "types": "lib/index.d.ts",
   "repository": {
@@ -15,18 +15,22 @@
   "author": "Shay Sheli",
   "homepage": "https://github.com/bigexchange/apps-infrastructure-node-js#readme",
   "devDependencies": {
+    "@types/chai": "^4.3.20",
     "@types/express": "^4.17.13",
     "@types/http-errors": "^1.8.1",
     "@types/mocha": "10.0.3",
+    "@types/nock": "^11.1.0",
     "@types/node": "^16.11.10",
     "@types/node-schedule": "^2.1.0",
     "@typescript-eslint/eslint-plugin": "4.6.1",
     "@typescript-eslint/parser": "4.6.1",
+    "chai": "4.5.0",
     "eslint": "7.12.1",
     "eslint-config-prettier": "^6.15.0",
     "eslint-plugin-no-only-tests": "2.4.0",
     "eslint-plugin-prettier": "^3.1.4",
     "jsdoc": "4.0.2",
+    "nock": "^13.5.6",
     "prettier": "^2.4.1",
     "typescript": "^4.5.2"
   },

package/src/services/bigidProxyService.ts

@@ -15,6 +15,12 @@ export enum RequestMethod {
   DELETE = 'delete',
 }
 
+interface BigIdApiRequestOptions {
+  bodyJson?: ActionResponseDetails;
+  useEndpointWithoutBigIdBasePath?: boolean;
+  additionalHeaderFields?: Record<string, any>;
+}
+
 export const getTenantRegistrations = async (bigidToken: string): Promise<TenantRegistration[]> => {
   const {
     data: {
@@ -32,6 +38,7 @@ export const doCallToUrl = async (
   requestMethod: RequestMethod,
   endpoint: string,
   bodyJson?: Record<string, any>,
+  additionalHeaderFields?: Record<string, any>,
 ) => {
   logInfo(`--> bigid-proxy::callBigIdApi: [${requestMethod}] endpoint: ${endpoint}`);
   try {
@@ -39,6 +46,7 @@ export const doCallToUrl = async (
       Accept: 'application/json, text/plain, */*',
       'Content-Type': 'application/json',
       Authorization: bigidToken,
+      ...(additionalHeaderFields || {}),
     };
     const parsedUrl = new URL(endpoint);
     parsedUrl.pathname = parsedUrl.pathname.replace(/\/+/g, '/');
@@ -71,11 +79,10 @@ async function callBigIdApi(
   executionContext: ExecutionContext,
   requestMethod: RequestMethod,
   endpoint: string,
-  bodyJson?: ActionResponseDetails,
-  useEndpointWithoutBigIdBasePath?: boolean,
+  options: BigIdApiRequestOptions,
 ) {
-  const url = useEndpointWithoutBigIdBasePath ? endpoint : executionContext.bigidBaseUrl + endpoint;
-  return await doCallToUrl(executionContext.bigidToken, requestMethod, url, bodyJson);
+  const url = options?.useEndpointWithoutBigIdBasePath ? endpoint : executionContext.bigidBaseUrl + endpoint;
+  return await doCallToUrl(executionContext.bigidToken, requestMethod, url, options?.bodyJson, options?.additionalHeaderFields);
 }
 
 /**
@@ -92,8 +99,10 @@ export const updateActionStatusToBigID = async (
     executionContext,
     RequestMethod.PUT,
     executionContext.updateResultCallback,
-    actionResponseDetails,
-    true,
+    {
+      bodyJson: actionResponseDetails,
+      useEndpointWithoutBigIdBasePath: true
+    }
   );
 
 /**
@@ -102,37 +111,39 @@ export const updateActionStatusToBigID = async (
  * @param endpoint - the endpoint in BigID, used for GET request. e.g - {BigIDBaseUrl}/ds_connections
  * @return - String containing the response from BigID
  */
-export const executeHttpGet = async (executionContext: ExecutionContext, endpoint: string) =>
-  await callBigIdApi(executionContext, RequestMethod.GET, endpoint);
+export const executeHttpGet = async (executionContext: ExecutionContext, endpoint: string, additionalHeaderFields?: Record<string, any>) =>
+  await callBigIdApi(executionContext, RequestMethod.GET, endpoint, { additionalHeaderFields });
 
 /**
  * the endpoint in BigID, used for POST requests. e.g - {BigIDBaseUrl}/scan
  */
-export const executeHttpPost = async (executionContext: ExecutionContext, endpoint: string, obj: any) =>
-  await callBigIdApi(executionContext, RequestMethod.POST, endpoint, obj);
+export const executeHttpPost = async (executionContext: ExecutionContext, endpoint: string, obj: any, additionalHeaderFields?: Record<string, any>) =>
+  await callBigIdApi(executionContext, RequestMethod.POST, endpoint, { bodyJson: obj, additionalHeaderFields });
 
 /**
  * the endpoint in BigID, used for POST requests. e.g - {BigIDBaseUrl}/scan
  */
-export const executeHttpPut = async (executionContext: ExecutionContext, endpoint: string, obj: any) =>
-  await callBigIdApi(executionContext, RequestMethod.PUT, endpoint, obj);
+export const executeHttpPut = async (executionContext: ExecutionContext, endpoint: string, obj: any, additionalHeaderFields?: Record<string, any>) =>
+  await callBigIdApi(executionContext, RequestMethod.PUT, endpoint, { bodyJson: obj, additionalHeaderFields });
 
 /**
  * the endpoint in BigID, used for DELETE requests.
  */
-export const executeHttpDelete = async (executionContext: ExecutionContext, endpoint: string) =>
-  await callBigIdApi(executionContext, RequestMethod.DELETE, endpoint);
+export const executeHttpDelete = async (executionContext: ExecutionContext, endpoint: string, additionalHeaderFields?: Record<string, any>) =>
+  await callBigIdApi(executionContext, RequestMethod.DELETE, endpoint, { additionalHeaderFields });
 
 export const executePost = async (
   requestMethod: RequestMethod,
   baseUrl: string | undefined,
   bodyJson: Record<string, any>,
+  additionalHeaderFields?: Record<string, any>
 ) => {
   try {
     const url = baseUrl + 'api/v1/sessions';
     const headers = {
       Accept: 'application/json',
       'Content-type': 'application/json',
+      ...(additionalHeaderFields || {}),
     };
     const requestObj: Record<string, any> = {
       method: requestMethod,

package/test/mock.ts

@@ -0,0 +1,31 @@
+export const mockExecutionContext = {
+  actionName: 'helloWorld',
+  executionId: '6787da8066db56a1866ccb82',
+  presetId: '6787d2a566db56a1866c8ea7',
+  globalParams: [
+    {
+      paramName: 'username',
+      paramValue: 'admin',
+    },
+    {
+      paramName: 'password',
+      paramValue: 'admin',
+    },
+  ],
+  actionParams: [
+    {
+      paramName: 'idConnectionName',
+      paramValue: 'identity source',
+    },
+  ],
+  bigidToken:
+    'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyX25hbWUiOiJiaWdpZC13ZWIiLCJpc0FkbWluIjp0cnVlLCJyb2xlSWRzIjpbInN5c3RlbSJdLCJ0eXBlIjoiYWNjZXNzLXRva2VuIiwidGVuYW50SWQiOiJTSU5HTEVfVEVOQU5UIiwiaWF0IjoxNzM2OTU2NTQ0LCJleHAiOjE3Mzc1NjEzNDR9.jlcHlT8uKxHA615NGAxIsM8-Cgvda3aOuy2Lji_u5hk',
+  updateResultCallback: 'https://bigid-ui:9090/api/v1/tpa/executions/6787da8066db56a1866ccb82',
+  bigidBaseUrl: 'https://bigid-ui:9090/api/v1/',
+  tpaId: '6787d2a566db56a1866c8e9d',
+  tpaName: 'Basic demo Nodejs app',
+};
+
+export const mockBaseUrl = 'https://bigid-ui:9090/api/v1';
+
+export const mockDataResponse = { Response: 'ok' };

package/test/unit/api/requests.spec.ts

@@ -0,0 +1,44 @@
+import { expect } from 'chai';
+import nock = require("nock");
+import {
+  executeHttpGet,
+  executeHttpPost,
+  executeHttpPut,
+  executeHttpDelete,
+} from '../../../src/services/bigidProxyService';
+import { mockExecutionContext, mockBaseUrl, mockDataResponse } from '../../mock';
+
+describe('Main api requests unit tests', () => {
+  const apiUrl = 'id_connections';
+  const modifiedHeader = { AdditionalFieldName: 'AdditionalFieldValue' };
+  const expectedFieldName = 'AdditionalFieldName';
+  const expectedFieldValue = 'AdditionalFieldValue';
+
+  afterEach(() => {
+    nock.cleanAll();
+  });
+
+  it('Should verify modified header for executeHttpGet request', async () => {
+    nock(mockBaseUrl).get(`/${apiUrl}`).matchHeader(expectedFieldName,expectedFieldValue).reply(200, mockDataResponse);
+    const response = await executeHttpGet(mockExecutionContext, apiUrl, modifiedHeader);
+    expect(response.data).to.deep.equal(mockDataResponse);
+  });
+
+  it('Should verify modified header for executeHttpPost request', async () => {
+    nock(mockBaseUrl).post(`/${apiUrl}`).matchHeader(expectedFieldName,expectedFieldValue).reply(200, mockDataResponse);
+    const response = await executeHttpPost(mockExecutionContext, apiUrl, undefined, modifiedHeader);
+    expect(response.data).to.deep.equal(mockDataResponse);
+  });
+
+  it('Should verify modified header for executeHttpPut request', async () => {
+    nock(mockBaseUrl).put(`/${apiUrl}`).matchHeader(expectedFieldName,expectedFieldValue).reply(200, mockDataResponse);
+    const response = await executeHttpPut(mockExecutionContext, apiUrl, undefined, modifiedHeader);
+    expect(response.data).to.deep.equal(mockDataResponse);
+  });
+
+  it('Should verify modified header for executeHttpDelete request', async () => {
+    nock(mockBaseUrl).delete(`/${apiUrl}`).matchHeader(expectedFieldName,expectedFieldValue).reply(200, mockDataResponse);
+    const response = await executeHttpDelete(mockExecutionContext, apiUrl, modifiedHeader);
+    expect(response.data).to.deep.equal(mockDataResponse);
+  });
+});