badmfck-api-server 1.0.1

package/dist/apiServer/APIService.d.ts

@@ -0,0 +1,39 @@
+import { Response } from 'express';
+import { BaseService, IBaseService } from './BaseService';
+import { IBaseEndpoint } from './BaseEndpoint';
+import { SyncSignal } from '../signal/Signal';
+import { TransferPacketVO } from './structures/Interfaces';
+export interface APIServiceNetworkLogItem {
+    id: number;
+    created: number;
+    time: number;
+    request: {
+        [key: string]: any;
+    };
+    response: {
+        [key: string]: any;
+    };
+    error?: string | null;
+}
+export interface APIServiceOptions {
+    port: number;
+    baseEndPoint: string;
+    corsHostWhiteList: string[];
+    endpoints: IBaseEndpoint[];
+    jsonLimit: string;
+    onNetworkLog?: ((log: APIServiceNetworkLogItem) => void) | null;
+    onError?: ((...rest: any[]) => void) | null;
+}
+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 function Initializer(services: IBaseService[]): Promise<void>;
+export declare class APIService extends BaseService {
+    private static nextLogID;
+    private version;
+    private options;
+    netLog: APIServiceNetworkLogItem[];
+    constructor(options?: APIServiceOptions | null);
+    init(): Promise<void>;
+    sendResponse(res: Response, data: TransferPacketVO<any>, requestTime: number, endpoint?: string, log?: APIServiceNetworkLogItem | null): void;
+}

package/dist/apiServer/APIService.js

@@ -0,0 +1,169 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIService = exports.Initializer = exports.REQ_HTTP_LOG = exports.REQ_CREATE_NET_LOG = exports.getDefaultOptions = void 0;
+const express_1 = __importDefault(require("express"));
+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");
+function getDefaultOptions() {
+    return {
+        port: 8091,
+        baseEndPoint: '/api/',
+        corsHostWhiteList: [
+            'http://localhost:3000',
+            'http://localhost:8091'
+        ],
+        endpoints: [],
+        jsonLimit: "10mb",
+        onNetworkLog: function (log) {
+            console.log(log);
+        },
+        onError: function (err) {
+            console.error.call(this, err);
+        }
+    };
+}
+exports.getDefaultOptions = getDefaultOptions;
+exports.REQ_CREATE_NET_LOG = new Signal_1.SyncSignal();
+exports.REQ_HTTP_LOG = new Signal_1.SyncSignal();
+async function Initializer(services) {
+    for (let i of services) {
+        await i.init();
+    }
+    for (let i of services) {
+        i.applicationReady();
+    }
+}
+exports.Initializer = Initializer;
+class APIService extends BaseService_1.BaseService {
+    static nextLogID = 0;
+    version = "1.2.0";
+    options;
+    netLog = [];
+    constructor(options) {
+        super('HTTP Service');
+        this.options = options ?? getDefaultOptions();
+    }
+    async init() {
+        exports.REQ_HTTP_LOG.listener = (ignore, cb) => { cb(this.netLog); };
+        exports.REQ_CREATE_NET_LOG.listener = (ignore, cb) => {
+            const log = {
+                created: +new Date(),
+                time: 0,
+                request: {},
+                response: {},
+                error: null,
+                id: APIService.nextLogID++
+            };
+            this.netLog.push(log);
+            if (this.netLog.length > 1000)
+                this.netLog.shift();
+            cb(log);
+        };
+        const app = (0, express_1.default)();
+        app.use(express_1.default.json({ limit: '10mb' }));
+        app.use(express_1.default.urlencoded({ limit: '10mb', extended: true }));
+        const corsOptions = {
+            origin: (origin, callback) => {
+                const originIsWhitelisted = this.options.corsHostWhiteList.includes(origin);
+                callback(null, originIsWhitelisted);
+            },
+            credentials: true
+        };
+        app.use((0, cors_1.default)(corsOptions));
+        BaseEndpoint_1.BaseEndpoint.setEntryPoint(this.options.baseEndPoint);
+        for (let i of this.options.endpoints) {
+            await i.init();
+            for (let j of i.endpoints) {
+                const ep = BaseEndpoint_1.BaseEndpoint.getEntryPoint() + j;
+                app.all(ep, async (req, res) => {
+                    const tme = +new Date();
+                    let log = null;
+                    if (!i.ignoreHttpLogging) {
+                        log = await exports.REQ_CREATE_NET_LOG.request();
+                        log.request = {
+                            method: req.method,
+                            data: req.body,
+                            params: req.params
+                        };
+                    }
+                    if (this.options.onNetworkLog && log)
+                        this.options.onNetworkLog(log);
+                    const execute = async () => {
+                        const httpRequest = {
+                            raw: req,
+                            method: req.method,
+                            data: req.body,
+                            params: req.params,
+                            headers: req.headers,
+                            endpoint: ep
+                        };
+                        const result = await i.execute(httpRequest);
+                        this.sendResponse(res, result, tme, ep, log);
+                    };
+                    execute();
+                });
+            }
+        }
+        app.use((req, res, next) => {
+            const tme = +new Date();
+            this.sendResponse(res, {
+                error: DefaultErrors_1.default.UNKNOWN_REQUEST,
+                data: null,
+                httpStatus: 404
+            }, tme, req.path);
+        });
+        app.listen(this.options.port, () => {
+            console.log('API Service started at: ' + this.options.port + ", with base endpoint:" + this.options.baseEndPoint + ", ver.: " + this.version);
+        });
+    }
+    sendResponse(res, data, requestTime, endpoint, log) {
+        data.responseTime = (+new Date()) - requestTime;
+        data.version = this.version;
+        data.endpoint = endpoint ?? "no_endpoint";
+        if (log)
+            log.time = data.responseTime;
+        if (res.destroyed || res.closed) {
+            if (log)
+                log.error = "Connection already closed, can't send response";
+            if (this.options.onError)
+                this.options.onError("Connection already closed, can't send response", data);
+        }
+        else {
+            try {
+                if (data.redirect) {
+                    res.redirect(data.redirect);
+                    if (log)
+                        log.response = { redirect: data.redirect };
+                }
+                else {
+                    res.statusCode = data.httpStatus ?? 200;
+                    if (data.rawResponse) {
+                        res.send(data.data);
+                        if (log)
+                            log.response = data.data;
+                    }
+                    else {
+                        res.send(data);
+                        if (log)
+                            log.response = data;
+                    }
+                }
+            }
+            catch (e) {
+                if (this.options.onError)
+                    this.options.onError("Can't send response", e);
+                if (log)
+                    log.error = "Can't send response";
+            }
+        }
+        if (this.options.onNetworkLog && log)
+            this.options.onNetworkLog(log);
+    }
+}
+exports.APIService = APIService;

