badmfck-api-server 2.1.3 → 2.1.5

package/dist/apiServer/APIService.js

@@ -83,7 +83,7 @@ async function Initializer(services) {
 exports.Initializer = Initializer;
 class APIService extends BaseService_1.BaseService {
     static nextLogID = 0;
-    version = "2.1.3";
+    version = "2.1.5";
     options;
     monitor;
     monitorIndexFile;

package/dist/apiServer/MysqlService.d.ts

@@ -1,8 +1,9 @@
-import { FieldInfo, MysqlError, Pool, PoolConnection } from "mysql";
 import { BaseService } from "./BaseService";
 import Signal, { Req } from "badmfck-signal";
+import * as mysql from "mysql2/promise";
 export declare const S_MYSQL_STARTED: Signal<void>;
 export declare const REQ_MYSQL_QUERY: Req<MySqlQuery | MySqlQuery[], MysqlResult[]>;
+export declare const REQ_MYSQL_TRANSACTION: Req<MySqlQuery[], MysqlResult>;
 export declare const executeQuery: (query: MySqlQuery | MySqlQuery[]) => Promise<MysqlResult[]>;
 export interface MysqlServiceOptions {
     connectionLimit: number;
@@ -11,16 +12,24 @@ export interface MysqlServiceOptions {
     password: string;
     port: number;
     database: string;
+    queueLimit?: number;
     migrations?: {
         dir: string;
         callback: () => void;
     } | null;
 }
+export interface MysqlError {
+    code: string;
+    errno: number;
+    sql: string;
+    name: string;
+    message: string;
+    fatal?: boolean;
+}
 export interface MysqlResult {
     error?: MysqlError | null;
     rollbackError?: MysqlError | null;
     isDuplicateError?: boolean;
-    fields?: FieldInfo[] | null;
     data: any;
 }
 export interface MySqlQuery {
@@ -48,7 +57,7 @@ export interface MysqlQueryFieldObject extends Record<string, string | number |
 export declare class MysqlService extends BaseService {
     reconnectionTimeout: number;
     reconnecting: boolean;
-    pool: Pool | null;
+    pool: mysql.Pool | null;
     options: MysqlServiceOptions;
     serviceStarted: boolean;
     timeoutID: any;
@@ -56,19 +65,18 @@ export declare class MysqlService extends BaseService {
     constructor(options: MysqlServiceOptions);
     static executeQuery(query: MySqlQuery | MySqlQuery[]): Promise<MysqlResult[]>;
     init(): Promise<void>;
-    recreatePool(): Promise<void>;
+    recreatePool(): Promise<boolean>;
     onApplicationReady(): Promise<void>;
     static fieldsToObject(fields: MysqlQueryField[] | MysqlQueryFieldObject, ignoreSystemParameters?: boolean): MysqlQueryFieldObject;
     static objectToFields(obj: MysqlQueryFieldObject | MysqlQueryField[]): MysqlQueryField[];
     static prepareQuery(query: string, fields: MysqlQueryField[] | MysqlQueryFieldObject): string;
     static prepareQueryFieldValue(value: string | number | boolean | null | undefined, system?: boolean): string | number | boolean | null | undefined;
     execute(query: string, rollbackQuery: string | null): Promise<MysqlResult>;
-    sendQuery(conn: PoolConnection, query: string, resolve: (data: MysqlResult) => void, rollback: string | null): Promise<void>;
-    queryAsync(conn: PoolConnection, query: string): Promise<{
+    sendQuery(conn: mysql.PoolConnection, query: string, resolve: (data: MysqlResult) => void, rollback: string | null): Promise<void>;
+    queryAsync(conn: mysql.PoolConnection, query: string): Promise<{
         err: MysqlError | null;
         results?: any;
-        fields?: FieldInfo[];
     }>;
-    createPool(): Promise<boolean>;
+    createMysqlQueryError(err: any): MysqlError;
 }
 export default MysqlService;

package/dist/apiServer/MysqlService.js

@@ -22,18 +22,16 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MysqlService = exports.executeQuery = exports.REQ_MYSQL_QUERY = exports.S_MYSQL_STARTED = void 0;
-const mysql_1 = __importDefault(require("mysql"));
+exports.MysqlService = exports.executeQuery = exports.REQ_MYSQL_TRANSACTION = exports.REQ_MYSQL_QUERY = exports.S_MYSQL_STARTED = void 0;
 const BaseService_1 = require("./BaseService");
 const badmfck_signal_1 = __importStar(require("badmfck-signal"));
 const crypto_1 = require("crypto");
 const LogService_1 = require("./LogService");
+const mysql = __importStar(require("mysql2/promise"));
 exports.S_MYSQL_STARTED = new badmfck_signal_1.default();
 exports.REQ_MYSQL_QUERY = new badmfck_signal_1.Req(undefined, "REQ_MYSQL_QUERY");
+exports.REQ_MYSQL_TRANSACTION = new badmfck_signal_1.Req(undefined, "REQ_MYSQL_TRANSACTION");
 const executeQuery = async (query) => { return await exports.REQ_MYSQL_QUERY.request(query); };
 exports.executeQuery = executeQuery;
 class MysqlService extends BaseService_1.BaseService {
@@ -58,8 +56,33 @@ class MysqlService extends BaseService_1.BaseService {
     }
     static async executeQuery(query) { return await exports.REQ_MYSQL_QUERY.request(query); }
     async init() {
+        super.init();
+        process.on('SIGINT', async () => {
+            console.log('1. Received SIGINT. Performing cleanup...');
+            if (this.pool) {
+                try {
+                    await this.pool.end();
+                }
+                catch (e) {
+                    (0, LogService_1.logCrit)("${MysqlService.js}", "Can't close MYSQL pool!");
+                }
+            }
+            process.exit(0);
+        });
+        process.on('SIGTERM', () => {
+            console.log('2. Received SIGTERM. Performing cleanup...');
+            process.exit(0);
+        });
         this.serviceStarted = false;
-        await this.recreatePool();
+        let poolCreated = false;
+        while (!poolCreated) {
+            (0, LogService_1.logInfo)("${MysqlService.js}", "Connecting to MYSQL!");
+            poolCreated = await this.recreatePool();
+            if (!poolCreated) {
+                (0, LogService_1.logCrit)("${MysqlService.js}", "Can't connect to MYSQL! Retrying in 3 seconds...");
+                await new Promise((resolve) => setTimeout(resolve, 3000));
+            }
+        }
         exports.REQ_MYSQL_QUERY.listener = async (data) => {
             if (!Array.isArray(data))
                 data = [data];
@@ -70,22 +93,97 @@ class MysqlService extends BaseService_1.BaseService {
             }
             return await Promise.all(promises);
         };
+        exports.REQ_MYSQL_TRANSACTION.listener = async (data) => {
+            if (!this.pool)
+                return { error: { code: "NO_POOL", errno: 100000, fatal: true, sql: "", name: "NO_POOL", message: "Mysql pool not created" }, data: null };
+            const conn = await this.pool.getConnection();
+            if (!conn)
+                return { error: { code: "NO_CONN", errno: 100001, fatal: true, sql: "", name: "NO_CONN", message: "Mysql pool cant get connection" }, data: null };
+            let result = null;
+            let income = [];
+            try {
+                await conn.beginTransaction();
+                await conn.query("SET autocommit=0");
+                for (let i of data) {
+                    const d = await conn.query(MysqlService.prepareQuery(i.query, i.fields));
+                    income.push(d[0]);
+                }
+                await conn.commit();
+            }
+            catch (e) {
+                let rollbackError = null;
+                try {
+                    await conn.rollback();
+                }
+                catch (e2) {
+                    (0, LogService_1.logCrit)("${MysqlService.js}", "Can't rollback transaction!");
+                    rollbackError = this.createMysqlQueryError(e2);
+                }
+                result = { error: this.createMysqlQueryError(e), data: null, rollbackError: rollbackError };
+            }
+            try {
+                conn.release();
+            }
+            catch (e) { }
+            if (!result)
+                result = { error: null, data: income };
+            return result;
+        };
     }
     async recreatePool() {
-        (0, LogService_1.logInfo)("${MysqlService.js}", "Mysql server trying to create pool");
-        this.serviceStarted = false;
-        const ok = await this.createPool();
-        if (!ok) {
-            (0, LogService_1.logWarn)("${MysqlService.js}", "Mysql server not connected, retrying in 3 sec");
-            if (this.timeoutID)
-                clearTimeout(this.timeoutID);
-            this.timeoutID = setTimeout(() => { this.recreatePool(); }, 3000);
+        (0, LogService_1.logInfo)("${MysqlService.js}", "Connecting to mysql: \n HOST: " + this.options.host + '\n PORT:' + this.options.port);
+        if (this.pool) {
+            this.pool.removeAllListeners();
+            try {
+                await this.pool.end();
+            }
+            catch (e) {
+                (0, LogService_1.logCrit)("${MysqlService.js}", "Can't close MYSQL pool!");
+            }
+            this.pool = null;
         }
-        else {
-            this.serviceStarted = true;
-            (0, LogService_1.logInfo)("${MysqlService.js}", "Mysql Service started!");
-            exports.S_MYSQL_STARTED.invoke();
+        try {
+            this.pool = mysql.createPool({
+                host: this.options.host,
+                user: this.options.user,
+                password: this.options.password,
+                database: this.options.database,
+                port: this.options.port,
+                connectionLimit: this.options.connectionLimit,
+                queueLimit: 10
+            });
+        }
+        catch (e) {
+            (0, LogService_1.logCrit)("${MysqlService.js}", "Can't connect to MYSQL!");
+            return false;
         }
+        this.pool?.on('connection', (connection) => {
+            (0, LogService_1.logInfo)("${MysqlService.js}", "MYSQL CONNECTION CREATED");
+        });
+        this.pool?.on('acquire', (connection) => {
+            (0, LogService_1.logInfo)("${MysqlService.js}", "MYSQL CONNECTION ACQUIRED");
+        });
+        this.pool?.on('release', (connection) => {
+            (0, LogService_1.logInfo)("${MysqlService.js}", "MYSQL CONNECTION RELEASED");
+        });
+        this.pool?.on('enqueue', () => {
+            (0, LogService_1.logInfo)("${MysqlService.js}", "MYSQL CONNECTION ENQUEUED");
+        });
+        return new Promise(async (resolve, reject) => {
+            try {
+                const conn = await this.pool?.getConnection();
+                if (conn) {
+                    conn?.release();
+                    resolve(true);
+                }
+                else
+                    resolve(false);
+            }
+            catch (e) {
+                (0, LogService_1.logCrit)("${MysqlService.js}", "Can't connect to MYSQL!");
+                resolve(false);
+            }
+        });
     }
     async onApplicationReady() { }
     static fieldsToObject(fields, ignoreSystemParameters) {
@@ -207,7 +305,7 @@ class MysqlService extends BaseService_1.BaseService {
         return value;
     }
     async execute(query, rollbackQuery) {
-        return new Promise((resolve, reject) => {
+        return new Promise(async (resolve, reject) => {
             if (!this.pool) {
                 (0, LogService_1.logError)("${MysqlService.js}", "No pool");
                 resolve({
@@ -220,23 +318,11 @@ class MysqlService extends BaseService_1.BaseService {
                         message: "Mysql pool not created"
                     },
                     data: null,
-                    fields: null
                 });
                 return;
             }
-            this.pool.getConnection((err, conn) => {
-                if (err) {
-                    (0, LogService_1.logError)("${MysqlService.js}", err);
-                    if (`${err}`.indexOf('ECONNREFUSED') !== -1) {
-                        this.recreatePool();
-                    }
-                    resolve({
-                        error: err,
-                        data: null,
-                        fields: null
-                    });
-                    return;
-                }
+            try {
+                const conn = await this.pool.getConnection();
                 if (!conn) {
                     (0, LogService_1.logCrit)("${MysqlService.js}", `No connection created!`);
                     resolve({
@@ -249,11 +335,28 @@ class MysqlService extends BaseService_1.BaseService {
                             message: "Mysql pool cant get connection"
                         },
                         data: null,
-                        fields: null
                     });
+                    return;
                 }
                 this.sendQuery(conn, query, resolve, rollbackQuery);
-            });
+            }
+            catch (e) {
+                (0, LogService_1.logError)("${MysqlService.js}", e);
+                if (`${e}`.indexOf('ECONNREFUSED') !== -1)
+                    this.recreatePool();
+                resolve({
+                    error: {
+                        code: "NO_CONN",
+                        errno: 100001,
+                        fatal: true,
+                        sql: query,
+                        name: "NO_CONN",
+                        message: (e && typeof e === "object" && "message" in e) ? e.message : "Mysql cant get connection"
+                    },
+                    data: null
+                });
+                return;
+            }
         });
     }
     async sendQuery(conn, query, resolve, rollback) {
@@ -279,7 +382,6 @@ class MysqlService extends BaseService_1.BaseService {
                     message: "Error: " + err
                 },
                 data: null,
-                fields: null,
                 rollbackError: rollbackError
             });
         });
@@ -299,7 +401,6 @@ class MysqlService extends BaseService_1.BaseService {
             resolve({
                 error: queryResult.err,
                 data: null,
-                fields: null,
                 rollbackError: rollbackError,
                 isDuplicateError: dup
             });
@@ -312,87 +413,40 @@ class MysqlService extends BaseService_1.BaseService {
         resolve({
             error: queryResult.err,
             data: queryResult.results,
-            fields: queryResult.fields
         });
     }
     async queryAsync(conn, query) {
-        return new Promise((resolve, reject) => {
-            try {
-                conn.query(query, (err, results, fields) => {
-                    resolve({
-                        err: err,
-                        results: results,
-                        fields: fields
-                    });
-                });
-            }
-            catch (e) {
-                resolve({
-                    err: {
-                        code: "QUERY_ERR",
-                        errno: 100002,
-                        fatal: true,
-                        sql: query,
-                        name: "QUERY_ERR",
-                        message: "Error: " + e
-                    }
-                });
-            }
-        });
-    }
-    async createPool() {
-        (0, LogService_1.logInfo)("${MysqlService.js}", "Connecting to mysql: \n HOST: " + this.options.host + '\n PORT:' + this.options.port);
-        let err = false;
-        if (this.pool) {
-            try {
-                this.pool.removeAllListeners();
-                this.pool.end(err => {
-                    if (err)
-                        (0, LogService_1.logError)("${MysqlService.js}", err);
-                });
-            }
-            catch (e) {
-                (0, LogService_1.logCrit)("${MysqlService.js}", e);
-            }
-        }
         try {
-            this.pool = mysql_1.default.createPool({
-                connectionLimit: this.options.connectionLimit,
-                host: this.options.host,
-                user: this.options.user,
-                password: this.options.password,
-                port: this.options.port,
-                database: this.options.database,
-                multipleStatements: true
-            });
+            const result = await conn.query(query);
+            return {
+                err: null,
+                results: result[0],
+            };
         }
         catch (e) {
-            (0, LogService_1.logCrit)("${MysqlService.js}", "Can't connect to MYSQL!");
-            err = true;
+            return { err: this.createMysqlQueryError(e) };
         }
-        if (!err && this.pool) {
-            this.pool.on("error", (evt) => {
-                (0, LogService_1.logError)("${MysqlService.js}", evt);
-            });
+    }
+    createMysqlQueryError(err) {
+        if (err && typeof err === "object" && "code" in err && "errno" in err && "sql" in err && "name" in err && "message" in err) {
+            return {
+                code: err.code,
+                errno: err.errno,
+                sql: err.sql,
+                name: err.name,
+                message: err.message
+            };
+        }
+        else {
+            return {
+                code: "QUERY_ERR",
+                errno: 100002,
+                fatal: true,
+                sql: "no query",
+                name: "QUERY_ERR",
+                message: "Error: " + (err) ? err : ""
+            };
         }
-        return new Promise((res, rej) => {
-            if (err) {
-                res(false);
-                return;
-            }
-            if (!this.pool) {
-                res(false);
-                return;
-            }
-            this.pool.getConnection((e, cnn) => {
-                if (e) {
-                    (0, LogService_1.logError)("${MysqlService.js}", e.message);
-                    res(false);
-                    return;
-                }
-                res(true);
-            });
-        });
     }
 }
 exports.MysqlService = MysqlService;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "badmfck-api-server",
-  "version": "2.1.3",
+  "version": "2.1.5",
   "description": "Simple API http server based on express",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -25,7 +25,7 @@
     "cors": "^2.8.5",
     "express": "^4.19.2",
     "express-fileupload": "^1.5.0",
-    "mysql": "^2.18.1",
+    "mysql2": "^3.11.3",
     "ws": "^8.18.0"
   },
   "devDependencies": {