@bool-ts/core 1.4.2 → 1.5.0

package/.prettierrc

@@ -1,11 +1,11 @@
-{
-    "semi": true,
-    "tabWidth": 4,
-    "printWidth": 128,
-    "singleQuote": false,
-    "singleAttributePerLine": false,
-    "trailingComma": "none",
-    "bracketSameLine": true,
-    "bracketSpacing": true,
-    "htmlWhitespaceSensitivity": "ignore"
-}
+{
+    "semi": true,
+    "tabWidth": 4,
+    "printWidth": 128,
+    "singleQuote": false,
+    "singleAttributePerLine": false,
+    "trailingComma": "none",
+    "bracketSameLine": true,
+    "bracketSpacing": true,
+    "htmlWhitespaceSensitivity": "ignore"
+}

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2024 BoolTS
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2024 BoolTS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/__test/afterDispatcher.ts

@@ -0,0 +1,9 @@
+import { Dispatcher, IDispatcher } from "../src";
+
+@Dispatcher()
+export class AfterDispatcher implements IDispatcher {
+    execute() {
+        console.log("After dispatch");
+        console.log("===========================");
+    }
+}

package/__test/beforeDispatcher.ts

@@ -0,0 +1,9 @@
+import { Dispatcher, IDispatcher } from "../src";
+
+@Dispatcher()
+export class BeforeDispatcher implements IDispatcher {
+    execute() {
+        console.log("Before dispatch");
+        console.log("===========================");
+    }
+}

package/__test/controller.ts

@@ -1,66 +1,66 @@
-import type { IService } from "./interfaces";
-
-import * as Zod from "zod";
-
-import { Body, Controller, Delete, Get, Inject, Options, Params, Patch, Post, Put, ZodSchema } from "../src";
-import { TestService } from "./service";
-
-const postParamsSchema = Zod.object({
-    id: Zod.string(),
-    providerId: Zod.string().uuid()
-});
-
-const bodySchema = Zod.object({
-    data: Zod.object({
-        name: Zod.string(),
-        age: Zod.number()
-    })
-});
-
-const requestSchema = Zod.object({
-    headers: Zod.object({
-        authorization: Zod.string().min(10)
-    }),
-    body: bodySchema
-});
-
-const stringSchema = Zod.object({}).refine(async (val) => {
-    const delay = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
-    await delay(10000);
-
-    return val;
-});
-
-@Controller("test")
-export class TestController {
-    constructor(@Inject(TestService) private readonly testService: IService) {}
-
-    @Get("abc")
-    public get(req: Request) {
-        console.log("HEHE");
-        console.log("this.testService", this.testService.exec());
-    }
-
-    @Post("abc/:id/provider/:providerId")
-    public async post(
-        @Params(undefined, postParamsSchema)
-        params: any,
-        @Body(bodySchema)
-        req: Zod.infer<typeof bodySchema>
-    ) {
-        console.log("req.headers", req);
-        console.log("===========================");
-    }
-
-    @Put()
-    public put(req: any) {}
-
-    @Patch("abc/:testId")
-    public patch(req: Request) {}
-
-    @Delete()
-    public delete(req: Request) {}
-
-    @Options()
-    public options(req: Request) {}
-}
+import type { IService } from "./interfaces";
+
+import * as Zod from "zod";
+
+import { Body, Controller, Delete, Get, Inject, Options, Params, Patch, Post, Put, Param } from "../src";
+import { TestService } from "./service";
+
+const postParamsSchema = Zod.object({
+    id: Zod.string(),
+    providerId: Zod.string().uuid()
+});
+
+const bodySchema = Zod.object({
+    data: Zod.object({
+        name: Zod.string(),
+        age: Zod.number()
+    })
+});
+
+const requestSchema = Zod.object({
+    headers: Zod.object({
+        authorization: Zod.string().min(10)
+    }),
+    body: bodySchema
+});
+
+const stringSchema = Zod.object({}).refine(async (val) => {
+    const delay = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+    await delay(10000);
+
+    return val;
+});
+
+@Controller("test")
+export class TestController {
+    constructor(@Inject(TestService) private readonly testService: IService) {}
+
+    @Get("abc/:id")
+    public get(@Param("id") id: string) {
+        console.log("HEHE", id, typeof id);
+        console.log("this.testService", this.testService.exec());
+    }
+
+    @Post("abc/:id/provider/:providerId")
+    public async post(
+        @Params()
+        params: any,
+        @Body(bodySchema)
+        body: Zod.infer<typeof bodySchema>
+    ) {
+        console.log("req.headers", body, params);
+        console.log("===========================");
+    }
+
+    @Put()
+    public put(req: any) {}
+
+    @Patch("abc/:testId")
+    public patch(req: Request) {}
+
+    @Delete()
+    public delete(req: Request) {}
+
+    @Options()
+    public options(req: Request) {}
+}

