@powfix/core-js 0.18.1 → 0.18.2

package/dist/node/cjs/nodejs/constants/TransactionManagerLogLevel.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionManagerLogLevel = void 0;
+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 || (exports.TransactionManagerLogLevel = TransactionManagerLogLevel = {}));

package/dist/node/cjs/nodejs/constants/TransactionManagerTimeoutAction.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionManagerTimeoutAction = void 0;
+var TransactionManagerTimeoutAction;
+(function (TransactionManagerTimeoutAction) {
+    TransactionManagerTimeoutAction[TransactionManagerTimeoutAction["COMMIT"] = 1] = "COMMIT";
+    TransactionManagerTimeoutAction[TransactionManagerTimeoutAction["ROLLBACK"] = 2] = "ROLLBACK";
+})(TransactionManagerTimeoutAction || (exports.TransactionManagerTimeoutAction = TransactionManagerTimeoutAction = {}));

package/dist/node/cjs/nodejs/constants/index.js

@@ -0,0 +1,18 @@
+"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("./TransactionManagerLogLevel"), exports);
+__exportStar(require("./TransactionManagerTimeoutAction"), exports);

package/dist/node/cjs/nodejs/index.js

@@ -14,4 +14,9 @@ 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("./constants"), exports);
+__exportStar(require("./interfaces"), exports);
+__exportStar(require("./managers"), exports);
+__exportStar(require("./services"), exports);
+__exportStar(require("./types"), exports);
 __exportStar(require("./utils"), exports);

package/dist/node/cjs/nodejs/managers/TransactionManager.js

@@ -0,0 +1,151 @@
+"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.TransactionManager = void 0;
+const eventemitter3_1 = __importDefault(require("eventemitter3"));
+const constants_1 = require("../constants");
+const LOG_TAG = '[TransactionManager]';
+class TransactionManager {
+    constructor() {
+        // Members
+        this.logLevel = constants_1.TransactionManagerLogLevel.VERBOSE;
+        this.transactionTimeoutMap = new Map();
+        // Emitter
+        this.emitter = new eventemitter3_1.default();
+        if (this.logLevel <= constants_1.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 <= constants_1.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 <= constants_1.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 <= constants_1.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 <= constants_1.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 constants_1.TransactionManagerTimeoutAction.ROLLBACK: {
+                        yield transaction.rollback();
+                        finished = 'rollback';
+                        break;
+                    }
+                    case constants_1.TransactionManagerTimeoutAction.COMMIT: {
+                        yield transaction.commit();
+                        finished = 'commit';
+                        break;
+                    }
+                    default: {
+                        if (this.logLevel <= constants_1.TransactionManagerLogLevel.ERROR) {
+                            console.error(LOG_TAG, `unknown action`, action);
+                        }
+                        break;
+                    }
+                }
+                handled = finished != null;
+                if (finished != null) {
+                    if (this.logLevel <= constants_1.TransactionManagerLogLevel.ERROR) {
+                        console.error(LOG_TAG, this.getTransactionLogArg(transaction), `handled(${finished}) after`, reason);
+                    }
+                }
+                else {
+                    if (this.logLevel <= constants_1.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);
+    }
+}
+exports.TransactionManager = TransactionManager;
+TransactionManager.DEFAULT_TIMEOUT = 60 * 1000;
+TransactionManager.DEFAULT_ACTION = constants_1.TransactionManagerTimeoutAction.ROLLBACK;

package/dist/node/cjs/nodejs/managers/TransactionManager.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/node/cjs/nodejs/managers/index.js

@@ -0,0 +1,18 @@
+"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("./TransactionManager"), exports);
+__exportStar(require("./TransactionManager.types"), exports);

package/dist/node/cjs/nodejs/services/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("./redis"), exports);

package/dist/node/cjs/nodejs/services/redis/RedisClient.js

