@bool-ts/core 1.4.1 → 1.5.0

package/dist/decorators/guard.js

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

package/dist/decorators/http.d.ts

@@ -1,10 +1,11 @@
-export interface IControllerRoute {
+export type TRoute = {
     path: string;
     httpMethod: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS";
     methodName: string;
     descriptor: PropertyDescriptor;
-}
-export declare const controllerRoutesKey: unique symbol;
+};
+export type THttpMetadata = Array<TRoute>;
+export declare const controllerHttpKey: unique symbol;
 /**
  *
  * @param path

package/dist/decorators/http.js

@@ -1,18 +1,19 @@
-export const controllerRoutesKey = Symbol.for("__bool:controller.routes__");
+export const controllerHttpKey = Symbol.for("__bool:controller.http__");
 const defaultDecorator = (path, method) => (target, methodName, descriptor) => {
     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) || []),
+    const metadata = [
+        ...(Reflect.getOwnMetadata(controllerHttpKey, target.constructor) || []),
         {
             path: !path.startsWith("/") ? `/${path}` : path,
             httpMethod: method.toUpperCase(),
             methodName: methodName,
             descriptor: descriptor
         }
-    ], target.constructor);
+    ];
+    // Define controller metadata
+    Reflect.defineMetadata(controllerHttpKey, metadata, target.constructor);
 };
 /**
  *

package/dist/decorators/index.d.ts

@@ -1,7 +1,17 @@
-export { Headers, Body, Params, Param, Query, EArgumentTypes } from "./arguments";
+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 { Module, moduleKey, type TModuleOptions } from "./module";
-export { Get, Post, Put, Patch, Delete, Options, controllerRoutesKey, type IControllerRoute } from "./http";
+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/dist/decorators/index.js

@@ -1,7 +1,10 @@
-export { Headers, Body, Params, Param, Query, EArgumentTypes } from "./arguments";
+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, controllerRoutesKey } from "./http";
+export { Get, Post, Put, Patch, Delete, Options, controllerHttpKey } from "./http";
 export { ZodSchema, controllerRouteZodSchemaKey } from "./zodSchema";
+export { Dispatcher, dispatcherKey } from "./dispatcher";

package/dist/decorators/injectable.d.ts

@@ -1,3 +1,3 @@
 export declare const injectableKey: unique symbol;
-export declare const Injectable: () => <T extends Object>(target: T) => T;
+export declare const Injectable: () => <T extends Object>(target: T) => void;
 export default Injectable;

package/dist/decorators/injectable.js

@@ -1,6 +1,3 @@
 export const injectableKey = Symbol.for("__bool:injectable__");
-export const Injectable = () => (target) => {
-    Reflect.defineMetadata(injectableKey, undefined, target);
-    return target;
-};
+export const Injectable = () => (target) => Reflect.defineMetadata(injectableKey, undefined, target);
 export default Injectable;

package/dist/decorators/middleware.d.ts

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

package/dist/decorators/middleware.js

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

package/dist/decorators/module.d.ts

@@ -1,12 +1,33 @@
+import type { IModule } from "../interfaces/module";
+type TInstances = Array<new (...args: any[]) => any>;
 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">;
+    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 declare const moduleKey: unique symbol;
 export declare const Module: (args?: TModuleOptions) => <T extends {
-    new (...args: any[]): {};
-}>(target: T) => T;
+    new (...args: any[]): IModule;
+}>(target: T) => void;
 export default Module;

package/dist/decorators/module.js

@@ -1,6 +1,53 @@
+import { controllerKey } from "./controller";
+import { dispatcherKey } from "./dispatcher";
+import { guardKey } from "./guard";
+import { injectableKey } from "./injectable";
+import { middlewareKey } from "./middleware";
 export const moduleKey = Symbol.for("__bool:module__");
 export const Module = (args) => (target) => {
+    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);
-    return target;
 };
 export default Module;

package/dist/entities/route.d.ts

@@ -1,6 +1,6 @@
 import type { THttpMethods } from "../http";
 type THandler<T = unknown> = Required<{
-    constructor: new (...args: Array<any>) => T;
+    class: new (...args: Array<any>) => T;
     funcName: string | symbol;
     func: (...args: Array<any>) => unknown;
 }>;
@@ -47,7 +47,7 @@ export declare class Route {
      * @returns
      */
     connect(...handlers: Array<THandler>): this | Map<keyof THttpMethods, Required<{
-        constructor: new (...args: Array<any>) => unknown;
+        class: new (...args: Array<any>) => unknown;
         funcName: string | symbol;
         func: (...args: Array<any>) => unknown;
     }>[]>;
@@ -57,7 +57,7 @@ export declare class Route {
      * @returns
      */
     options(...handlers: Array<THandler>): this | Map<keyof THttpMethods, Required<{
-        constructor: new (...args: Array<any>) => unknown;
+        class: new (...args: Array<any>) => unknown;
         funcName: string | symbol;
         func: (...args: Array<any>) => unknown;
     }>[]>;
@@ -67,7 +67,7 @@ export declare class Route {
      * @returns
      */
     trace(...handlers: Array<THandler>): this | Map<keyof THttpMethods, Required<{
-        constructor: new (...args: Array<any>) => unknown;
+        class: new (...args: Array<any>) => unknown;
         funcName: string | symbol;
         func: (...args: Array<any>) => unknown;
     }>[]>;
@@ -77,7 +77,7 @@ export declare class Route {
      * @returns
      */
     patch(...handlers: Array<THandler>): this | Map<keyof THttpMethods, Required<{
-        constructor: new (...args: Array<any>) => unknown;
+        class: new (...args: Array<any>) => unknown;
         funcName: string | symbol;
         func: (...args: Array<any>) => unknown;
     }>[]>;

package/dist/entities/routerGroup.d.ts

@@ -6,7 +6,7 @@ export declare class RouterGroup {
     find(pathame: string, method: keyof THttpMethods): Readonly<{
         params: Record<string, string>;
         handlers: Array<Required<{
-            constructor: new (...args: Array<any>) => unknown;
+            class: new (...args: Array<any>) => unknown;
             funcName: string | symbol;
             func: (...args: Array<any>) => unknown;
         }>>;

package/dist/hooks/factory.d.ts

@@ -13,7 +13,7 @@ export type TBoolFactoryOptions = Required<{
     }>;
     queryParser: Parameters<typeof Qs.parse>[1];
 }>;
-export declare const controllerCreator: (controllerConstructor: new (...args: any[]) => unknown, group: RouterGroup) => RouterGroup;
-export declare const controllerActionArgumentsResolution: (data: unknown, zodSchema: Zod.Schema, argumentIndex: number, funcName: string | symbol) => Promise<any>;
-export declare const BoolFactory: (target: new (...args: any[]) => unknown, options: TBoolFactoryOptions) => void;
+export declare const controllerCreator: (controllerConstructor: new (...args: any[]) => unknown, group: RouterGroup, prefix?: string) => RouterGroup;
+export declare const argumentsResolution: (data: unknown, zodSchema: Zod.Schema, argumentIndex: number, funcName: string | symbol) => Promise<any>;
+export declare const BoolFactory: (target: new (...args: any[]) => unknown, options: TBoolFactoryOptions) => import("bun").Server | undefined;
 export default BoolFactory;