@bool-ts/core 1.0.11 → 1.1.1

package/src/hooks/factory.ts

@@ -1,181 +1,193 @@
-import "reflect-metadata";
-import "colors";
-
-import * as Qs from "qs";
-import * as ResponseTime from "response-time";
-
-import { type IControllerRoute, type TModuleOptions, controllerKey, controllerRoutesKey, moduleKey } from "../decorators";
-import { default as ExpressApp, Router, json, urlencoded, Request, Response, NextFunction, Errback } from "express";
-import { Injector } from "./injector";
-
-
-/**
- * 
- * @param target 
- * @param router 
- */
-const controllerCreator = (
-    target: new (...args: any[]) => unknown,
-    router = Router()
-) => {
-    if (!Reflect.getOwnMetadataKeys(target).includes(controllerKey)) {
-        throw Error(`${target.name} is not a controller.`);
-    }
-
-    const controller = Injector.get(target);
-
-    if (!controller) {
-        throw Error("Can not initialize controller.");
-    }
-
-    const controllerMetadata = Reflect.getOwnMetadata(controllerKey, target) || "/";
-    const routesMetadata = (Reflect.getOwnMetadata(controllerRoutesKey, target) || []) as Array<IControllerRoute>;
-    const innerRouter = router.route(controllerMetadata);
-
-    routesMetadata.forEach(route => {
-        if (typeof route.descriptor.value !== "function") {
-            return;
-        }
-
-        switch (route.httpMethod) {
-            case "GET":
-                return innerRouter.get(route.descriptor.value.bind(controller));
-            case "POST":
-                return innerRouter.post(route.descriptor.value.bind(controller));
-            case "PUT":
-                return innerRouter.put(route.descriptor.value.bind(controller));
-            case "PATCH":
-                return innerRouter.patch(route.descriptor.value.bind(controller));
-            case "DELETE":
-                return innerRouter.delete(route.descriptor.value.bind(controller));
-            case "OPTIONS":
-                return innerRouter.options(route.descriptor.value.bind(controller));
-        }
-    });
-
-    return router;
-}
-
-
-/**
- * 
- * @param target 
- */
-export const BoolFactory = (
-    target: new (...args: any[]) => unknown
-) => {
-    if (!Reflect.getOwnMetadataKeys(target).includes(moduleKey)) {
-        throw Error(`${target.name} is not a module.`);
-    }
-
-    const metadata = Reflect.getOwnMetadata(moduleKey, target) as TModuleOptions;
-    const routers = !metadata?.controllers ? [] : metadata.controllers.map(controllerConstructor => controllerCreator(controllerConstructor));
-    const allowOrigins = !metadata?.allowOrigins ?
-        ["*"] : typeof metadata.allowOrigins !== "string" ?
-            metadata.allowOrigins : [metadata.allowOrigins];
-    const allowMethods = !metadata?.allowMethods ?
-        ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"] : metadata.allowMethods;
-    const app = ExpressApp();
-    const configs = Object.freeze({
-        allowLogsMethods: [
-            "GET",
-            "POST",
-            "PUT",
-            "PATCH",
-            "DELETE"
-        ]
-    });
-
-    app.set("etag", "strong");
-    app.set("query parser", (query: string) => Qs.parse(query, {
-        depth: 10,
-        arrayLimit: 50
-    }));
-
-    app.use(
-        urlencoded({
-            extended: true,
-            inflate: true,
-            limit: "1mb",
-            parameterLimit: 20,
-            type: "application/x-www-form-urlencoded",
-            verify: undefined
-        }),
-        json({
-            inflate: true,
-            limit: "5mb",
-            reviver: undefined,
-            strict: true,
-            type: "application/json",
-            verify: undefined
-        }),
-        // Headers parser
-        (req: Request, res: Response, next: NextFunction) => {
-            for (const [key, value] of Object.entries(req.headers)) {
-                req.headers[key] = typeof value !== "string" ? value : decodeURI(value)
-            }
-
-            next();
-        },
-        // Body parser
-        (req: Request, res: Response, next: NextFunction) => {
-            if (typeof req.body !== "object" || !req.body) {
-                req.body = Object.freeze({});
-            }
-
-            next();
-        },
-        // Error catcher
-        (err: Errback, req: Request, res: Response, next: NextFunction) => {
-            console.error(err);
-
-            next();
-        },
-        // Response time log
-        ResponseTime.default((req: Request, res: Response, time: number) => {
-            const requestMethod = req.method.toUpperCase();
-
-            if (!configs.allowLogsMethods.includes(requestMethod)) {
-                return;
-            }
-
-            const convertedMethod = `${requestMethod.yellow}`.bgBlue;
-            const convertedPID = `${process.pid}`.yellow;
-            const convertedReqIp = `${req.headers["x-forwarded-for"] || req.headers["x-real-ip"] || req.ip || "<Unknown>"}`.yellow;
-            const convertedTime = `${Math.round((time + Number.EPSILON) * 10 ** 2) / 10 ** 2}ms`.yellow;
-
-            console.info(`PID: ${convertedPID} - Method: ${convertedMethod} - IP: ${convertedReqIp} - ${req.originalUrl.blue} - Time: ${convertedTime}`);
-        })
-    );
-
-    app.use((req: Request, res: Response, next: NextFunction) => {
-        if (!allowOrigins.includes("*")) {
-            if (!allowOrigins.includes(req.headers.origin || "*")) {
-                return res.status(403).json({
-                    httpCode: 403,
-                    data: {
-                        origin: {
-                            code: "origin:invalid:0x00001",
-                            message: "Invalid origin."
-                        }
-                    }
-                });
-            }
-        }
-
-        res.header("Access-Control-Allow-Origin", req.headers.origin || "*");
-        res.header("Access-Control-Allow-Headers", "*");
-        res.header("Access-Control-Allow-Credentials", "true");
-        res.header("Access-Control-Allow-Methods", allowMethods.join(", "));
-
-        next();
-    });
-
-    if (routers.length > 0) {
-        app.use(routers);
-    }
-
-    return app;
-}
-
-export default BoolFactory;
+import "reflect-metadata";
+import "colors";
+
+import * as Qs from "qs";
+import * as ResponseTime from "response-time";
+
+import { type IControllerRoute, type TModuleOptions, controllerKey, controllerRoutesKey, moduleKey } from "../decorators";
+import { default as ExpressApp, Router, json, urlencoded, Request, Response, NextFunction, Errback } from "express";
+import { Injector } from "./injector";
+import { errorInfer } from "../http";
+
+
+export type TBoolFactoryOptions = Partial<{
+    debug: boolean;
+    log: Partial<{
+        methods: Array<"GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS">;
+    }>;
+    queryParser: Partial<{
+        depth: 10,
+        arrayLimit: 50
+    }>;
+}>;
+
+
+/**
+ * 
+ * @param target 
+ * @param router 
+ */
+const controllerCreator = (
+    target: new (...args: any[]) => unknown,
+    router = Router()
+) => {
+    if (!Reflect.getOwnMetadataKeys(target).includes(controllerKey)) {
+        throw Error(`${target.name} is not a controller.`);
+    }
+
+    const controller = Injector.get(target);
+
+    if (!controller) {
+        throw Error("Can not initialize controller.");
+    }
+
+    const controllerMetadata = Reflect.getOwnMetadata(controllerKey, target) || "/";
+    const routesMetadata = (Reflect.getOwnMetadata(controllerRoutesKey, target) || []) as Array<IControllerRoute>;
+    const innerRouter = router.route(controllerMetadata);
+
+    routesMetadata.forEach(route => {
+        if (typeof route.descriptor.value !== "function") {
+            return;
+        }
+
+        switch (route.httpMethod) {
+            case "GET":
+                return innerRouter.get(route.descriptor.value.bind(controller));
+            case "POST":
+                return innerRouter.post(route.descriptor.value.bind(controller));
+            case "PUT":
+                return innerRouter.put(route.descriptor.value.bind(controller));
+            case "PATCH":
+                return innerRouter.patch(route.descriptor.value.bind(controller));
+            case "DELETE":
+                return innerRouter.delete(route.descriptor.value.bind(controller));
+            case "OPTIONS":
+                return innerRouter.options(route.descriptor.value.bind(controller));
+        }
+    });
+
+    return router;
+}
+
+
+/**
+ * 
+ * @param target 
+ */
+export const BoolFactory = (
+    target: new (...args: any[]) => unknown,
+    options?: TBoolFactoryOptions
+) => {
+    if (!Reflect.getOwnMetadataKeys(target).includes(moduleKey)) {
+        throw Error(`${target.name} is not a module.`);
+    }
+
+    const metadata = Reflect.getOwnMetadata(moduleKey, target) as TModuleOptions;
+    const routers = !metadata?.controllers ? [] : metadata.controllers.map(controllerConstructor => controllerCreator(controllerConstructor));
+    const allowOrigins = !metadata?.allowOrigins ?
+        ["*"] : typeof metadata.allowOrigins !== "string" ?
+            metadata.allowOrigins : [metadata.allowOrigins];
+    const allowMethods = !metadata?.allowMethods ?
+        ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"] : metadata.allowMethods;
+    const app = ExpressApp();
+    const factoryOptions = Object.freeze({
+        allowLogsMethods: !options?.log?.methods ? ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"] : options.log.methods
+    });
+
+    app.set("etag", "strong");
+    app.set("query parser", (query: string) => Qs.parse(query, {
+        depth: !options?.queryParser?.depth || options.queryParser.depth < 0 ? 10 : options.queryParser.depth,
+        arrayLimit: !options?.queryParser?.arrayLimit || options.queryParser.arrayLimit < 0 ? 50 : options.queryParser.arrayLimit
+    }));
+
+    app.use(
+        urlencoded({
+            extended: true,
+            inflate: true,
+            limit: "1mb",
+            parameterLimit: 20,
+            type: "application/x-www-form-urlencoded",
+            verify: undefined
+        }),
+        json({
+            inflate: true,
+            limit: "5mb",
+            reviver: undefined,
+            strict: true,
+            type: "application/json",
+            verify: undefined
+        }),
+        // Headers parser
+        (req: Request, res: Response, next: NextFunction) => {
+            for (const [key, value] of Object.entries(req.headers)) {
+                req.headers[key] = typeof value !== "string" ? value : decodeURI(value)
+            }
+
+            next();
+        },
+        // Body parser
+        (req: Request, res: Response, next: NextFunction) => {
+            if (typeof req.body !== "object" || !req.body) {
+                req.body = Object.freeze({});
+            }
+
+            next();
+        },
+        // Error catcher
+        (err: Errback, req: Request, res: Response, next: NextFunction) => {
+            errorInfer(res, err);
+
+            if (!options?.debug) {
+                return;
+            }
+
+            console.error("Headers:", JSON.stringify(req.headers), "\nBody:", JSON.stringify(req.body), "\nError:", JSON.stringify(err));
+        },
+        // Response time log
+        ResponseTime.default((req: Request, res: Response, time: number) => {
+            const requestMethod = req.method.toUpperCase();
+
+            if (!factoryOptions.allowLogsMethods.includes(requestMethod)) {
+                return;
+            }
+
+            const convertedMethod = `${requestMethod.yellow}`.bgBlue;
+            const convertedPID = `${process.pid}`.yellow;
+            const convertedReqIp = `${req.headers["x-forwarded-for"] || req.headers["x-real-ip"] || req.ip || "<Unknown>"}`.yellow;
+            const convertedTime = `${Math.round((time + Number.EPSILON) * 10 ** 2) / 10 ** 2}ms`.yellow;
+
+            console.info(`PID: ${convertedPID} - Method: ${convertedMethod} - IP: ${convertedReqIp} - ${req.originalUrl.blue} - Time: ${convertedTime}`);
+        })
+    );
+
+    app.use((req: Request, res: Response, next: NextFunction) => {
+        if (!allowOrigins.includes("*")) {
+            if (!allowOrigins.includes(req.headers.origin || "*")) {
+                return res.status(403).json({
+                    httpCode: 403,
+                    data: {
+                        origin: {
+                            code: "origin:invalid:0x00001",
+                            message: "Invalid origin."
+                        }
+                    }
+                });
+            }
+        }
+
+        res.header("Access-Control-Allow-Origin", req.headers.origin || "*");
+        res.header("Access-Control-Allow-Headers", "*");
+        res.header("Access-Control-Allow-Credentials", "true");
+        res.header("Access-Control-Allow-Methods", allowMethods.join(", "));
+
+        next();
+    });
+
+    if (routers.length > 0) {
+        app.use(routers);
+    }
+
+    return app;
+}
+
+export default BoolFactory;

