emilsoftware-utilities 1.1.0 → 1.1.2

package/.idea/.name

@@ -0,0 +1 @@
+emilsoftware-utilities

package/.idea/emilsoftware-utilities.iml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/.tmp" />
+      <excludeFolder url="file://$MODULE_DIR$/temp" />
+      <excludeFolder url="file://$MODULE_DIR$/tmp" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

package/.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,10 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="DuplicatedCode" enabled="true" level="WEAK WARNING" enabled_by_default="true">
+      <Languages>
+        <language minSize="63" name="TypeScript" />
+      </Languages>
+    </inspection_tool>
+  </profile>
+</component>

package/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/emilsoftware-utilities.iml" filepath="$PROJECT_DIR$/.idea/emilsoftware-utilities.iml" />
+    </modules>
+  </component>
+</project>

package/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

package/autobind.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Return a descriptor removing the value and returning a getter
+ * The getter will return a .bind version of the function
+ * and memoize the result against a symbol on the instance
+ */
+export declare function boundMethod(target: any, key: any, descriptor: any): {
+    configurable: boolean;
+    get(): any;
+    set(value: any): void;
+};
+/**
+ * Use boundMethod to bind all methods on the target.prototype
+ */
+export declare function boundClass(target: any): any;
+export default function autobind(...args: any[]): any;

package/autobind.js

@@ -0,0 +1,95 @@
+"use strict";
+// DECORATOR
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.boundClass = exports.boundMethod = void 0;
+/**
+ * Return a descriptor removing the value and returning a getter
+ * The getter will return a .bind version of the function
+ * and memoize the result against a symbol on the instance
+ */
+function boundMethod(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));
+    }
+    // In IE11 calling Object.defineProperty has a side effect of evaluating the
+    // getter for the property which is being replaced. This causes infinite
+    // recursion and an "Out of stack space" error.
+    var definingProperty = false;
+    return {
+        configurable: true,
+        get: function () {
+            // eslint-disable-next-line no-prototype-builtins
+            if (definingProperty || this === target.prototype || this.hasOwnProperty(key) ||
+                typeof fn !== 'function') {
+                return fn;
+            }
+            var boundFn = fn.bind(this);
+            definingProperty = true;
+            if (key) {
+                Object.defineProperty(this, key, {
+                    configurable: true,
+                    get: function () {
+                        return boundFn;
+                    },
+                    set: function (value) {
+                        fn = value;
+                        // @ts-ignore
+                        delete this[key];
+                    }
+                });
+            }
+            definingProperty = false;
+            return boundFn;
+        },
+        set: function (value) {
+            fn = value;
+        }
+    };
+}
+exports.boundMethod = boundMethod;
+/**
+ * Use boundMethod to bind all methods on the target.prototype
+ */
+function boundClass(target) {
+    // (Using reflect to get all keys including symbols)
+    var keys;
+    // Use Reflect if exists
+    if (typeof Reflect !== 'undefined' && typeof Reflect.ownKeys === 'function') {
+        keys = Reflect.ownKeys(target.prototype);
+    }
+    else {
+        keys = Object.getOwnPropertyNames(target.prototype);
+        // Use symbols if support is provided
+        if (typeof Object.getOwnPropertySymbols === 'function') {
+            // @ts-ignore
+            keys = keys.concat(Object.getOwnPropertySymbols(target.prototype));
+        }
+    }
+    keys.forEach(function (key) {
+        // Ignore special case target method
+        if (key === 'constructor') {
+            return;
+        }
+        var descriptor = Object.getOwnPropertyDescriptor(target.prototype, key);
+        // Only methods need binding
+        if (typeof (descriptor === null || descriptor === void 0 ? void 0 : descriptor.value) === 'function') {
+            Object.defineProperty(target.prototype, key, boundMethod(target, key, descriptor));
+        }
+    });
+    return target;
+}
+exports.boundClass = boundClass;
+function autobind() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    if (args.length === 1) {
+        // @ts-ignore
+        return boundClass.apply(void 0, args);
+    }
+    // @ts-ignore
+    return boundMethod.apply(void 0, args);
+}
+exports.default = autobind;

package/index.d.ts

@@ -0,0 +1,6 @@
+import autobind from "./autobind";
+import logExecutionTime from "./log-execution-time";
+import { Logger, LogLevels } from "./logger";
+import { Orm } from "./orm";
+import { Utilities } from "./utilities";
+export { autobind, logExecutionTime, Logger, LogLevels, Orm, Utilities };

package/log-execution-time.d.ts

