@bool-ts/core 1.6.13 → 1.7.0

package/src/decorators/guard.ts

@@ -1,18 +1,18 @@
-import type { IGuard } from "../interfaces";
-import { guardKey } from "../keys";
-
-export type TGuardMetadata = undefined;
-
-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;
+import type { IGuard } from "../interfaces";
+import { guardKey } from "../keys";
+
+export type TGuardMetadata = undefined;
+
+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 @@
-import { controllerHttpKey } from "../keys";
-
-export type TRoute = {
-    path: string;
-    httpMethod: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS";
-    methodName: string;
-    descriptor: PropertyDescriptor;
-};
-
-export type THttpMetadata = Array<TRoute>;
-
-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
-};
+import { controllerHttpKey } from "../keys";
+
+export type TRoute = {
+    path: string;
+    httpMethod: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS";
+    methodName: string;
+    descriptor: PropertyDescriptor;
+};
+
+export type THttpMetadata = Array<TRoute>;
+
+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
+};

package/src/decorators/index.ts

@@ -1,29 +1,29 @@
-export {
-    Body,
-    Context,
-    Param,
-    Params,
-    Query,
-    Request,
-    RequestHeader,
-    RequestHeaders,
-    ResponseHeaders,
-    RouteModel
-} from "./arguments";
-export { Controller } from "./controller";
-export { Dispatcher } from "./dispatcher";
-export { Guard } from "./guard";
-export { Delete, Get, Options, Patch, Post, Put } from "./http";
-export { Inject } from "./inject";
-export { Injectable } from "./injectable";
-export { Middleware } from "./middleware";
-export { Module } from "./module";
-export { ZodSchema } from "./zodSchema";
-
-export type { TArgumentsMetadata } from "./arguments";
-export type { TControllerMetadata } from "./controller";
-export type { TDispatcherMetadata } from "./dispatcher";
-export type { TGuardMetadata } from "./guard";
-export type { THttpMetadata } from "./http";
-export type { TMiddlewareMetadata } from "./middleware";
-export type { TModuleMetadata, TModuleOptions } from "./module";
+export {
+    Context,
+    Param,
+    Params,
+    Query,
+    Request,
+    RequestBody,
+    RequestHeader,
+    RequestHeaders,
+    ResponseHeaders,
+    RouteModel
+} from "./arguments";
+export { Controller } from "./controller";
+export { Dispatcher } from "./dispatcher";
+export { Guard } from "./guard";
+export { Delete, Get, Options, Patch, Post, Put } from "./http";
+export { Inject } from "./inject";
+export { Injectable } from "./injectable";
+export { Middleware } from "./middleware";
+export { Module } from "./module";
+export { ZodSchema } from "./zodSchema";
+
+export type { TArgumentsMetadata } from "./arguments";
+export type { TControllerMetadata } from "./controller";
+export type { TDispatcherMetadata } from "./dispatcher";
+export type { TGuardMetadata } from "./guard";
+export type { THttpMetadata } from "./http";
+export type { TMiddlewareMetadata } from "./middleware";
+export type { TModuleMetadata, TModuleOptions } from "./module";

package/src/decorators/inject.ts

@@ -1,13 +1,13 @@
-import { injectKey } from "../keys";
-
-export const Inject = <T extends Object>(definition: { new (...args: any[]): T } | string | symbol) => {
-    return (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
-        const designParameterTypes: any[] = Reflect.getMetadata(injectKey, target) || [];
-
-        designParameterTypes[parameterIndex] = definition;
-
-        Reflect.defineMetadata(injectKey, designParameterTypes, target);
-    };
-};
-
-export default Inject;
+import { injectKey } from "../keys";
+
+export const Inject = <T extends Object>(definition: { new (...args: any[]): T } | string | symbol) => {
+    return (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+        const designParameterTypes: any[] = Reflect.getMetadata(injectKey, target) || [];
+
+        designParameterTypes[parameterIndex] = definition;
+
+        Reflect.defineMetadata(injectKey, designParameterTypes, target);
+    };
+};
+
+export default Inject;

package/src/decorators/injectable.ts

@@ -1,8 +1,8 @@
-import { injectableKey } from "../keys";
-
-export const Injectable =
-    () =>
-    <T extends Object>(target: T) =>
-        Reflect.defineMetadata(injectableKey, undefined, target);
-
-export default Injectable;
+import { injectableKey } from "../keys";
+
+export const Injectable =
+    () =>
+    <T extends Object>(target: T) =>
+        Reflect.defineMetadata(injectableKey, undefined, target);
+
+export default Injectable;

package/src/decorators/middleware.ts