package/src/hooks/index.ts

@@ -1,2 +1,2 @@
-export { BoolFactory } from "./factory";
-export { Injector } from "./injector";
+export { BoolFactory } from "./factory";
+export { Injector } from "./injector";

package/src/hooks/injector.ts

@@ -1,43 +1,43 @@
-import "reflect-metadata";
-
-import { injectableKey, injectKey } from "../decorators";
-
-
-interface IInjector {
-    get<T>(classDefinition: { new(...args: any[]): T }): T
-}
-
-export const Injector: IInjector = new class {
-
-    private readonly _mapper: Map<Function, any> = new Map();
-
-    /**
-     * 
-     * @param constructor 
-     */
-    get<T>(
-        classDefinition: { new(...args: any[]): T }
-    ) {
-        if (this._mapper.has(classDefinition)) {
-            return this._mapper.get(classDefinition) as T;
-        }
-
-        const ownMetadataKeys = Reflect.getMetadataKeys(classDefinition);
-
-        if (!ownMetadataKeys.includes(injectableKey)) {
-            throw Error("Missing dependency declaration, please check @Injectable() used on dependency(ies).");
-        }
-
-        // Initialize dependencies injection
-        const dependencies: any[] = Reflect.getOwnMetadata(injectKey, classDefinition) || [];
-        const injections: any[] = dependencies.map(dependency => Injector.get(dependency));
-        const instance = new classDefinition(...injections);
-
-        this._mapper.set(classDefinition, instance);
-
-        return instance;
-    }
-
-}
-
-export default Injector;
+import "reflect-metadata";
+
+import { injectableKey, injectKey } from "../decorators";
+
+
+interface IInjector {
+    get<T>(classDefinition: { new(...args: any[]): T }): T
+}
+
+export const Injector: IInjector = new class {
+
+    private readonly _mapper: Map<Function, any> = new Map();
+
+    /**
+     * 
+     * @param constructor 
+     */
+    get<T>(
+        classDefinition: { new(...args: any[]): T }
+    ) {
+        if (this._mapper.has(classDefinition)) {
+            return this._mapper.get(classDefinition) as T;
+        }
+
+        const ownMetadataKeys = Reflect.getMetadataKeys(classDefinition);
+
+        if (!ownMetadataKeys.includes(injectableKey)) {
+            throw Error("Missing dependency declaration, please check @Injectable() used on dependency(ies).");
+        }
+
+        // Initialize dependencies injection
+        const dependencies: any[] = Reflect.getOwnMetadata(injectKey, classDefinition) || [];
+        const injections: any[] = dependencies.map(dependency => Injector.get(dependency));
+        const instance = new classDefinition(...injections);
+
+        this._mapper.set(classDefinition, instance);
+
+        return instance;
+    }
+
+}
+
+export default Injector;

