@bigid/apps-infrastructure-node-js 0.1.0

package/lib/services/bigidProxyService.js

@@ -0,0 +1,135 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setValuesForBigIDProxy = exports.saveInStorage = exports.getValueFromAppStorage = exports.getAppStorage = exports.uploadAttachment = exports.executeHttpPut = exports.executeHttpPost = exports.executeHttpGet = exports.updateActionStatusToBigID = exports.initBigIDProxy = void 0;
+const fs_1 = require("fs");
+const https_1 = require("https");
+const form_data_1 = __importDefault(require("form-data"));
+const axios_1 = __importDefault(require("axios"));
+const utils_1 = require("../utils");
+const RequestMethod = {
+    POST: 'post',
+    GET: 'get',
+    PUT: 'put',
+    PATCH: 'patch',
+    DELETE: 'delete',
+};
+let bigidUrl;
+let bigidUpdateStatusUrl;
+let bigidToken;
+let proxyTpaId;
+const initBigIDProxy = (bigIdUrl, callBackUrl, bigIdToken, tpaId) => {
+    bigidUrl = bigIdUrl;
+    bigidUpdateStatusUrl = callBackUrl;
+    bigidToken = bigIdToken;
+    proxyTpaId = tpaId;
+};
+exports.initBigIDProxy = initBigIDProxy;
+const doCallToUrl = (requestMethod, endpoint, bodyJson) => __awaiter(void 0, void 0, void 0, function* () {
+    utils_1.appLogger.info('--> bigid-proxy::callBigIdApi: [%s] %s', requestMethod, endpoint);
+    try {
+        const headers = {
+            'Accept': 'application/json, text/plain, */*',
+            'Content-Type': 'application/json',
+            'Authorization': bigidToken,
+        };
+        const requestObj = {
+            method: requestMethod,
+            url: endpoint,
+            headers: headers,
+            httpsAgent: new https_1.Agent({
+                rejectUnauthorized: false
+            })
+        };
+        if (bodyJson && Object.keys(bodyJson).length > 0) {
+            requestObj.data = bodyJson;
+        }
+        const res = yield (0, axios_1.default)(requestObj);
+        utils_1.appLogger.info('<-- bigid-proxy::callBigIdApi: %s success', endpoint);
+        return res;
+    }
+    catch (error) {
+        utils_1.appLogger.info('<-- bigid-proxy::callBigIdApi: error calling bigID on %s %o', endpoint, error);
+        utils_1.appLogger.error(error);
+        return error === null || error === void 0 ? void 0 : error.message;
+    }
+});
+function callBigIdApi(requestMethod, endpoint, bodyJson, useEndpointWithoutBigIdBasePath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const url = useEndpointWithoutBigIdBasePath ? endpoint : bigidUrl + endpoint;
+        return yield doCallToUrl(requestMethod, url, bodyJson);
+    });
+}
+/**
+ * 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)
+ * @param actionResponseDetailsParam
+ */
+const updateActionStatusToBigID = (actionResponseDetails) => __awaiter(void 0, void 0, void 0, function* () {
+    return yield callBigIdApi(RequestMethod.PUT, `${bigidUpdateStatusUrl}`, actionResponseDetails, true);
+});
+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 = (endpoint) => __awaiter(void 0, void 0, void 0, function* () { return yield callBigIdApi(RequestMethod.GET, endpoint); });
+exports.executeHttpGet = executeHttpGet;
+/**
+ * the endpoint in BigID, used for POST requests. e.g - {BigIDBaseUrl}/scan
+ */
+const executeHttpPost = (endpoint, actionResponseDetails) => __awaiter(void 0, void 0, void 0, function* () { return yield callBigIdApi(RequestMethod.POST, endpoint, actionResponseDetails); });
+exports.executeHttpPost = executeHttpPost;
+/**
+ * the endpoint in BigID, used for POST requests. e.g - {BigIDBaseUrl}/scan
+ */
+const executeHttpPut = (endpoint, obj) => __awaiter(void 0, void 0, void 0, function* () { return yield callBigIdApi(RequestMethod.PUT, endpoint, obj); });
+exports.executeHttpPut = executeHttpPut;
+const uploadAttachment = (filePathToUpload) => {
+    const formData = new form_data_1.default();
+    formData.append('file', (0, fs_1.createReadStream)(filePathToUpload));
+    const headers = {
+        'Content-Type': `multipart/form-data; boundary=${formData.getBoundary()}`,
+        'Authorization': bigidToken,
+    };
+    const requestObj = {
+        method: RequestMethod.POST,
+        url: `${bigidUpdateStatusUrl}/attachment`,
+        headers: headers,
+        httpsAgent: new https_1.Agent({
+            rejectUnauthorized: false
+        })
+    };
+    requestObj.data = formData;
+    return (0, axios_1.default)(requestObj);
+};
+exports.uploadAttachment = uploadAttachment;
+const getAppStorage = () => (0, exports.executeHttpGet)(`tpa/${proxyTpaId}/storage`);
+exports.getAppStorage = getAppStorage;
+const getValueFromAppStorage = (key) => __awaiter(void 0, void 0, void 0, function* () {
+    const { data } = yield (0, exports.executeHttpGet)(`tpa/${proxyTpaId}/storage/key/${key}`);
+    return data === "Key not found" ? null : data.value;
+});
+exports.getValueFromAppStorage = getValueFromAppStorage;
+const saveInStorage = (keyToStore, valueToStore) => __awaiter(void 0, void 0, void 0, function* () { return yield (0, exports.executeHttpPut)(`/tpa/${proxyTpaId}/storage`, { keysValues: [{ key: keyToStore, value: valueToStore }] }); });
+exports.saveInStorage = saveInStorage;
+const setValuesForBigIDProxy = (executionContext) => {
+    if (!executionContext.bigidBaseUrl || !executionContext.bigidToken) {
+        utils_1.appLogger.error(`Missing bigidUrl and/or bigidToken. bigidUrl=${executionContext.bigidBaseUrl}, bigidToken=${executionContext.bigidToken}`);
+        return;
+    }
+    (0, exports.initBigIDProxy)(executionContext.bigidBaseUrl, executionContext.updateResultCallback, executionContext.bigidToken, executionContext.tpaId);
+};
+exports.setValuesForBigIDProxy = setValuesForBigIDProxy;

