badmfck-api-server 2.1.1 → 2.1.3

package/dist/apiServer/APIService.d.ts

@@ -9,6 +9,7 @@ export interface APIServiceNetworkLogItem {
     id: number;
     created: number;
     time: number;
+    referer?: string;
     request: {
         [key: string]: any;
     };
@@ -59,6 +60,6 @@ export declare class APIService extends BaseService {
     netLog: APIServiceNetworkLogItem[];
     constructor(options?: APIServiceOptions | null);
     init(): Promise<void>;
-    sendResponse(res: Response, data: TransferPacketVO<any>, requestTime: number, endpoint?: string, log?: APIServiceNetworkLogItem | null, req?: HTTPRequestVO): Promise<void>;
+    sendResponse(ref: string, res: Response, data: TransferPacketVO<any>, requestTime: number, endpoint?: string, log?: APIServiceNetworkLogItem | null, req?: HTTPRequestVO): Promise<void>;
     checkDataLength(data: any, result?: any, lvl?: number): any;
 }

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.1";
+    version = "2.1.3";
     options;
     monitor;
     monitorIndexFile;
@@ -154,10 +154,10 @@ class APIService extends BaseService_1.BaseService {
         app.use(express_1.default.urlencoded({ limit: '10mb', extended: true }));
         app.use((0, express_fileupload_1.default)({
             limitHandler: (req, res, next) => {
-                this.sendResponse(res, {
+                this.sendResponse(req.get("Referer") ?? "", res, {
                     error: DefaultErrors_1.default.FILE_TOO_LARGE,
                     data: null,
-                    httpStatus: 413
+                    httpStatus: 413,
                 }, +new Date(), req.path);
             },
             limits: { fileSize: this.options.fileLimit },
@@ -182,7 +182,7 @@ class APIService extends BaseService_1.BaseService {
             if (typeof err === "object" && err.status === 400 && 'body' in err && err.type === 'entity.parse.failed') {
                 responseError = DefaultErrors_1.default.JSON_MALFORMED;
             }
-            this.sendResponse(resp, {
+            this.sendResponse(req.get("Referer") ?? "", resp, {
                 error: responseError,
                 data: null,
                 httpStatus: 400
@@ -231,7 +231,8 @@ class APIService extends BaseService_1.BaseService {
                             params: req.params,
                             headers: req.headers,
                             endpoint: ep,
-                            files: req.files ?? null
+                            files: req.files ?? null,
+                            referer: req.get("Referer"),
                         };
                         if (this.options.preproducer) {
                             try {
@@ -240,7 +241,7 @@ class APIService extends BaseService_1.BaseService {
                                     httpRequest.preproducerResult = preproducerResult;
                             }
                             catch (e) {
-                                this.sendResponse(res, { error: { code: 10002, message: "Internal server error", details: `${e}` }, data: null, httpStatus: 500 }, tme, ep, log, httpRequest);
+                                this.sendResponse(req.get("Referer") ?? "", res, { error: { code: 10002, message: "Internal server error", details: `${e}` }, data: null, httpStatus: 500 }, tme, ep, log, httpRequest);
                                 return;
                             }
                         }
@@ -251,7 +252,7 @@ class APIService extends BaseService_1.BaseService {
                                 if (this.options.interceptor) {
                                     interceptorResult = await this.options.interceptor.execute(httpRequest);
                                     if (interceptorResult.error && !j.allowInterceptorError) {
-                                        this.sendResponse(res, interceptorResult, tme, ep, log, httpRequest);
+                                        this.sendResponse(req.get("Referer") ?? "", res, interceptorResult, tme, ep, log, httpRequest);
                                         return;
                                     }
                                     httpRequest.interceptorResult = interceptorResult;
@@ -261,7 +262,7 @@ class APIService extends BaseService_1.BaseService {
                                 httpRequest.precheck = { data: this.options.monitor };
                             const precheck = await i.precheck(httpRequest);
                             if (precheck && precheck.error) {
-                                this.sendResponse(res, precheck, tme, ep, log, httpRequest);
+                                this.sendResponse(req.get("Referer") ?? "", res, precheck, tme, ep, log, httpRequest);
                                 return;
                             }
                             httpRequest.precheck = precheck;
@@ -273,7 +274,7 @@ class APIService extends BaseService_1.BaseService {
                                 this.options.onError(e);
                             if (this.monitor)
                                 this.monitor.registrateFatalError(ep);
-                            this.sendResponse(res, {
+                            this.sendResponse(req.get("Referer") ?? "", res, {
                                 httpStatus: 500,
                                 error: {
                                     code: 10002,
@@ -283,7 +284,7 @@ class APIService extends BaseService_1.BaseService {
                             }, tme, ep, log, httpRequest);
                             return;
                         }
-                        this.sendResponse(res, result, tme, ep, log, httpRequest);
+                        this.sendResponse(req.get("Referer") ?? "", res, result, tme, ep, log, httpRequest);
                     };
                     execute();
                 });
@@ -311,7 +312,7 @@ class APIService extends BaseService_1.BaseService {
                             res.status(200).send(this.monitorIndexFile);
                         }
                         catch (e) {
-                            this.sendResponse(res, {
+                            this.sendResponse(req.get("Referer") ?? "", res, {
                                 error: {
                                     code: 10002,
                                     message: "Internal server error",
@@ -325,7 +326,7 @@ class APIService extends BaseService_1.BaseService {
                     }
                 }
             }
-            this.sendResponse(res, {
+            this.sendResponse(req.get("Referer") ?? "", res, {
                 error: DefaultErrors_1.default.UNKNOWN_REQUEST,
                 data: null,
                 httpStatus: 404
@@ -335,7 +336,7 @@ class APIService extends BaseService_1.BaseService {
             (0, LogService_1.logCrit)('${APIService.js}', 'API Service started at: ' + this.options.port + ", with base endpoint:" + this.options.baseEndPoint + ", ver.: " + this.version);
         });
     }
-    async sendResponse(res, data, requestTime, endpoint, log, req) {
+    async sendResponse(ref, res, data, requestTime, endpoint, log, req) {
         if (this.options.postproducer) {
             try {
                 data = await this.options.postproducer(req, res, data, requestTime, endpoint, log);
@@ -351,8 +352,10 @@ class APIService extends BaseService_1.BaseService {
         data.endpoint = endpoint ?? "no_endpoint";
         if (this.options.appVersion)
             data.version = this.options.appVersion;
-        if (log)
+        if (log) {
             log.time = data.responseTime;
+            log.referer = ref;
+        }
         if (this.monitor)
             this.monitor.registrateResponse(data.endpoint, data.responseTime);
         if (res.destroyed || res.closed) {
@@ -365,6 +368,24 @@ class APIService extends BaseService_1.BaseService {
         }
         else {
             try {
+                if (data.file) {
+                    res.sendFile(data.file, err => {
+                        if (err) {
+                            if (log)
+                                log.error = "Can't send file: " + data.file;
+                            if (this.options.onError)
+                                this.options.onError("Can't send file: " + data.file, err);
+                            if (this.monitor && data.endpoint)
+                                this.monitor.registrateAPIError(data.endpoint);
+                            this.sendResponse(ref, res, {
+                                error: DefaultErrors_1.default.CANT_SEND_FILE,
+                                data: null,
+                                httpStatus: 500
+                            }, requestTime, data.endpoint);
+                        }
+                    });
+                    return;
+                }
                 if (data.redirect) {
                     res.redirect(data.redirect);
                     if (log)

package/dist/apiServer/MysqlService.d.ts

@@ -18,6 +18,7 @@ export interface MysqlServiceOptions {
 }
 export interface MysqlResult {
     error?: MysqlError | null;
+    rollbackError?: MysqlError | null;
     isDuplicateError?: boolean;
     fields?: FieldInfo[] | null;
     data: any;
@@ -25,6 +26,7 @@ export interface MysqlResult {
 export interface MySqlQuery {
     query: string;
     fields: MysqlQueryField[] | MysqlQueryFieldObject;
+    rollbackQuery?: string | null;
 }
 export interface MysqlQueryField {
     name: string;
@@ -60,8 +62,13 @@ export declare class MysqlService extends BaseService {
     static objectToFields(obj: MysqlQueryFieldObject | MysqlQueryField[]): MysqlQueryField[];
     static prepareQuery(query: string, fields: MysqlQueryField[] | MysqlQueryFieldObject): 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;
+    execute(query: string, rollbackQuery: string | null): Promise<MysqlResult>;
+    sendQuery(conn: PoolConnection, query: string, resolve: (data: MysqlResult) => void, rollback: string | null): Promise<void>;
+    queryAsync(conn: PoolConnection, query: string): Promise<{
+        err: MysqlError | null;
+        results?: any;
+        fields?: FieldInfo[];
+    }>;
     createPool(): Promise<boolean>;
 }
 export default MysqlService;

package/dist/apiServer/MysqlService.js

@@ -66,7 +66,7 @@ class MysqlService extends BaseService_1.BaseService {
             const promises = [];
             for (let i of data) {
                 const query = MysqlService.prepareQuery(i.query, i.fields);
-                promises.push(this.execute(query));
+                promises.push(this.execute(query, i.rollbackQuery ?? null));
             }
             return await Promise.all(promises);
         };
@@ -206,7 +206,7 @@ class MysqlService extends BaseService_1.BaseService {
             return "NULL";
         return value;
     }
-    async execute(query) {
+    async execute(query, rollbackQuery) {
         return new Promise((resolve, reject) => {
             if (!this.pool) {
                 (0, LogService_1.logError)("${MysqlService.js}", "No pool");
@@ -252,40 +252,23 @@ class MysqlService extends BaseService_1.BaseService {
                         fields: null
                     });
                 }
-                try {
-                    this.sendQuery(conn, query, resolve);
-                }
-                catch (e) {
-                    try {
-                        conn.removeAllListeners();
-                        conn.release();
-                    }
-                    catch (e) { }
-                    (0, LogService_1.logError)("${MysqlService.js}", "QUERY_ERR: " + e);
-                    resolve({
-                        error: {
-                            code: "QUERY_ERR",
-                            errno: 100002,
-                            fatal: true,
-                            sql: query,
-                            name: "QUERY_ERR",
-                            message: "Error: " + e
-                        },
-                        data: null,
-                        fields: null
-                    });
-                }
+                this.sendQuery(conn, query, resolve, rollbackQuery);
             });
         });
     }
-    sendQuery(conn, query, resolve) {
+    async sendQuery(conn, query, resolve, rollback) {
         let errCatched = false;
-        conn.on("error", err => {
+        conn.on("error", async (err) => {
             errCatched = true;
-            conn.release();
-            conn.removeAllListeners();
-            (0, LogService_1.logError)("${MysqlService.js}", err);
-            conn.removeAllListeners();
+            let rollbackError = null;
+            if (rollback)
+                rollbackError = (await this.queryAsync(conn, rollback)).err;
+            (0, LogService_1.logError)("${MysqlService.js}->conn.on('error')", err);
+            try {
+                conn.release();
+                conn.removeAllListeners();
+            }
+            catch (e) { }
             resolve({
                 error: {
                     code: "CONN_ERR",
@@ -296,32 +279,65 @@ class MysqlService extends BaseService_1.BaseService {
                     message: "Error: " + err
                 },
                 data: null,
-                fields: null
+                fields: null,
+                rollbackError: rollbackError
             });
         });
         (0, LogService_1.logInfo)("${MysqlService.js}", query);
-        conn.query(query, (err, results, fields) => {
+        const queryResult = await this.queryAsync(conn, query);
+        if (queryResult.err) {
+            let rollbackError = null;
+            if (rollback)
+                rollbackError = (await this.queryAsync(conn, rollback)).err;
+            try {
+                conn.release();
+                conn.removeAllListeners();
+            }
+            catch (e) { }
+            const dup = `${queryResult.err}`.toLowerCase().indexOf("er_dup_entry") !== -1;
+            (0, LogService_1.logError)("${MysqlService.js}->query error", queryResult.err);
+            resolve({
+                error: queryResult.err,
+                data: null,
+                fields: null,
+                rollbackError: rollbackError,
+                isDuplicateError: dup
+            });
+        }
+        try {
             conn.release();
             conn.removeAllListeners();
-            if (errCatched)
-                return;
-            if (err) {
-                const dup = `${err}`.toLowerCase().indexOf("er_dup_entry") !== -1;
-                (0, LogService_1.logError)("${MysqlService.js}", err);
+        }
+        catch (e) { }
+        resolve({
+            error: queryResult.err,
+            data: queryResult.results,
+            fields: queryResult.fields
+        });
+    }
+    async queryAsync(conn, query) {
+        return new Promise((resolve, reject) => {
+            try {
+                conn.query(query, (err, results, fields) => {
+                    resolve({
+                        err: err,
+                        results: results,
+                        fields: fields
+                    });
+                });
+            }
+            catch (e) {
                 resolve({
-                    error: err,
-                    data: null,
-                    fields: null,
-                    isDuplicateError: dup
+                    err: {
+                        code: "QUERY_ERR",
+                        errno: 100002,
+                        fatal: true,
+                        sql: query,
+                        name: "QUERY_ERR",
+                        message: "Error: " + e
+                    }
                 });
-                return;
             }
-            resolve({
-                error: err,
-                data: results,
-                fields: fields
-            });
-            return;
         });
     }
     async createPool() {

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

@@ -4,6 +4,8 @@ declare class DefaultErrors {
     static UNKNOWN_REQUEST: IError;
     static JSON_MALFORMED: IError;
     static FILE_TOO_LARGE: IError;
+    static CANT_SEND_FILE: IError;
+    static FILE_NOT_EXISTS: IError;
 }
 export declare class ErrorUtils {
     static isError(obj: any): boolean;

package/dist/apiServer/structures/DefaultErrors.js

@@ -7,6 +7,8 @@ class DefaultErrors {
     static UNKNOWN_REQUEST = { code: 2, message: "Unknown request" };
     static JSON_MALFORMED = { code: 3, message: "JSON malformed" };
     static FILE_TOO_LARGE = { code: 4, message: "File is too large" };
+    static CANT_SEND_FILE = { code: 5, message: "Can't send file" };
+    static FILE_NOT_EXISTS = { code: 5, message: "File not exists" };
 }
 class ErrorUtils {
     static isError(obj) {

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

@@ -12,6 +12,7 @@ export interface TransferPacketVO<T = any> {
     headers?: {
         [key: string]: string;
     };
+    file?: string;
 }
 export interface HTTPRequestVO<T = any> {
     raw: any;
@@ -28,6 +29,7 @@ export interface HTTPRequestVO<T = any> {
     preproducerResult?: any;
     precheck?: TransferPacketVO<any> | null;
     files: FileArray | null | undefined;
+    referer?: string;
     unlocked?: boolean;
 }
 export interface IError {

package/package.json

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