package/src/http/clientError.ts

@@ -0,0 +1,57 @@
+import * as ExpressJS from "express";
+
+
+export const httpClientErrors = Object.freeze({
+    400: "BAD_REQUEST",
+    401: "UNAUTHORIZED",
+    402: "PAYMENT_REQUIRED",
+    403: "FORBIDDEN",
+    404: "NOT_FOUND",
+    405: "METHOD_NOT_ALLOWED",
+    406: "NOT_ACCEPTABLE",
+    407: "PROXY_AUTHENCATION_REQUIRED",
+    408: "REQUEST_TIMEOUT",
+    409: "CONFLICT",
+    410: "GONE",
+    411: "LENGTH_REQUIRED",
+    412: "PRECONDITION_FAILED",
+    413: "PAYLOAD_TOO_LARGE",
+    414: "URI_TOO_LONG",
+    415: "UNSUPPORTED_MEDIA_TYPE",
+    416: "RANGE_NOT_SATISFIABLE",
+    417: "EXPECTATION_FAILED",
+    418: "IM_A_TEAPOT",
+    421: "MISDIRECTED_REQUEST",
+    422: "UNPROCESSABLE_ENTITY",
+    423: "LOCKED",
+    424: "FAILED_DEPENDENCY",
+    425: "TOO_EARLY_",
+    426: "UPGRAGE_REQUIRED",
+    428: "PRECONDITION_REQUIRED",
+    429: "TOO_MANY_REQUESTS",
+    431: "REQUEST_HEADER_FIELDS_TOO_LARGE",
+    451: "UNAVAILABLE_FOR_LEGAL_REASONS"
+});
+
+export class HttpClientError<
+    T extends keyof typeof httpClientErrors = keyof typeof httpClientErrors,
+    K = any
+> extends Error {
+    public readonly httpCode: T;
+    public readonly message: typeof httpClientErrors[T];
+    public readonly data: K;
+
+    constructor({
+        httpCode,
+        data
+    }: {
+        ["httpCode"]: T;
+        ["data"]: K;
+    }) {
+        super();
+
+        this.httpCode = httpCode;
+        this.message = httpClientErrors[httpCode];
+        this.data = data;
+    }
+}

