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

package/lib/services/batchProcessManager.js

@@ -0,0 +1,45 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleBatchProcess = void 0;
+const tokenUtil_1 = require("../utils/tokenUtil");
+const bigidProxyService_1 = require("./bigidProxyService");
+const utils_1 = require("../utils");
+const path_1 = require("path");
+const scriptName = (0, path_1.basename)(__filename).replace('.ts', '');
+const handleBatchProcess = (callback) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        (0, utils_1.logInfo)(`Starting scheduled process: ${callback.name}`);
+        const auth0Token = yield (0, tokenUtil_1.getAuth0Token)();
+        const bigidToken = yield (0, tokenUtil_1.tokenExchange)(auth0Token);
+        const appRegistrations = yield (0, bigidProxyService_1.getTenantRegistrations)(bigidToken);
+        appRegistrations.forEach(tenantRegistration => executeBatchForTenant(auth0Token, tenantRegistration, callback));
+    }
+    catch (err) {
+        (0, utils_1.logError)(`Problem occurred while fetching registrations info: ${err.message}`);
+    }
+});
+exports.handleBatchProcess = handleBatchProcess;
+const executeBatchForTenant = (auth0Token, tenantRegistration, callback) => __awaiter(void 0, void 0, void 0, function* () {
+    const { tenantId, tenantDomain, companyName } = tenantRegistration;
+    try {
+        (0, utils_1.logInfo)(`Fetching token for scheduled process`, { tenantId, functionName: executeBatchForTenant.name, scriptName });
+        const tenantToken = yield (0, tokenUtil_1.tokenExchange)(auth0Token, tenantId);
+        callback(tenantId, tenantDomain, tenantToken);
+    }
+    catch (err) {
+        (0, utils_1.logError)(`Problem occurred while starting scheduled process for tenant: ${companyName}. error: ${err.message}`, {
+            tenantId,
+            functionName: executeBatchForTenant.name,
+            scriptName,
+        });
+    }
+});

package/lib/services/bigidProxyService.d.ts

