lemon-core 4.1.14 → 4.2.0

package/dist/cores/cache/cache-service.js

@@ -1,18 +1,12 @@
 "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.fromTTL = exports.toTTL = exports.sleep = exports.DummyCacheService = exports.CacheService = void 0;
+exports.DummyCacheService = exports.CacheService = void 0;
+exports.sleep = sleep;
+exports.toTTL = toTTL;
+exports.fromTTL = fromTTL;
 /**
  * `cache-services.ts`
  * - common service for remote cache
@@ -36,23 +30,43 @@ const NS = engine_1.$U.NS('CCHS', 'green'); // NAMESPACE TO BE PRINTED.
  */
 class CacheService {
     /**
-     * Protected constructor -> use CacheService.create()
-     * WARN! - do not create directly.˜
-     *
-     * @param backend  cache backend object
-     * @param params   params to create service.
-     * @protected
+     * Environment variable name for cache server endpoint
+     * @static
      */
-    constructor(backend, params) {
-        if (!backend)
-            throw new Error(`@backend (cache-backend) is required!`);
-        const ns = (params === null || params === void 0 ? void 0 : params.ns) || '';
-        (0, engine_1._inf)(NS, `! cache-service instantiated with [${backend.name}] backend. [ns=${ns}]`);
-        this.backend = backend;
-        this.ns = ns;
-        this.options = params.options;
-        this.maker = params === null || params === void 0 ? void 0 : params.maker;
-    }
+    static ENV_CACHE_ENDPOINT = 'CACHE_ENDPOINT';
+    /**
+     * Environment variable name for default cache timeout
+     * @static
+     */
+    static ENV_CACHE_DEFAULT_TIMEOUT = 'CACHE_DEFAULT_TIMEOUT';
+    /**
+     * Default cache timeout
+     * @static
+     */
+    static DEF_CACHE_DEFAULT_TIMEOUT = 24 * 60 * 60; // 1-day
+    /**
+     * Namespace delimiter
+     * @private
+     * @static
+     */
+    static NAMESPACE_DELIMITER = '::';
+    /**
+     * Namespace of cache key
+     */
+    ns;
+    /**
+     * the final options to create this service.
+     */
+    options;
+    /**
+     * maker of cache-key
+     */
+    maker;
+    /**
+     * Cache backend instance
+     * @private
+     */
+    backend;
     /**
      * Factory method
      *
@@ -61,11 +75,11 @@ class CacheService {
      * @static
      */
     static create(options, maker) {
-        const type = (options === null || options === void 0 ? void 0 : options.type) || 'redis';
-        const endpoint = (options === null || options === void 0 ? void 0 : options.endpoint) || engine_1.$U.env(CacheService.ENV_CACHE_ENDPOINT);
-        const ns = (options === null || options === void 0 ? void 0 : options.ns) || '';
-        const defTimeout = engine_1.$U.N(options === null || options === void 0 ? void 0 : options.defTimeout, engine_1.$U.N(engine_1.$U.env(CacheService.ENV_CACHE_DEFAULT_TIMEOUT), CacheService.DEF_CACHE_DEFAULT_TIMEOUT));
-        options = Object.assign(Object.assign({}, options), { type, endpoint, ns, defTimeout });
+        const type = options?.type || 'redis';
+        const endpoint = options?.endpoint || engine_1.$U.env(CacheService.ENV_CACHE_ENDPOINT);
+        const ns = options?.ns || '';
+        const defTimeout = engine_1.$U.N(options?.defTimeout, engine_1.$U.N(engine_1.$U.env(CacheService.ENV_CACHE_DEFAULT_TIMEOUT), CacheService.DEF_CACHE_DEFAULT_TIMEOUT));
+        options = { ...options, type, endpoint, ns, defTimeout };
         (0, engine_1._log)(NS, `constructing [${type}] cache ...`);
         (0, engine_1._log)(NS, ` > endpoint =`, endpoint);
         (0, engine_1._log)(NS, ` > ns =`, ns);
@@ -83,6 +97,24 @@ class CacheService {
         }
         return new CacheService(backend, { ns, options, maker });
     }
+    /**
+     * Protected constructor -> use CacheService.create()
+     * WARN! - do not create directly.˜
+     *
+     * @param backend  cache backend object
+     * @param params   params to create service.
+     * @protected
+     */
+    constructor(backend, params) {
+        if (!backend)
+            throw new Error(`@backend (cache-backend) is required!`);
+        const ns = params?.ns || '';
+        (0, engine_1._inf)(NS, `! cache-service instantiated with [${backend.name}] backend. [ns=${ns}]`);
+        this.backend = backend;
+        this.ns = ns;
+        this.options = params.options;
+        this.maker = params?.maker;
+    }
     /**
      * Say hello
      */
@@ -105,41 +137,35 @@ class CacheService {
     /**
      * Close backend and connection
      */
-    close() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.backend.close();
-        });
+    async close() {
+        await this.backend.close();
     }
     /**
      * Check whether the key is cached
      *
      * @return  true if the key is cached
      */
-    exists(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const namespacedKey = this.asNamespacedKey(key);
-            const ret = yield this.backend.has(namespacedKey);
-            (0, engine_1._log)(NS, `.exists ${namespacedKey} / ret =`, typeof ret === 'string' ? ret : engine_1.$U.json(ret));
-            return ret;
-        });
+    async exists(key) {
+        const namespacedKey = this.asNamespacedKey(key);
+        const ret = await this.backend.has(namespacedKey);
+        (0, engine_1._log)(NS, `.exists ${namespacedKey} / ret =`, typeof ret === 'string' ? ret : engine_1.$U.json(ret));
+        return ret;
     }
     /**
      * List all keys
      *
      * @return  list of keys
      */
