badmfck-api-server 2.3.2 → 2.3.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.3.2";
+    version = "2.3.5";
     options;
     monitor;
     monitorIndexFile;

package/dist/apiServer/MysqlService.d.ts

@@ -95,6 +95,7 @@ export declare class MysqlService extends BaseService {
     constructor(options: MysqlServiceOptions);
     static executeQuery(query: MySqlQuery | MySqlQuery[]): Promise<MysqlResult[]>;
     init(): Promise<void>;
+    rollbackTransaction(trx: ITransaction, donNotRemove?: boolean): Promise<void>;
     finishApp(): Promise<void>;
     storeTransactionAsProblem(trx: ITransaction, message: string): Promise<void>;
     recreatePool(): Promise<boolean>;

package/dist/apiServer/MysqlService.js

@@ -76,22 +76,15 @@ class MysqlService extends BaseService_1.BaseService {
         setInterval(() => {
             const now = Date.now();
             const count = this.transactions.length;
-            this.transactions = this.transactions.filter(async (i) => {
-                if (now - i.timestamp < this.maxTransactionWaitTime)
-                    return true;
-                try {
+            const removedIDs = [];
+            for (let i of this.transactions) {
+                if (now - i.timestamp > this.maxTransactionWaitTime) {
                     (0, LogService_1.logError)("Release transaction connection due to timeout");
-                    i.conn.removeAllListeners();
-                    await i.conn.rollback();
-                    i.conn.release();
-                    this.storeTransactionAsProblem(i, "Timeout");
-                }
-                catch (e) {
-                    (0, LogService_1.logError)("Can't release transaction", e);
-                    this.storeTransactionAsProblem(i, "Timeout, cant,release");
+                    this.rollbackTransaction(i, true);
+                    removedIDs.push(i.id);
                 }
-                return false;
-            });
+            }
+            this.transactions = this.transactions.filter(i => !removedIDs.includes(i.id));
             if (this.debug)
                 console.log("Removed: ", count - this.transactions.length);
         }, 1000 * 30);
@@ -168,14 +161,7 @@ class MysqlService extends BaseService_1.BaseService {
                     console.log("Transaction started, SET autocommit=0 ", tid, res);
             }
             catch (e) {
-                try {
-                    if (this.debug)
-                        console.log("Transaction failed to start ", tid, e);
-                    conn.removeAllListeners();
-                    await conn.rollback();
-                    conn.release();
-                }
-                catch (e) { }
+                this.rollbackTransaction({ id: tid, conn: conn, timestamp: Date.now(), queries: [{ sql: "SET autocommit=0", status: "error" }] });
                 return this.createMysqlQueryError(e);
             }
             this.transactions.push({
@@ -201,7 +187,6 @@ class MysqlService extends BaseService_1.BaseService {
                     }, data: null, rollbackError: null };
             const query = MysqlService.prepareQuery(data.query.query, data.query.fields);
             let err = null;
-            let rollbackError = null;
             let sqlData = null;
             if (this.debug)
                 console.log("Execute query on transaction: ", trx);
@@ -211,25 +196,14 @@ class MysqlService extends BaseService_1.BaseService {
             catch (e) {
                 err = this.createMysqlQueryError(e);
             }
-            if (err) {
-                try {
-                    trx.conn.removeAllListeners();
-                    await trx.conn.rollback();
-                    trx.conn.release();
-                    this.transactions = this.transactions.filter(i => i.id !== data.tid);
-                    this.storeTransactionAsProblem(trx, err.message);
-                }
-                catch (e) {
-                    rollbackError = this.createMysqlQueryError(e);
-                }
-            }
+            if (err)
+                this.rollbackTransaction(trx);
             if (this.debug)
                 console.log("Query execution status:", err ? err.message : "completed");
             trx.queries.push({ sql: query, status: err ? err.message : "completed" });
             return {
                 data: sqlData,
                 error: err,
-                rollbackError: rollbackError
             };
         };
         exports.REQ_MYSQL_TROLLBACK.listener = async (tid) => {
@@ -249,17 +223,7 @@ class MysqlService extends BaseService_1.BaseService {
             this.transactions = this.transactions.filter(i => i.id !== tid);
             if (this.debug)
                 console.log("Transaction pool:", this.transactions);
-            try {
-                await trx.conn.rollback();
-                trx.conn.removeAllListeners();
-                trx.conn.release();
-                if (this.debug)
-                    console.log("Rollback complete");
-            }
-            catch (e) {
-                (0, LogService_1.logError)("Can't rollback transaction");
-                return this.createMysqlQueryError(e);
-            }
+            this.rollbackTransaction(trx);
             return null;
         };
         exports.REQ_MYSQL_TCOMMIT.listener = async (tid) => {
@@ -287,17 +251,7 @@ class MysqlService extends BaseService_1.BaseService {
                     console.log("Commit completed:");
             }
             catch (e) {
-                this.storeTransactionAsProblem(trx, "Can't commit transaction");
-                try {
-                    if (this.debug)
-                        console.log("Commit error, try rollback");
-                    trx.conn.removeAllListeners();
-                    await trx.conn.rollback();
-                    trx.conn.release();
-                }
-                catch (e) {
-                    (0, LogService_1.logError)("Can't rollback transaction");
-                }
+                this.rollbackTransaction(trx);
                 return this.createMysqlQueryError(e);
             }
             return null;
@@ -348,35 +302,33 @@ class MysqlService extends BaseService_1.BaseService {
                 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);
-                }
+                await this.rollbackTransaction(trx);
                 const err = this.createMysqlQueryError(e);
-                this.storeTransactionAsProblem(trx, err.message);
-                return { error: err, data: null, rollbackError: rollbackError };
+                return { error: err, data: null };
             }
             return { error: null, data: income };
         };
     }
+    async rollbackTransaction(trx, donNotRemove) {
+        try {
+            console.log("Rollback started", trx.conn);
+            await trx.conn.rollback();
+            trx.conn.removeAllListeners();
+            trx.conn.release();
+            if (!donNotRemove)
+                this.transactions = this.transactions.filter(i => i.id !== trx.id);
+            if (this.debug)
+                console.log("Rollback complete", trx.conn);
+        }
+        catch (e) {
+            (0, LogService_1.logCrit)("${MysqlService.js}", "Can't rollback transaction", trx);
+        }
+        this.storeTransactionAsProblem(trx, "rollback");
+    }
     async finishApp() {
         console.log("Finishing mysql service");
-        for (let i of this.transactions) {
-            try {
-                this.storeTransactionAsProblem(i, "SIGINT");
-                i.conn.removeAllListeners();
-                await i.conn.rollback();
-                i.conn.release();
-                console.log("Transaction rollbacked: ", i.id, i.queries);
-            }
-            catch (e) {
-                (0, LogService_1.logError)("Can't release transaction connection", e);
-            }
-        }
+        for (let i of this.transactions)
+            this.rollbackTransaction(i);
         if (this.pool) {
             try {
                 await this.pool.end();
@@ -410,7 +362,9 @@ class MysqlService extends BaseService_1.BaseService {
             }
             if (this.debug)
                 console.log("Store transaction fail report: ", file, trx, message);
-            this.failReportFileStream?.write(JSON.stringify({ trx, date, message }) + "\n{'s':'&$5__1AzZa'}\n", err => {
+            if (!this.failReportFileStream)
+                this.failReportFileStream = fs_1.default.createWriteStream(file, { flags: 'a' });
+            this.failReportFileStream.write(JSON.stringify({ queries: trx.queries, time: trx.timestamp, date, message }) + "\n{'s':'&$5__1AzZa'}\n", err => {
                 if (err)
                     (0, LogService_1.logCrit)("${MysqlService.js}", "Can't write to transaction fail report file");
                 else

package/package.json

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