@@ -1,28 +1,43 @@
-import { ExecutionContext } from "../dto";
-import { ActionResponseDetails } from '../dto/actionResponseDetails';
-export declare const initBigIDProxy: (bigIdUrl: string, callBackUrl: string, bigIdToken: string, tpaId: string) => void;
+import { ActionResponseDetails, ExecutionContext } from '../dto';
+import { TenantRegistration } from '../dto/tenantRegistration';
+export declare enum RequestMethod {
+    POST = "post",
+    GET = "get",
+    PUT = "put",
+    PATCH = "patch",
+    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>;
 /**
  * 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
+ * @param executionContext
+ * @param actionResponseDetails
  */
-export declare const updateActionStatusToBigID: (actionResponseDetails: ActionResponseDetails) => Promise<any>;
+export declare const updateActionStatusToBigID: (executionContext: ExecutionContext, actionResponseDetails: ActionResponseDetails) => Promise<any>;
 /**
  *
+ * @param executionContext
  * @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: (endpoint: string) => Promise<any>;
+export declare const executeHttpGet: (executionContext: ExecutionContext, endpoint: string) => Promise<any>;
 /**
  * the endpoint in BigID, used for POST requests. e.g - {BigIDBaseUrl}/scan
  */
-export declare const executeHttpPost: (endpoint: string, actionResponseDetails: ActionResponseDetails) => Promise<any>;
+export declare const executeHttpPost: (executionContext: ExecutionContext, endpoint: string, obj: any) => Promise<any>;
 /**
  * the endpoint in BigID, used for POST requests. e.g - {BigIDBaseUrl}/scan
  */
-export declare const executeHttpPut: (endpoint: string, obj: any) => Promise<any>;
-export declare const uploadAttachment: (filePathToUpload: string) => import("axios").AxiosPromise<any>;
-export declare const getAppStorage: () => Promise<any>;
-export declare const getValueFromAppStorage: (key: string) => Promise<any>;
-export declare const saveInStorage: (keyToStore: any, valueToStore: any) => Promise<any>;
-export declare const setValuesForBigIDProxy: (executionContext: ExecutionContext) => void;
+export declare const executeHttpPut: (executionContext: ExecutionContext, endpoint: string, obj: any) => Promise<any>;
+/**
+ * the endpoint in BigID, used for DELETE requests.
+ */
+export declare const executeHttpDelete: (executionContext: ExecutionContext, endpoint: string) => Promise<any>;
+export declare const uploadAttachment: (executionContext: ExecutionContext, filePathToUpload: string) => import("axios").AxiosPromise<any>;
+export declare const getAppStorage: (executionContext: ExecutionContext) => Promise<any>;
+export declare const getValueFromAppStorage: (executionContext: ExecutionContext, key: string) => Promise<string>;
+export declare const deleteKeyFromAppStorage: (executionContext: ExecutionContext, key: string) => Promise<void>;
+export declare const sendBiEvent: (executionContext: ExecutionContext, eventType: string, data: Object) => Promise<any>;
+export declare const saveInStorage: (executionContext: ExecutionContext, keyToStore: any, valueToStore: any) => Promise<void>;

package/lib/services/bigidProxyService.js

@@ -12,124 +12,136 @@ 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;
+exports.saveInStorage = exports.sendBiEvent = exports.deleteKeyFromAppStorage = exports.getValueFromAppStorage = exports.getAppStorage = exports.uploadAttachment = exports.executeHttpDelete = exports.executeHttpPut = exports.executeHttpPost = exports.executeHttpGet = exports.updateActionStatusToBigID = exports.doCallToUrl = exports.getTenantRegistrations = exports.RequestMethod = 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);
+var RequestMethod;
+(function (RequestMethod) {
+    RequestMethod["POST"] = "post";
+    RequestMethod["GET"] = "get";
+    RequestMethod["PUT"] = "put";
+    RequestMethod["PATCH"] = "patch";
+    RequestMethod["DELETE"] = "delete";
+})(RequestMethod || (exports.RequestMethod = RequestMethod = {}));
+const getTenantRegistrations = (bigidToken) => __awaiter(void 0, void 0, void 0, function* () {
+    const { data: { data: { tenants }, }, } = yield (0, exports.doCallToUrl)(bigidToken, RequestMethod.GET, `${process.env.BIGID_BASE_URL}/api/v1/tenant-service/applications/registrations`);
+    return tenants;
+});
+exports.getTenantRegistrations = getTenantRegistrations;
+const doCallToUrl = (bigidToken, requestMethod, endpoint, bodyJson) => __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, */*',
+            Accept: 'application/json, text/plain, */*',
             'Content-Type': 'application/json',
-            'Authorization': bigidToken,
+            Authorization: bigidToken,
         };
         const requestObj = {
             method: requestMethod,
             url: endpoint,
             headers: headers,
             httpsAgent: new https_1.Agent({
-                rejectUnauthorized: false
-            })
+                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);
+        (0, utils_1.logInfo)(`<-- bigid-proxy::callBigIdApi: ${endpoint} success`);
         return res;
     }
     catch (error) {
-        utils_1.appLogger.info('<-- bigid-proxy::callBigIdApi: error calling bigID on %s %o', endpoint, error);
-        utils_1.appLogger.error(error);
+        (0, utils_1.logInfo)(`<-- bigid-proxy::callBigIdApi: error calling bigID on endpoint: ${endpoint}, error: ${error}`);
+        (0, utils_1.logError)(error.message);
         return error === null || error === void 0 ? void 0 : error.message;
     }
 });
