@klapeks/micro-db-utils 0.0.1

package/dist/backups/mysql.backup.d.ts

@@ -0,0 +1,7 @@
+import { DatabaseOptions } from "@klapeks/utils";
+export declare function runRawBackup({ module, options, tables, outputFolder }: {
+    module: string;
+    options: DatabaseOptions;
+    tables: string[];
+    outputFolder: string;
+}): Promise<void>;

package/dist/backups/mysql.backup.js

@@ -0,0 +1,156 @@
+"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 __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runRawBackup = void 0;
+var path_1 = __importDefault(require("path"));
+var fs_1 = __importDefault(require("fs"));
+var child_process_1 = require("child_process");
+var os_1 = __importDefault(require("os"));
+var utils_1 = require("@klapeks/utils");
+var pad = function (s) { return s < 10 ? "0".concat(s) : s; };
+function dateToStr(date) {
+    return date.getFullYear()
+        + '-' + pad(date.getMonth() + 1)
+        + '-' + pad(date.getDate());
+}
+function runRawBackup(_a) {
+    var _b;
+    var module = _a.module, options = _a.options, tables = _a.tables, outputFolder = _a.outputFolder;
+    return __awaiter(this, void 0, void 0, function () {
+        var date, filePath_1, file_1, dump_1, stat, err_1;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    if (!options.type)
+                        return [2 /*return*/];
+                    if (!(tables === null || tables === void 0 ? void 0 : tables.length))
+                        return [2 /*return*/];
+                    if (os_1.default.platform() == 'win32')
+                        return [2 /*return*/];
+                    if (!fs_1.default.existsSync(outputFolder)) {
+                        fs_1.default.mkdirSync(outputFolder, { recursive: true });
+                    }
+                    utils_1.logger.log("Starting database backup:", options.type, '|', tables);
+                    date = new Date();
+                    if (!(options.type == 'mysql')) return [3 /*break*/, 4];
+                    filePath_1 = path_1.default.join(outputFolder, 'backup-' + dateToStr(date) + '-' + module + '.sql');
+                    if (fs_1.default.existsSync(filePath_1))
+                        fs_1.default.rmSync(filePath_1, { force: true });
+                    file_1 = fs_1.default.createWriteStream(filePath_1);
+                    file_1.write('-- BSB v4 dump. Tables: ' + tables.join(', ') + '\n');
+                    file_1.write('-- DateTime: ' + new Date().toISOString().replace('T', ' ').replace('Z', '') + '\n');
+                    _c.label = 1;
+                case 1:
+                    _c.trys.push([1, 3, , 4]);
+                    dump_1 = (0, child_process_1.spawn)('mysqldump', __spreadArray([
+                        '--skip-extended-insert',
+                        '--host=' + options.host,
+                        '--port=' + options.port,
+                        '--user=' + options.username,
+                        '--password=' + options.password,
+                        '--databases', options.database,
+                        '--tables'
+                    ], tables, true));
+                    return [4 /*yield*/, new Promise(function (resolve, reject) {
+                            var error = '';
+                            dump_1.stdout.on('data', function (data) { return file_1.write(data); });
+                            dump_1.stderr.on('data', function (data) {
+                                if (String(data).toLowerCase().includes('[warning]'))
+                                    return;
+                                error += String(data);
+                            });
+                            dump_1.once('exit', function (code) {
+                                dump_1.kill();
+                                if (code) {
+                                    utils_1.logger.log('child process exited with code ' + code);
+                                    return reject(error);
+                                }
+                                resolve("Done");
+                            });
+                        })];
+                case 2:
+                    _c.sent();
+                    file_1.end();
+                    utils_1.logger.log("└ Backup completed and saved at\n", filePath_1);
+                    stat = fs_1.default.statSync(filePath_1);
+                    utils_1.logger.log("└ Backup size:", +(stat.size / 1024).toFixed(2), 'KB', '/', +(stat.size / 1024 / 1024).toFixed(2), 'MB');
+                    return [2 /*return*/];
+                case 3:
+                    err_1 = _c.sent();
+                    file_1.end(function () {
+                        fs_1.default.rmSync(filePath_1, { force: true });
+                    });
+                    if ((_b = err_1 === null || err_1 === void 0 ? void 0 : err_1.sqlMessage) === null || _b === void 0 ? void 0 : _b.toLowerCase().includes("unknown database"))
+                        return [2 /*return*/];
+                    utils_1.logger.error("Error while backuping database:", err_1);
+                    return [2 /*return*/];
+                case 4: throw "Unknown database type for backup: " + options.type;
+            }
+        });
+    });
+}
+exports.runRawBackup = runRawBackup;
+// export function runMicroBackup(micro: MicroServer, dataSource: DataSource) {
+//     return runRawBackup({
+//         module: micro.options.microServer, 
+//         options: dataSourceOptions(),
+//         tables: Object.values(dataSource.options.entities || []).map((m: any) => {
+//             if (m instanceof EntitySchema) return m.options.name;
+//             return undefined;
+//         }).filter(Boolean) as string[],
+//         outputFolder: minEnv.coreDataFile('backups')
+//     })
+// }
+// export async function initBackups(micro: MicroServer, dataSource: DataSource) {
+//     cron.schedule('50 23 * * *', async () => {
+//         await runMicroBackup(micro, dataSource);
+//     });
+//     await runMicroBackup(micro, dataSource);
+// }