@@ -0,0 +1,75 @@
+"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.RedisClient = void 0;
+const redis_1 = require("redis");
+const LOG_PREFIX = 'RedisClient';
+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 = (0, redis_1.createClient)(options.redisOptions);
+        }
+        else {
+            this.client = (0, redis_1.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);
+    }
+}
+exports.RedisClient = RedisClient;
+(function (RedisClient) {
+    let Status;
+    (function (Status) {
+        Status[Status["RUNNING"] = 0] = "RUNNING";
+        Status[Status["STOPPED"] = 1] = "STOPPED";
+    })(Status = RedisClient.Status || (RedisClient.Status = {}));
+})(RedisClient || (exports.RedisClient = RedisClient = {}));

package/dist/node/cjs/nodejs/services/redis/RedisPublisher.js

@@ -0,0 +1,64 @@
+"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.RedisPublisher = void 0;
+const RedisClient_1 = require("./RedisClient");
+const LOG_TAG = '[REDIS-PUB]';
+class RedisPublisher extends RedisClient_1.RedisClient {
+    constructor(options) {
+        super(options);
+        this.logging = 'length';
+        console.log(Date.now(), "RedisPublisher", 'initialized');
+    }
+    start() {
+        const _super = Object.create(null, {
+            start: { get: () => super.start }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.start.call(this);
+        });
+    }
+    stop() {
+        const _super = Object.create(null, {
+            stop: { get: () => super.stop }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.stop.call(this);
+        });
+    }
+    setLogging(logging) {
+        this.logging = logging;
+    }
+    getLogging() {
+        return this.logging;
+    }
+    // Make public method
+    publish(channel, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const stringifyData = typeof data !== 'string' ? JSON.stringify(data) : data;
+            switch (this.logging) {
+                case "none": {
+                    break;
+                }
+                case "length": {
+                    console.log(new Date().toISOString(), LOG_TAG, channel, `[len=${stringifyData.length}]`);
+                    break;
+                }
+                case "data": {
+                    console.log(new Date().toISOString(), LOG_TAG, channel, stringifyData);
+                    break;
+                }
+            }
+            yield this.client.publish(channel, stringifyData);
+        });
+    }
+}
+exports.RedisPublisher = RedisPublisher;

package/dist/node/cjs/nodejs/services/redis/RedisSubscriber.js

@@ -0,0 +1,73 @@
+"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.RedisSubscriber = void 0;
+const RedisClient_1 = require("./RedisClient");
+const utils_1 = require("../../../shared/utils");
+class RedisSubscriber extends RedisClient_1.RedisClient {
+    constructor(options) {
+        super(options);
+        console.log(Date.now(), 'Subscriber', 'initialized');
+    }
+    subscribe(channels, listener, bufferMode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const channel of (0, utils_1.castArray)(channels)) {
+                if ((/\*/g).test(channel)) {
+                    yield this.client.pSubscribe(channel, listener, bufferMode);
+                }
+                else {
+                    yield this.client.subscribe(channel, listener, bufferMode);
+                }
+            }
+        });
+    }
+    unsubscribe(channels, listener, bufferMode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const channel of (0, utils_1.castArray)(channels)) {
+                if ((/\*/g).test(channel)) {
+                    yield this.client.pUnsubscribe(channel, listener, bufferMode);
+                }
+                else {
+                    yield this.client.unsubscribe(channel, listener, bufferMode);
+                }
+            }
+        });
+    }
+    start() {
+        const _super = Object.create(null, {
+            start: { get: () => super.start }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const status = yield _super.start.call(this);
+            yield this.registerListeners();
+            return status;
+        });
+    }
+    stop() {
+        const _super = Object.create(null, {
+            stop: { get: () => super.stop }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const status = yield _super.stop.call(this);
+            yield this.unregisterListeners();
+            return status;
+        });
+    }
+    registerListeners() {
+        return __awaiter(this, void 0, void 0, function* () {
+        });
+    }
+    unregisterListeners() {
+        return __awaiter(this, void 0, void 0, function* () {
+        });
+    }
+}
+exports.RedisSubscriber = RedisSubscriber;