package/lib/services/index.d.ts

@@ -0,0 +1 @@
+export * from './bigidProxyService';

package/lib/services/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./bigidProxyService"), exports);

package/lib/utils/appLogger.d.ts

@@ -0,0 +1 @@
+export declare const appLogger: import("log4js").Logger;

package/lib/utils/appLogger.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appLogger = void 0;
+const log4js_1 = require("log4js");
+const constants_1 = require("./constants");
+(0, log4js_1.configure)({
+    appenders: {
+        console: { type: 'stdout', layout: { type: 'colored' } },
+        dateFile: {
+            type: 'dateFile',
+            layout: { type: 'basic' },
+            filename: constants_1.LOGS_PATH,
+            compress: true,
+            daysToKeep: 14,
+            keepFileExt: true
+        }
+    },
+    categories: {
+        default: { appenders: ['console', 'dateFile'], level: process.env.LOG_LEVEL || 'info' }
+    }
+});
+exports.appLogger = (0, log4js_1.getLogger)();

package/lib/utils/constants.d.ts

@@ -0,0 +1 @@
+export declare const LOGS_PATH = "log/app.log";

package/lib/utils/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOGS_PATH = void 0;
+exports.LOGS_PATH = 'log/app.log';

package/lib/utils/index.d.ts

@@ -0,0 +1 @@
+export { appLogger } from './appLogger';

package/lib/utils/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appLogger = void 0;
+var appLogger_1 = require("./appLogger");
+Object.defineProperty(exports, "appLogger", { enumerable: true, get: function () { return appLogger_1.appLogger; } });

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@bigid/apps-infrastructure-node-js",
+  "version": "0.1.0",
+  "description": "",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bigexchange/apps-infrastructure-node-js.git"
+  },
+  "author": "Shay Sheli",
+  "homepage": "https://github.com/bigexchange/apps-infrastructure-node-js#readme",
+  "devDependencies": {
+    "@types/express": "^4.17.13",
+    "@types/http-errors": "^1.8.1",
+    "@types/node": "^16.11.10",
+    "@typescript-eslint/eslint-plugin": "4.6.1",
+    "@typescript-eslint/parser": "4.6.1",
+    "eslint": "7.12.1",
+    "eslint-config-prettier": "^6.15.0",
+    "eslint-plugin-no-only-tests": "2.4.0",
+    "eslint-plugin-prettier": "^3.1.4",
+    "prettier": "^2.4.1",
+    "typescript": "^4.5.2"
+  },
+  "dependencies": {
+    "axios": "^0.24.0",
+    "express": "^4.17.1",
+    "form-data": "^4.0.0",
+    "http-errors": "^1.8.1",
+    "log4js": "^6.3.0"
+  }
+}

