@powfix/core-js 0.15.0-beta-2 → 0.15.0-beta-4

package/dist/node/cjs/utils/try-catch/index.js

@@ -0,0 +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 });
+__exportStar(require("./TryCatch"), exports);

package/dist/node/esm/constants/COORDINATE.mjs

@@ -0,0 +1,6 @@
+export class COORDINATE {
+}
+COORDINATE.LATITUDE_MIN_LENGTH = 1;
+COORDINATE.LATITUDE_MAX_LENGTH = 10;
+COORDINATE.LONGITUDE_MIN_LENGTH = 1;
+COORDINATE.LONGITUDE_MAX_LENGTH = 11;

package/dist/node/esm/constants/CRUD.mjs

@@ -0,0 +1,19 @@
+export var CRUD;
+(function (CRUD) {
+    CRUD[CRUD["CREATE"] = 1] = "CREATE";
+    CRUD[CRUD["READ"] = 2] = "READ";
+    CRUD[CRUD["UPDATE"] = 3] = "UPDATE";
+    CRUD[CRUD["DELETE"] = 4] = "DELETE";
+})(CRUD || (CRUD = {}));
+(function (CRUD) {
+    function toString(crud) {
+        switch (crud) {
+            case CRUD.CREATE: return 'Create';
+            case CRUD.READ: return 'Read';
+            case CRUD.UPDATE: return 'Update';
+            case CRUD.DELETE: return 'Delete';
+            default: throw new Error('Unknown crud: ' + crud);
+        }
+    }
+    CRUD.toString = toString;
+})(CRUD || (CRUD = {}));

package/dist/node/esm/constants/DATE.mjs

@@ -0,0 +1,22 @@
+export class DATE {
+}
+(function (DATE) {
+    let FORMAT;
+    (function (FORMAT) {
+        FORMAT[FORMAT["UNIX"] = 1] = "UNIX";
+        FORMAT[FORMAT["SECONDS"] = 2] = "SECONDS";
+        FORMAT[FORMAT["MILLISECONDS"] = 3] = "MILLISECONDS";
+        FORMAT[FORMAT["ISO_8601"] = 4] = "ISO_8601";
+    })(FORMAT = DATE.FORMAT || (DATE.FORMAT = {}));
+    (function (FORMAT) {
+        function toString(format) {
+            switch (format) {
+                case FORMAT.UNIX: return 'UNIX';
+                case FORMAT.SECONDS: return 'SECONDS';
+                case FORMAT.MILLISECONDS: return 'MILLISECONDS';
+                case FORMAT.ISO_8601: return 'ISO_8601';
+            }
+        }
+        FORMAT.toString = toString;
+    })(FORMAT = DATE.FORMAT || (DATE.FORMAT = {}));
+})(DATE || (DATE = {}));

package/dist/node/esm/constants/DISTANCE.mjs

@@ -0,0 +1,14 @@
+export class DISTANCE {
+}
+(function (DISTANCE) {
+    let UNIT;
+    (function (UNIT) {
+        UNIT["FEET"] = "FEET";
+        UNIT["KILOMETERS"] = "KILOMETERS";
+        UNIT["MILLIMETERS"] = "MILLIMETERS";
+        UNIT["CENTIMETERS"] = "CENTIMETERS";
+        UNIT["METERS"] = "METERS";
+        UNIT["MILES"] = "MILES";
+        UNIT["YARDS"] = "YARDS";
+    })(UNIT = DISTANCE.UNIT || (DISTANCE.UNIT = {}));
+})(DISTANCE || (DISTANCE = {}));

package/dist/node/esm/constants/DURATION.mjs

@@ -0,0 +1,17 @@
+export class DURATION {
+}
+(function (DURATION) {
+    let UNIT;
+    (function (UNIT) {
+        UNIT["NANOSECONDS"] = "NANOSECONDS";
+        UNIT["MICROSECONDS"] = "MICROSECONDS";
+        UNIT["MILLISECONDS"] = "MILLISECONDS";
+        UNIT["SECONDS"] = "SECONDS";
+        UNIT["MINUTES"] = "MINUTES";
+        UNIT["HOURS"] = "HOURS";
+        UNIT["DAYS"] = "DAYS";
+        UNIT["YEARS"] = "YEARS";
+        UNIT["DECADES"] = "DECADES";
+        UNIT["CENTURIES"] = "CENTURIES";
+    })(UNIT = DURATION.UNIT || (DURATION.UNIT = {}));
+})(DURATION || (DURATION = {}));

package/dist/node/esm/constants/NOT_NULL.mjs

@@ -0,0 +1 @@
+export const NOT_NULL = Symbol('!null');

