@bool-ts/core 1.4.2 → 1.5.1

package/src/decorators/arguments.ts

@@ -1,186 +1,214 @@
-import * as Zod from "zod";
-
-export enum EArgumentTypes {
-    headers = "HEADERS",
-    body = "BODY",
-    params = "PARAMS",
-    param = "PARAM",
-    query = "QUERY",
-    request = "REQUEST"
-}
-
-export type TMetadata =
-    | {
-          index: number;
-          type: EArgumentTypes.headers;
-          zodSchema?: Zod.Schema;
-      }
-    | {
-          index: number;
-          type: EArgumentTypes.body;
-          zodSchema?: Zod.Schema;
-          parser?: "arrayBuffer" | "blob" | "formData" | "json" | "text";
-      }
-    | {
-          index: number;
-          type: EArgumentTypes.params;
-          zodSchema?: Zod.Schema;
-      }
-    | {
-          index: number;
-          type: EArgumentTypes.param;
-          key: string;
-          zodSchema?: Zod.Schema;
-      }
-    | {
-          index: number;
-          type: EArgumentTypes.query;
-          zodSchema?: Zod.Schema;
-      }
-    | {
-          index: number;
-          type: EArgumentTypes.request;
-          zodSchema?: Zod.Schema;
-      };
-
-export const controllerActionArgumentsKey = Symbol.for("__bool:controller.action::arguments__");
-
-export const Headers = (zodSchema?: Zod.Schema) => {
-    return (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
-        if (!methodName) {
-            return;
-        }
-
-        const headersMetadata = Reflect.getOwnMetadata(controllerActionArgumentsKey, target.constructor, methodName) || {};
-
-        headersMetadata[`argumentIndexes.${parameterIndex}`] = {
-            index: parameterIndex,
-            type: EArgumentTypes.headers,
-            zodSchema: zodSchema
-        } satisfies Extract<
-            TMetadata,
-            {
-                type: EArgumentTypes.headers;
-            }
-        >;
-
-        Reflect.defineMetadata(controllerActionArgumentsKey, headersMetadata, target.constructor, methodName);
-    };
-};
-
-export const Body = (zodSchema?: Zod.Schema, parser?: "arrayBuffer" | "blob" | "formData" | "json" | "text") => {
-    return (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
-        if (!methodName) {
-            return;
-        }
-
-        const bodyMetadata = Reflect.getOwnMetadata(controllerActionArgumentsKey, target.constructor, methodName) || {};
-
-        bodyMetadata[`argumentIndexes.${parameterIndex}`] = {
-            index: parameterIndex,
-            type: EArgumentTypes.body,
-            zodSchema: zodSchema,
-            parser: parser
-        } satisfies Extract<
-            TMetadata,
-            {
-                type: EArgumentTypes.body;
-            }
-        >;
-
-        Reflect.defineMetadata(controllerActionArgumentsKey, bodyMetadata, target.constructor, methodName);
-    };
-};
-
-export const Params = (zodSchema?: Zod.Schema) => {
-    return (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
-        if (!methodName) {
-            return;
-        }
-
-        const paramsMetadata = Reflect.getOwnMetadata(controllerActionArgumentsKey, target.constructor, methodName) || {};
-
-        paramsMetadata[`argumentIndexes.${parameterIndex}`] = {
-            index: parameterIndex,
-            type: EArgumentTypes.params,
-            zodSchema: zodSchema
-        } satisfies Extract<
-            TMetadata,
-            {
-                type: EArgumentTypes.params;
-            }
-        >;
-
-        Reflect.defineMetadata(controllerActionArgumentsKey, paramsMetadata, target.constructor, methodName);
-    };
-};
-
-export const Param = (key: string, zodSchema?: Zod.Schema) => {
-    return (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
-        if (!methodName) {
-            return;
-        }
-
-        const paramsMetadata = Reflect.getOwnMetadata(controllerActionArgumentsKey, target.constructor, methodName) || {};
-
-        paramsMetadata[`argumentIndexes.${parameterIndex}`] = {
-            index: parameterIndex,
-            type: EArgumentTypes.param,
-            key: key,
-            zodSchema: zodSchema
-        } satisfies Extract<
-            TMetadata,
-            {
-                type: EArgumentTypes.param;
-            }
-        >;
-
-        Reflect.defineMetadata(controllerActionArgumentsKey, paramsMetadata, target.constructor, methodName);
-    };
-};
-
-export const Query = (zodSchema?: Zod.Schema) => {
-    return (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
-        if (!methodName) {
-            return;
-        }
-
-        const queryMetadata = Reflect.getOwnMetadata(controllerActionArgumentsKey, target.constructor, methodName) || {};
-
-        queryMetadata[`argumentIndexes.${parameterIndex}`] = {
-            index: parameterIndex,
-            type: EArgumentTypes.params,
-            zodSchema: zodSchema
-        } satisfies Extract<
-            TMetadata,
-            {
-                type: EArgumentTypes.params;
-            }
-        >;
-
-        Reflect.defineMetadata(controllerActionArgumentsKey, queryMetadata, target.constructor, methodName);
-    };
-};
-
-export const Request = (zodSchema?: Zod.Schema) => {
-    return (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
-        if (!methodName) {
-            return;
-        }
-
-        const queryMetadata = Reflect.getOwnMetadata(controllerActionArgumentsKey, target.constructor, methodName) || {};
-
-        queryMetadata[`argumentIndexes.${parameterIndex}`] = {
-            index: parameterIndex,
-            type: EArgumentTypes.request,
-            zodSchema: zodSchema
-        } satisfies Extract<
-            TMetadata,
-            {
-                type: EArgumentTypes.request;
-            }
-        >;
-
-        Reflect.defineMetadata(controllerActionArgumentsKey, queryMetadata, target.constructor, methodName);
-    };
-};
+import * as Zod from "zod";
+
+export enum EArgumentTypes {
+    requestHeaders = "REQUEST_HEADERS",
+    body = "BODY",
+    params = "PARAMS",
+    param = "PARAM",
+    query = "QUERY",
+    request = "REQUEST",
+    responseHeaders = "RESPONSE_HEADERS"
+}
+
+export type TArgumentsMetadata =
+    | {
+          index: number;
+          type: EArgumentTypes.requestHeaders;
+          zodSchema?: Zod.Schema;
+      }
+    | {
+          index: number;
+          type: EArgumentTypes.body;
+          zodSchema?: Zod.Schema;
+          parser?: "arrayBuffer" | "blob" | "formData" | "json" | "text";
+      }
+    | {
+          index: number;
+          type: EArgumentTypes.params;
+          zodSchema?: Zod.Schema;
+      }
+    | {
+          index: number;
+          type: EArgumentTypes.param;
+          key: string;
+          zodSchema?: Zod.Schema;
+      }
+    | {
+          index: number;
+          type: EArgumentTypes.query;
+          zodSchema?: Zod.Schema;
+      }
+    | {
+          index: number;
+          type: EArgumentTypes.request;
+          zodSchema?: Zod.Schema;
+      }
+    | {
+          index: number;
+          type: EArgumentTypes.responseHeaders;
+          zodSchema?: Zod.Schema;
+      };
+
+export const argumentsKey = Symbol.for("__bool:arguments__");
+
+export const RequestHeaders = (zodSchema?: Zod.Schema) => {
+    return (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+        if (!methodName) {
+            return;
+        }
+
+        const headersMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+
+        headersMetadata[`argumentIndexes.${parameterIndex}`] = {
+            index: parameterIndex,
+            type: EArgumentTypes.requestHeaders,
+            zodSchema: zodSchema
+        } satisfies Extract<
+            TArgumentsMetadata,
+            {
+                type: EArgumentTypes.requestHeaders;
+            }
+        >;
+
+        Reflect.defineMetadata(argumentsKey, headersMetadata, target.constructor, methodName);
+    };
+};
+
+export const Body = (zodSchema?: Zod.Schema, parser?: "arrayBuffer" | "blob" | "formData" | "json" | "text") => {
+    return (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+        if (!methodName) {
+            return;
+        }
+
+        const bodyMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+
+        bodyMetadata[`argumentIndexes.${parameterIndex}`] = {
+            index: parameterIndex,
+            type: EArgumentTypes.body,
+            zodSchema: zodSchema,
+            parser: parser
+        } satisfies Extract<
+            TArgumentsMetadata,
+            {
+                type: EArgumentTypes.body;
+            }
+        >;
+
+        Reflect.defineMetadata(argumentsKey, bodyMetadata, target.constructor, methodName);
+    };
+};
+
+export const Params =
+    (zodSchema?: Zod.Schema) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+        if (!methodName) {
+            return;
+        }
+
+        const paramsMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+
+        paramsMetadata[`argumentIndexes.${parameterIndex}`] = {
+            index: parameterIndex,
+            type: EArgumentTypes.params,
+            zodSchema: zodSchema
+        } satisfies Extract<
+            TArgumentsMetadata,
+            {
+                type: EArgumentTypes.params;
+            }
+        >;
+
+        Reflect.defineMetadata(argumentsKey, paramsMetadata, target.constructor, methodName);
+    };
+
+export const Param = (key: string, zodSchema?: Zod.Schema) => {
+    return (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+        if (!methodName) {
+            return;
+        }
+
+        const paramsMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+
+        paramsMetadata[`argumentIndexes.${parameterIndex}`] = {
+            index: parameterIndex,
+            type: EArgumentTypes.param,
+            key: key,
+            zodSchema: zodSchema
+        } satisfies Extract<
+            TArgumentsMetadata,
+            {
+                type: EArgumentTypes.param;
+            }
+        >;
+
+        Reflect.defineMetadata(argumentsKey, paramsMetadata, target.constructor, methodName);
+    };
+};
+
+export const Query = (zodSchema?: Zod.Schema) => {
+    return (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+        if (!methodName) {
+            return;
+        }
+
+        const queryMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+
+        queryMetadata[`argumentIndexes.${parameterIndex}`] = {
+            index: parameterIndex,
+            type: EArgumentTypes.params,
+            zodSchema: zodSchema
+        } satisfies Extract<
+            TArgumentsMetadata,
+            {
+                type: EArgumentTypes.params;
+            }
+        >;
+
+        Reflect.defineMetadata(argumentsKey, queryMetadata, target.constructor, methodName);
+    };
+};
+
+export const Request = (zodSchema?: Zod.Schema) => {
+    return (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+        if (!methodName) {
+            return;
+        }
+
+        const queryMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+
+        queryMetadata[`argumentIndexes.${parameterIndex}`] = {
+            index: parameterIndex,
+            type: EArgumentTypes.request,
+            zodSchema: zodSchema
+        } satisfies Extract<
+            TArgumentsMetadata,
+            {
+                type: EArgumentTypes.request;
+            }
+        >;
+
+        Reflect.defineMetadata(argumentsKey, queryMetadata, target.constructor, methodName);
+    };
+};
+
+export const ResponseHeaders = (zodSchema?: Zod.Schema) => {
+    return (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+        if (!methodName) {
+            return;
+        }
+
+        const queryMetadata = Reflect.getOwnMetadata(argumentsKey, target.constructor, methodName) || {};
+
+        queryMetadata[`argumentIndexes.${parameterIndex}`] = {
+            index: parameterIndex,
+            type: EArgumentTypes.responseHeaders,
+            zodSchema: zodSchema
+        } satisfies Extract<
+            TArgumentsMetadata,
+            {
+                type: EArgumentTypes.responseHeaders;
+            }
+        >;
+
+        Reflect.defineMetadata(argumentsKey, queryMetadata, target.constructor, methodName);
+    };
+};