package/dist/node/cjs/nodejs/services/redis/index.js

@@ -0,0 +1,20 @@
+"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 });
+// Files
+__exportStar(require("./RedisClient"), exports);
+__exportStar(require("./RedisPublisher"), exports);
+__exportStar(require("./RedisSubscriber"), exports);

package/dist/node/cjs/nodejs/types/UpsertResult.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/node/cjs/nodejs/types/index.js

@@ -0,0 +1,18 @@
+"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("./UpsertResult"), exports);
+__exportStar(require("./mariaDb"), exports);

package/dist/node/cjs/nodejs/types/mariaDb.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/node/esm/nodejs/constants/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/nodejs/constants/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/nodejs/constants/index.mjs

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

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

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

package/dist/node/esm/nodejs/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/nodejs/managers/TransactionManager.types.mjs

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

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

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

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

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

package/dist/node/esm/nodejs/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 = {}));

package/dist/node/esm/nodejs/services/redis/RedisPublisher.mjs

@@ -0,0 +1,60 @@
+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 { RedisClient } from "./RedisClient.mjs";
+const LOG_TAG = '[REDIS-PUB]';
+export class RedisPublisher extends RedisClient {
+    constructor(options) {
+        super(options);
+        this.logging = 'length';
+        console.log(Date.now(), "RedisPublisher", 'initialized');
+    }
+    start() {
+        const _super = Object.create(null, {
+            start: { get: () => super.start }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.start.call(this);
+        });
+    }
+    stop() {
+        const _super = Object.create(null, {
+            stop: { get: () => super.stop }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            return _super.stop.call(this);
+        });
+    }
+    setLogging(logging) {
+        this.logging = logging;
+    }
+    getLogging() {
+        return this.logging;
+    }
+    // Make public method
+    publish(channel, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const stringifyData = typeof data !== 'string' ? JSON.stringify(data) : data;
+            switch (this.logging) {
+                case "none": {
+                    break;
+                }
+                case "length": {
+                    console.log(new Date().toISOString(), LOG_TAG, channel, `[len=${stringifyData.length}]`);
+                    break;
+                }
+                case "data": {
+                    console.log(new Date().toISOString(), LOG_TAG, channel, stringifyData);
+                    break;
+                }
+            }
+            yield this.client.publish(channel, stringifyData);
+        });
+    }
+}

package/dist/node/esm/nodejs/services/redis/RedisSubscriber.mjs

@@ -0,0 +1,69 @@
+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 { RedisClient } from "./RedisClient.mjs";
+import { castArray } from "../../../shared/utils/index.mjs";
+export class RedisSubscriber extends RedisClient {
+    constructor(options) {
+        super(options);
+        console.log(Date.now(), 'Subscriber', 'initialized');
+    }
+    subscribe(channels, listener, bufferMode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const channel of castArray(channels)) {
+                if ((/\*/g).test(channel)) {
+                    yield this.client.pSubscribe(channel, listener, bufferMode);
+                }
+                else {
+                    yield this.client.subscribe(channel, listener, bufferMode);
+                }
+            }
+        });
+    }
+    unsubscribe(channels, listener, bufferMode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const channel of castArray(channels)) {
+                if ((/\*/g).test(channel)) {
+                    yield this.client.pUnsubscribe(channel, listener, bufferMode);
+                }
+                else {
+                    yield this.client.unsubscribe(channel, listener, bufferMode);
+                }
+            }
+        });
+    }
+    start() {
+        const _super = Object.create(null, {
+            start: { get: () => super.start }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const status = yield _super.start.call(this);
+            yield this.registerListeners();
+            return status;
+        });
+    }
+    stop() {
+        const _super = Object.create(null, {
+            stop: { get: () => super.stop }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const status = yield _super.stop.call(this);
+            yield this.unregisterListeners();
+            return status;
+        });
+    }
+    registerListeners() {
+        return __awaiter(this, void 0, void 0, function* () {
+        });
+    }
+    unregisterListeners() {
+        return __awaiter(this, void 0, void 0, function* () {
+        });
+    }
+}

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