package/src/http/index.ts

@@ -0,0 +1,68 @@
+import { Response } from "express";
+import { HttpClientError } from "./clientError";
+import { HttpServerError } from "./serverError";
+
+
+export const errorInfer = (res: Response, data: any) => {
+    if (res.headersSent) {
+        return;
+    }
+
+    try {
+        if (data instanceof HttpClientError) {
+            res.status(data.httpCode).json(data);
+            return;
+        }
+
+        if (data instanceof HttpServerError) {
+            res.status(data.httpCode).json(data);
+            return;
+        }
+
+        if (typeof data === "object") {
+            res.status(500).json({
+                httpCode: 500,
+                message: "INTERNAL SERVER ERROR",
+                data: data
+            });
+            return;
+        }
+
+        switch (typeof data) {
+            case "string":
+                res.status(500).json({
+                    httpCode: 500,
+                    message: "INTERNAL SERVER ERROR",
+                    data: {
+                        message: data
+                    }
+                });
+                return;
+
+            case "number":
+                res.status(500).json({
+                    httpCode: 500,
+                    message: "INTERNAL SERVER ERROR",
+                    data: {
+                        code: data
+                    }
+                });
+                return;
+
+            default:
+                res.status(500).json({
+                    httpCode: 500,
+                    message: "INTERNAL SERVER ERROR",
+                    data: undefined
+                });
+                return;
+        }
+    }
+    catch (error) {
+        console.error(error);
+        res.end();
+    }
+}
+
+export * from "./clientError";
+export * from "./serverError";