package/dist/apiServer/BaseEndpoint.d.ts

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

package/dist/apiServer/BaseEndpoint.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseEndpoint = void 0;
+const DefaultErrors_1 = __importDefault(require("./structures/DefaultErrors"));
+class BaseEndpoint {
+    ignoreHttpLogging = false;
+    static entrypoint = "/";
+    static setEntryPoint = (ep) => {
+        this.entrypoint = ep;
+        if (!this.entrypoint.endsWith("/")) {
+            this.entrypoint += "/";
+        }
+        if (!ep.startsWith("/"))
+            this.entrypoint = "/" + ep;
+    };
+    static getEntryPoint = () => {
+        return this.entrypoint;
+    };
+    endpoints;
+    constructor(ep) {
+        if (typeof ep === "string")
+            ep = [ep];
+        let eps = [];
+        for (let i of ep) {
+            if (i.startsWith("/"))
+                i = i.substring(1);
+            eps.push(i);
+        }
+        this.endpoints = eps;
+    }
+    async init() {
+        for (let i of this.endpoints)
+            console.log("endpoint: " + BaseEndpoint.entrypoint + i + " initalized");
+    }
+    ;
+    async execute(req) {
+        return {
+            error: DefaultErrors_1.default.NOT_IMPLEMENTED,
+            data: null
+        };
+    }
+}
+exports.BaseEndpoint = BaseEndpoint;

package/dist/apiServer/BaseService.d.ts

@@ -0,0 +1,10 @@
+export interface IBaseService {
+    init: () => Promise<void>;
+    applicationReady: () => void;
+}
+export declare class BaseService implements IBaseService {
+    protected name: string;
+    constructor(name: string);
+    init(): Promise<void>;
+    applicationReady(): void;
+}

package/dist/apiServer/BaseService.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseService = void 0;
+class BaseService {
+    name;
+    constructor(name) {
+        this.name = name;
+    }
+    async init() {
+        console.log("Service: " + this.name + " initialized");
+    }
+    applicationReady() { }
+}
+exports.BaseService = BaseService;

package/dist/apiServer/LocalRequest.d.ts