package/dist/node/esm/constants/index.browser.mjs

@@ -0,0 +1,6 @@
+export * from './COORDINATE.mjs';
+export * from './CRUD.mjs';
+export * from './DATE.mjs';
+export * from './DISTANCE.mjs';
+export * from './DURATION.mjs';
+export * from './NOT_NULL.mjs';

package/dist/node/esm/constants/index.mjs

@@ -0,0 +1,2 @@
+export * from './index.browser.mjs';
+export * from './nodejs/index.mjs';

package/dist/node/esm/constants/nodejs/TransactionManagerLogLevel.mjs

@@ -0,0 +1,8 @@
+export var TransactionManagerLogLevel;
+(function (TransactionManagerLogLevel) {
+    TransactionManagerLogLevel[TransactionManagerLogLevel["VERBOSE"] = 1] = "VERBOSE";
+    TransactionManagerLogLevel[TransactionManagerLogLevel["INFO"] = 2] = "INFO";
+    TransactionManagerLogLevel[TransactionManagerLogLevel["WARNING"] = 3] = "WARNING";
+    TransactionManagerLogLevel[TransactionManagerLogLevel["ERROR"] = 4] = "ERROR";
+    TransactionManagerLogLevel[TransactionManagerLogLevel["CRITICAL"] = 5] = "CRITICAL";
+})(TransactionManagerLogLevel || (TransactionManagerLogLevel = {}));

package/dist/node/esm/constants/nodejs/TransactionManagerTimeoutAction.mjs

@@ -0,0 +1,5 @@
+export var TransactionManagerTimeoutAction;
+(function (TransactionManagerTimeoutAction) {
+    TransactionManagerTimeoutAction[TransactionManagerTimeoutAction["COMMIT"] = 1] = "COMMIT";
+    TransactionManagerTimeoutAction[TransactionManagerTimeoutAction["ROLLBACK"] = 2] = "ROLLBACK";
+})(TransactionManagerTimeoutAction || (TransactionManagerTimeoutAction = {}));

package/dist/node/esm/constants/nodejs/index.mjs

@@ -0,0 +1,2 @@
+export * from './TransactionManagerLogLevel.mjs';
+export * from './TransactionManagerTimeoutAction.mjs';

package/dist/node/esm/index.browser.mjs

@@ -0,0 +1,7 @@
+export * from './constants/index.browser.mjs';
+export * from './interfaces/index.browser.mjs';
+export * from './managers/index.browser.mjs';
+export * from './scripts/index.browser.mjs';
+export * from './services/index.browser.mjs';
+export * from './types/index.browser.mjs';
+export * from './utils/index.browser.mjs';

package/dist/node/esm/index.mjs

@@ -0,0 +1,8 @@
+export * from './index.browser.mjs';
+export * from './constants/index.mjs';
+export * from './interfaces/index.mjs';
+export * from './managers/index.mjs';
+export * from './scripts/index.mjs';
+export * from './services/index.mjs';
+export * from './types/index.mjs';
+export * from './utils/index.mjs';

package/dist/node/esm/interfaces/Coordinate.mjs

@@ -0,0 +1 @@
+export {};

package/dist/node/esm/interfaces/Point2.mjs

@@ -0,0 +1 @@
+export {};

package/dist/node/esm/interfaces/Point3.mjs

@@ -0,0 +1 @@
+export {};

package/dist/node/esm/interfaces/StorageProvider.mjs

@@ -0,0 +1 @@
+export {};

package/dist/node/esm/interfaces/index.browser.mjs

@@ -0,0 +1,4 @@
+export * from './Coordinate.mjs';
+export * from './Point2.mjs';
+export * from './Point3.mjs';
+export * from './StorageProvider.mjs';

package/dist/node/esm/interfaces/index.mjs

@@ -0,0 +1,2 @@
+export * from './index.browser.mjs';
+export * from './nodejs/index.mjs';

package/dist/node/esm/interfaces/nodejs/db/index.mjs

@@ -0,0 +1 @@
+export * from './sequelize/index.mjs';

package/dist/node/esm/interfaces/nodejs/db/sequelize/Hook.mjs

@@ -0,0 +1 @@
+export {};

package/dist/node/esm/interfaces/nodejs/db/sequelize/HookFn.mjs

@@ -0,0 +1 @@
+export {};

package/dist/node/esm/interfaces/nodejs/db/sequelize/HookType.mjs

@@ -0,0 +1 @@
+export {};

package/dist/node/esm/interfaces/nodejs/db/sequelize/ReloadOption.mjs

@@ -0,0 +1 @@
+export {};