@@ -0,0 +1 @@
+export default function logExecutionTime(fileName?: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;

package/log-execution-time.js

@@ -0,0 +1,79 @@
+"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 });
+// 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);
+        var originalMethod = descriptor.value;
+        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;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            start = process.hrtime();
+                            logger.info(" ".concat(propertyKey, " method execution started . . ."));
+                            _a.label = 1;
+                        case 1:
+                            _a.trys.push([1, 3, , 4]);
+                            return [4 /*yield*/, originalMethod.apply(this, args)];
+                        case 2:
+                            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"));
+                            return [2 /*return*/, result];
+                        case 3:
+                            error_1 = _a.sent();
+                            throw error_1;
+                        case 4: return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        return descriptor;
+    };
+}
+exports.default = logExecutionTime;

package/logger.d.ts

@@ -0,0 +1,20 @@
+export declare enum LogLevels {
+    INFO = "INFO",
+    ERROR = "ERROR",
+    DEBUG = "DEBUG",
+    LOG = "LOG"
+}
+export declare class Logger {
+    private readonly winstonLogger;
+    tag: string;
+    private logFormat;
+    constructor(tag: string);
+    private getFileName;
+    execStart(prefix?: string): any;
+    execStop(prefix: string, startTime: any, error?: boolean): any;
+    info(...data: any): void;
+    debug(...data: any): void;
+    log(...data: any): void;
+    error(...data: any): void;
+    private print;
+}

package/logger.js

@@ -0,0 +1,138 @@
+"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 __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 __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 = __importStar(require("fs"));
+var LogLevels;
+(function (LogLevels) {
+    LogLevels["INFO"] = "INFO";
+    LogLevels["ERROR"] = "ERROR";
+    LogLevels["DEBUG"] = "DEBUG";
+    LogLevels["LOG"] = "LOG";
+})(LogLevels || (exports.LogLevels = LogLevels = {}));
+var Logger = /** @class */ (function () {
+    function Logger(tag) {
+        this.tag = "[UNTAGGED]";
+        this.logFormat = winston_1.default.format.printf(function (tmp) {
+            var time = tmp.time, file = tmp.file, level = tmp.level, message = tmp.message;
+            return "".concat(JSON.stringify({ time: time, file: file === null || file === void 0 ? void 0 : file.replaceAll("\\", "/"), level: level, message: message }), ",");
+        });
+        var fileName = this.getFileName();
+        var logsDirectory = "logs";
+        var logFilePath = path.join(logsDirectory, fileName + ".json");
+        if (!fs.existsSync(logsDirectory)) {
+            fs.mkdirSync(logsDirectory);
+        }
+        this.tag = tag;
+        this.winstonLogger = winston_1.default.createLogger({
+            format: winston_1.default.format.json(),
+            transports: [new winston_1.default.transports.File({ filename: logFilePath, format: this.logFormat })],
+        });
+    }
+    Logger.prototype.getFileName = function () {
+        var now = new Date();
+        return now.getDate() + "-" + (now.getMonth() + 1) + "-" + now.getFullYear();
+    };
+    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; }
+        switch (error) {
+            case true: {
+                this.print(LogLevels.ERROR, "".concat(prefix, " - Execution ended due to an error. Execution time: ").concat(performance.now() - startTime, " ms"));
+                break;
+            }
+            case false: {
+                this.print(LogLevels.INFO, "".concat(prefix, " - Execution ended successfully. Execution time: ").concat(performance.now() - startTime, " ms"));
+                break;
+            }
+        }
+    };
+    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.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.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 _a;
+        if (level === void 0) { level = LogLevels.INFO; }
+        var data = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            data[_i - 1] = arguments[_i];
+        }
+        var now = new Date();
+        // Utilities.getNowDateString();
+        this.winstonLogger.defaultMeta = {
+            file: this.tag, time: now,
+            level: level
+        };
+        (_a = this.winstonLogger)[level.toLowerCase()].apply(_a, data);
+        // @ts-ignore
+        console[level.toLowerCase()].apply(console, __spreadArray(["[".concat(level, "][").concat(now, "][").concat(this.tag.split("\\").pop(), "]")], data, false));
+    };
+    return Logger;
+}());
+exports.Logger = Logger;

package/orm.d.ts

@@ -0,0 +1,14 @@
+import { Database, Options, Transaction } from "node-firebird";
+interface Orm {
+    quote: (value: string) => string;
+    testConnection: (options: Options) => Promise<any>;
+    query: (options: Options, query: any, parameters?: any[]) => Promise<any>;
+    execute: (options: Options, query: any, parameters?: any[]) => Promise<any>;
+    trimParam: (param: any) => string;
+    connect: (options: Options) => Promise<any>;
+    startTransaction: (db: Database) => Promise<any>;
+    executeQueries: (transaction: Transaction, queries: string[], params: any[]) => any;
+    commitTransaction: (transaction: Transaction) => Promise<any>;
+}
+export declare const Orm: Orm;
+export {};

package/orm.js

