emilsoftware-utilities 1.3.10 → 1.3.11

package/dist/Autbobind.d.ts

@@ -0,0 +1,19 @@
+export declare class Autobind {
+    /**
+     * Binds a method to the instance, ensuring `this` references are preserved.
+     */
+    static boundMethod(target: any, key: any, descriptor: any): {
+        configurable: boolean;
+        get(): any;
+        set(value: any): void;
+    };
+    /**
+     * Applies `boundMethod` to all methods in the class prototype.
+     */
+    static boundClass(target: any): any;
+    /**
+     * Retrieves all property keys (including symbols) from the prototype.
+     */
+    private static getPrototypeKeys;
+    static apply(...args: any[]): any;
+}

package/dist/Autbobind.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Autobind = void 0;
+var Autobind = /** @class */ (function () {
+    function Autobind() {
+    }
+    /**
+     * Binds a method to the instance, ensuring `this` references are preserved.
+     */
+    Autobind.boundMethod = function (target, key, descriptor) {
+        var fn = descriptor === null || descriptor === void 0 ? void 0 : descriptor.value;
+        if (typeof fn !== 'function') {
+            throw new TypeError("@boundMethod decorator can only be applied to methods, not: ".concat(typeof fn));
+        }
+        var definingProperty = false;
+        return {
+            configurable: true,
+            get: function () {
+                if (definingProperty ||
+                    this === target.prototype ||
+                    Object.prototype.hasOwnProperty.call(this, key) ||
+                    typeof fn !== 'function') {
+                    return fn;
+                }
+                var boundFn = fn.bind(this);
+                definingProperty = true;
+                Object.defineProperty(this, key, {
+                    configurable: true,
+                    get: function () {
+                        return boundFn;
+                    },
+                    set: function (value) {
+                        fn = value;
+                        delete this[key];
+                    },
+                });
+                definingProperty = false;
+                return boundFn;
+            },
+            set: function (value) {
+                fn = value;
+            },
+        };
+    };
+    /**
+     * Applies `boundMethod` to all methods in the class prototype.
+     */
+    Autobind.boundClass = function (target) {
+        var keys = Autobind.getPrototypeKeys(target.prototype);
+        keys.forEach(function (key) {
+            if (key === 'constructor')
+                return;
+            var descriptor = Object.getOwnPropertyDescriptor(target.prototype, key);
+            if (descriptor && typeof descriptor.value === 'function') {
+                Object.defineProperty(target.prototype, key, Autobind.boundMethod(target, key, descriptor));
+            }
+        });
+        return target;
+    };
+    /**
+     * Retrieves all property keys (including symbols) from the prototype.
+     */
+    Autobind.getPrototypeKeys = function (proto) {
+        if (typeof Reflect !== 'undefined' && typeof Reflect.ownKeys === 'function') {
+            return Reflect.ownKeys(proto);
+        }
+        var keys = Object.getOwnPropertyNames(proto);
+        if (typeof Object.getOwnPropertySymbols === 'function') {
+            return keys.concat(Object.getOwnPropertySymbols(proto));
+        }
+        return keys;
+    };
+    Autobind.apply = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (args.length === 1) {
+            return Autobind.boundClass(args[0]);
+        }
+        return Autobind.boundMethod(args[0], args[1], args[2]);
+    };
+    return Autobind;
+}());
+exports.Autobind = Autobind;

package/dist/DatabaseUpdater.d.ts