package/dist/connections/cloud/s3.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type { S3Client } from "@aws-sdk/client-s3";
+export interface S3ConnectionConfig {
+    bucket: string;
+    url: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+}
+export declare class S3Connection {
+    readonly client: S3Client;
+    private _config;
+    constructor(config: S3ConnectionConfig);
+    get bucketName(): string;
+    presignedUploadObjectUrl(path: string, mimeType: string): Promise<{
+        url: string;
+        mimeType: string;
+    }>;
+    uploadObject(path: string, buffer: Buffer, mimeType: string): Promise<import("@aws-sdk/client-s3").PutObjectCommandOutput>;
+    listByPrefix(prefix: string): Promise<import("@aws-sdk/client-s3").ListObjectsCommandOutput>;
+    deleteFiles(keys: string[]): Promise<import("@aws-sdk/client-s3").DeleteObjectsCommandOutput | undefined>;
+    removeDirectory(directory: string): Promise<void>;
+}

package/dist/connections/cloud/s3.js

@@ -0,0 +1,169 @@
+"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 __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.S3Connection = void 0;
+var utils_1 = require("@klapeks/utils");
+var quiet_require_1 = require("../quiet.require");
+var s3ClientModule = (0, quiet_require_1.quietRequire)('@aws-sdk/client-s3');
+var s3PresignerModule = (0, quiet_require_1.quietRequire)('@aws-sdk/s3-request-presigner');
+var logger = new utils_1.Logger("S3/R2");
+var fixPath = function (path) {
+    while (path[0] == '/')
+        path = path.substring(1);
+    if (path.includes('?'))
+        path = path.split('?')[0];
+    return path;
+};
+var S3Connection = /** @class */ (function () {
+    function S3Connection(config) {
+        if (!s3ClientModule)
+            throw "No @aws-sdk/client-s3 module installed";
+        this._config = config;
+        this.client = new s3ClientModule.S3Client({
+            region: "auto",
+            endpoint: config.url,
+            credentials: {
+                accessKeyId: config.accessKeyId,
+                secretAccessKey: config.secretAccessKey
+            },
+        });
+        logger.log("S3 connection created:", config.bucket);
+    }
+    Object.defineProperty(S3Connection.prototype, "bucketName", {
+        get: function () {
+            return this._config.bucket;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    S3Connection.prototype.presignedUploadObjectUrl = function (path, mimeType) {
+        return __awaiter(this, void 0, void 0, function () {
+            var url;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!s3PresignerModule)
+                            throw "No @aws-sdk/s3-request-presigner module";
+                        return [4 /*yield*/, s3PresignerModule.getSignedUrl(this.client, new s3ClientModule.PutObjectCommand({
+                                Bucket: this.bucketName,
+                                Key: fixPath(path),
+                                ContentType: mimeType,
+                            }), { expiresIn: 3600 })];
+                    case 1:
+                        url = _a.sent();
+                        return [2 /*return*/, { url: url, mimeType: mimeType }];
+                }
+            });
+        });
+    };
+    S3Connection.prototype.uploadObject = function (path, buffer, mimeType) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.client.send(new s3ClientModule.PutObjectCommand({
+                            Bucket: this.bucketName,
+                            Key: fixPath(path),
+                            Body: buffer,
+                            ContentType: mimeType,
+                        }))];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    S3Connection.prototype.listByPrefix = function (prefix) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        while (prefix[0] == '/')
+                            prefix = prefix.substring(1);
+                        return [4 /*yield*/, this.client.send(new s3ClientModule.ListObjectsCommand({
+                                Bucket: this.bucketName, Prefix: prefix
+                            }))];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    S3Connection.prototype.deleteFiles = function (keys) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!keys.length)
+                            return [2 /*return*/];
+                        return [4 /*yield*/, this.client.send(new s3ClientModule.DeleteObjectsCommand({
+                                Bucket: this.bucketName,
+                                Delete: {
+                                    Objects: keys.map(function (k) { return ({ Key: fixPath(k) }); })
+                                }
+                            }))];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    S3Connection.prototype.removeDirectory = function (directory) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function () {
+            var listedObjects, result;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        while (directory[0] == '/')
+                            directory = directory.substring(1);
+                        return [4 /*yield*/, this.listByPrefix(directory)];
+                    case 1:
+                        listedObjects = _c.sent();
+                        listedObjects.Contents = (_a = listedObjects.Contents) === null || _a === void 0 ? void 0 : _a.filter(function (k) { return k.Key; });
+                        logger.log("content:", listedObjects.Contents);
+                        if (!((_b = listedObjects.Contents) === null || _b === void 0 ? void 0 : _b.length))
+                            return [2 /*return*/];
+                        return [4 /*yield*/, this.deleteFiles(listedObjects.Contents.map(function (k) { return k.Key; }))];
+                    case 2:
+                        result = _c.sent();
+                        logger.log("Deleted:", result);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return S3Connection;
+}());
+exports.S3Connection = S3Connection;