@@ -0,0 +1,140 @@
+"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 __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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Orm = void 0;
+// @ts-ignore
+var Firebird = __importStar(require("es-node-firebird"));
+var logger_1 = require("./logger");
+var quote = function (value) {
+    return "\"" + value + "\"";
+};
+var testConnection = function (options) {
+    var logger = new logger_1.Logger(__filename);
+    return new Promise(function (resolve) {
+        Firebird.attach(options, function (err, db) {
+            if (err) {
+                logger.error("La connessione con il DATABASE non è andata a buon fine.");
+                return resolve(false);
+            }
+            logger.info("DATABASE connesso.");
+            return resolve(true);
+        });
+    });
+};
+var query = function (options, query, parameters) {
+    if (parameters === void 0) { parameters = []; }
+    return new Promise(function (resolve, reject) {
+        Firebird.attach(options, function (err, db) {
+            if (err) {
+                return reject(err);
+            }
+            db.query(query, parameters, function (error, result) {
+                if (error) {
+                    db.detach();
+                    return reject(error);
+                }
+                db.detach();
+                return resolve(result);
+            });
+        });
+    });
+};
+var execute = function (options, query, parameters) {
+    if (parameters === void 0) { parameters = []; }
+    return new Promise(function (resolve, reject) {
+        Firebird.attach(options, function (err, db) {
+            if (err) {
+                return reject(err);
+            }
+            db.execute(query, parameters, function (error, result) {
+                if (error) {
+                    db.detach();
+                    return reject(error);
+                }
+                db.detach();
+                return resolve(result);
+            });
+        });
+    });
+};
+var trimParam = function (param) {
+    if (typeof param === "string" || param instanceof String) {
+        return param.trim();
+    }
+    return param;
+};
+var connect = function (options) {
+    return new Promise(function (resolve, reject) {
+        Firebird.attach(options, function (err, db) {
+            if (err)
+                return reject(err);
+            else
+                return resolve(db);
+        });
+    });
+};
+var startTransaction = function (db) {
+    return new Promise(function (resolve, reject) {
+        db.transaction(Firebird.ISOLATION_READ_COMMITTED, function (err, transaction) {
+            if (err)
+                return reject(err);
+            else
+                return resolve(transaction);
+        });
+    });
+};
+var executeQueries = function (transaction, queries, params) {
+    return queries.reduce(function (promiseChain, currentQuery, index) {
+        return promiseChain.then(function () { return new Promise(function (resolve, reject) {
+            transaction.query(currentQuery, params[index], function (err, result) {
+                if (err)
+                    return reject(err);
+                else
+                    return resolve(result);
+            });
+        }); });
+    }, Promise.resolve());
+};
+var commitTransaction = function (transaction) {
+    return new Promise(function (resolve, reject) {
+        transaction.commit(function (err) {
+            if (err)
+                return reject(err);
+            else
+                return resolve('Transaction committed successfully.');
+        });
+    });
+};
+exports.Orm = {
+    quote: quote,
+    testConnection: testConnection,
+    query: query,
+    execute: execute,
+    trimParam: trimParam,
+    connect: connect,
+    startTransaction: startTransaction,
+    executeQueries: executeQueries,
+    commitTransaction: commitTransaction
+};

package/package.json

@@ -1,11 +1,8 @@
 {
   "name": "emilsoftware-utilities",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "Utilities for EmilSoftware",
   "main": "index.js",
-  "files": [
-    "dist"
-  ],
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
     "build": "tsc",
@@ -26,6 +23,7 @@
     "winston": "^3.11.0"
   },
   "devDependencies": {
+    "@types/express": "^4.17.21",
     "@types/node": "^20.10.5",
     "typescript": "^5.3.3"
   }

package/src/autobind.ts

