@bigid/apps-infrastructure-node-js 0.1.0 → 1.180.0

package/lib/utils/tokenUtil.js

@@ -0,0 +1,62 @@
+"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.tokenExchange = exports.getAuth0Token = exports.getAccessTokenFromRefreshToken = void 0;
+const axios_1 = __importDefault(require("axios"));
+const https_1 = require("https");
+const services_1 = require("../services");
+const auth0Payload = {
+    client_id: process.env.CLIENT_ID,
+    client_secret: process.env.CLIENT_SECRET,
+    audience: process.env.AUTH0_AUDIENCE || 'bigid-api-v1',
+    grant_type: 'client_credentials',
+};
+let auth0Token;
+let accessToken;
+const getAccessTokenFromRefreshToken = (refreshToken) => __awaiter(void 0, void 0, void 0, function* () {
+    if (canUseLocalToken(accessToken))
+        return accessToken;
+    const bigidBaseUrl = process.env.BIGID_BASE_URL;
+    const { data: { systemToken }, } = yield (0, services_1.doCallToUrl)(refreshToken, services_1.RequestMethod.GET, new URL('api/v1/refresh-access-token', bigidBaseUrl).toString());
+    accessToken = systemToken;
+    return accessToken;
+});
+exports.getAccessTokenFromRefreshToken = getAccessTokenFromRefreshToken;
+const getAuth0Token = () => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    if (canUseLocalToken(auth0Token))
+        return auth0Token;
+    const auth0Domain = (_a = process.env.AUTH0_DOMAIN) === null || _a === void 0 ? void 0 : _a.replace(/\/$/, '');
+    const { data: { access_token }, } = yield axios_1.default.post(`${auth0Domain}/oauth/token`, auth0Payload);
+    auth0Token = access_token;
+    return access_token;
+});
+exports.getAuth0Token = getAuth0Token;
+const tokenExchange = (auth0Token, tenantId) => __awaiter(void 0, void 0, void 0, function* () {
+    const { data: { data }, } = yield axios_1.default.post(`${process.env.BIGID_BASE_URL}/api/v1/token-exchange`, { tenantId }, {
+        headers: { authorization: auth0Token },
+        httpsAgent: new https_1.Agent({
+            rejectUnauthorized: false,
+        }),
+    });
+    return data[0];
+});
+exports.tokenExchange = tokenExchange;
+const getTokenPayloadAsJson = (token) => JSON.parse(Buffer.from(token.split('.')[1], 'base64').toString());
+const canUseLocalToken = (token) => {
+    if (!token)
+        return false;
+    const { exp } = getTokenPayloadAsJson(token);
+    return Date.now() < exp * 1000;
+};

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "@bigid/apps-infrastructure-node-js",
-  "version": "0.1.0",
+  "version": "1.180.0",
   "description": "",
   "main": "lib/index.js",
+  "scripts": {
+    "docs": "npx tsc && ./node_modules/.bin/jsdoc -c jsdoc.json"
+  },
   "types": "lib/index.d.ts",
   "repository": {
     "type": "git",
@@ -14,6 +17,7 @@
     "@types/express": "^4.17.13",
     "@types/http-errors": "^1.8.1",
     "@types/node": "^16.11.10",
+    "@types/node-schedule": "^2.1.0",
     "@typescript-eslint/eslint-plugin": "4.6.1",
     "@typescript-eslint/parser": "4.6.1",
     "eslint": "7.12.1",
@@ -24,10 +28,13 @@
     "typescript": "^4.5.2"
   },
   "dependencies": {
-    "axios": "^0.24.0",
-    "express": "^4.17.1",
+    "axios": "0.24.0",
+    "follow-redirects": "1.15.2",
+    "express": "4.17.3",
     "form-data": "^4.0.0",
     "http-errors": "^1.8.1",
-    "log4js": "^6.3.0"
+    "jsdoc": "4.0.2",
+    "log4js": "^6.4.0",
+    "node-schedule": "2.1.1"
   }
 }

package/src/abstractProviders/configureProvider.ts

@@ -0,0 +1,15 @@
+import { Request, Response } from 'express';
+
+export type ConfigurePayload = {
+  tenantId: string;
+  bigidBaseUrl?: string;
+  isDeleted?: boolean;
+};
+
+export const handleTenantConfigure = async (req: Request, res: Response, configureProvider: ConfigureProvider) => {
+  await configureProvider.configureTenant(req.body, res);
+};
+
+export abstract class ConfigureProvider {
+  public abstract configureTenant(configurePayload: ConfigurePayload, res: Response): Promise<void> | void;
+}

package/src/abstractProviders/executionProvider.ts

@@ -1,6 +1,5 @@
 import { Request, Response } from 'express';