-    keys() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const namespacedKeys = yield this.backend.keys();
-            const ret = namespacedKeys.reduce((keys, namespacedKey) => {
-                const [ns, key] = namespacedKey.split(CacheService.NAMESPACE_DELIMITER);
-                if (ns === this.ns)
-                    keys.push(key);
-                return keys;
-            }, []);
-            (0, engine_1._log)(NS, `.keys / ret =`, typeof ret === 'string' ? ret : engine_1.$U.json(ret));
-            return ret;
-        });
+    async keys() {
+        const namespacedKeys = await this.backend.keys();
+        const ret = namespacedKeys.reduce((keys, namespacedKey) => {
+            const [ns, key] = namespacedKey.split(CacheService.NAMESPACE_DELIMITER);
+            if (ns === this.ns)
+                keys.push(key);
+            return keys;
+        }, []);
+        (0, engine_1._log)(NS, `.keys / ret =`, typeof ret === 'string' ? ret : engine_1.$U.json(ret));
+        return ret;
     }
     /**
      * Store a key
@@ -149,18 +175,16 @@ class CacheService {
      * @param timeout   (optional) TTL in seconds or Timeout object
      * @return  true on success
      */
-    set(key, val, timeout) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!key)
-                throw new Error(`@key (CacheKey) is required.`);
-            if (val === undefined)
-                throw new Error(`@val (CacheValue) cannot be undefined.`);
-            const namespacedKey = this.asNamespacedKey(key);
-            const ttl = timeout && toTTL(timeout);
-            const ret = yield this.backend.set(namespacedKey, val, ttl);
-            (0, engine_1._log)(NS, `.set ${namespacedKey} ${val} / ret =`, typeof ret === 'string' ? ret : engine_1.$U.json(ret));
-            return ret;
-        });
+    async set(key, val, timeout) {
+        if (!key)
+            throw new Error(`@key (CacheKey) is required.`);
+        if (val === undefined)
+            throw new Error(`@val (CacheValue) cannot be undefined.`);
+        const namespacedKey = this.asNamespacedKey(key);
+        const ttl = timeout && toTTL(timeout);
+        const ret = await this.backend.set(namespacedKey, val, ttl);
+        (0, engine_1._log)(NS, `.set ${namespacedKey} ${val} / ret =`, typeof ret === 'string' ? ret : engine_1.$U.json(ret));
+        return ret;
     }
     /**
      * Store multiple keys
@@ -168,61 +192,55 @@ class CacheService {
      * @param entries
      * @return  true on success
      */
-    setMulti(entries) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const param = entries.map(({ key, val, timeout }, idx) => {
-                if (!key)
-                    throw new Error(`.key (CacheKey) is required (at @entries[${idx}]).`);
-                if (val === undefined)
-                    throw new Error(`.val (CacheValue) cannot be undefined (at @entries[${idx}]).`);
-                return {
-                    key: this.asNamespacedKey(key),
-                    val,
-                    ttl: timeout && toTTL(timeout),
-                };
-            });
-            const ret = yield this.backend.mset(param);
-            (0, engine_1._log)(NS, `.setMulti ${entries.map(entry => entry.key)} / ret =`, typeof ret === 'string' ? ret : engine_1.$U.json(ret));
-            return ret;
+    async setMulti(entries) {
+        const param = entries.map(({ key, val, timeout }, idx) => {
+            if (!key)
+                throw new Error(`.key (CacheKey) is required (at @entries[${idx}]).`);
+            if (val === undefined)
+                throw new Error(`.val (CacheValue) cannot be undefined (at @entries[${idx}]).`);
+            return {
+                key: this.asNamespacedKey(key),
+                val,
+                ttl: timeout && toTTL(timeout),
+            };
         });
+        const ret = await this.backend.mset(param);
+        (0, engine_1._log)(NS, `.setMulti ${entries.map(entry => entry.key)} / ret =`, typeof ret === 'string' ? ret : engine_1.$U.json(ret));
+        return ret;
     }
     /**
      * Retrieve a key
      *
      * @param key
      */
-    get(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!key)
-                throw new Error(`@key (CacheKey) is required.`);
-            const namespacedKey = this.asNamespacedKey(key);
-            const ret = yield this.backend.get(namespacedKey);
-            (0, engine_1._log)(NS, `.get ${namespacedKey} / ret =`, typeof ret === 'string' ? ret : engine_1.$U.json(ret));
-            return ret;
-        });
+    async get(key) {
+        if (!key)
+            throw new Error(`@key (CacheKey) is required.`);
+        const namespacedKey = this.asNamespacedKey(key);
+        const ret = await this.backend.get(namespacedKey);
+        (0, engine_1._log)(NS, `.get ${namespacedKey} / ret =`, typeof ret === 'string' ? ret : engine_1.$U.json(ret));
+        return ret;
     }
     /**
      * Get multiple keys
      *
      * @param keys
      */