@@ -0,0 +1,94 @@
+// DECORATOR
+
+/**
+ * Return a descriptor removing the value and returning a getter
+ * The getter will return a .bind version of the function
+ * and memoize the result against a symbol on the instance
+ */
+export function boundMethod(target:any, key: any, descriptor: any) {
+    let fn = descriptor?.value;
+
+    if (typeof fn !== 'function') {
+        throw new TypeError(`@boundMethod decorator can only be applied to methods not: ${typeof fn}`);
+    }
+
+    // In IE11 calling Object.defineProperty has a side effect of evaluating the
+    // getter for the property which is being replaced. This causes infinite
+    // recursion and an "Out of stack space" error.
+    let definingProperty = false;
+
+    return {
+        configurable: true,
+        get() {
+            // eslint-disable-next-line no-prototype-builtins
+            if (definingProperty || this === target.prototype || this.hasOwnProperty(key as string | number | symbol) ||
+                typeof fn !== 'function') {
+                return fn;
+            }
+
+            const boundFn = fn.bind(this);
+            definingProperty = true;
+            if (key) {
+                Object.defineProperty(this, key, {
+                    configurable: true,
+                    get() {
+                        return boundFn;
+                    },
+                    set(value) {
+                        fn = value;
+                        // @ts-ignore
+                        delete this[key];
+                    }
+                });
+            }
+            definingProperty = false;
+            return boundFn;
+        },
+        set(value: any) {
+            fn = value;
+        }
+    };
+}
+
+/**
+ * Use boundMethod to bind all methods on the target.prototype
+ */
+export function boundClass(target: any) {
+    // (Using reflect to get all keys including symbols)
+    let keys;
+    // Use Reflect if exists
+    if (typeof Reflect !== 'undefined' && typeof Reflect.ownKeys === 'function') {
+        keys = Reflect.ownKeys(target.prototype);
+    } else {
+        keys = Object.getOwnPropertyNames(target.prototype);
+        // Use symbols if support is provided
+        if (typeof Object.getOwnPropertySymbols === 'function') {
+            // @ts-ignore
+            keys = keys.concat(Object.getOwnPropertySymbols(target.prototype));
+        }
+    }
+
+    keys.forEach(key => {
+        // Ignore special case target method
+        if (key === 'constructor') {
+            return;
+        }
+
+        const descriptor = Object.getOwnPropertyDescriptor(target.prototype, key);
+
+        // Only methods need binding
+        if (typeof descriptor?.value === 'function') {
+            Object.defineProperty(target.prototype, key, boundMethod(target, key, descriptor));
+        }
+    });
+    return target;
+}
+
+export default function autobind(...args: any[]) {
+    if (args.length === 1) {
+        // @ts-ignore
+        return boundClass(...args);
+    }
+    // @ts-ignore
+    return boundMethod(...args);
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+import autobind from "./autobind"
+import logExecutionTime from "./log-execution-time"
+import {Logger, LogLevels} from "./logger";
+import {Orm} from "./orm";
+import {Utilities} from "./utilities";
+export {autobind, logExecutionTime, Logger, LogLevels, Orm, Utilities};

package/src/log-execution-time.ts

@@ -0,0 +1,25 @@
+// DECORATOR
+import {Logger} from "./logger";
+
+export default function logExecutionTime(fileName: string = "") {
+    return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
+        const logger: Logger = new Logger(fileName);
+        const originalMethod = descriptor.value;
+        descriptor.value = async function (...args: any[]) {
+            const start = process.hrtime();
+            logger.info(` ${propertyKey} method execution started . . .`);
+            try {
+                const result = await originalMethod.apply(this, args);
+                const end = process.hrtime(start);
+                const durationInMilliseconds = end[0] * 1000 + end[1] / 1e6;
+                logger.info(` ${propertyKey} method took ${durationInMilliseconds.toFixed(2)} ms to execute`)
+                return result;
+            } catch (error) {
+                throw error;
+            }
+        };
+        return descriptor;
+
+    }
+
+}

package/src/logger.ts

@@ -0,0 +1,83 @@
+import {Utilities} from "./utilities";
+import winston from "winston";
+import * as path from "path";
+import * as fs from "fs";
+
+export enum LogLevels {
+    INFO = "INFO", ERROR = "ERROR", DEBUG = "DEBUG", LOG = "LOG"
+}
+
+export class Logger {
+    private readonly winstonLogger: any;
+    public tag: string = "[UNTAGGED]";
+
+    private logFormat: winston.Logform.Format = winston.format.printf((tmp: winston.Logform.TransformableInfo): string => {
+        const {time, file, level, message} = tmp;
+        return `${JSON.stringify({time, file: file?.replaceAll("\\", "/"), level, message})},`;
+    });
+
+    constructor(tag: string) {
+        const fileName: string = this.getFileName();
+        const logsDirectory = "logs";
+        const logFilePath = path.join(logsDirectory, fileName + ".json");
+
+        if (!fs.existsSync(logsDirectory)) {
+            fs.mkdirSync(logsDirectory);
+        }
+        this.tag = tag;
+        this.winstonLogger = winston.createLogger({
+            format: winston.format.json(),
+            transports: [new winston.transports.File({filename: logFilePath, format: this.logFormat})],
+        });
+    }
+
+    private getFileName(): string {
+        const now = new Date();
+        return now.getDate() + "-" + (now.getMonth() + 1) + "-" + now.getFullYear();
+    }
+
+    public execStart(prefix: string = ""): any {
+        this.print(LogLevels.INFO, `${prefix} - Execution started`);
+        return performance.now();
+    }
+
+    public execStop(prefix: string = "", startTime: any, error: boolean = false): any {
+        switch (error) {
+            case true: {
+                this.print(LogLevels.ERROR, `${prefix} - Execution ended due to an error. Execution time: ${performance.now() - startTime} ms`);
+                break;
+            }
+            case false: {
+                this.print(LogLevels.INFO, `${prefix} - Execution ended successfully. Execution time: ${performance.now() - startTime} ms`);
+                break;
+            }
+        }
+    }
+
+    public info(...data: any): void {
+        this.print(LogLevels.INFO, ...data);
+    }
+
+    public debug(...data: any): void {
+        this.print(LogLevels.DEBUG, ...data);
+    }
+
+    public log(...data: any): void {
+        this.print(LogLevels.LOG, ...data);
+    }
+
+    public error(...data: any): void {
+        this.print(LogLevels.ERROR, ...data);
+    }
+
+    private print(level: LogLevels = LogLevels.INFO, ...data: any): void {
+        const now = new Date();
+        // Utilities.getNowDateString();
+        this.winstonLogger.defaultMeta = {
+            file: this.tag, time: now, level
+        };
+        this.winstonLogger[level.toLowerCase()](...data);
+        // @ts-ignore
+        console[level.toLowerCase()](`[${level}][${now}][${this.tag.split("\\").pop()}]`, ...data);
+    }
+}