package/dist/node/esm/interfaces/nodejs/db/sequelize/TransactionOption.mjs

@@ -0,0 +1 @@
+export {};

package/dist/node/esm/interfaces/nodejs/db/sequelize/UpsertOptions.mjs

@@ -0,0 +1 @@
+export {};

package/dist/node/esm/interfaces/nodejs/db/sequelize/index.mjs

@@ -0,0 +1,6 @@
+export * from './Hook.mjs';
+export * from './HookFn.mjs';
+export * from './HookType.mjs';
+export * from './ReloadOption.mjs';
+export * from './TransactionOption.mjs';
+export * from './UpsertOptions.mjs';

package/dist/node/esm/interfaces/nodejs/index.mjs

@@ -0,0 +1 @@
+export * from './db/index.mjs';

package/dist/node/esm/managers/SessionManager.mjs

@@ -0,0 +1,127 @@
+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());
+    });
+};
+import { jwtDecode } from "jwt-decode";
+import moment from "moment";
+import EventEmitter from 'eventemitter3';
+export class SessionManager extends EventEmitter {
+    constructor(options) {
+        super();
+        // Init service parameters
+        this.api = options.api;
+        this.storageProvider = options.storageProvider;
+        // Logging
+        console.log('SessionManager initialized', Date.now(), options.api);
+    }
+    get key() {
+        try {
+            if (this.storageProvider.key) {
+                return this.storageProvider.key();
+            }
+        }
+        catch (e) {
+            console.error(e);
+        }
+        return SessionManager.DEFAULT_AUTHORIZATION_STORAGE_KEY;
+    }
+    hasAuthorization() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return !!(yield this.getAuthorization());
+        });
+    }
+    getAuthorization() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.storageProvider.get(this.key);
+        });
+    }
+    setAuthorization(authorization) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (authorization === null) {
+                yield this.removeAuthorization();
+                return null;
+            }
+            let nextAuthorization = yield (() => __awaiter(this, void 0, void 0, function* () {
+                if (authorization === undefined) {
+                    return yield this.getAuthorization();
+                }
+                return authorization;
+            }))();
+            if (!nextAuthorization) {
+                console.log('nextAuthorization is null or undefined');
+                return null;
+            }
+            try {
+                // Replace Bearer prefix
+                nextAuthorization = nextAuthorization.replace(/^Bearer\s+/, '');
+                const decoded = jwtDecode(nextAuthorization);
+                if (!decoded) {
+                    console.warn('JWT decode failed');
+                    return null;
+                }
+                console.log('Session:JWT decoded');
+                (() => {
+                    console.log(' - User', decoded.uuid);
+                    console.log(' - IAT', ...(() => {
+                        if (!decoded.iat) {
+                            return [decoded.iat];
+                        }
+                        const iat = moment.unix(decoded.iat);
+                        if (!iat.isValid()) {
+                            return [decoded.iat];
+                        }
+                        return [decoded.iat, iat.format(), iat.diff(Date.now(), 'days'), 'days left'];
+                    })());
+                    console.log(' - NBF', ...(() => {
+                        if (!decoded.nbf) {
+                            return [decoded.nbf];
+                        }
+                        const nbf = moment.unix(decoded.nbf);
+                        if (!nbf.isValid()) {
+                            return [decoded.nbf];
+                        }
+                        return [decoded.nbf, nbf.format(), nbf.diff(Date.now(), 'days'), 'days left'];
+                    })());
+                    console.log(' - EXP', ...(() => {
+                        if (!decoded.exp) {
+                            return [decoded.exp];
+                        }
+                        const exp = moment.unix(decoded.exp);
+                        if (!exp.isValid()) {
+                            return [decoded.exp];
+                        }
+                        return [decoded.exp, exp.format(), exp.diff(Date.now(), 'days'), 'days left'];
+                    })());
+                })();
+                // AsyncStorage 에 토큰 저장
+                yield this.storageProvider.set(this.key, nextAuthorization);
+                // API Instance header 설정
+                this.api.defaults.headers.common.Authorization = `Bearer ${nextAuthorization}`;
+                // Emit
+                this.emit('AUTHORIZATION_CHANGED', nextAuthorization);
+                // Return
+                return nextAuthorization;
+            }
+            catch (e) {
+                console.error(e);
+            }
+            return null;
+        });
+    }
+    removeAuthorization() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // API Instance header 에서 토큰 제거
+            delete this.api.defaults.headers.common.Authorization;
+            // 스토리지에서 authorization 제거
+            yield this.storageProvider.remove(this.key);
+            // Emit
+            this.emit('AUTHORIZATION_CHANGED', null);
+        });
+    }
+}
+SessionManager.DEFAULT_AUTHORIZATION_STORAGE_KEY = 'AUTHORIZATION';