@@ -0,0 +1,4 @@
+// Files
+export * from './RedisClient.mjs';
+export * from './RedisPublisher.mjs';
+export * from './RedisSubscriber.mjs';

package/dist/node/esm/nodejs/types/UpsertResult.mjs

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

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

@@ -0,0 +1,2 @@
+export * from './UpsertResult.mjs';
+export * from './mariaDb.mjs';

package/dist/node/esm/nodejs/types/mariaDb.mjs

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

package/dist/node/types/nodejs/constants/TransactionManagerLogLevel.d.ts

@@ -0,0 +1,7 @@
+export declare enum TransactionManagerLogLevel {
+    VERBOSE = 1,
+    INFO = 2,
+    WARNING = 3,
+    ERROR = 4,
+    CRITICAL = 5
+}

package/dist/node/types/nodejs/constants/TransactionManagerTimeoutAction.d.ts

@@ -0,0 +1,4 @@
+export declare enum TransactionManagerTimeoutAction {
+    COMMIT = 1,
+    ROLLBACK = 2
+}

package/dist/node/types/nodejs/constants/index.d.ts

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

package/dist/node/types/nodejs/index.d.ts

@@ -1 +1,6 @@
+export * from './constants';
+export * from './interfaces';
+export * from './managers';
+export * from './services';
+export * from './types';
 export * from './utils';

package/dist/node/types/nodejs/managers/TransactionManager.d.ts

@@ -0,0 +1,27 @@
+import { Transaction } from "sequelize";
+import EventEmitter from 'eventemitter3';
+import { TransactionManagerLogLevel, TransactionManagerTimeoutAction } from "../constants";
+import { TransactionManagerAddOption, TransactionManagerEventTypes } from "./TransactionManager.types";
+export declare class TransactionManager {
+    static DEFAULT_TIMEOUT: number;
+    static DEFAULT_ACTION: TransactionManagerTimeoutAction;
+    private static instance;
+    private logLevel;
+    private transactionTimeoutMap;
+    private readonly emitter;
+    constructor();
+    static getInstance(): TransactionManager;
+    private getTransactionLogArg;
+    setLogLevel(logLevel: TransactionManagerLogLevel): void;
+    addListener<T extends EventEmitter.EventNames<TransactionManagerEventTypes>>(event: T, fn: EventEmitter.EventListener<TransactionManagerEventTypes, T>): void;
+    removeListener<T extends EventEmitter.EventNames<TransactionManagerEventTypes>>(event: T, fn: EventEmitter.EventListener<TransactionManagerEventTypes, T>): void;
+    add(transaction: Transaction, option?: TransactionManagerAddOption): void;
+    remove(transaction: Transaction): void;
+    flush(action?: TransactionManagerTimeoutAction): Promise<PromiseSettledResult<{
+        handled: boolean;
+        transaction: Transaction;
+    }>[]>;
+    private execute;
+    private timeout;
+    private afterCommit;
+}

package/dist/node/types/nodejs/managers/TransactionManager.types.d.ts

@@ -0,0 +1,9 @@
+import { TransactionManagerTimeoutAction } from "../constants";
+import { Transaction } from "sequelize";
+export interface TransactionManagerAddOption {
+    timeout?: number;
+    timeoutAction?: TransactionManagerTimeoutAction;
+}
+export type TransactionManagerEventTypes = {
+    onUnhandledTransaction: (transaction: Transaction, handled: boolean) => any;
+};

package/dist/node/types/nodejs/managers/index.d.ts

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

