badmfck-api-server 2.9.4 → 2.9.5

package/dist/apiServer/DBService.d.ts

@@ -21,6 +21,18 @@ export interface IDBQuery {
     calculateCount?: boolean;
     parseQueryOnly?: boolean;
 }
+export interface IDBBulkQuery {
+    dbid?: string;
+    bulk: {
+        query: string;
+        fields: {
+            [key: string]: IDBQueryField | null | string | number | boolean;
+        };
+        throwable?: boolean;
+        calculateCount?: boolean;
+    }[];
+    queued?: boolean;
+}
 export interface IDBError {
     code: string;
     errno: number;
@@ -52,6 +64,7 @@ export interface DBAdapterOptions {
     debug?: boolean;
 }
 export declare const REQ_DB: Req<IDBQuery, IDBResult>;
+export declare const REQ_DBX: Req<IDBBulkQuery, IDBResult[]>;
 export declare class DBService extends BaseService {
     static allInstances: DBService[];
     options: IDBSericeOptions;

package/dist/apiServer/DBService.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DBService = exports.REQ_DB = void 0;
+exports.DBService = exports.REQ_DBX = exports.REQ_DB = void 0;
 const badmfck_signal_1 = require("badmfck-signal");
 const BaseService_1 = require("./BaseService");
 const MysqlAdapter_1 = require("./db/MysqlAdapter");
-exports.REQ_DB = new badmfck_signal_1.Req(undefined, "DB_SELECT");
+exports.REQ_DB = new badmfck_signal_1.Req(undefined, "REQ_DB");
+exports.REQ_DBX = new badmfck_signal_1.Req(undefined, "REQ_DBX");
 class DBService extends BaseService_1.BaseService {
     static allInstances = [];
     options;
@@ -25,6 +26,29 @@ class DBService extends BaseService_1.BaseService {
         if (this.options.type === "mysql") {
             await this.createMysqlDatabase();
         }
+        exports.REQ_DBX.listener = async (req) => {
+            if (!req.dbid && DBService.allInstances.length === 1 && DBService.allInstances[0].adapter)
+                return DBService.allInstances[0].adapter.bulk(req);
+            for (let i of DBService.allInstances) {
+                if (i.options.id === req.dbid && i.adapter)
+                    return i.adapter.bulk(req);
+            }
+            const error = {
+                code: "DB_NOT_FOUND",
+                errno: -1,
+                fatal: true,
+                sql: "",
+                name: "DB_NOT_FOUND",
+                message: "DB not found: " + req.dbid
+            };
+            let result = [];
+            for (let i of req.bulk) {
+                result.push({ error: error });
+                if (i.throwable)
+                    throw error;
+            }
+            return result;
+        };
         exports.REQ_DB.listener = async (req) => {
             if (!req.dbid && DBService.allInstances.length === 1 && DBService.allInstances[0].adapter)
                 return DBService.allInstances[0].adapter.query(req);

package/dist/apiServer/MysqlService.js

@@ -151,8 +151,11 @@ class MysqlService extends BaseService_1.BaseService {
                 const query = MysqlService.prepareQuery(i.query, i.fields);
                 promises.push(this.execute(query, i.rollbackQuery ?? null, i.transactionID ?? 0, i.throwable ?? false, i.calculateCount ?? false));
             }
-            if (this.debug)
+            if (this.debug) {
                 console.log("Execute queries: ", data.length);
+                for (let i of data)
+                    console.log(i);
+            }
             const result = await Promise.all(promises);
             for (let i of result) {
                 if (i.error && i.error.code === "CONN_ERR") {

package/dist/apiServer/db/IDBAdapter.d.ts

@@ -1,7 +1,8 @@
-import { IDBQuery, IDBResult } from "../DBService";
+import { IDBBulkQuery, IDBQuery, IDBResult } from "../DBService";
 export interface IDBAdapter {
     init(): Promise<void>;
     finish(): Promise<void>;
     prepareQuery(request: IDBQuery): string;
     query(request: IDBQuery): Promise<IDBResult>;
+    bulk(request: IDBBulkQuery): Promise<IDBResult[]>;
 }

package/dist/apiServer/db/MysqlAdapter.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { DBAdapterOptions, IDBError, IDBQuery, IDBQueryField, IDBResult } from "../DBService";
+import { DBAdapterOptions, IDBBulkQuery, IDBError, IDBQuery, IDBQueryField, IDBResult } from "../DBService";
 import { IDBAdapter } from "./IDBAdapter";
 import mysql from 'mysql2/promise';
 import fs from 'fs';
@@ -34,7 +34,9 @@ export declare class MysqlAdapter implements IDBAdapter {
     init(): Promise<void>;
     setupTimers(): void;
     recreatePool(): Promise<boolean>;
-    query(request: IDBQuery): Promise<IDBResult>;
+    bulk(request: IDBBulkQuery): Promise<IDBResult[]>;
+    getConnection(transactionId?: number): Promise<mysql.PoolConnection | IDBError>;
+    query(request: IDBQuery, conn?: mysql.PoolConnection): Promise<IDBResult>;
     finalizeConnection(conn: mysql.PoolConnection): void;
     prepareQuery(request: IDBQuery): string;
     static prepareQueryFieldValue(field: IDBQueryField): string | number | boolean | null | undefined;
@@ -44,5 +46,6 @@ export declare class MysqlAdapter implements IDBAdapter {
     finish(): Promise<void>;
     createMysqlQueryError(err: any, throwable?: boolean): IDBError;
     storeTransactionAsProblem(trx: ITransaction, message: string): Promise<void>;
+    isError(obj: any): obj is IDBError;
 }
 export {};

package/dist/apiServer/db/MysqlAdapter.js

@@ -154,104 +154,132 @@ class MysqlAdapter {
         }
         return true;
     }
-    async query(request) {
-        const query = this.prepareQuery(request);
-        if (request.parseQueryOnly) {
-            return {
-                data: [{ query }],
-                error: null,
-            };
+    async bulk(request) {
+        const results = [];
+        let queries = [];
+        let conn = null;
+        if (request.queued) {
+            conn = await this.getConnection();
+            if (this.isError(conn)) {
+                for (let i of request.bulk)
+                    results.push({ data: null, error: conn });
+                return results;
+            }
         }
+        for (let i of request.bulk) {
+            if (request.queued && conn) {
+                const response = await this.query({
+                    query: i.query,
+                    fields: i.fields,
+                    throwable: i.throwable,
+                }, conn);
+                results.push(response);
+                continue;
+            }
+            queries.push(this.query({
+                query: i.query,
+                fields: i.fields,
+                throwable: i.throwable,
+            }));
+        }
+        if (conn) {
+            this.finalizeConnection(conn);
+            conn = null;
+        }
+        if (queries && queries.length > 0) {
+            const responses = await Promise.all(queries);
+            for (let i of responses)
+                results.push(i);
+        }
+        return results;
+    }
+    async getConnection(transactionId) {
         if (!this.pool) {
             (0, LogService_1.logError)("${MysqlAdapter.js}", "No pool created, can't execute query");
-            const error = {
+            return {
                 code: "NO_POOL",
                 errno: 100000,
                 fatal: true,
-                sql: query,
+                sql: "",
                 name: "NO_POOL",
                 message: "Mysql pool not created",
             };
-            if (request.throwable)
-                throw { ...DefaultErrors_1.default.DB_ERROR, details: error.message, stack: error };
-            return {
-                data: null,
-                error: error,
-            };
         }
         try {
             let conn = null;
-            if (request.transactionID && request.transactionID > 0) {
-                conn = this.transactions.find(i => i.id === request.transactionID)?.conn ?? null;
+            if (transactionId && transactionId > 0) {
+                conn = this.transactions.find(i => i.id === transactionId)?.conn ?? null;
                 if (this.options.debug)
                     console.log("Execute query on transaction: ", conn?.threadId);
             }
             else
                 conn = await this.pool.getConnection();
+            if (this.options.debug) {
+                console.log("Pool status: ", this.poolConnections, this.acquiredPoolConnections);
+            }
             if (this.options.debug)
                 console.log("Execute query", conn?.threadId);
-            if (!conn) {
-                (0, LogService_1.logCrit)("${MysqlAdapter.js}", `No connection created!`);
-                const error = {
-                    code: "NO_CONN",
-                    errno: 100001,
-                    fatal: true,
-                    sql: query,
-                    name: "NO_CONN",
-                    message: "Mysql pool cant get connection",
-                };
-                if (request.throwable)
-                    throw { ...DefaultErrors_1.default.DB_ERROR, details: error.message, stack: error };
-                return {
-                    data: null,
-                    error: error,
-                };
-            }
-            try {
-                if (this.options.debug)
-                    (0, LogService_1.logInfo)("Execute query:", query);
-                const result = await conn.query(query);
-                this.lastSuccessQueryTime = +new Date();
-                if (!request.transactionID)
-                    this.finalizeConnection(conn);
-                return {
-                    data: result[0],
-                    error: null
-                };
-            }
-            catch (e) {
-                if (!request.transactionID)
-                    this.finalizeConnection(conn);
-                else if (request.transactionID && request.throwable) {
-                    this.rollbackTransaction(this.transactions.find(i => i.id === request.transactionID));
-                    this.finalizeConnection(conn);
-                }
-                const error = this.createMysqlQueryError(e);
-                if (`${e}`.indexOf('ECONNREFUSED') !== -1)
-                    this.recreatePool();
-                if (request.throwable)
-                    throw { ...DefaultErrors_1.default.DB_ERROR, details: error.message, stack: error };
+            if (conn)
+                return conn;
+        }
+        catch (e) {
+            if (`${e}`.indexOf('ECONNREFUSED') !== -1)
+                this.recreatePool();
+        }
+        (0, LogService_1.logCrit)("${MysqlAdapter.js}", `No connection created!`);
+        return {
+            code: "NO_CONN",
+            errno: 100001,
+            fatal: true,
+            sql: "",
+            name: "NO_CONN",
+            message: "Mysql pool cant get connection",
+        };
+    }
+    async query(request, conn) {
+        const query = this.prepareQuery(request);
+        if (request.parseQueryOnly) {
+            return {
+                data: [{ query }],
+                error: null,
+            };
+        }
+        let doCloseConnection = false;
+        if (!conn) {
+            doCloseConnection = true;
+            conn = await this.getConnection(request.transactionID ?? -1);
+            if (this.isError(conn)) {
                 return {
                     data: null,
-                    error: this.createMysqlQueryError(e),
+                    error: conn,
                 };
             }
         }
-        catch (e) {
-            (0, LogService_1.logCrit)("MysqlAdapter", `Error when executing query: ${query}`, e);
-            const error = {
-                code: "EXEC_ERROR",
-                errno: 100002,
-                fatal: true,
-                sql: query,
-                name: "EXECUTION_ERROR",
-                message: e + "",
+        try {
+            const result = await conn.query(query);
+            this.lastSuccessQueryTime = +new Date();
+            if (!request.transactionID && doCloseConnection)
+                this.finalizeConnection(conn);
+            return {
+                data: result[0],
+                error: null
             };
+        }
+        catch (e) {
+            if (!request.transactionID && doCloseConnection)
+                this.finalizeConnection(conn);
+            else if (request.transactionID && request.throwable) {
+                this.rollbackTransaction(this.transactions.find(i => i.id === request.transactionID));
+                this.finalizeConnection(conn);
+            }
+            const error = this.createMysqlQueryError(e);
+            if (`${e}`.indexOf('ECONNREFUSED') !== -1)
+                this.recreatePool();
             if (request.throwable)
                 throw { ...DefaultErrors_1.default.DB_ERROR, details: error.message, stack: error };
             return {
                 data: null,
-                error: error,
+                error: this.createMysqlQueryError(e),
             };
         }
     }
@@ -464,6 +492,9 @@ class MysqlAdapter {
         if (this.options.transactionFailReport)
             this.options.transactionFailReport(trx, message);
     }
+    isError(obj) {
+        return obj && "code" in obj && "errno" in obj && "name" in obj && "message" in obj;
+    }
 }
 exports.MysqlAdapter = MysqlAdapter;
 const secret_key = "AKLWkajw%^&dgwqhw#98453i23bfk23rn2knknglrgjeit";

package/package.json

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