@bool-ts/core 1.4.1 → 1.5.0

package/src/decorators/index.ts

@@ -1,7 +1,28 @@
-export { Headers, Body, Params, Param, Query, EArgumentTypes } from "./arguments";
-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";
-export { ZodSchema, controllerRouteZodSchemaKey } from "./zodSchema";
+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,11 +1,8 @@
-export const injectableKey = Symbol.for("__bool:injectable__");
-
-export const Injectable =
-    () =>
-    <T extends Object>(target: T) => {
-        Reflect.defineMetadata(injectableKey, undefined, target);
-
-        return 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

@@ -0,0 +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;

package/src/decorators/module.ts

@@ -1,21 +1,100 @@
-export type TModuleOptions =
-    | Partial<{
-          prefix: string;
-          controllers: Array<new (...args: any[]) => unknown>;
-          dependencies: Array<new (...args: any[]) => unknown>;
-          allowOrigins: string | Array<string>;
-          allowMethods: Array<"GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS">;
-      }>
-    | undefined;
-
-export const moduleKey = Symbol.for("__bool:module__");
-
-export const Module =
-    (args?: TModuleOptions) =>
-    <T extends { new (...args: any[]): {} }>(target: T) => {
-        Reflect.defineMetadata(moduleKey, args, target);
-
-        return 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<{
+          options: Partial<{
+              prefix: string;
+              allowOrigins: string | Array<string>;
+              allowMethods: Array<"GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS">;
+          }>;
+          dependencies: TInstances;
+          controllers: TInstances;
+          middlewares: TInstances;
+          guards: TInstances;
+          beforeDispatchers: TInstances;
+          afterDispatchers: TInstances;
+      }>
+    | undefined;
+
+export type TModuleMetadata =
+    | Partial<{
+          options: Partial<{
+              prefix: string;
+              allowOrigins: string | Array<string>;
+              allowMethods: Array<"GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS">;
+          }>;
+          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";