-    getMulti(keys) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const namespacedKeys = keys.map((key, idx) => {
-                if (!key)
-                    throw new Error(`@key (CacheKey) is required (at @keys[${idx}]).`);
-                return this.asNamespacedKey(key);
-            });
-            const map = yield this.backend.mget(namespacedKeys);
-            // Remove namespace prefix from keys
-            const ret = Object.entries(map).reduce((newMap, [namespacedKey, val]) => {
-                const key = namespacedKey.split(CacheService.NAMESPACE_DELIMITER)[1];
-                newMap[key] = val;
-                return newMap;
-            }, {});
-            (0, engine_1._log)(NS, `.getMulti ${namespacedKeys} / ret =`, typeof ret === 'string' ? ret : engine_1.$U.json(ret));
-            return ret;
+    async getMulti(keys) {
+        const namespacedKeys = keys.map((key, idx) => {
+            if (!key)
+                throw new Error(`@key (CacheKey) is required (at @keys[${idx}]).`);
+            return this.asNamespacedKey(key);
         });
+        const map = await this.backend.mget(namespacedKeys);
+        // Remove namespace prefix from keys
+        const ret = Object.entries(map).reduce((newMap, [namespacedKey, val]) => {
+            const key = namespacedKey.split(CacheService.NAMESPACE_DELIMITER)[1];
+            newMap[key] = val;
+            return newMap;
+        }, {});
+        (0, engine_1._log)(NS, `.getMulti ${namespacedKeys} / ret =`, typeof ret === 'string' ? ret : engine_1.$U.json(ret));
+        return ret;
     }
     /**
      * Increment the integer value of a key
@@ -230,17 +248,15 @@ class CacheService {
      * @param key
      * @param inc   number to increment
      */
-    increment(key, inc) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!key)
-                throw new Error(`@key (CacheKey) is required.`);
-            if (inc === undefined)
-                throw new Error(`@inc (number) cannot be undefined.`);
-            const namespacedKey = this.asNamespacedKey(key);
-            const ret = yield this.backend.incr(namespacedKey, inc);
-            (0, engine_1._log)(NS, `.increment ${namespacedKey} ${inc} / ret =`, typeof ret === 'string' ? ret : engine_1.$U.json(ret));
-            return ret;
-        });
+    async increment(key, inc) {
+        if (!key)
+            throw new Error(`@key (CacheKey) is required.`);
+        if (inc === undefined)
+            throw new Error(`@inc (number) cannot be undefined.`);
+        const namespacedKey = this.asNamespacedKey(key);
+        const ret = await this.backend.incr(namespacedKey, inc);
+        (0, engine_1._log)(NS, `.increment ${namespacedKey} ${inc} / ret =`, typeof ret === 'string' ? ret : engine_1.$U.json(ret));
+        return ret;
     }
     /**
      * same as increment()
@@ -251,52 +267,48 @@ class CacheService {
     /**
      * Set the value of a key and return its old value
      */
-    getAndSet(key, val) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!key)
-                throw new Error(`@key (CacheKey) is required.`);
-            if (val === undefined)
-                throw new Error(`@val (CacheValue) cannot be undefined.`);
-            const namespacedKey = this.asNamespacedKey(key);
-            let ret;
-            if (this.backend.getset) {
-                ret = yield this.backend.getset(namespacedKey, val);
-            }
-            else {
-                ret = yield this.backend.get(namespacedKey);
-                // Best effort to keep remaining TTL
-                let ttl = yield this.backend.ttl(namespacedKey);
-                if (ttl !== undefined) {
-                    ttl = Math.ceil(ttl / 1000);
-                }
-                if (!(yield this.backend.set(namespacedKey, val, ttl)))
-                    throw new Error(`getAndSet() failed`);
+    async getAndSet(key, val) {
+        if (!key)
+            throw new Error(`@key (CacheKey) is required.`);
+        if (val === undefined)
+            throw new Error(`@val (CacheValue) cannot be undefined.`);
+        const namespacedKey = this.asNamespacedKey(key);
+        let ret;
+        if (this.backend.getset) {
+            ret = await this.backend.getset(namespacedKey, val);
+        }
+        else {
+            ret = await this.backend.get(namespacedKey);
+            // Best effort to keep remaining TTL
+            let ttl = await this.backend.ttl(namespacedKey);
+            if (ttl !== undefined) {
+                ttl = Math.ceil(ttl / 1000);
             }
-            (0, engine_1._log)(NS, `.getAndSet ${namespacedKey} ${val} / ret =`, typeof ret === 'string' ? ret : engine_1.$U.json(ret));
-            return ret;
-        });
+            if (!(await this.backend.set(namespacedKey, val, ttl)))
+                throw new Error(`getAndSet() failed`);
+        }
+        (0, engine_1._log)(NS, `.getAndSet ${namespacedKey} ${val} / ret =`, typeof ret === 'string' ? ret : engine_1.$U.json(ret));
+        return ret;
     }
     /**
      * Get and delete the key
      *
      * @param key
      */
-    getAndDelete(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!key)
-                throw new Error(`@key (CacheKey) is required.`);
-            const namespacedKey = this.asNamespacedKey(key);
-            let ret;
-            if (this.backend.pop) {
-                ret = yield this.backend.pop(namespacedKey);
-            }
-            else {
-                ret = yield this.backend.get(namespacedKey);
-                yield this.backend.del(namespacedKey);
-            }
-            (0, engine_1._log)(NS, `.getAndDelete ${namespacedKey} / ret =`, typeof ret === 'string' ? ret : engine_1.$U.json(ret));
-            return ret;
-        });
+    async getAndDelete(key) {
+        if (!key)
+            throw new Error(`@key (CacheKey) is required.`);
+        const namespacedKey = this.asNamespacedKey(key);
+        let ret;
+        if (this.backend.pop) {
+            ret = await this.backend.pop(namespacedKey);
+        }
+        else {
+            ret = await this.backend.get(namespacedKey);
+            await this.backend.del(namespacedKey);
+        }
+        (0, engine_1._log)(NS, `.getAndDelete ${namespacedKey} / ret =`, typeof ret === 'string' ? ret : engine_1.$U.json(ret));
+        return ret;
     }
     /**
      * Delete a key
@@ -304,15 +316,13 @@ class CacheService {
      * @param key
      * @return  true on success
      */