package/src/decorators/controller.ts

@@ -1,14 +1,22 @@
-import { injectableKey } from "./injectable";
-
-export const controllerKey = Symbol.for("__bool:controller__");
-
-export const Controller =
-    (prefix: string) =>
-    <T extends Object>(target: T) => {
-        Reflect.defineMetadata(controllerKey, !prefix.startsWith("/") ? `/${prefix}` : prefix, target);
-        Reflect.defineMetadata(injectableKey, undefined, target);
-
-        return target;
-    };
-
-export default Controller;
+import type { IController } from "../interfaces/controller";
+import { controllerHttpKey, type THttpMetadata } from "./http";
+
+export type TControllerMetadata = Required<{
+    prefix: string;
+    httpMetadata: THttpMetadata;
+}>;
+
+export const controllerKey = Symbol.for("__bool:controller__");
+
+export const Controller =
+    (prefix: string) =>
+    <T extends { new (...args: any[]): IController }>(target: T) => {
+        const metadata: TControllerMetadata = {
+            prefix: !prefix.startsWith("/") ? `/${prefix}` : prefix,
+            httpMetadata: [...(Reflect.getOwnMetadata(controllerHttpKey, target.constructor) || [])]
+        };
+
+        Reflect.defineMetadata(controllerKey, metadata, target);
+    };
+
+export default Controller;