@@ -1,4 +1,4 @@
-import { Logger } from "./logger";
+import { Logger } from "./Logger";
 import { Options } from "es-node-firebird";
 export declare abstract class DatabaseUpdater {
     protected static options: Options;

package/dist/DatabaseUpdater.js

@@ -37,8 +37,8 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DatabaseUpdater = void 0;
-var orm_1 = require("./orm");
-var logger_1 = require("./logger");
+var Orm_1 = require("./Orm");
+var Logger_1 = require("./Logger");
 var DatabaseUpdater = /** @class */ (function () {
     function DatabaseUpdater() {
     }
@@ -58,7 +58,7 @@ var DatabaseUpdater = /** @class */ (function () {
                 switch (_a.label) {
                     case 0:
                         query = "\n      SELECT 1 \n      FROM RDB$RELATION_FIELDS \n      WHERE RDB$RELATION_NAME = ? \n        AND RDB$FIELD_NAME = ?";
-                        return [4 /*yield*/, orm_1.Orm.query(options, query, [
+                        return [4 /*yield*/, Orm_1.Orm.query(options, query, [
                                 table.toUpperCase(),
                                 column.toUpperCase(),
                             ])];
@@ -79,7 +79,7 @@ var DatabaseUpdater = /** @class */ (function () {
             var parameters;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, orm_1.Orm.query(options, "SELECT CODPAR, DESPAR FROM PARAMETRI WHERE CODPAR = ?", ["VersioneDB"])];
+                    case 0: return [4 /*yield*/, Orm_1.Orm.query(options, "SELECT CODPAR, DESPAR FROM PARAMETRI WHERE CODPAR = ?", ["VersioneDB"])];
                     case 1:
                         parameters = (_a.sent());
                         return [2 /*return*/, parameters.length > 0 ? parameters[0].DESPAR : null];
@@ -96,7 +96,7 @@ var DatabaseUpdater = /** @class */ (function () {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, orm_1.Orm.query(options, "UPDATE PARAMETRI SET DESPAR = ? WHERE CODPAR = ?", [
+                    case 0: return [4 /*yield*/, Orm_1.Orm.query(options, "UPDATE PARAMETRI SET DESPAR = ? WHERE CODPAR = ?", [
                             version,
                             "VersioneDB",
                         ])];
@@ -126,16 +126,16 @@ var DatabaseUpdater = /** @class */ (function () {
                         if (columnAlreadyExists)
                             return [2 /*return*/];
                         createTableQuery = "\n        CREATE TABLE PARAMETRI (\n          CODPAR  VARCHAR(15) NOT NULL,\n          DESPAR  VARCHAR(255),\n          NOTE    BLOB SUB_TYPE 1 SEGMENT SIZE 80,\n          GRUPPO  VARCHAR(20)\n        );";
-                        return [4 /*yield*/, orm_1.Orm.query(options, createTableQuery)];
+                        return [4 /*yield*/, Orm_1.Orm.query(options, createTableQuery)];
                     case 2:
                         _a.sent();
-                        return [4 /*yield*/, orm_1.Orm.query(options, "ALTER TABLE PARAMETRI ADD CONSTRAINT PK_PARAMETRI PRIMARY KEY (CODPAR);")];
+                        return [4 /*yield*/, Orm_1.Orm.query(options, "ALTER TABLE PARAMETRI ADD CONSTRAINT PK_PARAMETRI PRIMARY KEY (CODPAR);")];
                     case 3:
                         _a.sent();
-                        return [4 /*yield*/, orm_1.Orm.query(options, "GRANT ALL ON PARAMETRI TO PUBLIC;")];
+                        return [4 /*yield*/, Orm_1.Orm.query(options, "GRANT ALL ON PARAMETRI TO PUBLIC;")];
                     case 4:
                         _a.sent();
-                        return [4 /*yield*/, orm_1.Orm.query(options, "GRANT SELECT ON PARAMETRI TO TABX;")];
+                        return [4 /*yield*/, Orm_1.Orm.query(options, "GRANT SELECT ON PARAMETRI TO TABX;")];
                     case 5:
                         _a.sent();
                         return [3 /*break*/, 7];
@@ -148,7 +148,7 @@ var DatabaseUpdater = /** @class */ (function () {
                         versioneDb = _a.sent();
                         if (versioneDb !== null && versioneDb !== undefined)
                             return [2 /*return*/];
-                        return [4 /*yield*/, orm_1.Orm.query(options, "INSERT INTO PARAMETRI (CODPAR, DESPAR, NOTE, GRUPPO) VALUES (?,?,?,?)", ["VersioneDB", "0.0a", "versione", null])];
+                        return [4 /*yield*/, Orm_1.Orm.query(options, "INSERT INTO PARAMETRI (CODPAR, DESPAR, NOTE, GRUPPO) VALUES (?,?,?,?)", ["VersioneDB", "0.0a", "versione", null])];
                     case 9:
                         _a.sent();
                         return [2 /*return*/];
@@ -156,7 +156,7 @@ var DatabaseUpdater = /** @class */ (function () {
             });
         });
     };
-    DatabaseUpdater.logger = new logger_1.Logger(DatabaseUpdater.name);
+    DatabaseUpdater.logger = new Logger_1.Logger(DatabaseUpdater.name);
     return DatabaseUpdater;
 }());
 exports.DatabaseUpdater = DatabaseUpdater;

package/dist/ExecutionTimeLogger.d.ts

@@ -0,0 +1,10 @@
+export declare class ExecutionTimeLogger {
+    /**
+     * Wraps a method to log its execution time and errors.
+     * @param target The target object.
+     * @param propertyKey The name of the method.
+     * @param descriptor The property descriptor of the method.
+     * @description use ExecutionTimeLogger.apply on any method
+     */
+    static apply(target: any, propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;
+}

package/dist/{log-execution-time.js → ExecutionTimeLogger.js}

@@ -36,26 +36,37 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = logExecutionTime;
-// DECORATOR
-var logger_1 = require("./logger");
-function logExecutionTime(fileName) {
-    if (fileName === void 0) { fileName = ""; }
-    return function (target, propertyKey, descriptor) {
-        var logger = new logger_1.Logger(fileName);
+exports.ExecutionTimeLogger = void 0;
+var _1 = require("./");
+var ExecutionTimeLogger = /** @class */ (function () {
+    function ExecutionTimeLogger() {
+    }
+    /**
+     * Wraps a method to log its execution time and errors.
+     * @param target The target object.
+     * @param propertyKey The name of the method.
+     * @param descriptor The property descriptor of the method.
+     * @description use ExecutionTimeLogger.apply on any method
+     */
+    ExecutionTimeLogger.apply = function (target, propertyKey, descriptor) {
         var originalMethod = descriptor.value;
+        if (typeof originalMethod !== "function") {
+            throw new TypeError("ExecutionTimeLogger can only be applied to methods, not: ".concat(typeof originalMethod));
+        }
         descriptor.value = function () {
             var args = [];
             for (var _i = 0; _i < arguments.length; _i++) {
                 args[_i] = arguments[_i];
             }
             return __awaiter(this, void 0, void 0, function () {
-                var start, result, end, durationInMilliseconds, error_1;
+                var className, logger, start, result, end, durationInMilliseconds, error_1;
                 return __generator(this, function (_a) {
                     switch (_a.label) {
                         case 0:
+                            className = target.constructor.name;
+                            logger = new _1.Logger(className);
                             start = process.hrtime();
-                            logger.info(" ".concat(propertyKey, " method execution started . . ."));
+                            logger.info("[".concat(className, "] ").concat(propertyKey, " method execution started . . ."));
                             _a.label = 1;
                         case 1:
                             _a.trys.push([1, 3, , 4]);
@@ -64,10 +75,11 @@ function logExecutionTime(fileName) {
                             result = _a.sent();
                             end = process.hrtime(start);
                             durationInMilliseconds = end[0] * 1000 + end[1] / 1e6;
-                            logger.info(" ".concat(propertyKey, " method took ").concat(durationInMilliseconds.toFixed(2), " ms to execute"));
+                            logger.info("[".concat(className, "] ").concat(propertyKey, " method took ").concat(durationInMilliseconds.toFixed(2), " ms to execute"));
                             return [2 /*return*/, result];
                         case 3:
                             error_1 = _a.sent();
+                            logger.error("[".concat(className, "] ").concat(propertyKey, " method threw an error: ").concat(error_1.message));
                             throw error_1;
                         case 4: return [2 /*return*/];
                     }
@@ -76,4 +88,6 @@ function logExecutionTime(fileName) {
         };
         return descriptor;
     };
-}
+    return ExecutionTimeLogger;
+}());
+exports.ExecutionTimeLogger = ExecutionTimeLogger;

package/dist/Logger.d.ts

@@ -0,0 +1,35 @@
+import winston from "winston";
+export declare enum LogLevels {
+    INFO = "INFO",
+    ERROR = "ERROR",
+    WARNING = "WARNING",
+    DEBUG = "DEBUG",
+    LOG = "LOG",
+    DATABASE = "DATABASE"
+}
+export declare class Logger {
+    private readonly winstonLogger;
+    private readonly tag;
+    private readonly logDirectory;
+    private logFormat;
+    constructor(tag: string, config?: {
+        logDirectory?: string;
+        customFormat?: winston.Logform.Format;
+        transports?: winston.transport[];
+    });
+    private initializeDirectory;
+    private getFileName;
+    private replaceAll;
+    execStart(prefix?: string): number;
+    execStop(prefix: string, startTime: number, error?: boolean): void;
+    info(...data: Object[]): void;
+    dbLog(...data: Object[]): void;
+    debug(...data: Object[]): void;
+    warning(...data: Object[]): void;
+    log(...data: Object[]): void;
+    error(...data: Object[]): void;
+    private print;
+    static createLogger(tag: string, config?: {
+        logDirectory?: string;
+    }): Logger;
+}

package/dist/Logger.js

@@ -0,0 +1,283 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["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 __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+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.Logger = exports.LogLevels = void 0;
+var winston_1 = __importDefault(require("winston"));
+var path = __importStar(require("path"));
+var fs_1 = require("fs");
+var colorette_1 = require("colorette");
+var LogLevels;
+(function (LogLevels) {
+    LogLevels["INFO"] = "INFO";
+    LogLevels["ERROR"] = "ERROR";
+    LogLevels["WARNING"] = "WARNING";
+    LogLevels["DEBUG"] = "DEBUG";
+    LogLevels["LOG"] = "LOG";
+    LogLevels["DATABASE"] = "DATABASE";
+})(LogLevels || (exports.LogLevels = LogLevels = {}));
+var Logger = /** @class */ (function () {
+    function Logger(tag, config) {
+        var _this = this;
+        this.tag = tag || "[UNTAGGED]";
+        this.logDirectory = (config === null || config === void 0 ? void 0 : config.logDirectory) || "logs";
+        // Default log format
+        this.logFormat =
+            (config === null || config === void 0 ? void 0 : config.customFormat) ||
+                winston_1.default.format.printf(function (_a) {
+                    var timestamp = _a.timestamp, file = _a.file, level = _a.level, message = _a.message, meta = __rest(_a, ["timestamp", "file", "level", "message"]);
+                    return JSON.stringify(__assign({ timestamp: timestamp || new Date().toISOString(), tag: _this.tag, file: _this.replaceAll(file + "", "\\", "/"), level: level, message: message }, meta));
+                });
+        this.initializeDirectory();
+        // Configure logger
+        this.winstonLogger = winston_1.default.createLogger({
+            format: winston_1.default.format.combine(winston_1.default.format.timestamp(), this.logFormat),
+            transports: (config === null || config === void 0 ? void 0 : config.transports) || [
+                new winston_1.default.transports.File({
+                    filename: path.join(this.logDirectory, this.getFileName() + ".json"),
+                }),
+            ],
+            levels: {
+                error: 1,
+                warn: 2,
+                warning: 2,
+                info: 3,
+                http: 4,
+                verbose: 5,
+                debug: 6,
+                silly: 7,
+                database: 8,
+            },
+        });
+        // Add colors for console logging
+        winston_1.default.addColors({
+            database: "green",
+            error: "red",
+            warning: "yellow",
+            info: "blue",
+            debug: "magenta",
+            log: "cyan",
+        });
+    }
+    Logger.prototype.initializeDirectory = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var exists, err_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 4, , 5]);
+                        return [4 /*yield*/, fs_1.promises.access(this.logDirectory).then(function () { return true; }).catch(function () { return false; })];
+                    case 1:
+                        exists = _a.sent();
+                        if (!!exists) return [3 /*break*/, 3];
+                        return [4 /*yield*/, fs_1.promises.mkdir(this.logDirectory)];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3: return [3 /*break*/, 5];
+                    case 4:
+                        err_1 = _a.sent();
+                        console.error("Error initializing log directory:", err_1);
+                        return [3 /*break*/, 5];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Logger.prototype.getFileName = function () {
+        var now = new Date();
+        var dateString = now.toISOString().split("T")[0]; // YYYY-MM-DD
+        return dateString;
+    };
+    Logger.prototype.replaceAll = function (string, match, replacer) {
+        return string.split(match).join(replacer);
+    };
+    Logger.prototype.execStart = function (prefix) {
+        if (prefix === void 0) { prefix = ""; }
+        this.print(LogLevels.INFO, "".concat(prefix, " - Execution started"));
+        return performance.now();
+    };
+    Logger.prototype.execStop = function (prefix, startTime, error) {
+        if (prefix === void 0) { prefix = ""; }
+        if (error === void 0) { error = false; }
+        var executionTime = performance.now() - startTime;
+        var message = "".concat(prefix, " - Execution ended ").concat(error ? "due to an error" : "successfully", ". Execution time: ").concat(executionTime.toFixed(2), " ms");
+        this.print(error ? LogLevels.ERROR : LogLevels.INFO, message);
+    };
+    Logger.prototype.info = function () {
+        var data = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            data[_i] = arguments[_i];
+        }
+        this.print.apply(this, __spreadArray([LogLevels.INFO], data, false));
+    };
+    Logger.prototype.dbLog = function () {
+        var data = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            data[_i] = arguments[_i];
+        }
+        this.print.apply(this, __spreadArray([LogLevels.DATABASE], data, false));
+    };
+    Logger.prototype.debug = function () {
+        var data = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            data[_i] = arguments[_i];
+        }
+        this.print.apply(this, __spreadArray([LogLevels.DEBUG], data, false));
+    };
+    Logger.prototype.warning = function () {
+        var data = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            data[_i] = arguments[_i];
+        }
+        this.print.apply(this, __spreadArray([LogLevels.WARNING], data, false));
+    };
+    Logger.prototype.log = function () {
+        var data = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            data[_i] = arguments[_i];
+        }
+        this.print.apply(this, __spreadArray([LogLevels.LOG], data, false));
+    };
+    Logger.prototype.error = function () {
+        var data = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            data[_i] = arguments[_i];
+        }
+        this.print.apply(this, __spreadArray([LogLevels.ERROR], data, false));
+    };
+    Logger.prototype.print = function (level) {
+        var data = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            data[_i - 1] = arguments[_i];
+        }
+        var now = new Date();
+        var fileName = this.tag.split("\\").pop() || this.tag;
+        // Attach metadata to Winston logger
+        this.winstonLogger.defaultMeta = {
+            file: fileName,
+            time: now,
+            level: level,
+        };
+        var logEntry = {
+            level: level.toLowerCase(),
+            message: __spreadArray([], data, true).join(","),
+        };
+        // Log to console with colors
+        switch (level) {
+            case LogLevels.INFO:
+                console.info((0, colorette_1.blue)("[INFO][".concat(now, "][").concat(fileName, "]")), logEntry.message);
+                break;
+            case LogLevels.ERROR:
+                console.error((0, colorette_1.red)("[ERROR][".concat(now, "][").concat(fileName, "]")), logEntry.message);
+                break;
+            case LogLevels.DEBUG:
+                console.debug((0, colorette_1.magenta)("[DEBUG][".concat(now, "][").concat(fileName, "]")), logEntry.message);
+                break;
+            case LogLevels.LOG:
+                console.log((0, colorette_1.cyan)("[LOG][".concat(now, "][").concat(fileName, "]")), logEntry.message);
+                break;
+            case LogLevels.DATABASE:
+                console.log((0, colorette_1.green)("[DATABASE][".concat(now, "][").concat(fileName, "]")), logEntry.message);
+                break;
+        }
+        // Log to file
+        this.winstonLogger.log(logEntry);
+    };
+    Logger.createLogger = function (tag, config) {
+        return new Logger(tag, config);
+    };
+    return Logger;
+}());
+exports.Logger = Logger;

package/dist/Orm.d.ts

@@ -0,0 +1,18 @@
+import { Database, Options, Transaction } from "es-node-firebird";
+export declare class Orm {
+    private static logger;
+    static quote(value: string): string;
+    static testConnection(options: Options): Promise<boolean>;
+    static query(options: Options, query: string, parameters?: any[], logQuery?: boolean): Promise<any>;
+    static execute(options: Options, query: string, parameters?: any, logQuery?: boolean): Promise<any>;
+    static trimParam(param: any): string;
+    static connect(options: Options): Promise<Database>;
+    static startTransaction(db: Database): Promise<Transaction>;
+    static commitTransaction(transaction: Transaction): Promise<string>;
+    static rollbackTransaction(transaction: Transaction): Promise<string>;
+    static executeMultiple(options: Options, queriesWithParams: {
+        query: string;
+        params: any[];
+    }[]): Promise<string>;
+    static executeQueries(transaction: Transaction, queries: string[], params: any[]): Promise<any>;
+}