skyeye-svc-common-utils 0.0.209 → 0.0.211

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skyeye-svc-common-utils",
-  "version": "0.0.209",
+  "version": "0.0.211",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -33,6 +33,9 @@
     "@types/jsonwebtoken": "^8.3.7",
     "@types/swagger-jsdoc": "^3.0.2",
     "@types/swagger-ui-express": "^4.1.1",
+    "@types/ioredis": "^4.26.4",
+    "ioredis": "^4.27.6",
+    "cron-parser": "^4.6.0",
     "async-mutex": "^0.3.2",
     "azure-storage": "^2.10.3",
     "dateformat": "^3.0.3",

package/src/index.ts

@@ -18,4 +18,5 @@ export * from './lib/azure/azureBlobStorage';
 export * from './utils/documentation/swagger';
 export * from './lib/httpClient';
 export * from './utils/monitoring/apm';
-export * from './models/baseControllerParameter';
+export * from './models/baseControllerParameter';
+export * from './lib/redisClient';

package/src/lib/redisClient.ts

@@ -0,0 +1,115 @@
+import Redis, { RedisOptions } from 'ioredis';
+import { logger } from '../utils/logger/logger';
+import { commonAppConst } from '../utils/appConst'
+
+/**
+ * A wrapper class for Redis client that adds error handling and logging
+ */
+ class RedisClient extends Redis {
+    /**
+     * @constructor
+     * @param {RedisOptions} options - config options for redis connection
+     */
+    constructor(options: RedisOptions) {
+        super(options);
+        // emits immediately right after the connect event.
+        this.on("ready", () => {
+            logger.info(`RedisClient connected, host: ${options.host}, port: ${options.port}`);
+        });
+        // emits when an error occurs while connecting.
+        this.on("error", (err) => {
+            logger.error(`RedisClient connection error: ${err}`);
+        });
+    }
+
+    /**
+     * @override It returns the value of the key from the Redis database.
+     * @param {string} key - The key to get the value of.
+     * @returns {Promise<string | null>} Value of the key.
+     */
+    async get(key: string): Promise<string | null> {
+        logger.info("start RedisClient.get");
+        try {
+            return super.get(key);
+        } catch (err) {
+            logger.warn(`RedisClient/get error: ${err}`);
+            return null;
+        }
+    }
+
+    /**
+     * It sets a key-value pair in the Redis cache.
+     * @param {string} key - The key to store the value in.
+     * @param {any} value - The value for the key
+     * @param {number} time - Time to live, in seconds
+     * @returns {Promise<boolean>} A boolean to tell whether it is able to set a key in redis.
+     */
+    async put(
+        key: string,
+        value: any,
+        time: number = commonAppConst.redis.TTLfor5min
+    ): Promise<boolean> {
+        logger.info("start RedisClient.put");
+        try {
+            return Promise.resolve(!!await super.set(key, value, commonAppConst.redis.expiryMode.inSeconds, time));
+        } catch (err) {
+            logger.warn(`RedisClient/put error: ${err}`);
+            return Promise.resolve(false);
+        }
+    }
+
+    /**
+     * It locks a key in redis with a default TTL of 5 minutes, if possible.
+     * @param {string} key - The key to lock.
+     * @param {number} time - Time to live, in seconds
+     * @returns {Promise<boolean>} A boolean to tell whether it is able to lock the key.
+     */
+    async lock(
+        key: string,
+        time: number = commonAppConst.redis.TTLfor5min
+    ): Promise<boolean> {
+        logger.info("start RedisClient.lock");
+        try {
+            return Promise.resolve(!!await super.set(key, null, commonAppConst.redis.expiryMode.inSeconds, time, commonAppConst.redis.setMode.setIfNotExist));
+        } catch (err) {
+            logger.error(`RedisClient/lock error: ${err}`);
+            return Promise.resolve(false);
+        }
+    }
+
+    /**
+     * If the key is locked (i.e. key exists in redis), return true, otherwise return false.
+     * @param {string} key - the key to check
+     * @returns {Promise<boolean>} A boolean to tell whether a key is locked in redis.
+     */
+    async isLocked(key: string): Promise<boolean> {
+        logger.info("start RedisClient.isLocked");
+        try {
+            return !!await super.exists(key);
+        } catch (err) {
+            logger.warn(`RedisClient/isLocked error: ${err}`);
+            return Promise.resolve(true);
+        }
+    }
+
+    /**
+     * It unlocks a key in redis.
+     * @param {string} key - The key to unlock.
+     */
+    async unlock(key: string): Promise<void> {
+        logger.info("start RedisClient.unlock");
+        try {
+            await super.del(key);
+        } catch (err) {
+            logger.error(`RedisClient/unlock error: ${err}`);
+        }
+    }
+}
+
+const options: RedisOptions = {
+    host: process.env.REDIS_URL,
+    port: Number(process.env.REDIS_PORT),
+    password: process.env.REDIS_PRIMARY_SECRET,
+    tls: {} // do not remove the ssl connection default config
+}
+export const redisClient = new RedisClient(options);

package/src/utils/appConst.ts

@@ -31,6 +31,15 @@ export const commonAppConst = {
 		id: "id",
 		createdDate: "createdDate",
 		lastModifiedDate: "lastModifiedDate"
+	},
+	redis: {
+		expiryMode: {
+			inSeconds: "ex"
+		},
+		TTLfor5min: 300, //5 minutes by default
+		setMode: {
+			setIfNotExist: 'nx'
+		}
 	}
 }
 

package/src/utils/commonUtils/cronUtils.ts

@@ -0,0 +1,25 @@
+import parser, { ParserOptions, CronExpression } from 'cron-parser';
+import { logger } from '../logger/logger';
+
+/**
+ * @description Get previous or next date given start date, cron expression and flag
+ * @param {string} cron - Cron expression
+ * @param {Date} [startDate] - a starting date
+ * @param {boolean} [getNext] - boolean value to indicate getting previous or next date
+ * @returns {Date} - the resultant date
+ * @throws Unexpected error
+ */
+export function getDateFromCron(cron: string, startDate: Date = new Date(), getNext: boolean = false): Date | never {
+
+    let options: ParserOptions = { 
+        currentDate: startDate 
+    };
+    try {
+        const interval: CronExpression = parser.parseExpression(cron, options);
+        const val = getNext ? interval.next() : interval.prev();
+        return val.toDate();
+    } catch (err) {
+        logger.error(`getDateFromCron with error, ${err}`);
+        throw err;
+    }
+}

package/src/utils/commonUtils/index.ts

@@ -1,4 +1,5 @@
 export * from './appUtils';
 export * from './responseUtils';
 export * from './validation';
-export * from './jwtUtils';
+export * from './jwtUtils';
+export * from './cronUtils';