@bool-ts/core 1.0.0

package/dist/hooks/factory.js

@@ -0,0 +1,119 @@
+import "reflect-metadata";
+import "colors";
+import * as Qs from "qs";
+import * as ResponseTime from "response-time";
+import { controllerKey, controllerRoutesKey, moduleKey } from "../decorators";
+import { default as ExpressApp, Router, json, urlencoded } from "express";
+import { Injector } from "./injector";
+/**
+ *
+ * @param target
+ * @param router
+ */
+const controllerCreator = (target, 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) || []);
+    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) => {
+    if (!Reflect.getOwnMetadataKeys(target).includes(moduleKey)) {
+        throw Error(`${target.name} is not a module.`);
+    }
+    const metadata = Reflect.getOwnMetadata(moduleKey, target);
+    const routers = !metadata?.controllers ? [] : metadata.controllers.map(controllerConstructor => controllerCreator(controllerConstructor));
+    const app = ExpressApp();
+    const configs = Object.freeze({
+        allowLogsMethods: [
+            "GET",
+            "POST",
+            "PUT",
+            "PATCH",
+            "DELETE"
+        ]
+    });
+    app.set("etag", "strong");
+    app.set("query parser", (query) => 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, res, next) => {
+        for (const [key, value] of Object.entries(req.headers)) {
+            req.headers[key] = typeof value !== "string" ? value : decodeURI(value);
+        }
+        next();
+    }, 
+    // Body parser
+    (req, res, next) => {
+        if (typeof req.body !== "object" || !req.body) {
+            req.body = Object.freeze({});
+        }
+        next();
+    }, 
+    // Error catcher
+    (err, req, res, next) => {
+        console.error(err);
+        next();
+    }, 
+    // Response time log
+    ResponseTime.default((req, res, time) => {
+        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(routers);
+    return app;
+};
+export default BoolFactory;

package/dist/hooks/index.d.ts

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

package/dist/hooks/index.js

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

package/dist/hooks/injector.d.ts

@@ -0,0 +1,6 @@
+import "reflect-metadata";
+interface IInjector {
+    get<T>(target: new (...args: any[]) => T): T;
+}
+export declare const Injector: IInjector;
+export default Injector;

package/dist/hooks/injector.js

@@ -0,0 +1,23 @@
+import "reflect-metadata";
+export const Injector = new class {
+    _mapper = new Map();
+    /**
+     *
+     * @param constructor
+     */
+    get(target) {
+        if (this._mapper.has(target)) {
+            return this._mapper.get(target);
+        }
+        if (!Reflect.getOwnMetadataKeys(target).includes("__bool:injectable__")) {
+            throw Error("Missing dependency declaration, please check @Injectable() used on dependency(ies).");
+        }
+        // Initialize dependencies injection
+        const dependencies = Reflect.getOwnMetadata("design:paramtypes", target) || [];
+        const injections = dependencies.map(dependency => Injector.get(dependency));
+        const instance = new target(...injections);
+        this._mapper.set(target, instance);
+        return instance;
+    }
+};
+export default Injector;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import "reflect-metadata";
+export * from "./interfaces";
+export * from "./hooks";
+export * from "./decorators";

package/dist/index.js

@@ -0,0 +1,4 @@
+import "reflect-metadata";
+export * from "./interfaces";
+export * from "./hooks";
+export * from "./decorators";

package/dist/interfaces/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/dist/interfaces/index.js

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

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@bool-ts/core",
+  "version": "1.0.0",
+  "description": "",
+  "main": "dist/index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "tsc"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/BoolTS/core.git"
+  },
+  "author": "Trần Đức Tâm (Neo)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/BoolTS/core/issues"
+  },
+  "homepage": "https://github.com/BoolTS/core#readme",
+  "dependencies": {
+    "colors": "^1.4.0",
+    "express": ">=5.0.0-beta.1",
+    "qs": "^6.12.1",
+    "reflect-metadata": "^0.2.2",
+    "response-time": "^2.3.2"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.21",
+    "@types/node-statsd": "^0.1.6",
+    "@types/response-time": "^2.3.8",
+    "typescript": "^5.4.5"
+  }
+}