package/dist/connections/index.d.ts

@@ -0,0 +1,5 @@
+export * from './mysql.connection';
+export * from './nosql/redis';
+export * from './nosql/mongo';
+export * from './kafka';
+export * from './cloud/s3';

package/dist/connections/index.js

@@ -0,0 +1,25 @@
+"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 });
+// RDBMS
+__exportStar(require("./mysql.connection"), exports);
+// NoSQL
+__exportStar(require("./nosql/redis"), exports);
+__exportStar(require("./nosql/mongo"), exports);
+// Brokers
+__exportStar(require("./kafka"), exports);
+// Cloud: S3 + R2
+__exportStar(require("./cloud/s3"), exports);

package/dist/connections/kafka/index.d.ts

@@ -0,0 +1,3 @@
+export * from './kafka.consumer';
+export * from './kafka.producer';
+export { KafkaConnection } from './kafka';

package/dist/connections/kafka/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KafkaConnection = void 0;
+__exportStar(require("./kafka.consumer"), exports);
+__exportStar(require("./kafka.producer"), exports);
+var kafka_1 = require("./kafka");
+Object.defineProperty(exports, "KafkaConnection", { enumerable: true, get: function () { return kafka_1.KafkaConnection; } });

package/dist/connections/kafka/kafka.consumer.d.ts

@@ -0,0 +1,13 @@
+import type { Consumer, ConsumerConfig, EachMessagePayload } from "kafkajs";
+import { KafkaConnection } from "./kafka";
+export type KafkaConnectionHandler = (message: any, payload: EachMessagePayload) => any;
+export declare class KafkaConsumer {
+    readonly connection: KafkaConnection;
+    private readonly config;
+    readonly consumer: Consumer;
+    constructor(connection: KafkaConnection, config: ConsumerConfig);
+    private _needConnection;
+    connect(): Promise<void>;
+    subscribe(topic: string, handler: KafkaConnectionHandler): Promise<void>;
+    disconnect(): Promise<void>;
+}

package/dist/connections/kafka/kafka.consumer.js

@@ -0,0 +1,128 @@
+"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 __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KafkaConsumer = void 0;
+var utils_1 = require("@klapeks/utils");
+var logger = new utils_1.Logger("Kafka Consumer");
+var KafkaConsumer = /** @class */ (function () {
+    function KafkaConsumer(connection, config) {
+        this.connection = connection;
+        this.config = config;
+        this._needConnection = true;
+        this.consumer = connection.kafka.consumer(config);
+    }
+    KafkaConsumer.prototype.connect = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this._needConnection)
+                            return [2 /*return*/];
+                        return [4 /*yield*/, this.consumer.connect()];
+                    case 1:
+                        _a.sent();
+                        this._needConnection = false;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    KafkaConsumer.prototype.subscribe = function (topic, handler) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this._needConnection) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.connect()];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, this.consumer.subscribe({
+                            topic: topic,
+                            fromBeginning: true,
+                        })];
+                    case 3:
+                        _a.sent();
+                        logger.log("Pre run:", topic);
+                        return [4 /*yield*/, this.consumer.run({
+                                eachMessage: function (payload) { return __awaiter(_this, void 0, void 0, function () {
+                                    var msg;
+                                    var _a;
+                                    return __generator(this, function (_b) {
+                                        switch (_b.label) {
+                                            case 0:
+                                                msg = (_a = payload.message.value) === null || _a === void 0 ? void 0 : _a.toString();
+                                                if (!msg)
+                                                    return [2 /*return*/];
+                                                try {
+                                                    msg = JSON.parse(msg);
+                                                }
+                                                catch (err) { }
+                                                return [4 /*yield*/, handler(msg, payload)];
+                                            case 1:
+                                                _b.sent();
+                                                return [2 /*return*/];
+                                        }
+                                    });
+                                }); },
+                            })];
+                    case 4:
+                        _a.sent();
+                        logger.log("Listening:", topic);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    KafkaConsumer.prototype.disconnect = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.consumer.disconnect()];
+                    case 1:
+                        _a.sent();
+                        logger.log("Consumer disconnected:", this.config.groupId);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return KafkaConsumer;
+}());
+exports.KafkaConsumer = KafkaConsumer;

package/dist/connections/kafka/kafka.d.ts

@@ -0,0 +1,16 @@
+import type { ConsumerConfig, Kafka, ProducerConfig } from "kafkajs";
+import { KafkaProducer } from "./kafka.producer";
+import { KafkaConsumer } from "./kafka.consumer";
+export declare const instances: {
+    producers: KafkaProducer[];
+    consumers: KafkaConsumer[];
+};
+export declare class KafkaConnection {
+    readonly clientId: string;
+    readonly kafka: Kafka;
+    constructor(clientId: string);
+    createTopic(topic: string, partitions: number, replicas: number): Promise<void>;
+    createProducer(config?: ProducerConfig): KafkaProducer;
+    createConsumer(config: ConsumerConfig): KafkaConsumer;
+    static cleanExit(): Promise<void>;
+}