-    delete(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!key)
-                throw new Error(`@key (CacheKey) is required.`);
-            const namespacedKey = this.asNamespacedKey(key);
-            const ret = yield this.backend.del(namespacedKey);
-            (0, engine_1._log)(NS, `.delete ${namespacedKey} / ret =`, typeof ret === 'string' ? ret : engine_1.$U.json(ret));
-            return ret;
-        });
+    async delete(key) {
+        if (!key)
+            throw new Error(`@key (CacheKey) is required.`);
+        const namespacedKey = this.asNamespacedKey(key);
+        const ret = await this.backend.del(namespacedKey);
+        (0, engine_1._log)(NS, `.delete ${namespacedKey} / ret =`, typeof ret === 'string' ? ret : engine_1.$U.json(ret));
+        return ret;
     }
     /**
      * Delete multiple keys
@@ -320,18 +330,16 @@ class CacheService {
      * @param keys
      * @return  number of deleted entries
      */
-    deleteMulti(keys) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const namespacedKeys = keys.map((key, idx) => {
-                if (!key)
-                    throw new Error(`@key (CacheKey) is required (at @keys[${idx}]).`);
-                return this.asNamespacedKey(key);
-            });
-            const promises = namespacedKeys.map(namespacedKey => this.backend.del(namespacedKey));
-            const ret = yield Promise.all(promises);
-            (0, engine_1._log)(NS, `.deleteMulti ${namespacedKeys} / ret =`, typeof ret === 'string' ? ret : engine_1.$U.json(ret));
-            return ret;
+    async deleteMulti(keys) {
+        const namespacedKeys = keys.map((key, idx) => {
+            if (!key)
+                throw new Error(`@key (CacheKey) is required (at @keys[${idx}]).`);
+            return this.asNamespacedKey(key);
         });
+        const promises = namespacedKeys.map(namespacedKey => this.backend.del(namespacedKey));
+        const ret = await Promise.all(promises);
+        (0, engine_1._log)(NS, `.deleteMulti ${namespacedKeys} / ret =`, typeof ret === 'string' ? ret : engine_1.$U.json(ret));
+        return ret;
     }
     /**
      * Set or update the timeout of a key
@@ -340,15 +348,13 @@ class CacheService {
      * @param timeout   TTL in seconds or Timeout object
      * @return  true on success
      */
-    setTimeout(key, timeout) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!key)
-                throw new Error(`@key (CacheKey) is required.`);
-            const namespacedKey = this.asNamespacedKey(key);
-            const ret = yield this.backend.expire(namespacedKey, toTTL(timeout));
-            (0, engine_1._log)(NS, `.setTimeout ${namespacedKey} ${timeout} / ret =`, typeof ret === 'string' ? ret : engine_1.$U.json(ret));
-            return ret;
-        });
+    async setTimeout(key, timeout) {
+        if (!key)
+            throw new Error(`@key (CacheKey) is required.`);
+        const namespacedKey = this.asNamespacedKey(key);
+        const ret = await this.backend.expire(namespacedKey, toTTL(timeout));
+        (0, engine_1._log)(NS, `.setTimeout ${namespacedKey} ${timeout} / ret =`, typeof ret === 'string' ? ret : engine_1.$U.json(ret));
+        return ret;
     }
     /**
      * Get remaining time to live in milliseconds
@@ -358,30 +364,26 @@ class CacheService {
      *  - undefined if the key does not exist
      *  - 0 if the key has no timeout
      */
-    getTimeout(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!key)
-                throw new Error(`@key (CacheKey) is required.`);
-            const namespacedKey = this.asNamespacedKey(key);
-            const ret = yield this.backend.ttl(namespacedKey);
-            (0, engine_1._log)(NS, `.getTimeout ${namespacedKey} / ret =`, typeof ret === 'string' ? ret : engine_1.$U.json(ret));
-            return ret;
-        });
+    async getTimeout(key) {
+        if (!key)
+            throw new Error(`@key (CacheKey) is required.`);
+        const namespacedKey = this.asNamespacedKey(key);
+        const ret = await this.backend.ttl(namespacedKey);
+        (0, engine_1._log)(NS, `.getTimeout ${namespacedKey} / ret =`, typeof ret === 'string' ? ret : engine_1.$U.json(ret));
+        return ret;
     }
     /**
      * Remove the timeout from a key
      *
      * @param key
      */