package/src/http/serverError.ts

@@ -0,0 +1,39 @@
+import * as ExpressJS from "express";
+
+
+export const httpServerErrors = Object.freeze({
+    500: "INTERNAL_SERVER_ERROR",
+    501: "NOT_IMPLEMENTED",
+    502: "BAD_GATEWAY",
+    503: "SERVICE_UNAVAILABLE",
+    504: "GATEWAY_TIMEOUT",
+    505: "HTTP_VERSION_NOT_SUPPORTED",
+    506: "VARIANT_ALSO_NEGOTIATES",
+    507: "INSUFFICIENT_STORAGE",
+    508: "LOOP_DETECTED",
+    510: "NOT_EXTENDED",
+    511: "NETWORK_AUTHENTICATION_REQUIRED"
+});
+
+export class HttpServerError<
+    T extends keyof typeof httpServerErrors = keyof typeof httpServerErrors,
+    K = any
+> extends Error {
+    public readonly httpCode: T;
+    public readonly message: typeof httpServerErrors[T];
+    public readonly data: K;
+
+    constructor({
+        httpCode,
+        data
+    }: {
+        ["httpCode"]: T;
+        ["data"]: K;
+    }) {
+        super();
+
+        this.httpCode = httpCode;
+        this.message = httpServerErrors[httpCode];
+        this.data = data;
+    }
+}

package/src/index.ts

@@ -1,5 +1,6 @@
-import "reflect-metadata";
-
-export * from "./interfaces";
-export * from "./hooks";
-export * from "./decorators";
+import "reflect-metadata";
+
+export * from "./interfaces";
+export * from "./hooks";
+export * from "./decorators";
+export * from "./http";

package/src/interfaces/index.ts

@@ -1,3 +1,3 @@
-
-
-export default {};
+
+
+export default {};