package/dist/node/types/nodejs/services/index.d.ts

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

package/dist/node/types/nodejs/services/redis/RedisClient.d.ts

@@ -0,0 +1,21 @@
+import redis, { RedisClientType, RedisDefaultModules, RedisFunctions, RedisModules, RedisScripts } from 'redis';
+export declare class RedisClient {
+    private readonly options;
+    private status;
+    readonly client: RedisClientType<RedisDefaultModules & RedisModules, RedisFunctions, RedisScripts>;
+    constructor(options?: RedisClient.RedisClientOptions);
+    getStatus(): RedisClient.Status;
+    start(): Promise<RedisClient.Status>;
+    stop(): Promise<RedisClient.Status>;
+    private handleOnConnect;
+    private handleOnError;
+}
+export declare namespace RedisClient {
+    enum Status {
+        RUNNING = 0,
+        STOPPED = 1
+    }
+    interface RedisClientOptions {
+        redisOptions?: redis.RedisClientOptions;
+    }
+}

package/dist/node/types/nodejs/services/redis/RedisPublisher.d.ts

@@ -0,0 +1,13 @@
+import { RedisClient } from "./RedisClient";
+export declare class RedisPublisher extends RedisClient {
+    private logging;
+    constructor(options?: RedisClient.RedisClientOptions);
+    start(): Promise<RedisClient.Status>;
+    stop(): Promise<RedisClient.Status>;
+    setLogging(logging: RedisPublisher.LOGGING): void;
+    getLogging(): RedisPublisher.LOGGING;
+    publish(channel: string, data: string | object): Promise<void>;
+}
+export declare namespace RedisPublisher {
+    type LOGGING = 'none' | 'length' | 'data';
+}

package/dist/node/types/nodejs/services/redis/RedisSubscriber.d.ts

@@ -0,0 +1,11 @@
+import { RedisClient } from "./RedisClient";
+import { PubSubListener } from "@redis/client/dist/lib/client/pub-sub";
+export declare class RedisSubscriber extends RedisClient {
+    constructor(options?: RedisClient.RedisClientOptions);
+    subscribe<T extends boolean = false>(channels: string | string[], listener: PubSubListener<T>, bufferMode?: T | undefined): Promise<void>;
+    unsubscribe<T extends boolean = false>(channels: string | string[], listener?: PubSubListener<T> | undefined, bufferMode?: T | undefined): Promise<void>;
+    start(): Promise<RedisClient.Status>;
+    stop(): Promise<RedisClient.Status>;
+    protected registerListeners(): Promise<void>;
+    protected unregisterListeners(): Promise<void>;
+}

package/dist/node/types/nodejs/services/redis/index.d.ts

@@ -0,0 +1,3 @@
+export * from './RedisClient';
+export * from './RedisPublisher';
+export * from './RedisSubscriber';

package/dist/node/types/nodejs/types/UpsertResult.d.ts

@@ -0,0 +1,2 @@
+import { Model } from "sequelize-typescript";
+export type UpsertResult<M extends Model> = [M, boolean];

package/dist/node/types/nodejs/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './UpsertResult';
+export * from './mariaDb';

package/dist/node/types/nodejs/types/mariaDb.d.ts

@@ -0,0 +1,8 @@
+import type { TransactionManager, TransactionManagerAddOption } from "../managers";
+import type { Sequelize } from "sequelize-typescript";
+import type { Transaction, TransactionOptions } from "sequelize";
+export interface MariaDbConnection {
+    transactionManager: TransactionManager;
+    sequelize: Sequelize;
+    transaction: (options?: TransactionOptions, managerOptions?: TransactionManagerAddOption) => Promise<Transaction>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@powfix/core-js",
-	"version": "0.18.1",
+	"version": "0.18.2",
 	"description": "core package",
 	"author": "Kwon Kyung-Min <powfix@gmail.com>",
 	"private": false,