badmfck-api-server 1.0.2 → 1.0.4

package/dist/apiServer/APIService.js

@@ -43,7 +43,7 @@ async function Initializer(services) {
 exports.Initializer = Initializer;
 class APIService extends BaseService_1.BaseService {
     static nextLogID = 0;
-    version = "1.2.0";
+    version = "1.2.1";
     options;
     netLog = [];
     constructor(options) {

package/dist/apiServer/MysqlService.d.ts

@@ -0,0 +1,46 @@
+import { FieldInfo, MysqlError, Pool, PoolConnection } from "mysql";
+import { BaseService } from "./BaseService";
+export interface MysqlServiceOptions {
+    connectionLimit: number;
+    host: string;
+    user: string;
+    password: string;
+    port: number;
+    database: string;
+    onLog?: (level: number, data: any) => void;
+}
+export interface MysqlResult {
+    error?: MysqlError | null;
+    isDuplicateError?: boolean;
+    fields?: FieldInfo[] | null;
+    data: any;
+}
+export interface MySqlQuery {
+    query: string;
+    fields: MysqlQueryField[];
+}
+export interface MysqlQueryField {
+    name: string;
+    value: string | number | boolean | null | undefined;
+    system?: boolean;
+    ignoreInInsert?: boolean;
+    ignoreInUpdate?: boolean;
+    useInReplace?: boolean;
+    _parsedValue?: string | number | boolean | null;
+}
+export declare class MysqlService extends BaseService {
+    reconnectionTimeout: number;
+    reconnecting: boolean;
+    pool: Pool | null;
+    options: MysqlServiceOptions;
+    retries: number;
+    constructor(options: MysqlServiceOptions);
+    init(): Promise<void>;
+    onApplicationReady(): Promise<void>;
+    static prepareQuery(query: string, fields: MysqlQueryField[]): 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>;
+}
+export default MysqlService;

package/dist/apiServer/MysqlService.js

@@ -0,0 +1,250 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MysqlService = void 0;
+const mysql_1 = __importDefault(require("mysql"));
+const BaseService_1 = require("./BaseService");
+const badmfck_signal_1 = require("badmfck-signal");
+const REQ_MYSQL_QUERY = new badmfck_signal_1.Req();
+class MysqlService extends BaseService_1.BaseService {
+    reconnectionTimeout = 1000 * 3;
+    reconnecting = false;
+    pool = null;
+    options;
+    retries = 5;
+    constructor(options) {
+        super("mysql");
+        this.options = options;
+        this.init();
+    }
+    async init() {
+        const ok = await this.createPool();
+        if (!ok) {
+            if (this.options.onLog)
+                this.options.onLog(2, "Mysql server not connected");
+        }
+        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));
+            }
+            return await Promise.all(promises);
+        };
+    }
+    async onApplicationReady() { }
+    static prepareQuery(query, fields) {
+        for (let i of fields) {
+            const val = this.prepareQueryFieldValue(i.value, i.system);
+            i._parsedValue = val;
+            query = query.replaceAll("@" + i.name, val + "");
+        }
+        const tmp = query.toLowerCase();
+        if (tmp.indexOf("select") === 0 && tmp.indexOf("limit") === -1)
+            query += " LIMIT 100";
+        query = query.replaceAll("@NOLIMIT", "");
+        if (query.indexOf("@fields") !== -1) {
+            let insertFieldNames = [];
+            let insertFieldValues = [];
+            for (let i of fields) {
+                if (i.ignoreInInsert)
+                    continue;
+                insertFieldNames.push('`' + i.name.replaceAll("`", '').replaceAll('\"', "").replaceAll('\'', "") + '`');
+                insertFieldValues.push(i._parsedValue);
+            }
+            query = query
+                .replaceAll('@fields', insertFieldNames.join(","))
+                .replaceAll('@values', insertFieldValues.join(","));
+        }
+        if (query.indexOf("@onupdate") !== -1) {
+            let onUpdate = [];
+            for (let i of fields) {
+                if (i.ignoreInUpdate)
+                    continue;
+                onUpdate.push('`' + i.name.replaceAll("`", '').replaceAll('\"', "").replaceAll('\'', "") + '` = ' + i._parsedValue);
+            }
+            query = query.replaceAll("@onupdate", onUpdate.join(" , "));
+        }
+        if (query.indexOf('@onduplicate') !== -1) {
+            let onDuplicate = [];
+            for (let i of fields) {
+                if (!i.useInReplace)
+                    continue;
+                onDuplicate.push('`' + i.name.replaceAll("`", '').replaceAll('\"', "").replaceAll('\'', "") + '` = ' + i._parsedValue);
+            }
+            query = query.replaceAll("@onduplicate", onDuplicate.join(" , "));
+        }
+        return query;
+    }
+    static prepareQueryFieldValue(value, system) {
+        if (!system && typeof value === "string") {
+            value = value ? value.replaceAll('"', '\\"') : null;
+            value = '"' + value + '"';
+        }
+        return value;
+    }
+    async execute(query) {
+        return new Promise((resolve, reject) => {
+            if (!this.pool) {
+                if (this.options.onLog)
+                    this.options.onLog(2, "No pool");
+                resolve({
+                    error: {
+                        code: "NO_POOL",
+                        errno: 100000,
+                        fatal: true,
+                        sql: query,
+                        name: "NO_POOL",
+                        message: "Mysql pool not created"
+                    },
+                    data: null,
+                    fields: null
+                });
+                return;
+            }
+            this.pool.getConnection((err, conn) => {
+                if (err) {
+                    if (this.options.onLog)
+                        this.options.onLog(2, `${err}`);
+                    resolve({
+                        error: err,
+                        data: null,
+                        fields: null
+                    });
+                    return;
+                }
+                if (!conn) {
+                    resolve({
+                        error: {
+                            code: "NO_CONN",
+                            errno: 100001,
+                            fatal: true,
+                            sql: query,
+                            name: "NO_CONN",
+                            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) { }
+                    resolve({
+                        error: {
+                            code: "QUERY_ERR",
+                            errno: 100002,
+                            fatal: true,
+                            sql: query,
+                            name: "QUERY_ERR",
+                            message: "Error: " + e
+                        },
+                        data: null,
+                        fields: null
+                    });
+                }
+            });
+        });
+    }
+    sendQuery(conn, query, resolve) {
+        let errCatched = false;
+        conn.on("error", err => {
+            errCatched = true;
+            conn.release();
+            conn.removeAllListeners();
+            if (this.options.onLog)
+                this.options.onLog(2, `${err}`);
+            conn.removeAllListeners();
+            resolve({
+                error: {
+                    code: "CONN_ERR",
+                    errno: 100003,
+                    fatal: true,
+                    sql: query,
+                    name: "CONN_ERR",
+                    message: "Error: " + err
+                },
+                data: null,
+                fields: null
+            });
+        });
+        if (this.options.onLog)
+            this.options.onLog(0, 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;
+                if (this.options.onLog)
+                    this.options.onLog(2, `${err}`);
+                resolve({
+                    error: err,
+                    data: null,
+                    fields: null,
+                    isDuplicateError: dup
+                });
+                return;
+            }
+            resolve({
+                error: err,
+                data: results,
+                fields: fields
+            });
+            return;
+        });
+    }
+    async createPool() {
+        if (this.options.onLog)
+            this.options.onLog(1, "Connecting to mysql: \n HOST: " + this.options.host + '\n USER:' + this.options.user + '\n PORT:' + this.options.port);
+        let err = false;
+        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
+            });
+        }
+        catch (e) {
+            if (this.options.onLog)
+                this.options.onLog(2, "Can't connect to MYSQL!");
+            err = true;
+        }
+        return new Promise((res, rej) => {
+            if (err) {
+                res(false);
+                return;
+            }
+            if (!this.pool) {
+                res(false);
+                return;
+            }
+            this.pool.getConnection((e, cnn) => {
+                if (e) {
+                    if (this.options.onLog)
+                        this.options.onLog(2, e.message);
+                    res(false);
+                    return;
+                }
+                res(true);
+            });
+        });
+    }
+}
+exports.MysqlService = MysqlService;
+exports.default = MysqlService;