@@ -1,18 +1,14 @@
-import type { IMiddleware } from "../interfaces";
-import { middlewareKey } from "../keys";
-
-export type TMiddlewareMetadata = undefined;
-
-export const Middleware =
-    () =>
-    <T extends { new (...args: any[]): IMiddleware }>(target: T) => {
-        if (!("enforce" in target.prototype) || typeof target.prototype.enforce !== "function") {
-            return;
-        }
-
-        const metadata: TMiddlewareMetadata = undefined;
-
-        Reflect.defineMetadata(middlewareKey, metadata, target);
-    };
-
-export default Middleware;
+import type { IMiddleware } from "../interfaces";
+import { middlewareKey } from "../keys";
+
+export type TMiddlewareMetadata = undefined;
+
+export const Middleware =
+    () =>
+    <T extends { new (...args: any[]): IMiddleware }>(target: T) => {
+        const metadata: TMiddlewareMetadata = undefined;
+
+        Reflect.defineMetadata(middlewareKey, metadata, target);
+    };
+
+export default Middleware;

package/src/decorators/module.ts

@@ -1,94 +1,84 @@
-import type { IModule } from "../interfaces/module";
-import { controllerKey, dispatcherKey, guardKey, injectableKey, middlewareKey, moduleKey } from "../keys";
-
-type TInstances = Array<new (...args: any[]) => any>;
-type TLoaders<TConfig extends {} = {}> = Record<
-    string | symbol,
-    (args: { config: TConfig }) => [string | symbol, any] | Promise<[string | symbol, any]>
->;
-
-export type TModuleOptions<TConfig extends {} = {}> =
-    | Partial<{
-          config: TConfig | (() => TConfig | Promise<TConfig>);
-          prefix: string;
-          dependencies: TInstances;
-          loaders: TLoaders<TConfig>;
-          middlewares: TInstances;
-          guards: TInstances;
-          beforeDispatchers: TInstances;
-          controllers: TInstances;
-          afterDispatchers: TInstances;
-      }>
-    | undefined;
-
-export type TModuleMetadata<TConfig extends {} = {}> =
-    | Partial<{
-          config: TConfig | ((...args: any[]) => TConfig | Promise<TConfig>);
-          prefix: string;
-          dependencies: TInstances;
-          loaders: TLoaders<TConfig>;
-          middlewares: TInstances;
-          guards: TInstances;
-          beforeDispatchers: TInstances;
-          controllers: TInstances;
-          afterDispatchers: TInstances;
-      }>
-    | undefined;
-
-export const Module =
-    <TConfig extends {} = {}>(args?: TModuleOptions<TConfig>) =>
-    <T extends { new (...args: any[]): IModule }>(target: T) => {
-        const { middlewares, guards, beforeDispatchers, controllers, afterDispatchers, dependencies } = args || {};
-
-        if (middlewares) {
-            for (let i = 0; i < middlewares.length; i++) {
-                if (!Reflect.getOwnMetadataKeys(middlewares[i]).includes(middlewareKey)) {
-                    throw Error(`${middlewares[i].name} is not a middleware.`);
-                }
-            }
-        }
-
-        if (guards) {
-            for (let i = 0; i < guards.length; i++) {
-                if (!Reflect.getOwnMetadataKeys(guards[i]).includes(guardKey)) {
-                    throw Error(`${guards[i].name} is not a guard.`);
-                }
-            }
-        }
-
-        if (beforeDispatchers) {
-            for (let i = 0; i < beforeDispatchers.length; i++) {
-                if (!Reflect.getOwnMetadataKeys(beforeDispatchers[i]).includes(dispatcherKey)) {
-                    throw Error(`${beforeDispatchers[i].name} is not a dispatcher.`);
-                }
-            }
-        }
-
-        if (controllers) {
-            for (let i = 0; i < controllers.length; i++) {
-                if (!Reflect.getOwnMetadataKeys(controllers[i]).includes(controllerKey)) {
-                    throw Error(`${controllers[i].name} is not a controller.`);
-                }
-            }
-        }
-
-        if (afterDispatchers) {
-            for (let i = 0; i < afterDispatchers.length; i++) {
-                if (!Reflect.getOwnMetadataKeys(afterDispatchers[i]).includes(dispatcherKey)) {
-                    throw Error(`${afterDispatchers[i].name} is not a dispatcher.`);
-                }
-            }
-        }
-
-        if (dependencies) {
-            for (let i = 0; i < dependencies.length; i++) {
-                if (!Reflect.getOwnMetadataKeys(dependencies[i]).includes(injectableKey)) {
-                    throw Error(`${dependencies[i].name} is not an injectable.`);
-                }
-            }
-        }
-
-        Reflect.defineMetadata(moduleKey, args, target);
-    };
-
-export default Module;
+import type { IModule } from "../interfaces/module";
+import { controllerKey, dispatcherKey, guardKey, injectableKey, middlewareKey, moduleKey } from "../keys";
+
+type TInstances = Array<new (...args: any[]) => any>;
+type TLoaders<TConfig extends {} = {}> = Record<
+    string | symbol,
+    (args: { config: TConfig }) => [string | symbol, any] | Promise<[string | symbol, any]>
+>;
+
+export type TModuleOptions<TConfig extends {} = {}> =
+    | Partial<{
+          config: TConfig | (() => TConfig | Promise<TConfig>);
+          prefix: string;
+          dependencies: TInstances;
+          loaders: TLoaders<TConfig>;
+          middlewares: TInstances;
+          guards: TInstances;
+          controllers: TInstances;
+          dispatchers: TInstances;
+      }>
+    | undefined;
+
+export type TModuleMetadata<TConfig extends {} = {}> =
+    | Partial<{
+          config: TConfig | ((...args: any[]) => TConfig | Promise<TConfig>);
+          prefix: string;
+          dependencies: TInstances;
+          loaders: TLoaders<TConfig>;
+          middlewares: TInstances;
+          guards: TInstances;
+          controllers: TInstances;
+          dispatchers: TInstances;
+      }>
+    | undefined;
+
+export const Module =
+    <TConfig extends {} = {}>(args?: TModuleOptions<TConfig>) =>
+    <T extends { new (...args: any[]): IModule }>(target: T) => {
+        const { middlewares, guards, dispatchers, controllers, dependencies } = args || {};
+
+        if (middlewares) {
+            for (let i = 0; i < middlewares.length; i++) {
+                if (!Reflect.getOwnMetadataKeys(middlewares[i]).includes(middlewareKey)) {
+                    throw Error(`${middlewares[i].name} is not a middleware.`);
+                }
+            }
+        }
+
+        if (guards) {
+            for (let i = 0; i < guards.length; i++) {
+                if (!Reflect.getOwnMetadataKeys(guards[i]).includes(guardKey)) {
+                    throw Error(`${guards[i].name} is not a guard.`);
+                }
+            }
+        }
+
+        if (dispatchers) {
+            for (let i = 0; i < dispatchers.length; i++) {
+                if (!Reflect.getOwnMetadataKeys(dispatchers[i]).includes(dispatcherKey)) {
+                    throw Error(`${dispatchers[i].name} is not a dispatcher.`);
+                }
+            }
+        }
+
+        if (controllers) {
+            for (let i = 0; i < controllers.length; i++) {
+                if (!Reflect.getOwnMetadataKeys(controllers[i]).includes(controllerKey)) {
+                    throw Error(`${controllers[i].name} is not a controller.`);
+                }
+            }
+        }
+
+        if (dependencies) {
+            for (let i = 0; i < dependencies.length; i++) {
+                if (!Reflect.getOwnMetadataKeys(dependencies[i]).includes(injectableKey)) {
+                    throw Error(`${dependencies[i].name} is not an injectable.`);
+                }
+            }
+        }
+
+        Reflect.defineMetadata(moduleKey, args, target);
+    };
+
+export default Module;