package/src/decorators/controller.ts

@@ -0,0 +1,18 @@
+import { injectableKey } from "./injectable";
+
+
+export const controllerKey = "__bool:controller__";
+
+export const Controller = (
+    prefix: string
+) => <T extends Object>(
+    target: T,
+    context?: ClassDecoratorContext
+) => {
+        Reflect.defineMetadata(controllerKey, !prefix.startsWith("/") ? `/${prefix}` : prefix, target);
+        Reflect.defineMetadata(injectableKey, undefined, target);
+
+        return target;
+    }
+
+export default Controller;

package/src/decorators/http.ts

@@ -0,0 +1,185 @@
+export interface IControllerRoute {
+    path: string;
+    httpMethod: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS";
+    methodName: string;
+    descriptor: PropertyDescriptor;
+}
+
+
+export const controllerRoutesKey = "__bool:controller.routes__";
+
+/**
+ * 
+ * @param path 
+ * @returns 
+ */
+export const Get = (
+    path = "/"
+) => (
+    target: Object,
+    methodName: string,
+    descriptor: PropertyDescriptor
+) => {
+        if (typeof descriptor.value !== "function") {
+            throw Error("Get decorator only use for method.");
+        }
+
+        Reflect.defineMetadata(controllerRoutesKey, [
+            ...Reflect.getOwnMetadata(controllerRoutesKey, target.constructor) || [],
+            {
+                path: !path.startsWith("/") ? `/${path}` : path,
+                httpMethod: "GET",
+                methodName: methodName,
+                descriptor: descriptor
+            }
+        ], target.constructor);
+    }
+
+
+/**
+ * 
+ * @param path 
+ * @returns 
+ */
+export const Post = (
+    path = "/"
+) => (
+    target: Object,
+    methodName: string,
+    descriptor: PropertyDescriptor
+) => {
+        if (typeof descriptor.value !== "function") {
+            throw Error("Post decorator only use for method.");
+        }
+
+        Reflect.defineMetadata(controllerRoutesKey, [
+            ...Reflect.getOwnMetadata(controllerRoutesKey, target.constructor) || [],
+            {
+                path: !path.startsWith("/") ? `/${path}` : path,
+                httpMethod: "POST",
+                methodName: methodName,
+                descriptor: descriptor
+            }
+        ], target.constructor);
+    }
+
+
+/**
+ * 
+ * @param path 
+ * @returns 
+ */
+export const Put = (
+    path = "/"
+) => (
+    target: Object,
+    methodName: string,
+    descriptor: PropertyDescriptor
+) => {
+        if (typeof descriptor.value !== "function") {
+            throw Error("Put decorator only use for method.");
+        }
+
+        Reflect.defineMetadata(controllerRoutesKey, [
+            ...Reflect.getOwnMetadata(controllerRoutesKey, target.constructor) || [],
+            {
+                path: !path.startsWith("/") ? `/${path}` : path,
+                httpMethod: "PUT",
+                methodName: methodName,
+                descriptor: descriptor
+            }
+        ], target.constructor);
+    }
+
+
+/**
+ * 
+ * @param path 
+ * @returns 
+ */
+export const Patch = (
+    path = "/"
+) => (
+    target: Object,
+    methodName: string,
+    descriptor: PropertyDescriptor
+) => {
+        if (typeof descriptor.value !== "function") {
+            throw Error("Patch decorator only use for method.");
+        }
+
+        Reflect.defineMetadata(controllerRoutesKey, [
+            ...Reflect.getOwnMetadata(controllerRoutesKey, target.constructor) || [],
+            {
+                path: !path.startsWith("/") ? `/${path}` : path,
+                httpMethod: "PATCH",
+                methodName: methodName,
+                descriptor: descriptor
+            }
+        ], target.constructor);
+    }
+
+
+/**
+ * 
+ * @param path 
+ * @returns 
+ */
+export const Delete = (
+    path = "/"
+) => (
+    target: Object,
+    methodName: string,
+    descriptor: PropertyDescriptor
+) => {
+        if (typeof descriptor.value !== "function") {
+            throw Error("Delete decorator only use for method.");
+        }
+
+        Reflect.defineMetadata(controllerRoutesKey, [
+            ...Reflect.getOwnMetadata(controllerRoutesKey, target.constructor) || [],
+            {
+                path: !path.startsWith("/") ? `/${path}` : path,
+                httpMethod: "DELETE",
+                methodName: methodName,
+                descriptor: descriptor
+            }
+        ], target.constructor);
+    }
+
+
+/**
+ * 
+ * @param path 
+ * @returns 
+ */
+export const Options = (
+    path = "/"
+) => (
+    target: Object,
+    methodName: string,
+    descriptor: PropertyDescriptor
+) => {
+        if (typeof descriptor.value !== "function") {
+            throw Error("Options decorator only use for method.");
+        }
+
+        Reflect.defineMetadata(controllerRoutesKey, [
+            ...Reflect.getOwnMetadata(controllerRoutesKey, target.constructor) || [],
+            {
+                path: !path.startsWith("/") ? `/${path}` : path,
+                httpMethod: "OPTIONS",
+                methodName: methodName,
+                descriptor: descriptor
+            }
+        ], target.constructor);
+    }
+
+export default {
+    Get,
+    Post,
+    Put,
+    Patch,
+    Delete
+};
+