package/__test/firstGuard.ts

@@ -0,0 +1,10 @@
+import { Guard, IGuard } from "../src";
+
+@Guard()
+export class FirstGuard implements IGuard {
+    enforce(): boolean | Promise<boolean> {
+        console.log("Guard 01");
+        console.log("===========================");
+        return true;
+    }
+}

package/__test/firstMiddleware.ts

@@ -0,0 +1,9 @@
+import { Middleware, IMiddleware } from "../src";
+
+@Middleware()
+export class FirstMiddleware implements IMiddleware {
+    enforce() {
+        console.log("Middleware 01");
+        console.log("===========================");
+    }
+}

package/__test/index.ts

@@ -1,8 +1,8 @@
-import "reflect-metadata";
-
-import { BoolFactory } from "../src";
-import { TestModule } from "./module";
-
-BoolFactory(TestModule, {
-    port: 3000
-});
+import "reflect-metadata";
+
+import { BoolFactory } from "../src";
+import { TestModule } from "./module";
+
+BoolFactory(TestModule, {
+    port: 3000
+});

package/__test/interfaces.ts

@@ -1,7 +1,7 @@
-export interface IRepository {
-    exec(): void;
-}
-
-export interface IService {
-    exec(): void;
-}
+export interface IRepository {
+    exec(): void;
+}
+
+export interface IService {
+    exec(): void;
+}

package/__test/module.ts

@@ -1,16 +1,25 @@
-import { Module } from "../src";
-import { TestController } from "./controller";
-// import { TestRepository } from "./repository";
-import { TestService } from "./service";
-
-@Module({
-    allowOrigins: ["http://localhost:7000"],
-    controllers: [TestController],
-    dependencies: [
-        // TestService,
-        // TestRepository
-    ]
-})
-export class TestModule {}
-
-export default TestModule;
+import { Module } from "../src";
+import { AfterDispatcher } from "./afterDispatcher";
+import { BeforeDispatcher } from "./beforeDispatcher";
+import { TestController } from "./controller";
+import { FirstGuard } from "./firstGuard";
+import { FirstMiddleware } from "./firstMiddleware";
+import { SecondMiddleware } from "./secondMiddleware";
+import { TestRepository } from "./repository";
+import { TestService } from "./service";
+import { SecondGuard } from "./secondGuard";
+
+@Module({
+    options: {
+        allowOrigins: ["*"]
+    },
+    middlewares: [FirstMiddleware, SecondMiddleware],
+    guards: [FirstGuard, SecondGuard],
+    beforeDispatchers: [BeforeDispatcher],
+    afterDispatchers: [AfterDispatcher],
+    controllers: [TestController],
+    dependencies: [TestService, TestRepository]
+})
+export class TestModule {}
+
+export default TestModule;

package/__test/repository.ts

@@ -1,16 +1,16 @@
-import type { IRepository } from "./interfaces";
-
-import { Injectable } from "../src";
-
-
-@Injectable()
-export class TestRepository implements IRepository {
-    /**
-     * 
-     */
-    exec() {
-        console.log("This is test repository.");
-    }
-}
-
-export default TestRepository;
+import type { IRepository } from "./interfaces";
+
+import { Injectable } from "../src";
+
+
+@Injectable()
+export class TestRepository implements IRepository {
+    /**
+     * 
+     */
+    exec() {
+        console.log("This is test repository.");
+    }
+}
+
+export default TestRepository;