-import { ActionResponseDetails } from '../dto/actionResponseDetails';
-import { setValuesForBigIDProxy } from '../services';
+import { ActionResponseDetails, ExecutionContext } from '../dto';
 
 export const StatusEnum = {
   COMPLETED: 'COMPLETED',
@@ -9,12 +8,11 @@ export const StatusEnum = {
 };
 
 export const handleExecution = async (req: Request, res: Response, executionProvider: ExecutionProvider) => {
-  setValuesForBigIDProxy(req.body);
-  await executionProvider.executeAction(req, res);
+  await executionProvider.executeAction(req.body, res);
 };
 
 export abstract class ExecutionProvider {
-  public abstract executeAction(req: Request, res: Response): Promise<void>;
+  public abstract executeAction(executionContext: ExecutionContext, res: Response): Promise<void>;
 
   generateSyncSuccessMessage = (res: Response, executionId: string, message: string) =>
     res.status(200).json(new ActionResponseDetails(executionId, StatusEnum.COMPLETED, 1, message));
@@ -22,6 +20,6 @@ export abstract class ExecutionProvider {
   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));
+  generateFailedResponse = (res: Response, executionId: string, errorMessage: string) =>
+    res.status(400).json(new ActionResponseDetails(executionId, StatusEnum.ERROR, 0, errorMessage));
 }

package/src/abstractProviders/index.ts

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

package/src/abstractProviders/logsProvider.ts

@@ -1,6 +1,14 @@
-import { createReadStream } from 'fs';
+import { readFileSync } 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);
+export const fetchLogs = (req: Request, res: Response) => {
+  const tenantId = req.headers.tenantid;
+  const data = readFileSync(LOGS_PATH, { encoding: 'utf8' });
+  const lines = data.split('\n');
+  const tenantLogLines = lines
+    .filter(line => line.includes(`[tenantId: ${tenantId}`) || !line.includes('[tenantId: '))
+    .join('\n');
+
+  return res.send(tenantLogLines);
+};

package/src/abstractProviders/manifestProvider.ts

@@ -1,3 +1,5 @@
+import { Response, Request } from 'express';
+
 export abstract class ManifestProvider {
-  public abstract getManifest(req: any, res: any): string;
+  public abstract getManifest(req: Request, res: Response): Response;
 }

package/src/dto/actionResponseDetails.ts