package/src/decorators/zodSchema.ts

@@ -1,19 +1,19 @@
-import * as Zod from "zod";
-import { controllerRouteZodSchemaKey } from "../keys";
-
-export const ZodSchema = (schema: Zod.Schema) => {
-    return (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
-        if (!methodName) {
-            return;
-        }
-
-        const zodSchemasMetadata = Reflect.getOwnMetadata(controllerRouteZodSchemaKey, target.constructor, methodName) || {};
-
-        zodSchemasMetadata[`paramterIndexes.${parameterIndex}`] = {
-            index: parameterIndex,
-            schema: schema
-        };
-
-        Reflect.defineMetadata(controllerRouteZodSchemaKey, zodSchemasMetadata, target.constructor, methodName);
-    };
-};
+import * as Zod from "zod";
+import { controllerRouteZodSchemaKey } from "../keys";
+
+export const ZodSchema = (schema: Zod.Schema) => {
+    return (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+        if (!methodName) {
+            return;
+        }
+
+        const zodSchemasMetadata = Reflect.getOwnMetadata(controllerRouteZodSchemaKey, target.constructor, methodName) || {};
+
+        zodSchemasMetadata[`paramterIndexes.${parameterIndex}`] = {
+            index: parameterIndex,
+            schema: schema
+        };
+
+        Reflect.defineMetadata(controllerRouteZodSchemaKey, zodSchemasMetadata, target.constructor, methodName);
+    };
+};

package/src/entities/index.ts

@@ -1,5 +1,5 @@
-export type { TRouteModel } from "./route";
-
-export { Route } from "./route";
-export { Router } from "./router";
-export { RouterGroup } from "./routerGroup";
+export type { TRouteModel } from "./route";
+
+export { Route } from "./route";
+export { Router } from "./router";
+export { RouterGroup } from "./routerGroup";