emilsoftware-utilities 1.3.6 → 1.3.8

package/src/autobind.ts

@@ -1,93 +0,0 @@
-// 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

@@ -1,6 +0,0 @@
-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

@@ -1,23 +0,0 @@
-// 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

@@ -1,144 +0,0 @@
-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", DATABASE = "DATABASE"
-}
-
-export class Logger {
-    private readonly winstonLogger: winston.Logger;
-    private readonly 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: this.replaceAll(file, "\\", "/"), level, message})},`;
-    });
-
-    private replaceAll(string: string, match: string, replacer: string) {
-        // @ts-ignore
-        return ("" + string)?.replaceAll(match, replacer);
-    }
-
-    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;
-
-        winston.addColors({
-            database: 'green',
-        });
-
-        this.winstonLogger = winston.createLogger({
-            format: winston.format.json(),
-            transports: [new winston.transports.File({filename: logFilePath, format: this.logFormat})],
-            levels: {
-                error: 1, warn: 2, info: 3, http: 4, verbose: 5, debug: 6, silly: 7, database: 8
-            }
-        });
-
-    }
-
-
-    private getFileName(): string {
-        const now = new Date();
-        let date = now.getDate();
-        let dateString = "" + date;
-        if (date < 10) dateString = "0" + dateString;
-
-        let month = (now.getMonth() + 1);
-        let monthString = "" + month;
-        if (month < 10) monthString = "0" + monthString;
-
-        let yearString = now.getFullYear() + "";
-        return dateString + "-" + monthString + "-" + yearString;
-    }
-
-    public execStart(prefix: string = ""): number {
-        this.print(LogLevels.INFO, `${prefix} - Execution started`);
-        return performance.now();
-    }
-
-    public execStop(prefix: string = "", startTime: number, error: boolean = false): void {
-        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: Object[]): void {
-        this.print(LogLevels.INFO, ...data);
-    }
-
-    public dbLog(...data: Object[]): void {
-        this.print(LogLevels.DATABASE, ...data);
-    }
-
-    public debug(...data: Object[]): void {
-        this.print(LogLevels.DEBUG, ...data);
-    }
-
-    public log(...data: Object[]): void {
-        this.print(LogLevels.LOG, ...data);
-    }
-
-    public error(...data: Object[]): void {
-        this.print(LogLevels.ERROR, ...data);
-    }
-
-    private test() {
-        let startTime = this.execStart("test");
-        this.execStop("test", startTime);
-        this.debug("test");
-        this.log("test");
-        this.error("test")
-        this.dbLog("test");
-    }
-
-    private print(level: LogLevels = LogLevels.INFO, ...data: Object[]): void {
-        const now: Date = new Date();
-        let tag = this.tag.split("\\").pop();
-
-        this.winstonLogger.defaultMeta = {
-            file: tag, time: now, level
-        };
-
-        let logEntry: winston.LogEntry = {level: level.toLowerCase(), message: [...data].join(",")};
-        //JSON.stringify([...data]);
-        switch (level) {
-            case LogLevels.INFO:
-                this.winstonLogger.info(logEntry);
-                console.info(`[INFO][${now}][${tag}]`, logEntry.message);
-                break;
-            case LogLevels.ERROR:
-                this.winstonLogger.error(logEntry);
-                console.error(`[ERROR][${now}][${tag}]`, logEntry.message);
-                break;
-            case LogLevels.DEBUG:
-                this.winstonLogger.debug(logEntry);
-                console.debug(`[DEBUG][${now}][${tag}]`, logEntry.message);
-                break;
-            case LogLevels.LOG: {
-                this.winstonLogger.log(logEntry);
-                console.log(`[LOG][${now}][${tag}]`, logEntry.message);
-            }
-            case LogLevels.DATABASE: {
-                this.winstonLogger.info(logEntry);
-                console.log(`[DATABASE][${now}][${tag}]`, logEntry.message);
-            }
-        }
-
-    }
-}

package/src/node-firebird.ts

@@ -1 +0,0 @@
-export * from "es-node-firebird";

package/src/orm.ts

@@ -1,221 +0,0 @@
-// @ts-ignore
-import * as Firebird from "es-node-firebird";
-import { Logger } from "./logger";
-import { Database, Options, Transaction } from "es-node-firebird";
-import { Utilities } from "./utilities";
-
-const logger: Logger = new Logger(__filename);
-
-const quote = (value: string): string => {
-    return "\"" + value + "\"";
-};
-const testConnection = (options: Options): Promise<any> => {
-    return new Promise((resolve): void => {
-        Firebird.attach(options, (err: Error, db: Database): void => {
-            if (err) {
-                logger.error('La connessione con il DATABASE non è andata a buon fine.');
-                return resolve(false);
-            }
-            logger.info("DATABASE connesso.");
-            if (db) db.detach();
-            return resolve(true);
-        })
-    })
-}
-
-const query = (options: Options, query: string, parameters: any[] = []): Promise<any> => {
-    try {
-        return new Promise((resolve, reject): void => {
-            Firebird.attach(options, (err: any, db: Database) => {
-                if (err) {
-                    logger.error(err);
-                    return reject(err);
-                }
-
-                logger.info(Utilities.printQueryWithParams(query, parameters));
-                db.query(query, parameters, (error: any, result: any) => {
-                    if (error) {
-                        logger.error(error);
-                        db.detach();
-                        return reject(error);
-                    }
-                    db.detach();
-                    return resolve(result);
-                });
-            });
-        });
-    } catch (error) {
-        logger.error(error);
-        throw error;
-    }
-}
-const execute = (options: Options, query: string, parameters: any = []): Promise<any> => {
-    try {
-        return new Promise((resolve, reject): void => {
-            Firebird.attach(options, (err: any, db: Database) => {
-                if (err) {
-                    logger.error(err);
-                    return reject(err);
-                }
-
-                logger.info(Utilities.printQueryWithParams(query, parameters));
-                db.execute(query, parameters, (error, result: any): void => {
-                    if (error) {
-                        logger.error(error);
-                        db.detach();
-                        return reject(error);
-                    }
-                    db.detach();
-                    return resolve(result);
-                });
-            });
-        });
-    } catch (error) {
-        logger.error(error);
-        throw error;
-    }
-}
-
-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 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.');
-        });
-    });
-}
-
-const rollbackTransaction = (transaction: Transaction): Promise<any> => {
-    return new Promise((resolve, reject) => {
-        transaction.rollback(err => {
-            if (err) return reject(err);
-            else return resolve('Transaction rolled back successfully.');
-        });
-    });
-}
-
-interface QueryWithParams {
-    query: string,
-    params: any[]
-}
-
-const executeMultiple = async (options: Options, queriesWithParams: QueryWithParams[]): Promise<any> => {
-    let db: Database;
-    let transaction: Transaction;
-
-    try {
-        // Connetti al database
-        db = await connect(options);
-
-        // Inizia la transazione
-        transaction = await startTransaction(db);
-
-        // Esegui le query in serie
-        for (const qwp of queriesWithParams) {
-            await new Promise((resolve, reject) => {
-                transaction.query(qwp.query, qwp.params, (err: any, result: any): void => {
-                    if (err) return reject(err);
-                    else return resolve(result);
-                });
-            });
-        }
-
-        // Commit della transazione
-        await commitTransaction(transaction);
-
-        // Stacca il database
-        db.detach();
-
-        // Ritorna il messaggio di successo
-        return 'OK';
-
-    } catch (error) {
-        // In caso di errore, fai rollback della transazione
-        if (transaction) {
-            await rollbackTransaction(transaction);
-        }
-        if (db) {
-            db.detach();
-        }
-        throw error;
-    }
-};
-
-const executeQueries = async (transaction: Transaction, queries: string[], params: any[]): Promise<any> => {
-    try {
-        try {
-            return await queries.reduce((promiseChain: Promise<any>, currentQuery: string, index: number) => {
-                return promiseChain.then(() => new Promise((resolve, reject) => {
-                    transaction.query(currentQuery, params[index], (err: any, result: any): void => {
-                        if (err) return reject(err);
-                        else return resolve(result);
-                    });
-                }));
-            }, Promise.resolve());
-        } catch (error) {
-            return await new Promise((resolve_1, reject_1) => {
-                transaction.rollback((rollbackErr: any) => {
-                    if (rollbackErr) {
-                        return reject_1(rollbackErr);
-                    } else {
-                        return reject_1(error);
-                    }
-                });
-            });
-        }
-    } catch (error) {
-        throw error;
-    }
-};
-
-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>,
-    executeMultiple: (options: Options, qwps: QueryWithParams[]) => any,
-    executeQueries: (transaction: Transaction, queries: string[], params: any[]) => any,
-    commitTransaction: (transaction: Transaction) => Promise<any>,
-    rollbackTransaction: (transaction: Transaction) => Promise<any>,
-}
-
-export const Orm: Orm = {
-    quote,
-    testConnection,
-    query,
-    execute,
-    trimParam,
-    connect,
-    startTransaction,
-    executeQueries,
-    executeMultiple,
-    commitTransaction,
-    rollbackTransaction
-}
-
-

package/src/routes-logger.ts

@@ -1,16 +0,0 @@
-import {NextFunction, Request, Response} from "express";
-import {Logger} from "./logger";
-
-// Middleware per misurare il tempo di esecuzione
-export function routesLogger(req: Request, res: Response, next: NextFunction, logger: Logger) {
-    const start: Date = new Date();
-    // Funzione da eseguire dopo il completamento del controller
-    res.on('finish', (): void => {
-        const end: Date = new Date();
-        const elapsed: number = end.getTime() - start.getTime();
-
-        logger.info(`Tempo di esecuzione per ${req.method} ${req.originalUrl}: ${elapsed} ms`);
-    });
-    // Continua l'esecuzione della catena middleware
-    return next();
-}