package/src/orm.ts

@@ -0,0 +1,120 @@
+// @ts-ignore
+import * as Firebird from "es-node-firebird";
+import {Logger} from "./logger";
+import {Database, Options, Transaction} from "node-firebird";
+
+
+const quote = (value: string): string => {
+    return "\"" + value + "\"";
+};
+const testConnection = (options: Options): Promise<any> => {
+    const logger: Logger = new Logger(__filename);
+    return new Promise((resolve): void => {
+        Firebird.attach(options, (err: any, db: any): void => {
+            if (err) {
+                logger.error("La connessione con il DATABASE non è andata a buon fine.");
+                return resolve(false);
+            }
+            logger.info("DATABASE connesso.");
+            return resolve(true);
+        })
+    })
+}
+
+const query = (options: Options, query: string, parameters: any[] = []): Promise<any> => {
+    return new Promise((resolve, reject): void => {
+        Firebird.attach(options, (err: any, db: {
+            query: (arg0: any, arg1: any[], arg2: (err: any, result: any) => void) => void; detach: () => void;
+        }) => {
+            if (err) {
+                return reject(err);
+            }
+            db.query(query, parameters, (error: any, result: any) => {
+                if (error) {
+                    db.detach();
+                    return reject(error);
+                }
+                db.detach();
+                return resolve(result);
+            });
+        });
+    });
+}
+const execute = (options: Options, query: string, parameters: any = []): Promise<any> => {
+    return new Promise((resolve, reject): void => {
+        Firebird.attach(options, (err: any, db: {
+            execute: (arg0: any, arg1: any, arg2: (error: any, result: any) => void) => void; detach: () => void;
+        }) => {
+            if (err) {
+                return reject(err);
+            }
+
+            db.execute(query, parameters, (error, result): void => {
+                if (error) {
+                    db.detach();
+                    return reject(error);
+                }
+                db.detach();
+                return resolve(result);
+            });
+        });
+    });
+}
+
+const trimParam = (param: any): string => {
+    if (typeof param === "string" || param instanceof String) {
+        return param.trim();
+    }
+    return param;
+}
+
+const connect = (options: Options): Promise<any> => {
+    return new Promise((resolve, reject): void => {
+        Firebird.attach(options, function (err: any, db: any): void {
+            if (err) return reject(err); else return resolve(db);
+        });
+    });
+}
+
+const startTransaction = (db: Database): Promise<any> => {
+    return new Promise((resolve, reject): void => {
+        db.transaction(Firebird.ISOLATION_READ_COMMITTED, function (err: any, transaction: any) {
+            if (err) return reject(err); else return resolve(transaction);
+        });
+    });
+}
+const executeQueries = (transaction: Transaction, queries: string[], params: any[]) => {
+    return queries.reduce((promiseChain: any, currentQuery: any, index: any) => {
+        return promiseChain.then(() => new Promise((resolve, reject): void => {
+            transaction.query(currentQuery, params[index], (err: any, result: any): void => {
+                if (err) return reject(err); else return resolve(result);
+            });
+        }));
+    }, Promise.resolve());
+}
+
+const commitTransaction = (transaction: Transaction): Promise<any> => {
+    return new Promise((resolve, reject): void => {
+        transaction.commit((err: any): void => {
+            if (err) return reject(err); else return resolve('Transaction committed successfully.');
+        });
+    });
+}
+
+interface Orm {
+    quote: (value: string) => string,
+    testConnection: (options: Options) => Promise<any>,
+    query: (options: Options, query: any, parameters?: any[]) => Promise<any>,
+    execute: (options: Options, query: any, parameters?: any[]) => Promise<any>,
+    trimParam: (param: any) => string,
+    connect: (options: Options) => Promise<any>,
+    startTransaction: (db: Database) => Promise<any>,
+    executeQueries: (transaction: Transaction, queries: string[], params: any[]) => any,
+    commitTransaction: (transaction: Transaction) => Promise<any>
+}
+
+export const Orm: Orm = {
+    quote, testConnection, query, execute, trimParam, connect, startTransaction, executeQueries, commitTransaction
+}
+
+