@@ -0,0 +1,3 @@
+export declare const LocalRequest: (ep: string, data?: any, method?: string, headers?: {
+    [key: string]: string;
+} | undefined) => Promise<void>;

package/dist/apiServer/LocalRequest.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalRequest = void 0;
+const axios_1 = __importDefault(require("axios"));
+axios_1.default.interceptors.request.use((x) => {
+    console.log(`AXIOS REQ:\n\turl:${x.url}\n\tmethod: ${x.method}\n\tdata: ${(() => {
+        if (typeof x.data === "string")
+            return x.data;
+        return JSON.stringify(x.data, null, "\t\t");
+    })()}\n\theaders:\n${(() => {
+        let h = "";
+        for (let i in x.headers) {
+            if (h !== "")
+                h += "\n";
+            h += "\t\t" + i + " = " + x.headers[i];
+        }
+        return h;
+    })()}`);
+    return x;
+});
+axios_1.default.interceptors.response.use((x) => {
+    console.log(`AXIOS RESP:\n\tdata: ${(() => {
+        if (typeof x.data === "string")
+            return x.data;
+        return JSON.stringify(x.data, null, "\t\t");
+    })()}\n\theaders:\n${(() => {
+        let h = "";
+        for (let i in x.headers) {
+            if (h !== "")
+                h += "\n";
+            h += "\t\t" + i + " = " + x.headers[i];
+        }
+        return h;
+    })()}`);
+    return x;
+});
+const LocalRequest = async (ep, data, method, headers) => {
+    let m = "get";
+    if (method)
+        m = method.toLowerCase();
+    if (data && !method)
+        m = "post";
+    if (ep.startsWith("/"))
+        ep = ep.substring(1);
+    let url = "http://localhost:8091/" + ep;
+    if (ep.toLowerCase().startsWith("http"))
+        url = ep;
+    let resp = null;
+    console.log("open url: ", url);
+    try {
+        if (m === "get")
+            resp = await axios_1.default.get(url, { headers: headers });
+        if (m === "post")
+            resp = await axios_1.default.post(url, data, { headers: headers });
+    }
+    catch (e) {
+        console.log("ERROR! cant open url", e);
+    }
+    console.log(resp);
+};
+exports.LocalRequest = LocalRequest;

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

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

package/dist/apiServer/structures/DefaultErrors.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class DefaultErrors {
+    static NOT_IMPLEMENTED = { code: 1, message: "Not implemented" };
+    static UNKNOWN_REQUEST = { code: 2, message: "Unknown request" };
+}
+exports.default = DefaultErrors;

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

@@ -0,0 +1,7 @@
+export declare enum HTTP_STATUS {
+    OK = 200,
+    NOT_FOUND = 404,
+    UNAUTHORIZED = 401,
+    BAD_REQUEST = 400,
+    SERVER_ERROR = 500
+}

package/dist/apiServer/structures/HTTPStatus.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTTP_STATUS = void 0;
+var HTTP_STATUS;
+(function (HTTP_STATUS) {
+    HTTP_STATUS[HTTP_STATUS["OK"] = 200] = "OK";
+    HTTP_STATUS[HTTP_STATUS["NOT_FOUND"] = 404] = "NOT_FOUND";
+    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 = {}));

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

@@ -0,0 +1,25 @@
+export interface TransferPacketVO<T> {
+    data?: T | null;
+    error?: ErrorVO | null;
+    responseTime?: number;
+    version?: string;
+    endpoint?: string;
+    httpStatus?: number;
+    redirect?: string;
+    rawResponse?: boolean;
+}
+export interface HTTPRequestVO {
+    raw: any;
+    method: string;
+    data: any;
+    params: {
+        [key: string]: string;
+    };
+    headers: any;
+    endpoint: string;
+}
+export interface ErrorVO {
+    code: number;
+    message: string;
+    details?: string;
+}

package/dist/apiServer/structures/Interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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; } });

package/dist/signal/Signal.d.ts

@@ -0,0 +1,28 @@
+declare class Signal<T> {
+    static nextID: number;
+    private busy;
+    private tempAdd;
+    private tempRem;
+    private tempInvoke;
+    private callbacks;
+    private tempClear;
+    constructor(name?: string);
+    add(callback: (data: T) => void, id?: string): string;
+    clear(): void;
+    remove(callback?: (data: T) => void, id?: string): string | undefined;
+    invoke(data: T): void;
+}
+export declare class SignalHandler {
+    static nextID: number;
+    private id;
+    private signals;
+    constructor();
+    add<T>(signal: Signal<T>, cb: (data: T) => void): void;
+    clear(): void;
+}
+export declare class SyncSignal<T, K> {
+    private worker?;
+    request(data: T): Promise<K>;
+    set listener(_listener: (request: T, response: (data: K) => void) => void);
+}
+export default Signal;