-    removeTimeout(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!key)
-                throw new Error(`@key (CacheKey) is required.`);
-            const namespacedKey = this.asNamespacedKey(key);
-            const ret = yield this.backend.expire(namespacedKey, 0);
-            (0, engine_1._log)(NS, `.removeTimeout ${namespacedKey} / ret =`, typeof ret === 'string' ? ret : engine_1.$U.json(ret));
-            return ret;
-        });
+    async removeTimeout(key) {
+        if (!key)
+            throw new Error(`@key (CacheKey) is required.`);
+        const namespacedKey = this.asNamespacedKey(key);
+        const ret = await this.backend.expire(namespacedKey, 0);
+        (0, engine_1._log)(NS, `.removeTimeout ${namespacedKey} / ret =`, typeof ret === 'string' ? ret : engine_1.$U.json(ret));
+        return ret;
     }
     /**
      * Get namespace prefixed cache key
@@ -397,31 +399,17 @@ class CacheService {
     }
 }
 exports.CacheService = CacheService;
-/**
- * Environment variable name for cache server endpoint
- * @static
- */
-CacheService.ENV_CACHE_ENDPOINT = 'CACHE_ENDPOINT';
-/**
- * Environment variable name for default cache timeout
- * @static
- */
-CacheService.ENV_CACHE_DEFAULT_TIMEOUT = 'CACHE_DEFAULT_TIMEOUT';
-/**
- * Default cache timeout
- * @static
- */
-CacheService.DEF_CACHE_DEFAULT_TIMEOUT = 24 * 60 * 60; // 1-day
-/**
- * Namespace delimiter
- * @private
- * @static
- */
-CacheService.NAMESPACE_DELIMITER = '::';
 /**
  * class `DummyCacheService`: use 'node-cache' library
  */
 class DummyCacheService extends CacheService {
+    /**
+     * Singleton node-cache backend
+     *
+     * @private
+     * @static
+     */
+    static backend;
     /**
      * Factory method
      *
@@ -429,9 +417,9 @@ class DummyCacheService extends CacheService {
      * @static
      */
     static create(options) {
-        const ns = (options === null || options === void 0 ? void 0 : options.ns) || '';
-        const defTimeout = engine_1.$U.N(options === null || options === void 0 ? void 0 : options.defTimeout, engine_1.$U.N(engine_1.$U.env(CacheService.ENV_CACHE_DEFAULT_TIMEOUT), CacheService.DEF_CACHE_DEFAULT_TIMEOUT));
-        options = Object.assign(Object.assign({}, options), { ns, defTimeout });
+        const ns = options?.ns || '';
+        const defTimeout = engine_1.$U.N(options?.defTimeout, engine_1.$U.N(engine_1.$U.env(CacheService.ENV_CACHE_DEFAULT_TIMEOUT), CacheService.DEF_CACHE_DEFAULT_TIMEOUT));
+        options = { ...options, ns, defTimeout };
         (0, engine_1._log)(NS, `constructing dummy cache ...`);
         // NOTE: Use singleton backend instance
         // because node-cache is volatile and client instance does not share keys with other instance
@@ -451,12 +439,9 @@ exports.DummyCacheService = DummyCacheService;
  * function `sleep`
  * @param ms    duration in milliseconds
  */
-function sleep(ms) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return new Promise(resolve => setTimeout(resolve, ms));
-    });
+async function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
 }
-exports.sleep = sleep;
 /**
  * Get TTL from timeout
  * @param timeout   timeout in seconds or Timeout object
@@ -480,7 +465,6 @@ function toTTL(timeout) {
     }
     throw new Error(`@timeout (number | Timeout) is invalid.`);
 }
-exports.toTTL = toTTL;
 /**
  * Get timestamp of expiration from TTL
  * @param ttl   remaining time to live in seconds
@@ -489,7 +473,6 @@ exports.toTTL = toTTL;
 function fromTTL(ttl) {
     return ttl > 0 ? Date.now() + ttl * 1000 : 0;
 }
-exports.fromTTL = fromTTL;
 /** ********************************************************************************************************************
  *  Internal Classes
  ** ********************************************************************************************************************/
@@ -498,117 +481,98 @@ exports.fromTTL = fromTTL;
  * @internal
  */
 class NodeCacheBackend {
+    /**
+     * node-cache client
+     * @private
+     */
+    cache;
+    /**
+     * backend type
+     */
+    name = 'node-cache';
     /**
      * Public constructor
      */
     constructor(defTTL = 0) {
-        /**
-         * backend type
-         */
-        this.name = 'node-cache';
         this.cache = new node_cache_1.default({ stdTTL: defTTL });
     }
     /**
      * CacheBackend.set implementation
      */
-    set(key, val, ttl) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.cache.set(key, val, ttl);
-        });
+    async set(key, val, ttl) {
+        return this.cache.set(key, val, ttl);
     }
     /**
      * CacheBackend.get implementation
      */
-    get(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.cache.get(key);
-        });
+    async get(key) {
+        return this.cache.get(key);
     }
     /**
      * CacheBackend.mset implementation
      */
-    mset(entries) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.cache.mset(entries);
-        });
+    async mset(entries) {
+        return this.cache.mset(entries);
     }
     /**
      * CacheBackend.mget implementation
      */
-    mget(keys) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.cache.mget(keys);
-        });
+    async mget(keys) {
+        return this.cache.mget(keys);
     }
     /**
      * CacheBackend.pop implementation
      */
-    pop(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.cache.take(key);
-        });
+    async pop(key) {
+        return this.cache.take(key);
     }
     /**
      * CacheBackend.incr implementation
      */
-    incr(key, increment) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const org = this.cache.get(key);
-            if (typeof org !== 'number')
-                throw new Error(`@key [${key}] does not hold a number value.`);
-            const newVal = org + increment;
-            this.cache.set(key, newVal);
-            return newVal;
-        });
+    async incr(key, increment) {
+        const org = this.cache.get(key);
+        if (typeof org !== 'number')
+            throw new Error(`@key [${key}] does not hold a number value.`);
+        const newVal = org + increment;
+        this.cache.set(key, newVal);
+        return newVal;
     }
     /**
      * CacheBackend.keys implementation
      */
-    keys() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.cache.keys();
-        });
+    async keys() {
+        return this.cache.keys();
     }
     /**
      * CacheBackend.has implementation
      */
-    has(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.cache.has(key);
-        });
+    async has(key) {
+        return this.cache.has(key);
     }
     /**
      * CacheBackend.del implementation
      */
-    del(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.cache.del(key) === 1;
-        });
+    async del(key) {
+        return this.cache.del(key) === 1;
     }
     /**
      * CacheBackend.expire implementation
      */
-    expire(key, ttl) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.cache.ttl(key, ttl);
-        });
+    async expire(key, ttl) {
+        return this.cache.ttl(key, ttl);
     }
     /**
      * CacheBackend.ttl implementation
      */
-    ttl(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const ts = this.cache.getTtl(key); // Timestamp in milliseconds
-            return ts && ts - Date.now();
-        });
+    async ttl(key) {
+        const ts = this.cache.getTtl(key); // Timestamp in milliseconds
+        return ts && ts - Date.now();
     }
     /**
      * CacheBackend.close implementation
      */