package/src/abstractProviders/executionProvider.ts

@@ -0,0 +1,27 @@
+import { Request, Response } from 'express';
+import { ActionResponseDetails } from '../dto/actionResponseDetails';
+import { setValuesForBigIDProxy } from '../services';
+
+export const StatusEnum = {
+  COMPLETED: 'COMPLETED',
+  IN_PROGRESS: 'IN_PROGRESS',
+  ERROR: 'ERROR',
+};
+
+export const handleExecution = async (req: Request, res: Response, executionProvider: ExecutionProvider) => {
+  setValuesForBigIDProxy(req.body);
+  await executionProvider.executeAction(req, res);
+};
+
+export abstract class ExecutionProvider {
+  public abstract executeAction(req: Request, res: Response): Promise<void>;
+
+  generateSyncSuccessMessage = (res: Response, executionId: string, message: string) =>
+    res.status(200).json(new ActionResponseDetails(executionId, StatusEnum.COMPLETED, 1, message));
+
+  generateAsyncSuccessMessage = (res: Response, executionId: string, message: string) =>
+    res.status(202).json(new ActionResponseDetails(executionId, StatusEnum.IN_PROGRESS, 0, message));
+
+  generateFailedResponse = (res: Response, executionId: string, e: Error) =>
+    res.status(400).json(new ActionResponseDetails(executionId, StatusEnum.ERROR, 0, e.message));
+}

package/src/abstractProviders/iconsProviders.ts

@@ -0,0 +1,4 @@
+export abstract class IconsProviders {
+  public abstract getIconPath(): string;
+  public abstract getSideBarIconPath(): string;
+}

package/src/abstractProviders/index.ts

@@ -0,0 +1,3 @@
+export { ManifestProvider } from './manifestProvider';
+export { IconsProviders } from './iconsProviders';
+export { ExecutionProvider, StatusEnum } from './executionProvider';

package/src/abstractProviders/logsProvider.ts

@@ -0,0 +1,6 @@
+import { createReadStream } from 'fs';
+import { Request, Response } from 'express';
+import { LOGS_PATH } from '../utils/constants';
+
+export const fetchLogs = (req: Request, res: Response) =>
+  createReadStream(LOGS_PATH).pipe(res);

package/src/abstractProviders/manifestProvider.ts

@@ -0,0 +1,3 @@
+export abstract class ManifestProvider {
+  public abstract getManifest(req: any, res: any): string;
+}

package/src/dto/actionResponseDetails.ts

@@ -0,0 +1,15 @@
+export class ActionResponseDetails {
+  executionId: string;
+  statusEnum: string;
+  progress: number;
+  message: string;
+  additionalData?: any;
+
+  constructor(executionId: string, statusEnum: string, progress: number, message: string, additionalData?: any) {
+    this.executionId = executionId;
+    this.statusEnum = statusEnum;
+    this.progress = progress;
+    this.message = message;
+    this.additionalData = additionalData;
+  }
+}

package/src/dto/executionContext.ts

@@ -0,0 +1,30 @@
+export class ExecutionContext {
+  actionName: string;
+  executionId: string;
+  globalParams: Record<string, string>;
+  actionParams: Record<string, string>;
+  bigidBaseUrl: string;
+  bigidToken: string;
+  updateResultCallback: any;
+  tpaId: string;
+
+  constructor(
+    actionName: string,
+    executionId: string,
+    globalParams: Record<string, string>,
+    actionParams: Record<string, string>,
+    bigidBaseUrl: string,
+    bigidToken: string,
+    updateResultCallback: any,
+    tpaId: string,
+  ) {
+    this.actionName = actionName;
+    this.executionId = executionId;
+    this.globalParams = globalParams;
+    this.actionParams = actionParams;
+    this.bigidBaseUrl = bigidBaseUrl;
+    this.bigidToken = bigidToken;
+    this.updateResultCallback = updateResultCallback;
+    this.tpaId = tpaId;
+  }
+}

package/src/dto/index.ts

@@ -0,0 +1,2 @@
+export { ExecutionContext } from './executionContext';
+export { ActionResponseDetails } from './actionResponseDetails';

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from './abstractProviders';
+export * from './dto';
+export * from './utils';
+export { updateActionStatusToBigID, uploadAttachment, getValueFromAppStorage, saveInStorage, executeHttpGet } from './services';
+export { deployServer, ServerInit } from './server';