package/dist/node/esm/managers/SessionManager.type.mjs

@@ -0,0 +1 @@
+export {};

package/dist/node/esm/managers/TransactionManager.mjs

@@ -0,0 +1,144 @@
+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());
+    });
+};
+import EventEmitter from 'eventemitter3';
+import { TransactionManagerLogLevel, TransactionManagerTimeoutAction } from "../constants/index.mjs";
+const LOG_TAG = '[TransactionManager]';
+export class TransactionManager {
+    constructor() {
+        // Members
+        this.logLevel = TransactionManagerLogLevel.VERBOSE;
+        this.transactionTimeoutMap = new Map();
+        // Emitter
+        this.emitter = new EventEmitter();
+        if (this.logLevel <= TransactionManagerLogLevel.VERBOSE) {
+            console.log(LOG_TAG, 'TransactionManager instance initialized');
+        }
+    }
+    static getInstance() {
+        return this.instance || (this.instance = new TransactionManager());
+    }
+    getTransactionLogArg(transaction) {
+        const id = transaction === null || transaction === void 0 ? void 0 : transaction.id;
+        return id ? `transaction(${id})` : '';
+    }
+    setLogLevel(logLevel) {
+        this.logLevel = logLevel;
+        if (this.logLevel <= TransactionManagerLogLevel.VERBOSE) {
+            console.log(LOG_TAG, 'log level changed to', logLevel);
+        }
+    }
+    addListener(event, fn) {
+        this.emitter.addListener(event, fn);
+    }
+    removeListener(event, fn) {
+        this.emitter.removeListener(event, fn);
+    }
+    add(transaction, option) {
+        var _a, _b;
+        if (this.transactionTimeoutMap.has(transaction)) {
+            if (this.logLevel <= TransactionManagerLogLevel.ERROR) {
+                console.error(LOG_TAG, 'transaction already exists');
+            }
+            return;
+        }
+        const action = (_a = option === null || option === void 0 ? void 0 : option.timeoutAction) !== null && _a !== void 0 ? _a : TransactionManager.DEFAULT_ACTION;
+        const timeout = (_b = option === null || option === void 0 ? void 0 : option.timeout) !== null && _b !== void 0 ? _b : TransactionManager.DEFAULT_TIMEOUT;
+        const handler = setTimeout(this.timeout.bind(this), timeout, transaction, action);
+        this.transactionTimeoutMap.set(transaction, {
+            handler,
+            action,
+        });
+        // Callback
+        transaction.afterCommit(this.afterCommit.bind(this));
+    }
+    remove(transaction) {
+        const transactionTimeout = this.transactionTimeoutMap.get(transaction);
+        if (transactionTimeout != null) {
+            clearTimeout(transactionTimeout.handler);
+            this.transactionTimeoutMap.delete(transaction);
+            if (this.logLevel <= TransactionManagerLogLevel.VERBOSE) {
+                console.log(LOG_TAG, this.getTransactionLogArg(transaction), 'removed');
+            }
+        }
+    }
+    flush(action) {
+        return Promise.allSettled(Array.from(this.transactionTimeoutMap.entries()).map((_a) => __awaiter(this, [_a], void 0, function* ([transaction, transactionTimeout]) {
+            const handled = yield this.execute(transaction, action !== null && action !== void 0 ? action : transactionTimeout.action, 'flush');
+            this.remove(transaction);
+            return {
+                handled,
+                transaction,
+            };
+        })));
+    }
+    execute(transaction, action, reason) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let handled = false;
+            const finished = transaction === null || transaction === void 0 ? void 0 : transaction.finished;
+            if (finished != null) {
+                if (this.logLevel <= TransactionManagerLogLevel.VERBOSE) {
+                    console.log(LOG_TAG, this.getTransactionLogArg(transaction), `is already handled(${finished}) after`, reason);
+                }
+                this.remove(transaction);
+                return handled;
+            }
+            try {
+                let finished;
+                switch (action) {
+                    case TransactionManagerTimeoutAction.ROLLBACK: {
+                        yield transaction.rollback();
+                        finished = 'rollback';
+                        break;
+                    }
+                    case TransactionManagerTimeoutAction.COMMIT: {
+                        yield transaction.commit();
+                        finished = 'commit';
+                        break;
+                    }
+                    default: {
+                        if (this.logLevel <= TransactionManagerLogLevel.ERROR) {
+                            console.error(LOG_TAG, `unknown action`, action);
+                        }
+                        break;
+                    }
+                }
+                handled = finished != null;
+                if (finished != null) {
+                    if (this.logLevel <= TransactionManagerLogLevel.ERROR) {
+                        console.error(LOG_TAG, this.getTransactionLogArg(transaction), `handled(${finished}) after`, reason);
+                    }
+                }
+                else {
+                    if (this.logLevel <= TransactionManagerLogLevel.ERROR) {
+                        console.error(LOG_TAG, this.getTransactionLogArg(transaction), `not handled 🚫`);
+                    }
+                }
+            }
+            catch (e) {
+                console.error(e);
+            }
+            finally {
+                this.remove(transaction);
+            }
+            return handled;
+        });
+    }
+    timeout(transaction, action) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const handled = yield this.execute(transaction, action, 'timeout');
+            this.emitter.emit('onUnhandledTransaction', transaction, handled);
+        });
+    }
+    afterCommit(transaction) {
+        this.remove(transaction);
+    }
+}
+TransactionManager.DEFAULT_TIMEOUT = 60 * 1000;
+TransactionManager.DEFAULT_ACTION = TransactionManagerTimeoutAction.ROLLBACK;