-function callBigIdApi(requestMethod, endpoint, bodyJson, useEndpointWithoutBigIdBasePath) {
+exports.doCallToUrl = doCallToUrl;
+function callBigIdApi(executionContext, requestMethod, endpoint, bodyJson, useEndpointWithoutBigIdBasePath) {
     return __awaiter(this, void 0, void 0, function* () {
-        const url = useEndpointWithoutBigIdBasePath ? endpoint : bigidUrl + endpoint;
-        return yield doCallToUrl(requestMethod, url, bodyJson);
+        const url = useEndpointWithoutBigIdBasePath ? endpoint : executionContext.bigidBaseUrl + endpoint;
+        return yield (0, exports.doCallToUrl)(executionContext.bigidToken, 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
+ * @param executionContext
+ * @param actionResponseDetails
  */
-const updateActionStatusToBigID = (actionResponseDetails) => __awaiter(void 0, void 0, void 0, function* () {
-    return yield callBigIdApi(RequestMethod.PUT, `${bigidUpdateStatusUrl}`, actionResponseDetails, true);
+const updateActionStatusToBigID = (executionContext, actionResponseDetails) => __awaiter(void 0, void 0, void 0, function* () {
+    return yield callBigIdApi(executionContext, RequestMethod.PUT, executionContext.updateResultCallback, actionResponseDetails, true);
 });
 exports.updateActionStatusToBigID = updateActionStatusToBigID;
 /**
  *
+ * @param executionContext
  * @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); });
+const executeHttpGet = (executionContext, endpoint) => __awaiter(void 0, void 0, void 0, function* () { return yield callBigIdApi(executionContext, 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); });
+const executeHttpPost = (executionContext, endpoint, obj) => __awaiter(void 0, void 0, void 0, function* () { return yield callBigIdApi(executionContext, RequestMethod.POST, endpoint, obj); });
 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); });
+const executeHttpPut = (executionContext, endpoint, obj) => __awaiter(void 0, void 0, void 0, function* () { return yield callBigIdApi(executionContext, RequestMethod.PUT, endpoint, obj); });
 exports.executeHttpPut = executeHttpPut;
-const uploadAttachment = (filePathToUpload) => {
+/**
+ * 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); });
+exports.executeHttpDelete = executeHttpDelete;
+const uploadAttachment = (executionContext, 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,
+        Authorization: executionContext.bigidToken,
     };
     const requestObj = {
         method: RequestMethod.POST,
-        url: `${bigidUpdateStatusUrl}/attachment`,
+        url: `${executionContext.updateResultCallback}/attachment`,
         headers: headers,
         httpsAgent: new https_1.Agent({
-            rejectUnauthorized: false
-        })
+            rejectUnauthorized: false,
+        }),
     };
     requestObj.data = formData;
     return (0, axios_1.default)(requestObj);
 };
 exports.uploadAttachment = uploadAttachment;
-const getAppStorage = () => (0, exports.executeHttpGet)(`tpa/${proxyTpaId}/storage`);
+const getAppStorage = (executionContext) => (0, exports.executeHttpGet)(executionContext, `tpa/${executionContext.tpaId}/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;
+const getValueFromAppStorage = (executionContext, key) => __awaiter(void 0, void 0, void 0, function* () {
+    const { data } = yield (0, exports.executeHttpGet)(executionContext, `tpa/${executionContext.tpaId}/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 }] }); });
+const deleteKeyFromAppStorage = (executionContext, key) => __awaiter(void 0, void 0, void 0, function* () {
+    yield (0, exports.executeHttpDelete)(executionContext, `tpa/${executionContext.tpaId}/storage/key/${key}`);
+});
+exports.deleteKeyFromAppStorage = deleteKeyFromAppStorage;
+const sendBiEvent = (executionContext, eventType, data) => __awaiter(void 0, void 0, void 0, function* () {
+    return (0, exports.executeHttpPost)(executionContext, 'bi-events', { event_type: eventType, data: data });
+});
+exports.sendBiEvent = sendBiEvent;
+const saveInStorage = (executionContext, keyToStore, valueToStore) => __awaiter(void 0, void 0, void 0, function* () {
+    return yield (0, exports.executeHttpPut)(executionContext, `/tpa/${executionContext.tpaId}/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/dataSourceService.d.ts

@@ -0,0 +1,4 @@
+import { ExecutionContext } from '../dto';
+export declare const fetchDataSourceCredentials: (executionContext: ExecutionContext, dataSourceName: string) => Promise<{
+    [key: string]: string;
+}>;

package/lib/services/dataSourceService.js

@@ -0,0 +1,26 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchDataSourceCredentials = void 0;
+const encryptionService_1 = require("./encryptionService");
+const bigidProxyService_1 = require("./bigidProxyService");
+const fetchDataSourceCredentials = (executionContext, dataSourceName) => __awaiter(void 0, void 0, void 0, function* () {
+    const res = yield (0, bigidProxyService_1.executeHttpGet)(executionContext, '/tpa/' + executionContext.tpaId + '/credentials/' + dataSourceName.replace(' ', '%20'));
+    const resData = res.data;
+    return Object.keys(resData).reduce((acc, key) => {
+        var _a;
+        const credentialObject = resData[key];
+        const credentialValue = (_a = credentialObject.value) === null || _a === void 0 ? void 0 : _a.toString();
+        acc[key] = credentialObject.encrypted ? (0, encryptionService_1.decrypt)(credentialValue) : credentialValue;
+        return acc;
+    }, {});
+});
+exports.fetchDataSourceCredentials = fetchDataSourceCredentials;

package/lib/services/encryptionService.d.ts

@@ -0,0 +1 @@
+export declare const decrypt: (encryptedText: string) => string;

package/lib/services/encryptionService.js

@@ -0,0 +1,67 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decrypt = void 0;
+const crypto = __importStar(require("crypto"));
+var Defaults;
+(function (Defaults) {
+    Defaults["SHA_ALGORITHM"] = "sha256";
+    Defaults["AES_ALGORITHM"] = "aes-256-cbc";
+    Defaults["IV"] = "4e5Wa71fYoT7MFEX";
+    Defaults["BASE64_ENC"] = "base64";
+    Defaults["UTF8_ENC"] = "utf8";
+    Defaults["DOLLAR_DEL"] = "$";
+    Defaults["SECRET_KEY"] = "SECRET_KEY";
+})(Defaults || (Defaults = {}));
+const decrypt = (encryptedText) => {
+    const ivAndText = getAndUseOldIvOrNew(encryptedText);
+    const decipher = crypto.createDecipheriv(Defaults.AES_ALGORITHM, makeKey(), ivAndText.iv);
+    let decryptedData = decipher.update(ivAndText.cleanText, Defaults.BASE64_ENC, Defaults.UTF8_ENC);
+    decryptedData += decipher.final(Defaults.UTF8_ENC);
+    return decryptedData;
+};
+exports.decrypt = decrypt;
+const makeKey = () => {
+    var _a;
+    const md = crypto.createHash(Defaults.SHA_ALGORITHM);
+    try {
+        const secretKey = (_a = process.env.APPLICATION_CREDENTIALS_KEY) !== null && _a !== void 0 ? _a : '';
+        const key = md.update(secretKey).digest();
+        return key;
+    }
+    catch (error) {
+        throw new Error("Can't create a key. Check for APPLICATION_CREDENTIALS_KEY in your environment variables.");
+    }
+};
+const getAndUseOldIvOrNew = (text) => {
+    const ivAndText = { iv: Defaults.IV, cleanText: text };
+    if (text.includes(Defaults.DOLLAR_DEL)) {
+        const [cipher_blob, ...cipher_blob2] = text.split(Defaults.DOLLAR_DEL);
+        const cipherBlobPartTwo = cipher_blob2.join(Defaults.DOLLAR_DEL);
+        ivAndText.iv = Buffer.from(cipher_blob, Defaults.BASE64_ENC);
+        ivAndText.cleanText = Buffer.from(cipherBlobPartTwo, Defaults.BASE64_ENC);
+    }
+    return ivAndText;
+};

package/lib/services/index.d.ts

@@ -1 +1,4 @@
 export * from './bigidProxyService';
+export * from './dataSourceService';
+export * from './actionsHubService';
+export { scheduleFunction, unscheduleAllFunctions, unscheduleFunction } from './schedulerService';

package/lib/services/index.js

@@ -1,7 +1,11 @@
 "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]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -10,4 +14,11 @@ 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 });
+exports.unscheduleFunction = exports.unscheduleAllFunctions = exports.scheduleFunction = void 0;
 __exportStar(require("./bigidProxyService"), exports);
+__exportStar(require("./dataSourceService"), exports);
+__exportStar(require("./actionsHubService"), exports);
+var schedulerService_1 = require("./schedulerService");
+Object.defineProperty(exports, "scheduleFunction", { enumerable: true, get: function () { return schedulerService_1.scheduleFunction; } });
+Object.defineProperty(exports, "unscheduleAllFunctions", { enumerable: true, get: function () { return schedulerService_1.unscheduleAllFunctions; } });
+Object.defineProperty(exports, "unscheduleFunction", { enumerable: true, get: function () { return schedulerService_1.unscheduleFunction; } });

package/lib/services/schedulerService.d.ts

@@ -0,0 +1,11 @@
+import { BatchFunction } from './batchProcessManager';
+/**
+ * use this method to call a function execution according to a cron expression.
+ *
+ * @param batchUN - name for the job.
+ * @param cronExpression - the cron expression for the function call.
+ * @param callback - the function that will be called.
+ */
+export declare const scheduleFunction: (batchUN: string, cronExpression: string, callback: BatchFunction) => void;
+export declare const unscheduleFunction: (batchUN: string) => void;
+export declare const unscheduleAllFunctions: () => void;

package/lib/services/schedulerService.js

@@ -0,0 +1,41 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unscheduleAllFunctions = exports.unscheduleFunction = exports.scheduleFunction = void 0;
+const batchProcessManager_1 = require("./batchProcessManager");
+const node_schedule_1 = require("node-schedule");
+const tokenUtil_1 = require("../utils/tokenUtil");
+const scheduleSingleTenantProcess = (batchUN, cronExpression, callback) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!process.env.BIGID_BASE_URL || !process.env.BIGID_REFRESH_TOKEN)
+        throw new Error('Please make sure to fill out BIGID_BASE_URL && BIGID_REFRESH_TOKEN environment variables.');
+    const bigidAccessToken = yield (0, tokenUtil_1.getAccessTokenFromRefreshToken)(process.env.BIGID_REFRESH_TOKEN);
+    (0, node_schedule_1.scheduleJob)(batchUN, cronExpression, () => callback('SINGLE_TENANT', process.env.BIGID_BASE_URL, bigidAccessToken));
+});
+/**
+ * use this method to call a function execution according to a cron expression.
+ *
+ * @param batchUN - name for the job.
+ * @param cronExpression - the cron expression for the function call.
+ * @param callback - the function that will be called.
+ */
+const scheduleFunction = (batchUN, cronExpression, callback) => {
+    process.env.MULTI_TENANT_MODE
+        ? (0, node_schedule_1.scheduleJob)(batchUN, cronExpression, () => (0, batchProcessManager_1.handleBatchProcess)(callback))
+        : scheduleSingleTenantProcess(batchUN, cronExpression, callback);
+};
+exports.scheduleFunction = scheduleFunction;
+const unscheduleFunction = (batchUN) => {
+    const jobToCancel = node_schedule_1.scheduledJobs[batchUN];
+    jobToCancel.cancel();
+};
+exports.unscheduleFunction = unscheduleFunction;
+const unscheduleAllFunctions = () => Object.keys(node_schedule_1.scheduledJobs).forEach(jobName => node_schedule_1.scheduledJobs[jobName].cancel());
+exports.unscheduleAllFunctions = unscheduleAllFunctions;

package/lib/utils/appLogger.d.ts

@@ -1 +1,10 @@
-export declare const appLogger: import("log4js").Logger;
+type LogMetadata = {
+    tenantId: string;
+    functionName: string;
+    scriptName: string;
+};
+export declare const logInfo: (message: string, logMetadata?: LogMetadata) => void;
+export declare const logError: (message: string, logMetadata?: LogMetadata) => void;
+export declare const logWarn: (message: string, logMetadata?: LogMetadata) => void;
+export declare const logDebug: (message: string, logMetadata?: LogMetadata) => void;
+export {};

package/lib/utils/appLogger.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.appLogger = void 0;
+exports.logDebug = exports.logWarn = exports.logError = exports.logInfo = void 0;
 const log4js_1 = require("log4js");
 const constants_1 = require("./constants");
+const USER_LOG_BACKUPS = parseInt(process.env.LOG_BACKUPS + "") || 3;
+const MAX_BACKUPS = 10;
 (0, log4js_1.configure)({
     appenders: {
         console: { type: 'stdout', layout: { type: 'colored' } },
@@ -11,12 +13,41 @@ const constants_1 = require("./constants");
             layout: { type: 'basic' },
             filename: constants_1.LOGS_PATH,
             compress: true,
-            daysToKeep: 14,
-            keepFileExt: true
-        }
+            numBackups: USER_LOG_BACKUPS > MAX_BACKUPS ? MAX_BACKUPS : USER_LOG_BACKUPS,
+            keepFileExt: true,
+        },
     },
     categories: {
-        default: { appenders: ['console', 'dateFile'], level: process.env.LOG_LEVEL || 'info' }
-    }
+        default: { appenders: ['console', 'dateFile'], level: process.env.LOG_LEVEL || 'info' },
+    },
 });
-exports.appLogger = (0, log4js_1.getLogger)();
+const appLogger = (0, log4js_1.getLogger)();
+const formatLog = (message, logMetadata) => {
+    if (!logMetadata)
+        return message;
+    const params = Object.entries(logMetadata)
+        .filter(([value]) => value)
+        .map(([key, value]) => `[${key}: ${value}]`)
+        .join(' ');
+    return `${params} ${message}`;
+};
+const logInfo = (message, logMetadata) => {
+    const logMessage = formatLog(message, logMetadata);
+    appLogger.info(logMessage);
+};
+exports.logInfo = logInfo;
+const logError = (message, logMetadata) => {
+    const logMessage = formatLog(message, logMetadata);
+    appLogger.error(logMessage);
+};
+exports.logError = logError;
+const logWarn = (message, logMetadata) => {
+    const logMessage = formatLog(message, logMetadata);
+    appLogger.warn(logMessage);
+};
+exports.logWarn = logWarn;
+const logDebug = (message, logMetadata) => {
+    const logMessage = formatLog(message, logMetadata);
+    appLogger.debug(logMessage);
+};
+exports.logDebug = logDebug;

package/lib/utils/index.d.ts

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

package/lib/utils/index.js

@@ -1,5 +1,17 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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 });
-exports.appLogger = void 0;
-var appLogger_1 = require("./appLogger");
-Object.defineProperty(exports, "appLogger", { enumerable: true, get: function () { return appLogger_1.appLogger; } });
+__exportStar(require("./appLogger"), exports);

package/lib/utils/tokenUtil.d.ts

@@ -0,0 +1,3 @@
+export declare const getAccessTokenFromRefreshToken: (refreshToken: string) => Promise<string>;
+export declare const getAuth0Token: () => Promise<string>;
+export declare const tokenExchange: (auth0Token: string, tenantId?: string) => Promise<string>;