package/__test/secondGuard.ts

@@ -0,0 +1,10 @@
+import { Guard, IGuard } from "../src";
+
+@Guard()
+export class SecondGuard implements IGuard {
+    enforce(): boolean | Promise<boolean> {
+        console.log("Guard 02");
+        console.log("===========================");
+        return true;
+    }
+}

package/__test/secondMiddleware.ts

@@ -0,0 +1,9 @@
+import { Middleware, IMiddleware } from "../src";
+
+@Middleware()
+export class SecondMiddleware implements IMiddleware {
+    enforce() {
+        console.log("Middleware 02");
+        console.log("===========================");
+    }
+}

package/__test/service.ts

@@ -1,20 +1,20 @@
-import type { IService, IRepository } from "./interfaces";
-
-import { Inject, Injectable } from "../src";
-import { TestRepository } from "./repository";
-
-
-@Injectable()
-export class TestService implements IService {
-    constructor(
-        @Inject(TestRepository) private readonly testRepository: IRepository
-    ) { }
-
-    /**
-     * 
-     */
-    exec() {
-        console.log("This is test service.", this.testRepository);
-        this.testRepository.exec();
-    }
-}
+import type { IService, IRepository } from "./interfaces";
+
+import { Inject, Injectable } from "../src";
+import { TestRepository } from "./repository";
+
+
+@Injectable()
+export class TestService implements IService {
+    constructor(
+        @Inject(TestRepository) private readonly testRepository: IRepository
+    ) { }
+
+    /**
+     * 
+     */
+    exec() {
+        console.log("This is test service.", this.testRepository);
+        this.testRepository.exec();
+    }
+}

package/dist/decorators/arguments.d.ts

@@ -1,15 +1,16 @@
 import * as Zod from "zod";
 export declare enum EArgumentTypes {
-    headers = "HEADERS",
+    requestHeaders = "REQUEST_HEADERS",
     body = "BODY",
     params = "PARAMS",
     param = "PARAM",
     query = "QUERY",
-    request = "REQUEST"
+    request = "REQUEST",
+    responseHeaders = "RESPONSE_HEADERS"
 }