package/dist/apiServer/structures/HTTPStatus.js

@@ -8,4 +8,4 @@ var HTTP_STATUS;
     HTTP_STATUS[HTTP_STATUS["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
     HTTP_STATUS[HTTP_STATUS["BAD_REQUEST"] = 400] = "BAD_REQUEST";
     HTTP_STATUS[HTTP_STATUS["SERVER_ERROR"] = 500] = "SERVER_ERROR";
-})(HTTP_STATUS = exports.HTTP_STATUS || (exports.HTTP_STATUS = {}));
+})(HTTP_STATUS || (exports.HTTP_STATUS = HTTP_STATUS = {}));

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 import { APIService, Initializer } from "./apiServer/APIService";
 import { LocalRequest } from "./apiServer/LocalRequest";
-export { APIService, Initializer, LocalRequest };
+import { MysqlService } from "./apiServer/MysqlService";
+export { APIService, Initializer, LocalRequest, MysqlService };

package/dist/index.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LocalRequest = exports.Initializer = exports.APIService = void 0;
+exports.MysqlService = exports.LocalRequest = exports.Initializer = exports.APIService = void 0;
 const APIService_1 = require("./apiServer/APIService");
 Object.defineProperty(exports, "APIService", { enumerable: true, get: function () { return APIService_1.APIService; } });
 Object.defineProperty(exports, "Initializer", { enumerable: true, get: function () { return APIService_1.Initializer; } });
 const LocalRequest_1 = require("./apiServer/LocalRequest");
 Object.defineProperty(exports, "LocalRequest", { enumerable: true, get: function () { return LocalRequest_1.LocalRequest; } });
+const MysqlService_1 = require("./apiServer/MysqlService");
+Object.defineProperty(exports, "MysqlService", { enumerable: true, get: function () { return MysqlService_1.MysqlService; } });

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "badmfck-api-server",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Simple API http server based on express",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
     "prepublish": "tsc",
-    "build":"tsc",
+    "build": "tsc",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "keywords": [
@@ -17,10 +17,12 @@
     "express"
   ],
   "dependencies": {
+    "@types/mysql": "^2.15.21",
     "axios": "^1.4.0",
     "badmfck-signal": "^1.0.1",
     "cors": "^2.8.5",
-    "express": "^4.18.2"
+    "express": "^4.18.2",
+    "mysql": "^2.18.1"
   },
   "devDependencies": {
     "@types/cors": "^2.8.13",