package/src/server.ts

@@ -0,0 +1,52 @@
+import express, { NextFunction, Request, Response } from 'express';
+import { ManifestProvider } from './abstractProviders/manifestProvider';
+import { appLogger } from './utils/appLogger';
+import { IconsProviders } from './abstractProviders/iconsProviders';
+import { ExecutionProvider, handleExecution } from './abstractProviders/executionProvider';
+import { fetchLogs } from './abstractProviders/logsProvider';
+import createError from 'http-errors';
+
+export interface ServerInit {
+  manifestController: ManifestProvider;
+  iconsController: IconsProviders;
+  executionController: ExecutionProvider;
+  serverPort?: number;
+}
+
+const app = express();
+
+export const deployServer = (serverInit: ServerInit) => {
+  app.use(express.json());
+  app.use(express.urlencoded({ extended: false }));
+
+  app.get('/assets/icon', (req, res) => res.sendFile(serverInit.iconsController.getIconPath()));
+  app.get('/assets/sideBarIcon', (req, res) => res.sendFile(serverInit.iconsController.getSideBarIconPath()));
+  app.get('/manifest', serverInit.manifestController.getManifest);
+  app.post(
+    '/execute',
+    async (req: Request, res: Response) => await handleExecution(req, res, serverInit.executionController),
+  );
+  app.get('/logs', fetchLogs);
+
+  app.listen(process.env.PORT || serverInit.serverPort, () =>
+    appLogger.info(`Started server at port ${process.env.PORT || serverInit.serverPort}`),
+  );
+
+  // catch 404 and forward to error handler
+  app.use((req: Request, res: Response, next: NextFunction) => next(createError(404)));
+
+  // error handler
+  app.use((err: any, req: Request, res: Response, next: NextFunction) => {
+    const { message, status } = err;
+    appLogger.error(err);
+    res.locals.message = message;
+    res.locals.error = req.app.get('env') === 'development' ? err : {};
+
+    res.status(status || 500);
+    res.json({
+      status: 'error',
+      statusCode: status || 500,
+      message,
+    });
+  });
+};

package/src/services/bigidProxyService.ts