package/src/decorators/index.ts

@@ -0,0 +1,5 @@
+export { Controller, controllerKey } from "./controller";
+export { Inject, injectKey } from "./inject";
+export { Injectable, injectableKey } from "./injectable";
+export { Module, moduleKey, type TModuleOptions } from "./module";
+export { Get, Post, Put, Patch, Delete, Options, controllerRoutesKey, type IControllerRoute } from "./http";

package/src/decorators/inject.ts

@@ -0,0 +1,19 @@
+export const injectKey = "design:paramtypes";
+
+export const Inject = <T>(
+    constructor: new (...args: any[]) => T
+) => {
+    return (
+        target: Object,
+        parameterName: string | Symbol | undefined,
+        parameterIndex: number
+    ) => {
+        const designParameterTypes: any[] = Reflect.getMetadata(injectKey, target.constructor) || [];
+
+        designParameterTypes[parameterIndex] = constructor;
+
+        Reflect.defineMetadata(injectKey, designParameterTypes, target.constructor);
+    }
+}
+
+export default Inject;

package/src/decorators/injectable.ts

@@ -0,0 +1,12 @@
+export const injectableKey = "__bool:injectable__";
+
+export const Injectable = () => <T extends Object>(
+    target: T,
+    context?: ClassDecoratorContext
+) => {
+    Reflect.defineMetadata(injectableKey, undefined, target.constructor);
+
+    return target;
+}
+
+export default Injectable;

package/src/decorators/module.ts

@@ -0,0 +1,19 @@
+export type TModuleOptions = Partial<{
+    controllers: Array<new (...args: any[]) => unknown>;
+    dependencies: Array<new (...args: any[]) => unknown>;
+}> | undefined;
+
+export const moduleKey = "__bool:module__";
+
+export const Module = (
+    args?: TModuleOptions
+) => <T extends { new(...args: any[]): {} }>(
+    target: T,
+    context?: ClassDecoratorContext
+) => {
+        Reflect.defineMetadata(moduleKey, args, target);
+
+        return target;
+    }
+
+export default Module;

package/src/hooks/factory.ts

@@ -0,0 +1,151 @@
+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 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(routers);
+
+    return app;
+}
+
+export default BoolFactory;

package/src/hooks/index.ts

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

package/src/hooks/injector.ts

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

package/src/index.ts

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

package/src/interfaces/index.ts

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