-export type TMetadata = {
+export type TArgumentsMetadata = {
     index: number;
-    type: EArgumentTypes.headers;
+    type: EArgumentTypes.requestHeaders;
     zodSchema?: Zod.Schema;
 } | {
     index: number;
@@ -33,11 +34,16 @@ export type TMetadata = {
     index: number;
     type: EArgumentTypes.request;
     zodSchema?: Zod.Schema;
+} | {
+    index: number;
+    type: EArgumentTypes.responseHeaders;
+    zodSchema?: Zod.Schema;
 };
-export declare const controllerActionArgumentsKey: unique symbol;
-export declare const Headers: (zodSchema?: Zod.Schema) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => void;
+export declare const argumentsKey: unique symbol;
+export declare const RequestHeaders: (zodSchema?: Zod.Schema) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => void;
 export declare const Body: (zodSchema?: Zod.Schema, parser?: "arrayBuffer" | "blob" | "formData" | "json" | "text") => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => void;
 export declare const Params: (zodSchema?: Zod.Schema) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => void;
 export declare const Param: (key: string, zodSchema?: Zod.Schema) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => void;
 export declare const Query: (zodSchema?: Zod.Schema) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => void;
 export declare const Request: (zodSchema?: Zod.Schema) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => void;
+export declare const ResponseHeaders: (zodSchema?: Zod.Schema) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => void;

package/dist/decorators/arguments.js

@@ -1,26 +1,27 @@
 import * as Zod from "zod";
 export var EArgumentTypes;
 (function (EArgumentTypes) {
-    EArgumentTypes["headers"] = "HEADERS";
+    EArgumentTypes["requestHeaders"] = "REQUEST_HEADERS";
     EArgumentTypes["body"] = "BODY";
     EArgumentTypes["params"] = "PARAMS";
     EArgumentTypes["param"] = "PARAM";
     EArgumentTypes["query"] = "QUERY";
     EArgumentTypes["request"] = "REQUEST";
+    EArgumentTypes["responseHeaders"] = "RESPONSE_HEADERS";
 })(EArgumentTypes || (EArgumentTypes = {}));
-export const controllerActionArgumentsKey = Symbol.for("__bool:controller.action::arguments__");
-export const Headers = (zodSchema) => {
+export const argumentsKey = Symbol.for("__bool:arguments__");
+export const RequestHeaders = (zodSchema) => {
     return (target, methodName, parameterIndex) => {
         if (!methodName) {
             return;
         }
-        const headersMetadata = Reflect.getOwnMetadata(controllerActionArgumentsKey, target.constructor, methodName) || {};
+        const headersMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
         headersMetadata[`argumentIndexes.${parameterIndex}`] = {
             index: parameterIndex,
-            type: EArgumentTypes.headers,
+            type: EArgumentTypes.requestHeaders,
             zodSchema: zodSchema
         };
-        Reflect.defineMetadata(controllerActionArgumentsKey, headersMetadata, target.constructor, methodName);
+        Reflect.defineMetadata(argumentsKey, headersMetadata, target.constructor, methodName);
     };
 };
 export const Body = (zodSchema, parser) => {
@@ -28,43 +29,41 @@ export const Body = (zodSchema, parser) => {
         if (!methodName) {
             return;
         }
-        const bodyMetadata = Reflect.getOwnMetadata(controllerActionArgumentsKey, target.constructor, methodName) || {};
+        const bodyMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
         bodyMetadata[`argumentIndexes.${parameterIndex}`] = {
             index: parameterIndex,
             type: EArgumentTypes.body,
             zodSchema: zodSchema,
             parser: parser
         };
-        Reflect.defineMetadata(controllerActionArgumentsKey, bodyMetadata, target.constructor, methodName);
+        Reflect.defineMetadata(argumentsKey, bodyMetadata, target.constructor, methodName);
     };
 };
-export const Params = (zodSchema) => {
-    return (target, methodName, parameterIndex) => {
-        if (!methodName) {
-            return;
-        }
-        const paramsMetadata = Reflect.getOwnMetadata(controllerActionArgumentsKey, target.constructor, methodName) || {};
-        paramsMetadata[`argumentIndexes.${parameterIndex}`] = {
-            index: parameterIndex,
-            type: EArgumentTypes.params,
-            zodSchema: zodSchema
-        };
-        Reflect.defineMetadata(controllerActionArgumentsKey, paramsMetadata, target.constructor, methodName);
+export const Params = (zodSchema) => (target, methodName, parameterIndex) => {
+    if (!methodName) {
+        return;
+    }
+    const paramsMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+    paramsMetadata[`argumentIndexes.${parameterIndex}`] = {
+        index: parameterIndex,
+        type: EArgumentTypes.params,
+        zodSchema: zodSchema
     };
+    Reflect.defineMetadata(argumentsKey, paramsMetadata, target.constructor, methodName);
 };
 export const Param = (key, zodSchema) => {
     return (target, methodName, parameterIndex) => {
         if (!methodName) {
             return;
         }
-        const paramsMetadata = Reflect.getOwnMetadata(controllerActionArgumentsKey, target.constructor, methodName) || {};
+        const paramsMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
         paramsMetadata[`argumentIndexes.${parameterIndex}`] = {
             index: parameterIndex,
             type: EArgumentTypes.param,
             key: key,
             zodSchema: zodSchema
         };
-        Reflect.defineMetadata(controllerActionArgumentsKey, paramsMetadata, target.constructor, methodName);
+        Reflect.defineMetadata(argumentsKey, paramsMetadata, target.constructor, methodName);
     };
 };
 export const Query = (zodSchema) => {
@@ -72,13 +71,13 @@ export const Query = (zodSchema) => {
         if (!methodName) {
             return;
         }
-        const queryMetadata = Reflect.getOwnMetadata(controllerActionArgumentsKey, target.constructor, methodName) || {};
+        const queryMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
         queryMetadata[`argumentIndexes.${parameterIndex}`] = {
             index: parameterIndex,
             type: EArgumentTypes.params,
             zodSchema: zodSchema
         };
-        Reflect.defineMetadata(controllerActionArgumentsKey, queryMetadata, target.constructor, methodName);
+        Reflect.defineMetadata(argumentsKey, queryMetadata, target.constructor, methodName);
     };
 };
 export const Request = (zodSchema) => {
@@ -86,12 +85,26 @@ export const Request = (zodSchema) => {
         if (!methodName) {
             return;
         }
-        const queryMetadata = Reflect.getOwnMetadata(controllerActionArgumentsKey, target.constructor, methodName) || {};
+        const queryMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
         queryMetadata[`argumentIndexes.${parameterIndex}`] = {
             index: parameterIndex,
             type: EArgumentTypes.request,
             zodSchema: zodSchema
         };
-        Reflect.defineMetadata(controllerActionArgumentsKey, queryMetadata, target.constructor, methodName);
+        Reflect.defineMetadata(argumentsKey, queryMetadata, target.constructor, methodName);
+    };
+};
+export const ResponseHeaders = (zodSchema) => {
+    return (target, methodName, parameterIndex) => {
+        if (!methodName) {
+            return;
+        }
+        const queryMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+        queryMetadata[`argumentIndexes.${parameterIndex}`] = {
+            index: parameterIndex,
+            type: EArgumentTypes.responseHeaders,
+            zodSchema: zodSchema
+        };
+        Reflect.defineMetadata(argumentsKey, queryMetadata, target.constructor, methodName);
     };
 };

package/dist/decorators/controller.d.ts

@@ -1,3 +1,11 @@
+import type { IController } from "../interfaces/controller";
+import { type THttpMetadata } from "./http";
+export type TControllerMetadata = Required<{
+    prefix: string;
+    httpMetadata: THttpMetadata;
+}>;
 export declare const controllerKey: unique symbol;
-export declare const Controller: (prefix: string) => <T extends Object>(target: T) => T;
+export declare const Controller: (prefix: string) => <T extends {
+    new (...args: any[]): IController;
+}>(target: T) => void;
 export default Controller;

package/dist/decorators/controller.js

@@ -1,8 +1,10 @@
-import { injectableKey } from "./injectable";
+import { controllerHttpKey } from "./http";
 export const controllerKey = Symbol.for("__bool:controller__");
 export const Controller = (prefix) => (target) => {
-    Reflect.defineMetadata(controllerKey, !prefix.startsWith("/") ? `/${prefix}` : prefix, target);
-    Reflect.defineMetadata(injectableKey, undefined, target);
-    return target;
+    const metadata = {
+        prefix: !prefix.startsWith("/") ? `/${prefix}` : prefix,
+        httpMetadata: [...(Reflect.getOwnMetadata(controllerHttpKey, target.constructor) || [])]
+    };
+    Reflect.defineMetadata(controllerKey, metadata, target);
 };
 export default Controller;

package/dist/decorators/dispatcher.d.ts

@@ -0,0 +1,7 @@
+import type { IDispatcher } from "../interfaces/dispatcher";
+export type TDispatcherMetadata = undefined;
+export declare const dispatcherKey: unique symbol;
+export declare const Dispatcher: () => <T extends {
+    new (...args: any[]): IDispatcher;
+}>(target: T) => void;
+export default Dispatcher;

package/dist/decorators/dispatcher.js

@@ -0,0 +1,9 @@
+export const dispatcherKey = Symbol.for("__bool:dispatcher__");
+export const Dispatcher = () => (target) => {
+    if (!("execute" in target.prototype) || typeof target.prototype.execute !== "function") {
+        return;
+    }
+    const metadata = undefined;
+    Reflect.defineMetadata(dispatcherKey, metadata, target);
+};
+export default Dispatcher;

package/dist/decorators/guard.d.ts

@@ -0,0 +1,7 @@
+import type { IGuard } from "../interfaces";
+export type TGuardMetadata = undefined;
+export declare const guardKey: unique symbol;
+export declare const Guard: () => <T extends {
+    new (...args: any[]): IGuard;
+}>(target: T) => void;
+export default Guard;