-    close() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.cache.close();
-        });
+    async close() {
+        this.cache.close();
     }
 }
 /**
@@ -616,14 +580,24 @@ class NodeCacheBackend {
  * @internal
  */
 class MemcachedBackend {
+    /**
+     * Memcached promisified APIs
+     * @private
+     */
+    api;
+    /**
+     * Default TTL as number in seconds
+     * @private
+     */
+    defTTL;
+    /**
+     * backend type
+     */
+    name = 'memcached';
     /**
      * Public constructor
      */
     constructor(endpoint, defTTL = 0) {
-        /**
-         * backend type
-         */
-        this.name = 'memcached';
         const memcached = new memcached_1.default(endpoint || 'localhost:11211');
         // Build promisified API map
         this.api = {
@@ -654,159 +628,137 @@ class MemcachedBackend {
     /**
      * CacheBackend.set implementation
      */
-    set(key, val, ttl = this.defTTL) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const entry = { val, exp: fromTTL(ttl) };
-            (0, engine_1._log)(NS, `[${this.name}-backend] storing to key [${key}] =`, engine_1.$U.json(entry));
-            return yield this.api.set(key, entry, ttl);
-        });
+    async set(key, val, ttl = this.defTTL) {
+        const entry = { val, exp: fromTTL(ttl) };
+        (0, engine_1._log)(NS, `[${this.name}-backend] storing to key [${key}] =`, engine_1.$U.json(entry));
+        return await this.api.set(key, entry, ttl);
     }
     /**
      * CacheBackend.get implementation
      */
-    get(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const entry = yield this.api.get(key);
-            (0, engine_1._log)(NS, `[${this.name}-backend] entry fetched =`, engine_1.$U.json(entry));
-            return entry && entry.val;
-        });
+    async get(key) {
+        const entry = await this.api.get(key);
+        (0, engine_1._log)(NS, `[${this.name}-backend] entry fetched =`, engine_1.$U.json(entry));
+        return entry && entry.val;
     }
     /**
      * CacheBackend.mset implementation
      */
-    mset(entries) {
-        return __awaiter(this, void 0, void 0, function* () {
-            (0, engine_1._log)(NS, `[${this.name}-backend] storing multiple keys ...`);
-            const promises = entries.map(({ key, val, ttl = this.defTTL }, idx) => {
-                const entry = { val, exp: fromTTL(ttl) };
-                (0, engine_1._log)(NS, ` ${idx}) key [${key}] =`, engine_1.$U.json(entry));
-                return this.api.set(key, entry, ttl);
-            });
-            const results = yield Promise.all(promises);
-            return results.every(result => result === true);
+    async mset(entries) {
+        (0, engine_1._log)(NS, `[${this.name}-backend] storing multiple keys ...`);
+        const promises = entries.map(({ key, val, ttl = this.defTTL }, idx) => {
+            const entry = { val, exp: fromTTL(ttl) };
+            (0, engine_1._log)(NS, ` ${idx}) key [${key}] =`, engine_1.$U.json(entry));
+            return this.api.set(key, entry, ttl);
         });
+        const results = await Promise.all(promises);
+        return results.every(result => result === true);
     }
     /**
      * CacheBackend.mget implementation
      */
-    mget(keys) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const map = yield this.api.getMulti(keys);
-            (0, engine_1._log)(NS, `[${this.name}-backend] entry map fetched =`, engine_1.$U.json(map));
-            Object.keys(map).forEach(key => {
-                const entry = map[key];
-                map[key] = entry.val;
-            });
-            return map;
+    async mget(keys) {
+        const map = await this.api.getMulti(keys);
+        (0, engine_1._log)(NS, `[${this.name}-backend] entry map fetched =`, engine_1.$U.json(map));
+        Object.keys(map).forEach(key => {
+            const entry = map[key];
+            map[key] = entry.val;
         });
+        return map;
     }
     /**
      * CacheBackend.incr implementation
      */
-    incr(key, increment) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // NOTE:
-            // Memcached는 음수에 대한 incr/decr를 지원하지 않으며 0 미만으로 decr 되지 않는다.
-            // 이런 이유로 sets & cas 조합을 이용해 직접 구현함
-            (0, engine_1._log)(NS, `[${this.name}-backend] incrementing (${increment}) to key [${key}] ...`);
-            // Use get/check-and-save + retry strategy for consistency
-            for (let retry = 0; retry < 5; yield sleep(10), retry++) {
-                const result = yield this.api.gets(key); // Get entry w/ CAS id
-                if (result === undefined) {
-                    // Initialize to increment value if the key does not exist
-                    if (!(yield this.set(key, increment, 0)))
-                        break;
-                    return increment;
-                }
-                else {
-                    const { [key]: oldEntry, cas } = result;
-                    if (typeof oldEntry.val !== 'number')
-                        throw new Error(`.key [${key}] has non-numeric value.`);
-                    // Preserve remaining lifetime w/ best effort strategy, not accurate
-                    const now = Date.now();
-                    const ttl = oldEntry.exp && Math.round((oldEntry.exp - now) / 1000);
-                    const entry = {
-                        val: oldEntry.val + increment,
-                        exp: ttl && now + ttl * 1000,
-                    };
-                    if (yield this.api.cas(key, entry, cas, ttl))
-                        return entry.val;
-                }
+    async incr(key, increment) {
+        // NOTE:
+        // Memcached는 음수에 대한 incr/decr를 지원하지 않으며 0 미만으로 decr 되지 않는다.
+        // 이런 이유로 sets & cas 조합을 이용해 직접 구현함
+        (0, engine_1._log)(NS, `[${this.name}-backend] incrementing (${increment}) to key [${key}] ...`);
+        // Use get/check-and-save + retry strategy for consistency
+        for (let retry = 0; retry < 5; await sleep(10), retry++) {
+            const result = await this.api.gets(key); // Get entry w/ CAS id
+            if (result === undefined) {
+                // Initialize to increment value if the key does not exist
+                if (!(await this.set(key, increment, 0)))
+                    break;
+                return increment;
             }
-            throw new Error(`[memcached] failed to increment key [${key}].`);
-        });
+            else {
+                const { [key]: oldEntry, cas } = result;
+                if (typeof oldEntry.val !== 'number')
+                    throw new Error(`.key [${key}] has non-numeric value.`);
+                // Preserve remaining lifetime w/ best effort strategy, not accurate
+                const now = Date.now();
+                const ttl = oldEntry.exp && Math.round((oldEntry.exp - now) / 1000);
+                const entry = {
+                    val: oldEntry.val + increment,
+                    exp: ttl && now + ttl * 1000,
+                };
+                if (await this.api.cas(key, entry, cas, ttl))
+                    return entry.val;
+            }
+        }
+        throw new Error(`[memcached] failed to increment key [${key}].`);
     }
     /**
      * CacheBackend.keys implementation
      */
-    keys() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // NOTE:
-            //  memcached는 원래 keys 기능을 지원하지 않으며
-            //  아래와 같이 cachedump를 사용하여 가능하지만 set한 key가 dump 될 때 까지 상당한 시간이 소요되는 것으로 보인다.
-            //  따라서 이 operation의 결과를 신뢰하지 않도록 한다.
-            const item = (yield this.api.items())[0];
-            if (!item || Object.keys(item).length === 0)
-                return [];
-            const [server, slabid] = [item.server, Number(Object.keys(item)[0])];
-            const number = item[slabid].number;
-            const cachedump = yield this.api.cachedump(server, slabid, number);
-            return cachedump.map(({ key }) => key);
-        });
+    async keys() {
+        // NOTE:
+        //  memcached는 원래 keys 기능을 지원하지 않으며
+        //  아래와 같이 cachedump를 사용하여 가능하지만 set한 key가 dump 될 때 까지 상당한 시간이 소요되는 것으로 보인다.
+        //  따라서 이 operation의 결과를 신뢰하지 않도록 한다.
+        const item = (await this.api.items())[0];
+        if (!item || Object.keys(item).length === 0)
+            return [];
+        const [server, slabid] = [item.server, Number(Object.keys(item)[0])];
+        const number = item[slabid].number;
+        const cachedump = await this.api.cachedump(server, slabid, number);
+        return cachedump.map(({ key }) => key);
     }
     /**
      * CacheBackend.has implementation
      */
-    has(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (yield this.api.get(key)) !== undefined;
-        });
+    async has(key) {
+        return (await this.api.get(key)) !== undefined;
     }
     /**
      * CacheBackend.del implementation
      */
