@bool-ts/core 1.1.1 → 1.2.2

package/src/hooks/factory.ts

@@ -1,193 +1,199 @@
-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;
+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
+    }>;
+    prefix: string;
+}>;
+
+
+/**
+ * 
+ * @param target 
+ * @param router 
+ */
+const controllerCreator = (
+    controllerConstructor: new (...args: any[]) => unknown,
+    parentRouter: Router = Router()
+) => {
+    if (!Reflect.getOwnMetadataKeys(controllerConstructor).includes(controllerKey)) {
+        throw Error(`${controllerConstructor.name} is not a controller.`);
+    }
+
+    const controller = Injector.get(controllerConstructor);
+
+    if (!controller) {
+        throw Error("Can not initialize controller.");
+    }
+
+    const controllerMetadata = Reflect.getOwnMetadata(controllerKey, controllerConstructor) || "/";
+    const routesMetadata = (Reflect.getOwnMetadata(controllerRoutesKey, controllerConstructor) || []) as Array<IControllerRoute>;
+    const router = Router();
+
+    routesMetadata.forEach(routeMetadata => {
+        if (typeof routeMetadata.descriptor.value !== "function") {
+            return;
+        }
+
+        const route = router.route(routeMetadata.path);
+
+        switch (routeMetadata.httpMethod) {
+            case "GET":
+                return route.get(routeMetadata.descriptor.value.bind(controller));
+            case "POST":
+                return route.post(routeMetadata.descriptor.value.bind(controller));
+            case "PUT":
+                return route.put(routeMetadata.descriptor.value.bind(controller));
+            case "PATCH":
+                return route.patch(routeMetadata.descriptor.value.bind(controller));
+            case "DELETE":
+                return route.delete(routeMetadata.descriptor.value.bind(controller));
+            case "OPTIONS":
+                return route.options(routeMetadata.descriptor.value.bind(controller));
+        }
+    });
+
+    return parentRouter.use(controllerMetadata, 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 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
+    });
+    const routers = !metadata?.controllers ?
+        [] : metadata.controllers.map(controllerConstructor => controllerCreator(controllerConstructor));
+
+    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) {
+        !metadata?.prefix ?
+            app.use(routers) : app.use(!metadata.prefix.startsWith("/") ?
+                `/${metadata.prefix}` : metadata.prefix, 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

@@ -1,57 +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;
-    }
-}
+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;
+    }
+}