package/src/decorators/dispatcher.ts

@@ -0,0 +1,19 @@
+import type { IDispatcher } from "../interfaces/dispatcher";
+
+export type TDispatcherMetadata = undefined;
+
+export const dispatcherKey = Symbol.for("__bool:dispatcher__");
+
+export const Dispatcher =
+    () =>
+    <T extends { new (...args: any[]): IDispatcher }>(target: T) => {
+        if (!("execute" in target.prototype) || typeof target.prototype.execute !== "function") {
+            return;
+        }
+
+        const metadata: TDispatcherMetadata = undefined;
+
+        Reflect.defineMetadata(dispatcherKey, metadata, target);
+    };
+
+export default Dispatcher;

package/src/decorators/guard.ts

@@ -0,0 +1,19 @@
+import type { IGuard } from "../interfaces";
+
+export type TGuardMetadata = undefined;
+
+export const guardKey = Symbol.for("__bool:guard__");
+
+export const Guard =
+    () =>
+    <T extends { new (...args: any[]): IGuard }>(target: T) => {
+        if (!("enforce" in target.prototype) || typeof target.prototype.enforce !== "function") {
+            return;
+        }
+
+        const metadata = undefined;
+
+        Reflect.defineMetadata(guardKey, metadata, target);
+    };
+
+export default Guard;