-    del(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.api.del(key);
-        });
+    async del(key) {
+        return await this.api.del(key);
     }
     /**
      * CacheBackend.expire implementation
      */
-    expire(key, ttl) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let saved = false;
-            for (let retry = 0; !saved && retry < 5; yield sleep(10), retry++) {
-                const result = yield this.api.gets(key); // Get entry w/ CAS id
-                if (result === undefined)
-                    break; // If key does not exist or already expired
-                // Refresh timeout
-                const { [key]: oldEntry, cas } = result;
-                const newEntry = {
-                    val: oldEntry.val,
-                    exp: ttl && Date.now() + ttl * 1000,
-                };
-                saved = yield this.api.cas(key, newEntry, cas, ttl);
-            }
-            return saved;
-        });
+    async expire(key, ttl) {
+        let saved = false;
+        for (let retry = 0; !saved && retry < 5; await sleep(10), retry++) {
+            const result = await this.api.gets(key); // Get entry w/ CAS id
+            if (result === undefined)
+                break; // If key does not exist or already expired
+            // Refresh timeout
+            const { [key]: oldEntry, cas } = result;
+            const newEntry = {
+                val: oldEntry.val,
+                exp: ttl && Date.now() + ttl * 1000,
+            };
+            saved = await this.api.cas(key, newEntry, cas, ttl);
+        }
+        return saved;
     }
     /**
      * CacheBackend.ttl implementation
      */
-    ttl(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const entry = yield this.api.get(key); // undefined if key does not exist
-            return (entry === null || entry === void 0 ? void 0 : entry.exp) && entry.exp - Date.now();
-        });
+    async ttl(key) {
+        const entry = await this.api.get(key); // undefined if key does not exist
+        return entry?.exp && entry.exp - Date.now();
     }
     /**
      * CacheBackend.close implementation
      */
-    close() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.api.end();
-        });
+    async close() {
+        this.api.end();
     }
 }
 /**
@@ -814,156 +766,140 @@ class MemcachedBackend {
  * @internal
  */
 class RedisBackend {
+    /**
+     * ioredis client
+     * @private
+     */
+    redis;
+    /**
+     * Default TTL as number in seconds
+     * @private
+     */
+    defTTL;
+    /**
+     * backend type
+     */
+    name = 'redis';
     /**
      * Public constructor
      */
     constructor(endpoint, defTTL = 0) {
-        /**
-         * backend type
-         */
-        this.name = 'redis';
         this.redis = new ioredis_1.default(endpoint || 'localhost:6379');
         this.defTTL = defTTL;
     }
     /**
      * CacheBackend.set implementation
      */
-    set(key, val, ttl = this.defTTL) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const data = JSON.stringify(val); // Serialize
-            ttl > 0 ? yield this.redis.set(key, data, 'EX', ttl) : yield this.redis.set(key, data);
-            return true; // 'set' command always return OK
-        });
+    async set(key, val, ttl = this.defTTL) {
+        const data = JSON.stringify(val); // Serialize
+        ttl > 0 ? await this.redis.set(key, data, 'EX', ttl) : await this.redis.set(key, data);
+        return true; // 'set' command always return OK
     }
     /**
      * CacheBackend.get implementation
      */
