badmfck-api-server 2.1.9 → 2.2.0

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.9";
+    version = "2.2.0";
     options;
     monitor;
     monitorIndexFile;

package/dist/apiServer/MysqlService.d.ts

@@ -4,6 +4,12 @@ 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 REQ_MYSQL_TBEGIN: Req<void, number | MysqlError>;
+export declare const REQ_MYSQL_TQUERY: Req<{
+    query: MySqlQuery;
+    tid: number;
+}, MysqlResult>;
+export declare const REQ_MYSQL_TEND: Req<number, MysqlError | null>;
 export declare const executeQuery: (query: MySqlQuery | MySqlQuery[]) => Promise<MysqlResult[]>;
 export interface MysqlServiceOptions {
     connectionLimit: number;
@@ -13,6 +19,7 @@ export interface MysqlServiceOptions {
     port: number;
     database: string;
     queueLimit?: number;
+    transactionFailReport?: (trx: ITransaction, message: string) => void;
     migrations?: {
         dir: string;
         callback: () => void;
@@ -46,6 +53,15 @@ export interface MysqlQueryField {
     useInReplace?: boolean;
     _parsedValue?: string | number | boolean | null;
 }
+export interface ITransaction {
+    id: number;
+    timestamp: number;
+    conn: mysql.PoolConnection;
+    queries: {
+        sql: string;
+        status: string;
+    }[];
+}
 export interface MysqlQueryFieldObject extends Record<string, string | number | boolean | null | undefined | {
     value: string | number | boolean | null | undefined;
     system?: boolean;
@@ -62,9 +78,13 @@ export declare class MysqlService extends BaseService {
     serviceStarted: boolean;
     timeoutID: any;
     queries: never[];
+    static nextTransactionID: number;
+    transactions: ITransaction[];
+    maxTransactionWaitTime: number;
     constructor(options: MysqlServiceOptions);
     static executeQuery(query: MySqlQuery | MySqlQuery[]): Promise<MysqlResult[]>;
     init(): Promise<void>;
+    storeTransactionAsProblem(trx: ITransaction, message: string): Promise<void>;
     recreatePool(): Promise<boolean>;
     onApplicationReady(): Promise<void>;
     static fieldsToObject(fields: MysqlQueryField[] | MysqlQueryFieldObject, ignoreSystemParameters?: boolean): MysqlQueryFieldObject;

package/dist/apiServer/MysqlService.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MysqlService = exports.executeQuery = exports.REQ_MYSQL_TRANSACTION = exports.REQ_MYSQL_QUERY = exports.S_MYSQL_STARTED = void 0;
+exports.MysqlService = exports.executeQuery = exports.REQ_MYSQL_TEND = exports.REQ_MYSQL_TQUERY = exports.REQ_MYSQL_TBEGIN = 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");
@@ -32,6 +32,9 @@ 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");
+exports.REQ_MYSQL_TBEGIN = new badmfck_signal_1.Req(undefined, "REQ_MYSQL_TRANSACTION_BEGING");
+exports.REQ_MYSQL_TQUERY = new badmfck_signal_1.Req(undefined, "REQ_MYSQL_TRANSACTION_ADD_OPERATION");
+exports.REQ_MYSQL_TEND = new badmfck_signal_1.Req(undefined, "REQ_MYSQL_TRANSACTION_END");
 const executeQuery = async (query) => { return await exports.REQ_MYSQL_QUERY.request(query); };
 exports.executeQuery = executeQuery;
 class MysqlService extends BaseService_1.BaseService {
@@ -42,6 +45,9 @@ class MysqlService extends BaseService_1.BaseService {
     serviceStarted = false;
     timeoutID;
     queries = [];
+    static nextTransactionID = 0;
+    transactions = [];
+    maxTransactionWaitTime = 1000 * 60 * 2;
     constructor(options) {
         super("mysql");
         this.options = options;
@@ -53,12 +59,40 @@ class MysqlService extends BaseService_1.BaseService {
             this.options.database = decrypt(this.options.database.substring(1)) ?? this.options.database;
         if (this.options.password.startsWith("_"))
             this.options.password = decrypt(this.options.password.substring(1)) ?? this.options.password;
+        setInterval(() => {
+            const now = Date.now();
+            this.transactions = this.transactions.filter(async (i) => {
+                if (now - i.timestamp < this.maxTransactionWaitTime)
+                    return true;
+                try {
+                    (0, LogService_1.logError)("Release transaction connection due to timeout");
+                    i.conn.removeAllListeners();
+                    await i.conn.rollback();
+                    i.conn.release();
+                }
+                catch (e) {
+                    (0, LogService_1.logError)("Can't release transaction", e);
+                }
+                return false;
+            });
+        }, 1000 * 30);
     }
     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...');
+            for (let i of this.transactions) {
+                try {
+                    this.storeTransactionAsProblem(i, "SIGINT");
+                    i.conn.removeAllListeners();
+                    await i.conn.rollback();
+                    i.conn.release();
+                }
+                catch (e) {
+                    (0, LogService_1.logError)("Can't release transaction connection", e);
+                }
+            }
             if (this.pool) {
                 try {
                     await this.pool.end();
@@ -93,6 +127,93 @@ class MysqlService extends BaseService_1.BaseService {
             }
             return await Promise.all(promises);
         };
+        exports.REQ_MYSQL_TBEGIN.listener = async () => {
+            const conn = await this.pool?.getConnection();
+            if (!conn)
+                return { code: "NO_POOL", errno: 100000, fatal: true, sql: "", name: "NO_POOL", message: "Mysql pool not created" };
+            const tid = MysqlService.nextTransactionID++;
+            try {
+                await conn.beginTransaction();
+                await conn.query("SET autocommit=0");
+            }
+            catch (e) {
+                try {
+                    conn.removeAllListeners();
+                    await conn.rollback();
+                    conn.release();
+                }
+                catch (e) { }
+                return this.createMysqlQueryError(e);
+            }
+            this.transactions.push({
+                id: tid,
+                timestamp: Date.now(),
+                conn: conn,
+                queries: []
+            });
+            return tid;
+        };
+        exports.REQ_MYSQL_TQUERY.listener = async (data) => {
+            const trx = this.transactions.find(i => i.id === data.tid);
+            if (!trx)
+                return { err: {
+                        code: "NO_TRX",
+                        errno: 100004,
+                        fatal: true,
+                        sql: "",
+                        name: "NO_TRX",
+                        message: "Transaction not found"
+                    }, data: null, rollbackError: null };
+            const query = MysqlService.prepareQuery(data.query.query, data.query.fields);
+            let err = null;
+            let rollbackError = null;
+            let sqlData = null;
+            try {
+                sqlData = await trx.conn.query(query);
+            }
+            catch (e) {
+                err = this.createMysqlQueryError(e);
+            }
+            if (err) {
+                try {
+                    trx.conn.removeAllListeners();
+                    await trx.conn.rollback();
+                    trx.conn.release();
+                }
+                catch (e) {
+                    rollbackError = this.createMysqlQueryError(e);
+                }
+            }
+            trx.queries.push({ sql: query, status: err ? err.message : "completed" });
+            return {
+                data: sqlData,
+                error: err,
+                rollbackError: rollbackError
+            };
+        };
+        exports.REQ_MYSQL_TEND.listener = async (tid) => {
+            const trx = this.transactions.find(i => i.id === tid);
+            if (!trx)
+                return {
+                    code: "NO_TRX",
+                    errno: 100004,
+                    fatal: true,
+                    sql: "",
+                    name: "NO_TRX",
+                    message: "Transaction not found"
+                };
+            this.transactions = this.transactions.filter(i => i.id !== tid);
+            try {
+                await trx.conn.commit();
+                trx.conn.removeAllListeners();
+                trx.conn.release();
+            }
+            catch (e) {
+                this.storeTransactionAsProblem(trx, "Can't commit transaction");
+                return this.createMysqlQueryError(e);
+            }
+            return null;
+        };
         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 };
@@ -124,12 +245,21 @@ class MysqlService extends BaseService_1.BaseService {
             try {
                 conn.release();
             }
-            catch (e) { }
+            catch (e) {
+                (0, LogService_1.logCrit)("${MysqlService.js}", "Can't release connection!");
+            }
             if (!result)
                 result = { error: null, data: income };
             return result;
         };
     }
+    async storeTransactionAsProblem(trx, message) {
+        if (!this.options.transactionFailReport) {
+            (0, LogService_1.logCrit)("${MysqlService.js}", "Can't report failed transaction, no report function: transactionFailReport in options");
+            return;
+        }
+        this.options.transactionFailReport(trx, message);
+    }
     async recreatePool() {
         (0, LogService_1.logInfo)("${MysqlService.js}", "Connecting to mysql: \n HOST: " + this.options.host + '\n PORT:' + this.options.port);
         if (this.pool) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "badmfck-api-server",
-  "version": "2.1.9",
+  "version": "2.2.0",
   "description": "Simple API http server based on express",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",