badmfck-api-server 1.0.1 → 1.0.3

package/dist/apiServer/APIService.d.ts

@@ -1,8 +1,8 @@
 import { Response } from 'express';
 import { BaseService, IBaseService } from './BaseService';
 import { IBaseEndpoint } from './BaseEndpoint';
-import { SyncSignal } from '../signal/Signal';
 import { TransferPacketVO } from './structures/Interfaces';
+import { Req } from "badmfck-signal";
 export interface APIServiceNetworkLogItem {
     id: number;
     created: number;
@@ -23,10 +23,11 @@ export interface APIServiceOptions {
     jsonLimit: string;
     onNetworkLog?: ((log: APIServiceNetworkLogItem) => void) | null;
     onError?: ((...rest: any[]) => void) | null;
+    isProductionEnvironment: boolean;
 }
 export declare function getDefaultOptions(): APIServiceOptions;
-export declare const REQ_CREATE_NET_LOG: SyncSignal<void, APIServiceNetworkLogItem>;
-export declare const REQ_HTTP_LOG: SyncSignal<void, APIServiceNetworkLogItem[]>;
+export declare const REQ_CREATE_NET_LOG: Req<void, APIServiceNetworkLogItem>;
+export declare const REQ_HTTP_LOG: Req<void, APIServiceNetworkLogItem[]>;
 export declare function Initializer(services: IBaseService[]): Promise<void>;
 export declare class APIService extends BaseService {
     private static nextLogID;

package/dist/apiServer/APIService.js

@@ -9,7 +9,7 @@ const BaseService_1 = require("./BaseService");
 const cors_1 = __importDefault(require("cors"));
 const BaseEndpoint_1 = require("./BaseEndpoint");
 const DefaultErrors_1 = __importDefault(require("./structures/DefaultErrors"));
-const Signal_1 = require("../signal/Signal");
+const badmfck_signal_1 = require("badmfck-signal");
 function getDefaultOptions() {
     return {
         port: 8091,
@@ -25,12 +25,13 @@ function getDefaultOptions() {
         },
         onError: function (err) {
             console.error.call(this, err);
-        }
+        },
+        isProductionEnvironment: false
     };
 }
 exports.getDefaultOptions = getDefaultOptions;
-exports.REQ_CREATE_NET_LOG = new Signal_1.SyncSignal();
-exports.REQ_HTTP_LOG = new Signal_1.SyncSignal();
+exports.REQ_CREATE_NET_LOG = new badmfck_signal_1.Req();
+exports.REQ_HTTP_LOG = new badmfck_signal_1.Req();
 async function Initializer(services) {
     for (let i of services) {
         await i.init();
@@ -66,8 +67,32 @@ class APIService extends BaseService_1.BaseService {
             cb(log);
         };
         const app = (0, express_1.default)();
+        if (this.options.isProductionEnvironment)
+            app.set("env", 'production');
         app.use(express_1.default.json({ limit: '10mb' }));
         app.use(express_1.default.urlencoded({ limit: '10mb', extended: true }));
+        app.use(async (err, req, resp, next) => {
+            if (!err) {
+                next();
+                return;
+            }
+            const tme = +new Date();
+            const log = await exports.REQ_CREATE_NET_LOG.request();
+            log.request = {
+                method: req.method,
+                data: "",
+                params: req.params
+            };
+            let responseError = DefaultErrors_1.default.UNKNOWN_REQUEST;
+            if (typeof err === "object" && err.status === 400 && 'body' in err && err.type === 'entity.parse.failed') {
+                responseError = DefaultErrors_1.default.JSON_MALFORMED;
+            }
+            this.sendResponse(resp, {
+                error: responseError,
+                data: null,
+                httpStatus: 400
+            }, tme, "", log);
+        });
         const corsOptions = {
             origin: (origin, callback) => {
                 const originIsWhitelisted = this.options.corsHostWhiteList.includes(origin);

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;
+}
+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,248 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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.default = MysqlService;

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

@@ -2,5 +2,6 @@ import { ErrorVO } from "./Interfaces";
 declare class DefaultErrors {
     static NOT_IMPLEMENTED: ErrorVO;
     static UNKNOWN_REQUEST: ErrorVO;
+    static JSON_MALFORMED: ErrorVO;
 }
 export default DefaultErrors;

package/dist/apiServer/structures/DefaultErrors.js

@@ -3,5 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 class DefaultErrors {
     static NOT_IMPLEMENTED = { code: 1, message: "Not implemented" };
     static UNKNOWN_REQUEST = { code: 2, message: "Unknown request" };
+    static JSON_MALFORMED = { code: 3, message: "JSON malformed" };
 }
 exports.default = DefaultErrors;

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/package.json

@@ -1,12 +1,12 @@
 {
   "name": "badmfck-api-server",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "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",