badmfck-api-server 2.1.2 → 2.1.4

package/dist/apiServer/APIService.d.ts

@@ -9,6 +9,7 @@ export interface APIServiceNetworkLogItem {
     id: number;
     created: number;
     time: number;
+    referer?: string;
     request: {
         [key: string]: any;
     };
@@ -59,6 +60,6 @@ export declare class APIService extends BaseService {
     netLog: APIServiceNetworkLogItem[];
     constructor(options?: APIServiceOptions | null);
     init(): Promise<void>;
-    sendResponse(res: Response, data: TransferPacketVO<any>, requestTime: number, endpoint?: string, log?: APIServiceNetworkLogItem | null, req?: HTTPRequestVO): Promise<void>;
+    sendResponse(ref: string, res: Response, data: TransferPacketVO<any>, requestTime: number, endpoint?: string, log?: APIServiceNetworkLogItem | null, req?: HTTPRequestVO): Promise<void>;
     checkDataLength(data: any, result?: any, lvl?: number): any;
 }

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.2";
+    version = "2.1.4";
     options;
     monitor;
     monitorIndexFile;
@@ -154,10 +154,10 @@ class APIService extends BaseService_1.BaseService {
         app.use(express_1.default.urlencoded({ limit: '10mb', extended: true }));
         app.use((0, express_fileupload_1.default)({
             limitHandler: (req, res, next) => {
-                this.sendResponse(res, {
+                this.sendResponse(req.get("Referer") ?? "", res, {
                     error: DefaultErrors_1.default.FILE_TOO_LARGE,
                     data: null,
-                    httpStatus: 413
+                    httpStatus: 413,
                 }, +new Date(), req.path);
             },
             limits: { fileSize: this.options.fileLimit },
@@ -182,7 +182,7 @@ class APIService extends BaseService_1.BaseService {
             if (typeof err === "object" && err.status === 400 && 'body' in err && err.type === 'entity.parse.failed') {
                 responseError = DefaultErrors_1.default.JSON_MALFORMED;
             }
-            this.sendResponse(resp, {
+            this.sendResponse(req.get("Referer") ?? "", resp, {
                 error: responseError,
                 data: null,
                 httpStatus: 400
@@ -231,7 +231,8 @@ class APIService extends BaseService_1.BaseService {
                             params: req.params,
                             headers: req.headers,
                             endpoint: ep,
-                            files: req.files ?? null
+                            files: req.files ?? null,
+                            referer: req.get("Referer"),
                         };
                         if (this.options.preproducer) {
                             try {
@@ -240,7 +241,7 @@ class APIService extends BaseService_1.BaseService {
                                     httpRequest.preproducerResult = preproducerResult;
                             }
                             catch (e) {
-                                this.sendResponse(res, { error: { code: 10002, message: "Internal server error", details: `${e}` }, data: null, httpStatus: 500 }, tme, ep, log, httpRequest);
+                                this.sendResponse(req.get("Referer") ?? "", res, { error: { code: 10002, message: "Internal server error", details: `${e}` }, data: null, httpStatus: 500 }, tme, ep, log, httpRequest);
                                 return;
                             }
                         }
@@ -251,7 +252,7 @@ class APIService extends BaseService_1.BaseService {
                                 if (this.options.interceptor) {
                                     interceptorResult = await this.options.interceptor.execute(httpRequest);
                                     if (interceptorResult.error && !j.allowInterceptorError) {
-                                        this.sendResponse(res, interceptorResult, tme, ep, log, httpRequest);
+                                        this.sendResponse(req.get("Referer") ?? "", res, interceptorResult, tme, ep, log, httpRequest);
                                         return;
                                     }
                                     httpRequest.interceptorResult = interceptorResult;
@@ -261,7 +262,7 @@ class APIService extends BaseService_1.BaseService {
                                 httpRequest.precheck = { data: this.options.monitor };
                             const precheck = await i.precheck(httpRequest);
                             if (precheck && precheck.error) {
-                                this.sendResponse(res, precheck, tme, ep, log, httpRequest);
+                                this.sendResponse(req.get("Referer") ?? "", res, precheck, tme, ep, log, httpRequest);
                                 return;
                             }
                             httpRequest.precheck = precheck;
@@ -273,7 +274,7 @@ class APIService extends BaseService_1.BaseService {
                                 this.options.onError(e);
                             if (this.monitor)
                                 this.monitor.registrateFatalError(ep);
-                            this.sendResponse(res, {
+                            this.sendResponse(req.get("Referer") ?? "", res, {
                                 httpStatus: 500,
                                 error: {
                                     code: 10002,
@@ -283,7 +284,7 @@ class APIService extends BaseService_1.BaseService {
                             }, tme, ep, log, httpRequest);
                             return;
                         }
-                        this.sendResponse(res, result, tme, ep, log, httpRequest);
+                        this.sendResponse(req.get("Referer") ?? "", res, result, tme, ep, log, httpRequest);
                     };
                     execute();
                 });
@@ -311,7 +312,7 @@ class APIService extends BaseService_1.BaseService {
                             res.status(200).send(this.monitorIndexFile);
                         }
                         catch (e) {
-                            this.sendResponse(res, {
+                            this.sendResponse(req.get("Referer") ?? "", res, {
                                 error: {
                                     code: 10002,
                                     message: "Internal server error",
@@ -325,7 +326,7 @@ class APIService extends BaseService_1.BaseService {
                     }
                 }
             }
-            this.sendResponse(res, {
+            this.sendResponse(req.get("Referer") ?? "", res, {
                 error: DefaultErrors_1.default.UNKNOWN_REQUEST,
                 data: null,
                 httpStatus: 404
@@ -335,7 +336,7 @@ class APIService extends BaseService_1.BaseService {
             (0, LogService_1.logCrit)('${APIService.js}', 'API Service started at: ' + this.options.port + ", with base endpoint:" + this.options.baseEndPoint + ", ver.: " + this.version);
         });
     }
-    async sendResponse(res, data, requestTime, endpoint, log, req) {
+    async sendResponse(ref, res, data, requestTime, endpoint, log, req) {
         if (this.options.postproducer) {
             try {
                 data = await this.options.postproducer(req, res, data, requestTime, endpoint, log);
@@ -351,8 +352,10 @@ class APIService extends BaseService_1.BaseService {
         data.endpoint = endpoint ?? "no_endpoint";
         if (this.options.appVersion)
             data.version = this.options.appVersion;
-        if (log)
+        if (log) {
             log.time = data.responseTime;
+            log.referer = ref;
+        }
         if (this.monitor)
             this.monitor.registrateResponse(data.endpoint, data.responseTime);
         if (res.destroyed || res.closed) {
@@ -374,7 +377,7 @@ class APIService extends BaseService_1.BaseService {
                                 this.options.onError("Can't send file: " + data.file, err);
                             if (this.monitor && data.endpoint)
                                 this.monitor.registrateAPIError(data.endpoint);
-                            this.sendResponse(res, {
+                            this.sendResponse(ref, res, {
                                 error: DefaultErrors_1.default.CANT_SEND_FILE,
                                 data: null,
                                 httpStatus: 500

package/dist/apiServer/MysqlService.d.ts

@@ -1,6 +1,6 @@
-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 executeQuery: (query: MySqlQuery | MySqlQuery[]) => Promise<MysqlResult[]>;
@@ -11,20 +11,30 @@ 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 {
     query: string;
     fields: MysqlQueryField[] | MysqlQueryFieldObject;
+    rollbackQuery?: string | null;
 }
 export interface MysqlQueryField {
     name: string;
@@ -46,7 +56,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;
@@ -54,14 +64,17 @@ 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): Promise<MysqlResult>;
-    sendQuery(conn: PoolConnection, query: string, resolve: (data: MysqlResult) => void): void;
-    createPool(): Promise<boolean>;
+    execute(query: string, rollbackQuery: string | null): Promise<MysqlResult>;
+    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;
+    }>;
 }
 export default MysqlService;

package/dist/apiServer/MysqlService.js

@@ -22,16 +22,13 @@ 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"));
 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");
 const executeQuery = async (query) => { return await exports.REQ_MYSQL_QUERY.request(query); };
@@ -58,34 +55,98 @@ 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];
             const promises = [];
             for (let i of data) {
                 const query = MysqlService.prepareQuery(i.query, i.fields);
-                promises.push(this.execute(query));
+                promises.push(this.execute(query, i.rollbackQuery ?? null));
             }
             return await Promise.all(promises);
         };
     }
     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) {
@@ -206,8 +267,8 @@ class MysqlService extends BaseService_1.BaseService {
             return "NULL";
         return value;
     }
-    async execute(query) {
-        return new Promise((resolve, reject) => {
+    async execute(query, rollbackQuery) {
+        return new Promise(async (resolve, reject) => {
             if (!this.pool) {
                 (0, LogService_1.logError)("${MysqlService.js}", "No pool");
                 resolve({
@@ -220,23 +281,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,43 +298,43 @@ class MysqlService extends BaseService_1.BaseService {
                             message: "Mysql pool cant get connection"
                         },
                         data: null,
-                        fields: null
-                    });
-                }
-                try {
-                    this.sendQuery(conn, query, resolve);
-                }
-                catch (e) {
-                    try {
-                        conn.removeAllListeners();
-                        conn.release();
-                    }
-                    catch (e) { }
-                    (0, LogService_1.logError)("${MysqlService.js}", "QUERY_ERR: " + e);
-                    resolve({
-                        error: {
-                            code: "QUERY_ERR",
-                            errno: 100002,
-                            fatal: true,
-                            sql: query,
-                            name: "QUERY_ERR",
-                            message: "Error: " + e
-                        },
-                        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;
+            }
         });
     }
-    sendQuery(conn, query, resolve) {
+    async sendQuery(conn, query, resolve, rollback) {
         let errCatched = false;
-        conn.on("error", err => {
+        conn.on("error", async (err) => {
             errCatched = true;
-            conn.release();
-            conn.removeAllListeners();
-            (0, LogService_1.logError)("${MysqlService.js}", err);
-            conn.removeAllListeners();
+            let rollbackError = null;
+            if (rollback)
+                rollbackError = (await this.queryAsync(conn, rollback)).err;
+            (0, LogService_1.logError)("${MysqlService.js}->conn.on('error')", err);
+            try {
+                conn.release();
+                conn.removeAllListeners();
+            }
+            catch (e) { }
             resolve({
                 error: {
                     code: "CONN_ERR",
@@ -296,87 +345,71 @@ class MysqlService extends BaseService_1.BaseService {
                     message: "Error: " + err
                 },
                 data: null,
-                fields: null
+                rollbackError: rollbackError
             });
         });
         (0, LogService_1.logInfo)("${MysqlService.js}", query);
-        conn.query(query, (err, results, fields) => {
-            conn.release();
-            conn.removeAllListeners();
-            if (errCatched)
-                return;
-            if (err) {
-                const dup = `${err}`.toLowerCase().indexOf("er_dup_entry") !== -1;
-                (0, LogService_1.logError)("${MysqlService.js}", err);
-                resolve({
-                    error: err,
-                    data: null,
-                    fields: null,
-                    isDuplicateError: dup
-                });
-                return;
+        const queryResult = await this.queryAsync(conn, query);
+        if (queryResult.err) {
+            let rollbackError = null;
+            if (rollback)
+                rollbackError = (await this.queryAsync(conn, rollback)).err;
+            try {
+                conn.release();
+                conn.removeAllListeners();
             }
+            catch (e) { }
+            const dup = `${queryResult.err}`.toLowerCase().indexOf("er_dup_entry") !== -1;
+            (0, LogService_1.logError)("${MysqlService.js}->query error", queryResult.err);
             resolve({
-                error: err,
-                data: results,
-                fields: fields
+                error: queryResult.err,
+                data: null,
+                rollbackError: rollbackError,
+                isDuplicateError: dup
             });
-            return;
+        }
+        try {
+            conn.release();
+            conn.removeAllListeners();
+        }
+        catch (e) { }
+        resolve({
+            error: queryResult.err,
+            data: queryResult.results,
         });
     }
-    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);
-            }
-        }
+    async queryAsync(conn, query) {
         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;
-        }
-        if (!err && this.pool) {
-            this.pool.on("error", (evt) => {
-                (0, LogService_1.logError)("${MysqlService.js}", evt);
-            });
-        }
-        return new Promise((res, rej) => {
-            if (err) {
-                res(false);
-                return;
-            }
-            if (!this.pool) {
-                res(false);
-                return;
+            const err = e;
+            if (err && typeof err === "object" && "code" in err && "errno" in err && "sql" in err && "name" in err && "message" in err) {
+                return {
+                    err: {
+                        code: err.code,
+                        errno: err.errno,
+                        sql: query,
+                        name: err.name,
+                        message: err.message
+                    }
+                };
             }
-            this.pool.getConnection((e, cnn) => {
-                if (e) {
-                    (0, LogService_1.logError)("${MysqlService.js}", e.message);
-                    res(false);
-                    return;
+            return {
+                err: {
+                    code: "QUERY_ERR",
+                    errno: 100002,
+                    fatal: true,
+                    sql: query,
+                    name: "QUERY_ERR",
+                    message: "Error: " + e
                 }
-                res(true);
-            });
-        });
+            };
+        }
     }
 }
 exports.MysqlService = MysqlService;

package/dist/apiServer/structures/Interfaces.d.ts

@@ -29,6 +29,7 @@ export interface HTTPRequestVO<T = any> {
     preproducerResult?: any;
     precheck?: TransferPacketVO<any> | null;
     files: FileArray | null | undefined;
+    referer?: string;
     unlocked?: boolean;
 }
 export interface IError {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "badmfck-api-server",
-  "version": "2.1.2",
+  "version": "2.1.4",
   "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": {