@@ -1,15 +1,19 @@
+import { SubExecutionItem } from "./subExecutionItem";
+
 export class ActionResponseDetails {
   executionId: string;
   statusEnum: string;
   progress: number;
   message: string;
   additionalData?: any;
+  subExecutionItems?: SubExecutionItem[];
 
-  constructor(executionId: string, statusEnum: string, progress: number, message: string, additionalData?: any) {
+  constructor(executionId: string, statusEnum: string, progress: number, message: string, additionalData?: any, subExecutionItems?: SubExecutionItem[]) {
     this.executionId = executionId;
     this.statusEnum = statusEnum;
     this.progress = progress;
     this.message = message;
     this.additionalData = additionalData;
+    this.subExecutionItems = subExecutionItems;
   }
 }

package/src/dto/executionContext.ts

@@ -1,30 +1,15 @@
-export class ExecutionContext {
+export type ExecutionContext = {
   actionName: string;
   executionId: string;
-  globalParams: Record<string, string>;
-  actionParams: Record<string, string>;
+  globalParams: Array<GeneralParam>;
+  actionParams: Array<GeneralParam>;
   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;
-  }
-}
+export type GeneralParam = {
+  paramName: string;
+  paramValue: string;
+};

package/src/dto/index.ts

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

package/src/dto/subExecutionItem.ts

@@ -0,0 +1,13 @@
+export class SubExecutionItem {
+  name: string;
+  statusEnum: string;
+  message?: string;
+  errorCode?: string;
+
+  constructor(name: string, statusEnum: string, message?: string, errorCode?: string) {
+    this.name = name;
+    this.statusEnum = statusEnum;
+    this.message = message;
+    this.errorCode = errorCode;
+  }
+}

package/src/dto/tenantRegistration.ts

@@ -0,0 +1,5 @@
+export type TenantRegistration = {
+  tenantId: string;
+  tenantDomain: string;
+  companyName: string;
+};

package/src/index.ts

@@ -1,5 +1,21 @@
 export * from './abstractProviders';
 export * from './dto';
 export * from './utils';
-export { updateActionStatusToBigID, uploadAttachment, getValueFromAppStorage, saveInStorage, executeHttpGet } from './services';
+export {
+  updateActionStatusToBigID,
+  uploadAttachment,
+  getValueFromAppStorage,
+  saveInStorage,
+  executeHttpGet,
+  scheduleFunction,
+  unscheduleFunction,
+  unscheduleAllFunctions,
+  deleteKeyFromAppStorage,
+  sendBiEvent,
+  getCommandsRegistrations,
+  executeCommand,
+  getExecutionStatus,
+  registerActionAsCommand,
+  fetchDataSourceCredentials,
+} from './services';
 export { deployServer, ServerInit } from './server';

package/src/server.ts

@@ -1,36 +1,49 @@
-import express, { NextFunction, Request, Response } from 'express';
-import { ManifestProvider } from './abstractProviders/manifestProvider';
-import { appLogger } from './utils/appLogger';
-import { IconsProviders } from './abstractProviders/iconsProviders';
+import express, { Express, NextFunction, Request, Response } from 'express';
+import { ManifestProvider } from './abstractProviders';
+import { logInfo, logError } from './utils';
+import { IconsProviders } from './abstractProviders';
 import { ExecutionProvider, handleExecution } from './abstractProviders/executionProvider';
 import { fetchLogs } from './abstractProviders/logsProvider';
 import createError from 'http-errors';
+import { ConfigureProvider, handleTenantConfigure } from './abstractProviders/configureProvider';
 
-export interface ServerInit {
+export type ServerInit = {
   manifestController: ManifestProvider;
   iconsController: IconsProviders;
-  executionController: ExecutionProvider;
+  executionController?: ExecutionProvider;
+  configureController?: ConfigureProvider;
   serverPort?: number;
-}
+  additionalEndpoints?: (app: Express) => void;
+};
 
 const app = express();
 
-export const deployServer = (serverInit: ServerInit) => {
+export const deployServer = ({
+  manifestController,
+  iconsController,
+  executionController,
+  serverPort,
+  configureController,
+  additionalEndpoints,
+}: ServerInit): void => {
   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.get('/assets/icon', (req, res) => res.sendFile(iconsController.getIconPath()));
+  app.get('/assets/sideBarIcon', (req, res) => res.sendFile(iconsController.getSideBarIconPath()));
+  app.get('/manifest', manifestController.getManifest);
+  app.get('/logs', async (req: Request, res: Response) => await fetchLogs(req, res));
+
+  executionController &&
+    app.post('/execute', async (req: Request, res: Response) => await handleExecution(req, res, executionController));
+  configureController &&
+    app.post(
+      '/configure',
+      async (req: Request, res: Response) => await handleTenantConfigure(req, res, configureController),
+    );
+  additionalEndpoints && additionalEndpoints(app);
 
-  app.listen(process.env.PORT || serverInit.serverPort, () =>
-    appLogger.info(`Started server at port ${process.env.PORT || serverInit.serverPort}`),
-  );
+  app.listen(process.env.PORT || serverPort, () => logInfo(`Started server at port ${process.env.PORT || serverPort}`));
 
   // catch 404 and forward to error handler
   app.use((req: Request, res: Response, next: NextFunction) => next(createError(404)));
@@ -38,7 +51,7 @@ export const deployServer = (serverInit: ServerInit) => {
   // error handler
   app.use((err: any, req: Request, res: Response, next: NextFunction) => {
     const { message, status } = err;
-    appLogger.error(err);
+    logError(err);
     res.locals.message = message;
     res.locals.error = req.app.get('env') === 'development' ? err : {};
 

package/src/services/actionsHubService.ts

@@ -0,0 +1,141 @@
+import { doCallToUrl, RequestMethod } from './bigidProxyService';
+import { getAccessTokenFromRefreshToken } from '../utils/tokenUtil';
+
+const REFRESH_TOKEN = process.env.BIGID_REFRESH_TOKEN;
+
+const getBigidAccessToken = async (): Promise<string> => {
+  if (!REFRESH_TOKEN) {
+    throw new Error('BIGID_REFRESH_TOKEN must be supplied as an ENV var in order to call bigid actions hub');
+  }
+
+  return await getAccessTokenFromRefreshToken(REFRESH_TOKEN);
+};
+
+export type Param = {
+  name: string;
+  value: string;
+};
+
+export type Command = {
+  actionName: string;
+  command: string;
+  params: Param[];
+  id: string;
+};
+
+/**
+ * use this method to get the currently registered action-center commands.
+ * the method is building an execution context for the api call, so you must provide REFRESH_TOKEN and BIGID_BASE_URL as ENV variables
+ *
+ * @return {Promise<Command[]>} array of the action-center register commands
+ */
+export const getCommandsRegistrations = async (): Promise<Command[]> => {
+  try {
+    const bigidToken = await getBigidAccessToken();
+    const {
+      data: { commands },
+    } = await doCallToUrl(
+      bigidToken,
+      RequestMethod.GET,
+      `${process.env.BIGID_BASE_URL}/api/v1/action-center/general-commands`,
+    );
+    return commands;
+  } catch (e) {
+    throw new Error(`Could not get commands registrations from bigid: ${e}`);
+  }
+};
+
+/**
+ * use this method to execute an action-center commands.
+ * this method is used without endpoint for getting status messages, but rather return an execution id.
+ * the execution id can be used to poll the current execution status of the executed command.
+ *
+ * @param {string} actionName - the action name to be executed.
+ * @param {string} command    - the command to be executed.
+ * @param {string} requestorAppName - the app name of the execution requestor.
+ * @param {string} webhookEndpoint - the endpoint of the requestor app to receive execution status messages.
+ * @param {Record<string, any>} params - the relevant params of the action to be executed.
+ * @return {Promise<string>} execution id of the executed action.
+ */
+export const executeCommand = async (
+  actionName: string,
+  command: string,
+  requestorAppName?: string,
+  webhookEndpoint?: string,
+  params?: Record<string, any>[],
+): Promise<string> => {
+  try {
+    const bigidToken = await getBigidAccessToken();
+    const {
+      data: { executionId },
+    } = await doCallToUrl(
+      bigidToken,
+      RequestMethod.POST,
+      `${process.env.BIGID_BASE_URL}/api/v1/action-center/general-commands/execute`,
+      {
+        actionName,
+        command,
+        feedbackRequestorDetails:
+          requestorAppName && webhookEndpoint
+            ? {
+              requestorAppName,
+              requestorFeedbackEndpoint: webhookEndpoint,
+            }
+            : null,
+        ...(params && { params }),
+      },
+    );
+    return executionId;
+  } catch (e) {
+    throw new Error(`Could not execute ${command}: ${e}`);
+  }
+};
+
+/**
+ * use this method to poll an execution status from the action-center.
+ *
+ * @param {string} execution - the execution id to poll status for.
+ * @return object with the updated status details.
+ */
+export const getExecutionStatus = async (executionId: string): Promise<any> => {
+  try {
+    const bigidToken = await getBigidAccessToken();
+    const { data } = await doCallToUrl(
+      bigidToken,
+      RequestMethod.GET,
+      `${process.env.BIGID_BASE_URL}/api/v1/action-center/general-commands/execute/${executionId}`,
+    );
+    return data;
+  } catch (e) {
+    throw new Error(`Could not get status for execution id ${executionId}: ${e}`);
+  }
+};
+
+/**
+ * use this method to register application action as an action center command.
+ *
+ * @param {string} applicationName - the application name of the command to be registered.
+ * @param {string} actionName - the action name of the command to be registered.
+ * @param {string} command - the command to be registered.
+ */
+export const registerActionAsCommand = async (
+  applicationName: string,
+  actionName: string,
+  command: string,
+): Promise<void> => {
+  try {
+    const bigidToken = await getBigidAccessToken();
+    await doCallToUrl(
+      bigidToken,
+      RequestMethod.POST,
+      `${process.env.BIGID_BASE_URL}/api/v1/action-center/general-commands/register`,
+      {
+        applicationName,
+        actionName,
+        command,
+      },
+    );
+  } catch (e) {
+    throw new Error(`Could not register ${command}: ${e}`);
+  }
+};

package/src/services/batchProcessManager.ts

@@ -0,0 +1,39 @@
+import { getAuth0Token, tokenExchange } from '../utils/tokenUtil';
+import { getTenantRegistrations } from './bigidProxyService';
+import { TenantRegistration } from '../dto/tenantRegistration';
+import { logError, logInfo } from '../utils';
+import { basename } from 'path';
+
+export type BatchFunction = (tenantId: string, tenantDomain: string, tenantToken: string) => void;
+const scriptName = basename(__filename).replace('.ts', '');
+
+export const handleBatchProcess = async (callback: BatchFunction): Promise<void> => {
+  try {
+    logInfo(`Starting scheduled process: ${callback.name}`);
+    const auth0Token = await getAuth0Token();
+    const bigidToken = await tokenExchange(auth0Token);
+    const appRegistrations = await getTenantRegistrations(bigidToken);
+    appRegistrations.forEach(tenantRegistration => executeBatchForTenant(auth0Token, tenantRegistration, callback));
+  } catch (err: any) {
+    logError(`Problem occurred while fetching registrations info: ${err.message}`);
+  }
+};
+
+const executeBatchForTenant = async (
+  auth0Token: string,
+  tenantRegistration: TenantRegistration,
+  callback: BatchFunction,
+): Promise<void> => {
+  const { tenantId, tenantDomain, companyName } = tenantRegistration;
+  try {
+    logInfo(`Fetching token for scheduled process`, { tenantId, functionName: executeBatchForTenant.name, scriptName });
+    const tenantToken = await tokenExchange(auth0Token, tenantId);
+    callback(tenantId, tenantDomain, tenantToken);
+  } catch (err: any) {
+    logError(`Problem occurred while starting scheduled process for tenant: ${companyName}. error: ${err.message}`, {
+      tenantId,
+      functionName: executeBatchForTenant.name,
+      scriptName,
+    });
+  }
+};