@bool-ts/core 1.5.6 → 1.5.8

package/src/decorators/http.ts

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

package/src/decorators/index.ts

@@ -1,28 +1,28 @@
-export {
-    RequestHeaders,
-    Body,
-    Params,
-    Param,
-    Query,
-    Request,
-    ResponseHeaders,
-    EArgumentTypes,
-    argumentsKey
-} from "./arguments";
-export { Controller, controllerKey } from "./controller";
-export { Guard, guardKey } from "./guard";
-export { Inject, injectKey } from "./inject";
-export { Injectable, injectableKey } from "./injectable";
-export { Middleware, middlewareKey } from "./middleware";
-export { Module, moduleKey } from "./module";
-export { Get, Post, Put, Patch, Delete, Options, controllerHttpKey } from "./http";
-export { ZodSchema, controllerRouteZodSchemaKey } from "./zodSchema";
-export { Dispatcher, dispatcherKey } from "./dispatcher";
-
-export type { TControllerMetadata } from "./controller";
-export type { TModuleMetadata, TModuleOptions } from "./module";
-export type { THttpMetadata } from "./http";
-export type { TArgumentsMetadata } from "./arguments";
-export type { TMiddlewareMetadata } from "./middleware";
-export type { TGuardMetadata } from "./guard";
-export type { TDispatcherMetadata } from "./dispatcher";
+export {
+    RequestHeaders,
+    Body,
+    Params,
+    Param,
+    Query,
+    Request,
+    ResponseHeaders,
+    EArgumentTypes,
+    argumentsKey
+} from "./arguments";
+export { Controller, controllerKey } from "./controller";
+export { Guard, guardKey } from "./guard";
+export { Inject, injectKey } from "./inject";
+export { Injectable, injectableKey } from "./injectable";
+export { Middleware, middlewareKey } from "./middleware";
+export { Module, moduleKey } from "./module";
+export { Get, Post, Put, Patch, Delete, Options, controllerHttpKey } from "./http";
+export { ZodSchema, controllerRouteZodSchemaKey } from "./zodSchema";
+export { Dispatcher, dispatcherKey } from "./dispatcher";
+
+export type { TControllerMetadata } from "./controller";
+export type { TModuleMetadata, TModuleOptions } from "./module";
+export type { THttpMetadata } from "./http";
+export type { TArgumentsMetadata } from "./arguments";
+export type { TMiddlewareMetadata } from "./middleware";
+export type { TGuardMetadata } from "./guard";
+export type { TDispatcherMetadata } from "./dispatcher";

package/src/decorators/inject.ts

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

package/src/decorators/injectable.ts

@@ -1,8 +1,8 @@
-export const injectableKey = Symbol.for("__bool:injectable__");
-
-export const Injectable =
-    () =>
-    <T extends Object>(target: T) =>
-        Reflect.defineMetadata(injectableKey, undefined, target);
-
-export default Injectable;
+export const injectableKey = Symbol.for("__bool:injectable__");
+
+export const Injectable =
+    () =>
+    <T extends Object>(target: T) =>
+        Reflect.defineMetadata(injectableKey, undefined, target);
+
+export default Injectable;

package/src/decorators/middleware.ts

@@ -1,19 +1,19 @@
-import type { IMiddleware } from "../interfaces";
-
-export type TMiddlewareMetadata = undefined;
-
-export const middlewareKey = Symbol.for("__bool:middleware__");
-
-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";
+
+export type TMiddlewareMetadata = undefined;
+
+export const middlewareKey = Symbol.for("__bool:middleware__");
+
+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;

package/src/decorators/module.ts

@@ -1,92 +1,92 @@
-import type { IModule } from "../interfaces/module";
-import { controllerKey } from "./controller";
-import { dispatcherKey } from "./dispatcher";
-import { guardKey } from "./guard";
-import { injectableKey } from "./injectable";
-import { middlewareKey } from "./middleware";
-
-type TInstances = Array<new (...args: any[]) => any>;
-
-export type TModuleOptions =
-    | Partial<{
-          prefix: string;
-          dependencies: TInstances;
-          controllers: TInstances;
-          middlewares: TInstances;
-          guards: TInstances;
-          beforeDispatchers: TInstances;
-          afterDispatchers: TInstances;
-      }>
-    | undefined;
-
-export type TModuleMetadata =
-    | Partial<{
-          prefix: string;
-          controllers: TInstances;
-          dependencies: TInstances;
-          middlewares: TInstances;
-          guards: TInstances;
-          beforeDispatchers: TInstances;
-          afterDispatchers: TInstances;
-      }>
-    | undefined;
-
-export const moduleKey = Symbol.for("__bool:module__");
-
-export const Module =
-    (args?: TModuleOptions) =>
-    <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 } from "./controller";
+import { dispatcherKey } from "./dispatcher";
+import { guardKey } from "./guard";
+import { injectableKey } from "./injectable";
+import { middlewareKey } from "./middleware";
+
+type TInstances = Array<new (...args: any[]) => any>;
+
+export type TModuleOptions =
+    | Partial<{
+          prefix: string;
+          dependencies: TInstances;
+          controllers: TInstances;
+          middlewares: TInstances;
+          guards: TInstances;
+          beforeDispatchers: TInstances;
+          afterDispatchers: TInstances;
+      }>
+    | undefined;
+
+export type TModuleMetadata =
+    | Partial<{
+          prefix: string;
+          controllers: TInstances;
+          dependencies: TInstances;
+          middlewares: TInstances;
+          guards: TInstances;
+          beforeDispatchers: TInstances;
+          afterDispatchers: TInstances;
+      }>
+    | undefined;
+
+export const moduleKey = Symbol.for("__bool:module__");
+
+export const Module =
+    (args?: TModuleOptions) =>
+    <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;

package/src/decorators/zodSchema.ts

@@ -1,20 +1,20 @@
-import * as Zod from "zod";
-
-export const controllerRouteZodSchemaKey = Symbol.for("__bool:controller.route.zodSchema__");
-
-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";
+
+export const controllerRouteZodSchemaKey = Symbol.for("__bool:controller.route.zodSchema__");
+
+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,3 +1,3 @@
-export { Route } from "./route";
-export { Router } from "./router";
-export { RouterGroup } from "./routerGroup";
+export { Route } from "./route";
+export { Router } from "./router";
+export { RouterGroup } from "./routerGroup";