@@ -0,0 +1,150 @@
+import { createReadStream } from 'fs';
+import { Agent } from 'https';
+import { ExecutionContext } from '../dto';
+import FormData from 'form-data';
+
+import axios from 'axios';
+import { ActionResponseDetails } from '../dto/actionResponseDetails';
+import { appLogger } from '../utils';
+
+const RequestMethod = {
+  POST: 'post',
+  GET: 'get',
+  PUT: 'put',
+  PATCH: 'patch',
+  DELETE: 'delete',
+};
+
+let bigidUrl: string;
+let bigidUpdateStatusUrl: string;
+let bigidToken: string;
+let proxyTpaId: string;
+
+export const initBigIDProxy = (bigIdUrl: string, callBackUrl: string, bigIdToken: string, tpaId: string) => {
+  bigidUrl = bigIdUrl;
+  bigidUpdateStatusUrl = callBackUrl;
+  bigidToken = bigIdToken;
+  proxyTpaId = tpaId;
+};
+
+const doCallToUrl = async (requestMethod: string, endpoint: string, bodyJson?: ActionResponseDetails) => {
+  appLogger.info('--> bigid-proxy::callBigIdApi: [%s] %s', requestMethod, endpoint);
+  try {
+    const headers = {
+      Accept: 'application/json, text/plain, */*',
+      'Content-Type': 'application/json',
+      Authorization: bigidToken,
+    };
+
+    const requestObj: Record<string, any> = {
+      method: requestMethod,
+      url: endpoint,
+      headers: headers,
+      httpsAgent: new Agent({
+        rejectUnauthorized: false,
+      }),
+    };
+
+    if (bodyJson && Object.keys(bodyJson).length > 0) {
+      requestObj.data = bodyJson;
+    }
+
+    const res = await axios(requestObj);
+
+    appLogger.info('<-- bigid-proxy::callBigIdApi: %s success', endpoint);
+    return res;
+  } catch (error: any) {
+    appLogger.info('<-- bigid-proxy::callBigIdApi: error calling bigID on %s %o', endpoint, error);
+    appLogger.error(error);
+    return error?.message;
+  }
+};
+
+async function callBigIdApi(
+  requestMethod: string,
+  endpoint: string,
+  bodyJson?: ActionResponseDetails,
+  useEndpointWithoutBigIdBasePath?: boolean,
+) {
+  const url = useEndpointWithoutBigIdBasePath ? endpoint : bigidUrl + endpoint;
+  return await doCallToUrl(requestMethod, url, bodyJson);
+}
+
+/**
+ * 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)
+ * @param ActionResponseDetails
+ */
+export const updateActionStatusToBigID = async (actionResponseDetails: ActionResponseDetails) =>
+  await callBigIdApi(RequestMethod.PUT, `${bigidUpdateStatusUrl}`, actionResponseDetails, true);
+
+/**
+ *
+ * @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 (endpoint: string) => await callBigIdApi(RequestMethod.GET, endpoint);
+
+/**
+ * the endpoint in BigID, used for POST requests. e.g - {BigIDBaseUrl}/scan
+ */
+export const executeHttpPost = async (endpoint: string, actionResponseDetails: ActionResponseDetails) =>
+  await callBigIdApi(RequestMethod.POST, endpoint, actionResponseDetails);
+
+/**
+ * the endpoint in BigID, used for POST requests. e.g - {BigIDBaseUrl}/scan
+ */
+export const executeHttpPut = async (endpoint: string, obj: any) =>
+  await callBigIdApi(RequestMethod.PUT, endpoint, obj);
+
+export const uploadAttachment = (filePathToUpload: string) => {
+  const formData = new FormData();
+  formData.append('file', createReadStream(filePathToUpload));
+
+  const headers = {
+    'Content-Type': `multipart/form-data; boundary=${formData.getBoundary()}`,
+    Authorization: bigidToken,
+  };
+  const requestObj: Record<string, any> = {
+    method: RequestMethod.POST,
+    url: `${bigidUpdateStatusUrl}/attachment`,
+    headers: headers,
+    httpsAgent: new Agent({
+      rejectUnauthorized: false,
+    }),
+  };
+  requestObj.data = formData;
+  return axios(requestObj);
+};
+
+export const getAppStorage = () => executeHttpGet(`tpa/${proxyTpaId}/storage`);
+
+export const getValueFromAppStorage = async (key: string) => {
+  const { data } = await executeHttpGet(`tpa/${proxyTpaId}/storage/key/${key}`);
+  return data === 'Key not found' ? null : data.value;
+};
+
+export const saveInStorage = async (keyToStore: any, valueToStore: any) =>
+  await executeHttpPut(`/tpa/${proxyTpaId}/storage`, {
+    keysValues: [
+      {
+        key: keyToStore,
+        value: valueToStore,
+      },
+    ],
+  });
+
+export const setValuesForBigIDProxy = (executionContext: ExecutionContext) => {
+  if (!executionContext.bigidBaseUrl || !executionContext.bigidToken) {
+    appLogger.error(
+      `Missing bigidUrl and/or bigidToken. bigidUrl=${executionContext.bigidBaseUrl}, bigidToken=${executionContext.bigidToken}`,
+    );
+    return;
+  }
+  initBigIDProxy(
+    executionContext.bigidBaseUrl,
+    executionContext.updateResultCallback,
+    executionContext.bigidToken,
+    executionContext.tpaId,
+  );
+};

package/src/services/index.ts

@@ -0,0 +1 @@
+export * from './bigidProxyService';

package/src/utils/appLogger.ts

@@ -0,0 +1,21 @@
+import { configure, getLogger } from 'log4js';
+import { LOGS_PATH } from './constants';
+
+configure({
+  appenders: {
+    console: { type: 'stdout', layout: { type: 'colored' } },
+    dateFile: {
+      type: 'dateFile',
+      layout: { type: 'basic' },
+      filename: LOGS_PATH,
+      compress: true,
+      daysToKeep: 14,
+      keepFileExt: true
+    }
+  },
+  categories: {
+    default: { appenders: ['console', 'dateFile'], level: process.env.LOG_LEVEL || 'info' }
+  }
+});
+
+export const appLogger = getLogger();

package/src/utils/constants.ts

@@ -0,0 +1 @@
+export const LOGS_PATH = 'log/app.log';

package/src/utils/index.ts

@@ -0,0 +1 @@
+export { appLogger } from './appLogger'

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "exclude": [
+    "node_modules",
+    "lib",
+    "**/*.test*",
+    "**/*.spec*"
+  ],
+  "include": ["src"],
+  "compilerOptions": {
+    "target": "es2016",
+    "module": "commonjs",
+    "declaration": true,
+    "outDir": "./lib",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true
+  }
+}