badmfck-api-server 1.2.7 → 1.2.9

package/dist/apiServer/APIService.d.ts

@@ -24,6 +24,7 @@ export interface APIServiceOptions {
     onNetworkLog?: ((log: APIServiceNetworkLogItem) => void) | null;
     onError?: ((...rest: any[]) => void) | null;
     isProductionEnvironment: boolean;
+    interceptor?: IBaseEndpoint;
 }
 export declare function getDefaultOptions(): APIServiceOptions;
 export declare const REQ_CREATE_NET_LOG: Req<void, APIServiceNetworkLogItem>;

package/dist/apiServer/APIService.js

@@ -108,8 +108,10 @@ class APIService extends BaseService_1.BaseService {
         BaseEndpoint_1.BaseEndpoint.setEntryPoint(this.options.baseEndPoint);
         for (let i of this.options.endpoints) {
             await i.init();
+            if (!i.endpoints)
+                continue;
             for (let j of i.endpoints) {
-                const ep = BaseEndpoint_1.BaseEndpoint.getEntryPoint() + j;
+                const ep = BaseEndpoint_1.BaseEndpoint.getEntryPoint() + j.endpoint;
                 app.all(ep, async (req, res) => {
                     const tme = +new Date();
                     let log = null;
@@ -130,10 +132,19 @@ class APIService extends BaseService_1.BaseService {
                             data: req.body,
                             params: req.params,
                             headers: req.headers,
-                            endpoint: ep
+                            endpoint: ep,
                         };
                         let result;
                         try {
+                            let interceptorResult;
+                            if (this.options.interceptor) {
+                                interceptorResult = await this.options.interceptor.execute(httpRequest);
+                                if (interceptorResult.error) {
+                                    this.sendResponse(res, interceptorResult, tme, ep, log);
+                                    return;
+                                }
+                                httpRequest.interceptorResult = interceptorResult;
+                            }
                             result = await i.execute(httpRequest);
                         }
                         catch (e) {

package/dist/apiServer/BaseEndpoint.d.ts

@@ -1,6 +1,6 @@
 import { HTTPRequestVO, TransferPacketVO } from "./structures/Interfaces";
 export interface IBaseEndpoint {
-    endpoints: string[];
+    endpoints?: IEndpointHandler[];
     execute: (req: HTTPRequestVO) => Promise<TransferPacketVO<any>>;
     init: () => Promise<void>;
     ignoreHttpLogging: boolean;
@@ -10,13 +10,14 @@ export interface IEndpointHandler {
     handler: (req: HTTPRequestVO) => Promise<TransferPacketVO<any>>;
 }
 export declare class BaseEndpoint implements IBaseEndpoint {
+    endpoints?: IEndpointHandler[];
     ignoreHttpLogging: boolean;
     private static entrypoint;
-    private endpointHandlers;
+    private endpoint;
     static setEntryPoint: (ep: string) => void;
     static getEntryPoint: () => string;
-    endpoints: string[];
-    constructor(ep: string | string[] | IEndpointHandler[]);
+    constructor(endpoint: string);
+    registerEndpoints(endpoints: IEndpointHandler[]): void;
     init(): Promise<void>;
     execute(req: HTTPRequestVO): Promise<TransferPacketVO<any>>;
 }

package/dist/apiServer/BaseEndpoint.js

@@ -6,9 +6,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseEndpoint = void 0;
 const DefaultErrors_1 = __importDefault(require("./structures/DefaultErrors"));
 class BaseEndpoint {
+    endpoints;
     ignoreHttpLogging = false;
     static entrypoint = "/";
-    endpointHandlers = [];
+    endpoint = "";
     static setEntryPoint = (ep) => {
         this.entrypoint = ep;
         if (!this.entrypoint.endsWith("/")) {
@@ -20,37 +21,36 @@ class BaseEndpoint {
     static getEntryPoint = () => {
         return this.entrypoint;
     };
-    endpoints;
-    constructor(ep) {
-        if (typeof ep === "string")
-            ep = [ep];
-        let eps = [];
-        for (let i of ep) {
-            if (typeof i === "object" && "endpoint" in i && "handler" in i) {
-                if (i.endpoint.startsWith("/"))
-                    i.endpoint = i.endpoint.substring(1);
-                eps.push(i.endpoint);
-                this.endpointHandlers.push(i);
-                continue;
-            }
-            if (typeof i === "string") {
-                if (i.startsWith("/"))
-                    i = i.substring(1);
-                eps.push(i);
-                continue;
-            }
+    constructor(endpoint) {
+        if (endpoint.startsWith("/"))
+            endpoint = endpoint.substring(1);
+        if (!endpoint.endsWith("/"))
+            endpoint = endpoint + "/";
+        this.endpoint = endpoint;
+    }
+    registerEndpoints(endpoints) {
+        for (let i of endpoints) {
+            if (i.endpoint.startsWith("/"))
+                i.endpoint = i.endpoint.substring(1);
+            if (i.endpoint.endsWith("/"))
+                i.endpoint = i.endpoint.substring(0, i.endpoint.length - 1);
+            i.endpoint = this.endpoint + i.endpoint;
         }
-        this.endpoints = eps;
+        this.endpoints = endpoints;
     }
     async init() {
+        if (!this.endpoints) {
+            console.error("No endpoints registered for " + this.endpoint);
+            return;
+        }
         for (let i of this.endpoints)
-            console.log("endpoint: " + BaseEndpoint.entrypoint + i + " initalized");
+            console.log("endpoint: " + i.endpoint + " initalized");
     }
     ;
     async execute(req) {
-        if (this.endpointHandlers && this.endpointHandlers.length > 0) {
-            for (let i of this.endpointHandlers) {
-                if (BaseEndpoint.entrypoint + i.endpoint === req.endpoint)
+        if (this.endpoints && this.endpoints.length > 0) {
+            for (let i of this.endpoints) {
+                if (i.endpoint === req.endpoint)
                     return i.handler(req);
             }
         }

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

@@ -20,6 +20,7 @@ export interface HTTPRequestVO {
     };
     headers: any;
     endpoint: string;
+    interceptorResult?: TransferPacketVO<any>;
 }
 export interface ErrorVO {
     code: number;

package/package.json

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