package/src/decorators/http.ts

@@ -1,81 +1,81 @@
-export interface IControllerRoute {
-    path: string;
-    httpMethod: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS";
-    methodName: string;
-    descriptor: PropertyDescriptor;
-}
-
-export const controllerRoutesKey = Symbol.for("__bool:controller.routes__");
-
-const defaultDecorator =
-    (path: string, method: "Get" | "Post" | "Put" | "Patch" | "Delete" | "Options") =>
-    (target: Object, methodName: string, descriptor: PropertyDescriptor) => {
-        if (!(descriptor.value instanceof Function)) {
-            throw Error(`${method} decorator only use for class method.`);
-        }
-
-        // Define controller metadata
-        Reflect.defineMetadata(
-            controllerRoutesKey,
-            [
-                ...(Reflect.getOwnMetadata(controllerRoutesKey, target.constructor) || []),
-                {
-                    path: !path.startsWith("/") ? `/${path}` : path,
-                    httpMethod: method.toUpperCase(),
-                    methodName: methodName,
-                    descriptor: descriptor
-                }
-            ],
-            target.constructor
-        );
-    };
-
-/**
- *
- * @param path
- * @returns
- */
-export const Get = (path = "/") => defaultDecorator(path, "Get");
-
-/**
- *
- * @param path
- * @returns
- */
-export const Post = (path = "/") => defaultDecorator(path, "Post");
-
-/**
- *
- * @param path
- * @returns
- */
-export const Put = (path = "/") => defaultDecorator(path, "Put");
-
-/**
- *
- * @param path
- * @returns
- */
-export const Patch = (path = "/") => defaultDecorator(path, "Patch");
-
-/**
- *
- * @param path
- * @returns
- */
-export const Delete = (path = "/") => defaultDecorator(path, "Delete");
-
-/**
- *
- * @param path
- * @returns
- */
-export const Options = (path = "/") => defaultDecorator(path, "Options");
-
-export default {
-    Get,
-    Post,
-    Put,
-    Patch,
-    Delete
-};
+export type TRoute = {
+    path: string;
+    httpMethod: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS";
+    methodName: string;
+    descriptor: PropertyDescriptor;
+};
+
+export type THttpMetadata = Array<TRoute>;
+
+export const controllerHttpKey = Symbol.for("__bool:controller.http__");
+
+const defaultDecorator =
+    (path: string, method: "Get" | "Post" | "Put" | "Patch" | "Delete" | "Options") =>
+    (target: Object, methodName: string, descriptor: PropertyDescriptor) => {
+        if (!(descriptor.value instanceof Function)) {
+            throw Error(`${method} decorator only use for class method.`);
+        }
+
+        const metadata: THttpMetadata = [
+            ...(Reflect.getOwnMetadata(controllerHttpKey, target.constructor) || []),
+            {
+                path: !path.startsWith("/") ? `/${path}` : path,
+                httpMethod: method.toUpperCase(),
+                methodName: methodName,
+                descriptor: descriptor
+            }
+        ];
+
+        // Define controller metadata
+        Reflect.defineMetadata(controllerHttpKey, metadata, target.constructor);
+    };
+
+/**
+ *
+ * @param path
+ * @returns
+ */
+export const Get = (path = "/") => defaultDecorator(path, "Get");
+
+/**
+ *
+ * @param path
+ * @returns
+ */
+export const Post = (path = "/") => defaultDecorator(path, "Post");
+
+/**
+ *
+ * @param path
+ * @returns
+ */
+export const Put = (path = "/") => defaultDecorator(path, "Put");
+
+/**
+ *
+ * @param path
+ * @returns
+ */
+export const Patch = (path = "/") => defaultDecorator(path, "Patch");
+
+/**
+ *
+ * @param path
+ * @returns
+ */
+export const Delete = (path = "/") => defaultDecorator(path, "Delete");
+
+/**
+ *
+ * @param path
+ * @returns
+ */
+export const Options = (path = "/") => defaultDecorator(path, "Options");
+
+export default {
+    Get,
+    Post,
+    Put,
+    Patch,
+    Delete
+};