package/dist/signal/Signal.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyncSignal = exports.SignalHandler = void 0;
+class Signal {
+    static nextID = 0;
+    busy = false;
+    tempAdd = [];
+    tempRem = [];
+    tempInvoke = [];
+    callbacks = [];
+    tempClear = false;
+    constructor(name) { }
+    add(callback, id) {
+        if (!id)
+            id = "" + (Signal.nextID++);
+        if (this.busy) {
+            for (let i of this.tempAdd) {
+                if (i.cb === callback)
+                    return i.id;
+            }
+            this.tempAdd.push({ cb: callback, id: id });
+            return id;
+        }
+        for (let i of this.callbacks) {
+            if (i.cb === callback)
+                return i.id;
+        }
+        this.callbacks.push({ cb: callback, id: id });
+        return id;
+    }
+    clear() {
+        if (this.busy) {
+            this.tempClear = true;
+            return;
+        }
+        this.callbacks = [];
+    }
+    remove(callback, id) {
+        if (!callback && !id)
+            return;
+        if (this.busy) {
+            for (let i of this.tempRem) {
+                if (callback) {
+                    if (i.cb === callback)
+                        return;
+                }
+                if (id) {
+                    if (i.id === id)
+                        return;
+                }
+            }
+            this.tempRem.push({ cb: callback, id: id });
+            return id;
+        }
+        for (let i = 0; i < this.callbacks.length; i++) {
+            const itm = this.callbacks[i];
+            let remove = false;
+            if (callback)
+                remove = itm.cb === callback;
+            if (id)
+                remove = remove || itm.id === id;
+            if (remove) {
+                this.callbacks.splice(i, 1);
+                i--;
+            }
+        }
+    }
+    invoke(data) {
+        if (this.busy) {
+            this.tempInvoke.push({ data: data });
+            return;
+        }
+        this.busy = true;
+        for (let i of this.callbacks) {
+            if (i && i.cb && typeof i.cb === "function") {
+                i.cb(data);
+            }
+        }
+        this.busy = false;
+        for (let i of this.tempAdd) {
+            this.add(i.cb, i.id);
+        }
+        this.tempAdd = [];
+        for (let i of this.tempRem) {
+            this.remove(i.cb, i.id);
+        }
+        this.tempRem = [];
+        for (let i of this.tempInvoke) {
+            this.invoke(i.data);
+        }
+        if (this.tempClear)
+            this.clear();
+    }
+}
+class SignalHandler {
+    static nextID = 0;
+    id;
+    signals = [];
+    constructor() {
+        this.id = SignalHandler.nextID++;
+    }
+    add(signal, cb) {
+        let added = false;
+        for (let i of this.signals) {
+            if (i === signal) {
+                added = true;
+                break;
+            }
+        }
+        if (!added)
+            this.signals.push(signal);
+        signal.add(cb, "signaller_" + this.id);
+    }
+    clear() {
+        for (let i of this.signals)
+            i.remove(undefined, "signaller_" + this.id);
+        this.signals = [];
+    }
+}
+exports.SignalHandler = SignalHandler;
+class SyncSignal {
+    worker;
+    request(data) {
+        const executor = (resolve, reject) => {
+            if (!this.worker) {
+                console.error("No worker registered in SyncSignal");
+                reject("No worker registered in SyncSignal");
+                return;
+            }
+            this.worker(data, resolve);
+        };
+        const promise = new Promise(executor);
+        return promise;
+    }
+    set listener(_listener) {
+        this.worker = _listener;
+    }
+}
+exports.SyncSignal = SyncSignal;
+exports.default = Signal;

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "badmfck-api-server",
+  "version": "1.0.1",
+  "description": "Simple API http server based on express",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "prepublish": "tsc",
+    "build":"tsc",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "api",
+    "rest",
+    "http",
+    "server",
+    "express"
+  ],
+  "dependencies": {
+    "axios": "^1.4.0",
+    "badmfck-signal": "^1.0.1",
+    "cors": "^2.8.5",
+    "express": "^4.18.2"
+  },
+  "devDependencies": {
+    "@types/cors": "^2.8.13",
+    "@types/express": "^4.17.17"
+  },
+  "author": "Igor Bloom",
+  "license": "MIT"
+}