-    get(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const data = yield this.redis.get(key);
-            if (data !== null)
-                return JSON.parse(data); // Deserialize
-        });
+    async get(key) {
+        const data = await this.redis.get(key);
+        if (data !== null)
+            return JSON.parse(data); // Deserialize
     }
     /**
      * CacheBackend.mset implementation
      */
-    mset(entries) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Create transaction pipeline
-            //  -> MSET command를 사용할 수도 있으나 ttl 지정이 불가능하여 pipeline으로 구현함
-            const pipeline = entries.reduce((pipeline, { key, val, ttl = this.defTTL }) => {
-                const data = JSON.stringify(val); // Serialize
-                return ttl > 0 ? pipeline.set(key, data, 'EX', ttl) : pipeline.set(key, data);
-            }, this.redis.multi());
-            // Execute transaction
-            yield pipeline.exec(); // Always OK
-            return true;
-        });
+    async mset(entries) {
+        // Create transaction pipeline
+        //  -> MSET command를 사용할 수도 있으나 ttl 지정이 불가능하여 pipeline으로 구현함
+        const pipeline = entries.reduce((pipeline, { key, val, ttl = this.defTTL }) => {
+            const data = JSON.stringify(val); // Serialize
+            return ttl > 0 ? pipeline.set(key, data, 'EX', ttl) : pipeline.set(key, data);
+        }, this.redis.multi());
+        // Execute transaction
+        await pipeline.exec(); // Always OK
+        return true;
     }
     /**
      * CacheBackend.mget implementation
      */
-    mget(keys) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const list = yield this.redis.mget(keys);
-            // Deserialize and map array into object
-            return list.reduce((map, data, idx) => {
-                if (data !== null) {
-                    const key = keys[idx];
-                    map[key] = JSON.parse(data); // Deserialize
-                }
-                return map;
-            }, {});
-        });
+    async mget(keys) {
+        const list = await this.redis.mget(keys);
+        // Deserialize and map array into object
+        return list.reduce((map, data, idx) => {
+            if (data !== null) {
+                const key = keys[idx];
+                map[key] = JSON.parse(data); // Deserialize
+            }
+            return map;
+        }, {});
     }
     /**
      * CacheBackend.getset implementation
      */
-    getset(key, val) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const newData = JSON.stringify(val); // Serialize
-            const oldData = yield this.redis.getset(key, newData);
-            if (oldData !== null)
-                return JSON.parse(oldData); // Deserialize
-        });
+    async getset(key, val) {
+        const newData = JSON.stringify(val); // Serialize
+        const oldData = await this.redis.getset(key, newData);
+        if (oldData !== null)
+            return JSON.parse(oldData); // Deserialize
     }
     /**
      * CacheBackend.pop implementation
      */
-    pop(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const [[err, data]] = yield this.redis
-                .multi()
-                .get(key) // read
-                .del(key) // and delete
-                .exec();
-            if (!err && data !== null)
-                return JSON.parse(data);
-        });
+    async pop(key) {
+        const [[err, data]] = await this.redis
+            .multi()
+            .get(key) // read
+            .del(key) // and delete
+            .exec();
+        if (!err && data !== null)
+            return JSON.parse(data);
     }
     /**
      * CacheBackend.incr implementation
      */
-    incr(key, increment) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Support both integer and floating point
-            const ret = yield this.redis.incrbyfloat(key, increment);
-            return Number(ret);
-        });
+    async incr(key, increment) {
+        // Support both integer and floating point
+        const ret = await this.redis.incrbyfloat(key, increment);
+        return Number(ret);
     }
     /**
      * CacheBackend.keys implementation
      */
-    keys() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.redis.keys('*');
-        });
+    async keys() {
+        return await this.redis.keys('*');
     }
     /**
      * CacheBackend.has implementation
      */
-    has(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (yield this.redis.exists(key)) > 0; // 1: exists / 0: does not exist
-        });
+    async has(key) {
+        return (await this.redis.exists(key)) > 0; // 1: exists / 0: does not exist
     }
     /**
      * CacheBackend.del implementation
      */
-    del(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (yield this.redis.del(key)) === 1; // number of keys removed
-        });
+    async del(key) {
+        return (await this.redis.del(key)) === 1; // number of keys removed
     }
     /**
      * CacheBackend.expire implementation
      */
-    expire(key, ttl) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const ret = ttl > 0 ? yield this.redis.expire(key, ttl) : yield this.redis.persist(key);
-            return ret > 0; // 1: success / 0: key does not exist
-        });
+    async expire(key, ttl) {
+        const ret = ttl > 0 ? await this.redis.expire(key, ttl) : await this.redis.persist(key);
+        return ret > 0; // 1: success / 0: key does not exist
     }
     /**
      * CacheBackend.ttl implementation
      */
-    ttl(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const ms = yield this.redis.pttl(key); // -2: key does not exist / -1: no timeout
-            if (ms >= 0)
-                return ms;
-            if (ms === -1)
-                return 0;
-        });
+    async ttl(key) {
+        const ms = await this.redis.pttl(key); // -2: key does not exist / -1: no timeout
+        if (ms >= 0)
+            return ms;
+        if (ms === -1)
+            return 0;
     }
     /**
      * CacheBackend.close implementation
      */
-    close() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.redis.quit();
-        });
+    async close() {
+        await this.redis.quit();
     }
 }
 //# sourceMappingURL=cache-service.js.map