package/dist/node/esm/managers/TransactionManager.types.mjs

@@ -0,0 +1 @@
+export {};

package/dist/node/esm/managers/index.browser.mjs

@@ -0,0 +1,2 @@
+export * from './SessionManager.mjs';
+export * from './SessionManager.type.mjs';

package/dist/node/esm/managers/index.mjs

@@ -0,0 +1,2 @@
+export * from './TransactionManager.mjs';
+export * from './TransactionManager.types.mjs';

package/dist/node/esm/scripts/base64Polyfill.mjs

@@ -0,0 +1,10 @@
+import { decode, encode } from 'base-64';
+export const base64Polyfill = () => {
+    if (!global.btoa) {
+        global.btoa = encode;
+    }
+    if (!global.atob) {
+        global.atob = decode;
+    }
+    console.log('base64-polyfill initialized', Date.now());
+};

package/dist/node/esm/scripts/index.browser.mjs

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

package/dist/node/esm/scripts/index.mjs

@@ -0,0 +1 @@
+export * from './index.browser.mjs';

package/dist/node/esm/services/index.browser.mjs

@@ -0,0 +1 @@
+export * from './time/index.mjs';

package/dist/node/esm/services/index.mjs

@@ -0,0 +1,2 @@
+export * from './index.browser.mjs';
+export * from './redis/index.mjs';

package/dist/node/esm/services/redis/RedisClient.mjs

@@ -0,0 +1,71 @@
+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());
+    });
+};
+import { createClient } from 'redis';
+const LOG_PREFIX = 'RedisClient';
+export class RedisClient {
+    constructor(options) {
+        this.options = {};
+        this.status = RedisClient.Status.STOPPED;
+        console.log(Date.now(), LOG_PREFIX, 'initialized');
+        if (options) {
+            this.options = options;
+        }
+        if (options === null || options === void 0 ? void 0 : options.redisOptions) {
+            this.client = createClient(options.redisOptions);
+        }
+        else {
+            this.client = createClient({});
+        }
+    }
+    getStatus() {
+        return this.status;
+    }
+    start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log(LOG_PREFIX, 'trying to start');
+            // register event callback
+            this.client.on('connect', this.handleOnConnect);
+            this.client.on('error', this.handleOnError);
+            console.log('before connect');
+            yield this.client.connect();
+            console.log('after connect');
+            this.status = RedisClient.Status.RUNNING;
+            console.log(LOG_PREFIX, 'now started');
+            return this.status;
+        });
+    }
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log(LOG_PREFIX, 'trying to stop');
+            // unregister event callback
+            this.client.off('connect', this.handleOnConnect);
+            this.client.off('error', this.handleOnError);
+            if (this.client.isOpen) {
+                yield this.client.disconnect();
+            }
+            this.status = RedisClient.Status.STOPPED;
+            console.log(LOG_PREFIX, 'now stopped');
+            return this.status;
+        });
+    }
+    handleOnConnect() {
+        console.log(LOG_PREFIX, 'connected');
+    }
+    handleOnError(error) {
+        console.error(LOG_PREFIX, error);
+    }
+}
+(function (RedisClient) {
+    let Status;
+    (function (Status) {
+        Status[Status["RUNNING"] = 0] = "RUNNING";
+        Status[Status["STOPPED"] = 1] = "STOPPED";
+    })(Status = RedisClient.Status || (RedisClient.Status = {}));
+})(RedisClient || (RedisClient = {}));