package/src/utilities.ts

@@ -0,0 +1,180 @@
+import {Response} from 'express';
+
+
+enum STATUS_CODE {
+    OK = 0, WARNING = 1, ERROR = 2,
+}
+
+const parseDate = (date: string) => {
+    const parts: string[] = date.split("/");
+    return new Date(Number(parts[2]), Number(parts[1]) - 1, Number(parts[0]));
+}
+
+const sendOKMessage = (res: Response, message: string): Response => {
+    return res.send({
+        severity: "success", status: 200, statusCode: STATUS_CODE.OK, message,
+    });
+}
+
+
+const getNowDateString = (): string => {
+    const now: Date = new Date();
+    const day: string | number = now.getDate() < 9 ? "0" + now.getDate() : now.getDate();
+    const month: string | number = (now.getMonth() + 1) < 9 ? "0" + (now.getMonth() + 1) : (now.getMonth() + 1);
+    const year: number = now.getFullYear();
+    const hours: string | number = now.getHours() < 9 ? "0" + now.getHours() : now.getHours();
+    const minutes: string | number = now.getMinutes() < 9 ? "0" + now.getMinutes() : now.getMinutes();
+    const seconds: string | number = now.getSeconds() < 9 ? "0" + now.getSeconds() : now.getSeconds();
+    return day + "." + month + "." + year + " " + hours + ":" + minutes + ":" + seconds;
+}
+
+
+const sendErrorMessage = (res: Response, error: any, tag: string = "[BASE ERROR]", status: number = 500): Response => {
+    return res.status(status).send({
+        severity: "error",
+        status: 500,
+        statusCode: STATUS_CODE.ERROR,
+        message: " Si è verificato un errore",
+        error: tag + ": " + error,
+    });
+}
+
+const sendBaseResponse = (res: Response, payload: any): Response => {
+    try {
+        payload = JSON.parse(JSON.stringify(payload));
+        const clearPayload = payload;           // this.keysToCamel(payload);
+        const response = {
+            Status: {
+                errorCode: "0", errorDescription: "",
+            }, Result: clearPayload, Message: ""
+        };
+        return res.send(response);
+    } catch (error) {
+        return sendErrorMessage(res, "Errore nell'invio della risposta: " + error, "[UTILITIES]", 500);
+    }
+}
+
+
+const toCamel = (s: any) => {
+    return s.replace(/([-_][a-z])/gi, ($1: string) => {
+        return $1.toUpperCase().replace("-", "").replace("_", "");
+    });
+};
+
+const isArray = (a: any): boolean => {
+    return Array.isArray(a);
+};
+
+const isObject = (o: any): boolean => {
+    return o === Object(o) && !isArray(o) && typeof o !== "function";
+};
+
+
+const keysToCamel = (o: any): any => {
+    if (isObject(o)) {
+        const n = {};
+
+        Object.keys(o).forEach((k: any) => {
+            // @ts-ignore
+            n[toCamel(k)] = keysToCamel(o[k]);
+        });
+        return n;
+    } else if (isArray(o)) {
+        return o.map((i: any) => {
+            return keysToCamel(i);
+        });
+    }
+
+    return o;
+};
+
+const addStartingZeros = (num: number, totalLength: number): string => {
+    return String(num).padStart(totalLength, '0');
+}
+
+const dateToMoncler = (dData: Date, bAddMs: boolean = false): string => {
+    const yy: number = dData.getFullYear();
+    const mm: string = addStartingZeros(dData.getMonth() + 1, 2);
+    const dd: string = addStartingZeros(dData.getDate(), 2);
+    const hh: string = addStartingZeros(dData.getHours(), 2);
+    const nn: string = addStartingZeros(dData.getMinutes(), 2);
+    const ss: string = addStartingZeros(dData.getSeconds(), 2);
+    const ms: string = addStartingZeros(dData.getMilliseconds(), 3);
+    if (bAddMs) {
+        return yy + mm + dd + hh + nn + ss + ms;
+    } else {
+        return yy + mm + dd + hh + nn + ss;
+    }
+}
+
+const dateToSql = (dData: Date, bAddMs: boolean = false): string => {
+    const yy: number = dData.getFullYear();
+    const mm: string = addStartingZeros(dData.getMonth() + 1, 2);
+    const dd: string = addStartingZeros(dData.getDate(), 2);
+    const hh: string = addStartingZeros(dData.getHours(), 2);
+    const nn: string = addStartingZeros(dData.getMinutes(), 2);
+    const ss: string = addStartingZeros(dData.getSeconds(), 2);
+    const ms: string = addStartingZeros(dData.getMilliseconds(), 3);
+    if (bAddMs) {
+        return yy + '-' + mm + '-' + dd + ' ' + hh + ':' + nn + ':' + ss + '.' + ms;
+    } else {
+        return yy + '-' + mm + '-' + dd + ' ' + hh + ':' + nn + ':' + ss;
+
+    }
+}
+
+const dateToSimple = (dData: Date): string => {
+    const yy: number = dData.getFullYear();
+    const mm: string = addStartingZeros(dData.getMonth() + 1, 2);
+    const dd: string = addStartingZeros(dData.getDate(), 2);
+    return dd + '-' + mm + '-' + yy;
+}
+
+const sendExecMessage = (res: Response, executionObject: any, title: string): Response => {
+    try {
+        let sSql = "";
+        let response = {
+            Status: {
+                errorCode: "0", errorDescription: "",
+            }, Sql: sSql, ID: executionObject?.id, Title: title
+        };
+        return res.send(response);
+    } catch (error) {
+        return sendErrorMessage(res, "Errore nell'invio della risposta: " + error, title, 500);
+    }
+}
+
+interface Utilities {
+    parseDate: (date: string) => Date,
+    sendOKMessage: (res: Response, message: string) => Response,
+    sendExecMessage: (res: Response, executionObject: any, title: string) => Response,
+    getNowDateString: () => {},
+    sendErrorMessage: (res: Response, error: any, tag?: string, status?: number) => Response,
+    sendBaseResponse: (res: Response, payload: any) => Response,
+    toCamel: (s: any) => any,
+    isArray: (a: any) => boolean,
+    isObject: (o: any) => boolean,
+    keysToCamel: (o: any) => any,
+    addStartingZeros: (num: number, totalLength: number) => string,
+    dateToMoncler: (dData: Date, bAddMs?: boolean) => string,
+    dateToSql: (dData: Date, bAddMs?: boolean) => string,
+    dateToSimple: (dData: Date) => string
+}
+
+export const Utilities: Utilities = {
+    parseDate,
+    sendOKMessage,
+    sendExecMessage,
+    getNowDateString,
+    sendErrorMessage,
+    sendBaseResponse,
+    toCamel,
+    isArray,
+    isObject,
+    keysToCamel,
+    addStartingZeros,
+    dateToMoncler,
+    dateToSql,
+    dateToSimple
+}
+

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "es5",
+    "module": "commonjs",
+    "declaration": true,
+    "outDir": ".",
+    "esModuleInterop": true
+  },
+  "include": [
+    "src/index.ts",
+    "src/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}

package/utilities.d.ts

@@ -0,0 +1,19 @@
+import { Response } from 'express';
+interface Utilities {
+    parseDate: (date: string) => Date;
+    sendOKMessage: (res: Response, message: string) => Response;
+    sendExecMessage: (res: Response, executionObject: any, title: string) => Response;
+    getNowDateString: () => {};
+    sendErrorMessage: (res: Response, error: any, tag?: string, status?: number) => Response;
+    sendBaseResponse: (res: Response, payload: any) => Response;
+    toCamel: (s: any) => any;
+    isArray: (a: any) => boolean;
+    isObject: (o: any) => boolean;
+    keysToCamel: (o: any) => any;
+    addStartingZeros: (num: number, totalLength: number) => string;
+    dateToMoncler: (dData: Date, bAddMs?: boolean) => string;
+    dateToSql: (dData: Date, bAddMs?: boolean) => string;
+    dateToSimple: (dData: Date) => string;
+}
+export declare const Utilities: Utilities;
+export {};

package/utilities.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Utilities = void 0;
+var STATUS_CODE;
+(function (STATUS_CODE) {
+    STATUS_CODE[STATUS_CODE["OK"] = 0] = "OK";
+    STATUS_CODE[STATUS_CODE["WARNING"] = 1] = "WARNING";
+    STATUS_CODE[STATUS_CODE["ERROR"] = 2] = "ERROR";
+})(STATUS_CODE || (STATUS_CODE = {}));
+var parseDate = function (date) {
+    var parts = date.split("/");
+    return new Date(Number(parts[2]), Number(parts[1]) - 1, Number(parts[0]));
+};
+var sendOKMessage = function (res, message) {
+    return res.send({
+        severity: "success", status: 200, statusCode: STATUS_CODE.OK,
+        message: message,
+    });
+};
+var getNowDateString = function () {
+    var now = new Date();
+    var day = now.getDate() < 9 ? "0" + now.getDate() : now.getDate();
+    var month = (now.getMonth() + 1) < 9 ? "0" + (now.getMonth() + 1) : (now.getMonth() + 1);
+    var year = now.getFullYear();
+    var hours = now.getHours() < 9 ? "0" + now.getHours() : now.getHours();
+    var minutes = now.getMinutes() < 9 ? "0" + now.getMinutes() : now.getMinutes();
+    var seconds = now.getSeconds() < 9 ? "0" + now.getSeconds() : now.getSeconds();
+    return day + "." + month + "." + year + " " + hours + ":" + minutes + ":" + seconds;
+};
+var sendErrorMessage = function (res, error, tag, status) {
+    if (tag === void 0) { tag = "[BASE ERROR]"; }
+    if (status === void 0) { status = 500; }
+    return res.status(status).send({
+        severity: "error",
+        status: 500,
+        statusCode: STATUS_CODE.ERROR,
+        message: " Si è verificato un errore",
+        error: tag + ": " + error,
+    });
+};
+var sendBaseResponse = function (res, payload) {
+    try {
+        payload = JSON.parse(JSON.stringify(payload));
+        var clearPayload = payload; // this.keysToCamel(payload);
+        var response = {
+            Status: {
+                errorCode: "0", errorDescription: "",
+            }, Result: clearPayload, Message: ""
+        };
+        return res.send(response);
+    }
+    catch (error) {
+        return sendErrorMessage(res, "Errore nell'invio della risposta: " + error, "[UTILITIES]", 500);
+    }
+};
+var toCamel = function (s) {
+    return s.replace(/([-_][a-z])/gi, function ($1) {
+        return $1.toUpperCase().replace("-", "").replace("_", "");
+    });
+};
+var isArray = function (a) {
+    return Array.isArray(a);
+};
+var isObject = function (o) {
+    return o === Object(o) && !isArray(o) && typeof o !== "function";
+};
+var keysToCamel = function (o) {
+    if (isObject(o)) {
+        var n_1 = {};
+        Object.keys(o).forEach(function (k) {
+            // @ts-ignore
+            n_1[toCamel(k)] = keysToCamel(o[k]);
+        });
+        return n_1;
+    }
+    else if (isArray(o)) {
+        return o.map(function (i) {
+            return keysToCamel(i);
+        });
+    }
+    return o;
+};
+var addStartingZeros = function (num, totalLength) {
+    return String(num).padStart(totalLength, '0');
+};
+var dateToMoncler = function (dData, bAddMs) {
+    if (bAddMs === void 0) { bAddMs = false; }
+    var yy = dData.getFullYear();
+    var mm = addStartingZeros(dData.getMonth() + 1, 2);
+    var dd = addStartingZeros(dData.getDate(), 2);
+    var hh = addStartingZeros(dData.getHours(), 2);
+    var nn = addStartingZeros(dData.getMinutes(), 2);
+    var ss = addStartingZeros(dData.getSeconds(), 2);
+    var ms = addStartingZeros(dData.getMilliseconds(), 3);
+    if (bAddMs) {
+        return yy + mm + dd + hh + nn + ss + ms;
+    }
+    else {
+        return yy + mm + dd + hh + nn + ss;
+    }
+};
+var dateToSql = function (dData, bAddMs) {
+    if (bAddMs === void 0) { bAddMs = false; }
+    var yy = dData.getFullYear();
+    var mm = addStartingZeros(dData.getMonth() + 1, 2);
+    var dd = addStartingZeros(dData.getDate(), 2);
+    var hh = addStartingZeros(dData.getHours(), 2);
+    var nn = addStartingZeros(dData.getMinutes(), 2);
+    var ss = addStartingZeros(dData.getSeconds(), 2);
+    var ms = addStartingZeros(dData.getMilliseconds(), 3);
+    if (bAddMs) {
+        return yy + '-' + mm + '-' + dd + ' ' + hh + ':' + nn + ':' + ss + '.' + ms;
+    }
+    else {
+        return yy + '-' + mm + '-' + dd + ' ' + hh + ':' + nn + ':' + ss;
+    }
+};
+var dateToSimple = function (dData) {
+    var yy = dData.getFullYear();
+    var mm = addStartingZeros(dData.getMonth() + 1, 2);
+    var dd = addStartingZeros(dData.getDate(), 2);
+    return dd + '-' + mm + '-' + yy;
+};
+var sendExecMessage = function (res, executionObject, title) {
+    try {
+        var sSql = "";
+        var response = {
+            Status: {
+                errorCode: "0", errorDescription: "",
+            }, Sql: sSql, ID: executionObject === null || executionObject === void 0 ? void 0 : executionObject.id, Title: title
+        };
+        return res.send(response);
+    }
+    catch (error) {
+        return sendErrorMessage(res, "Errore nell'invio della risposta: " + error, title, 500);
+    }
+};
+exports.Utilities = {
+    parseDate: parseDate,
+    sendOKMessage: sendOKMessage,
+    sendExecMessage: sendExecMessage,
+    getNowDateString: getNowDateString,
+    sendErrorMessage: sendErrorMessage,
+    sendBaseResponse: sendBaseResponse,
+    toCamel: toCamel,
+    isArray: isArray,
+    isObject: isObject,
+    keysToCamel: keysToCamel,
+    addStartingZeros: addStartingZeros,
+    dateToMoncler: dateToMoncler,
+    dateToSql: dateToSql,
+    dateToSimple: dateToSimple
+};