@bool-ts/core 1.7.16 → 1.8.0

package/dist/hooks/injector.js

@@ -1,5 +1,5 @@
 import "reflect-metadata";
-import { controllerKey, dispatcherKey, guardKey, injectableKey, injectKey, middlewareKey } from "../keys";
+import { controllerKey, dispatcherKey, guardKey, injectableKey, injectKey, middlewareKey, webSocketKey } from "../keys";
 export class Injector {
     _mapper = new Map();
     /**
@@ -14,7 +14,7 @@ export class Injector {
             return undefined;
         }
         const ownMetadataKeys = Reflect.getMetadataKeys(definition);
-        if (![injectableKey, controllerKey, middlewareKey, guardKey, dispatcherKey].some((value) => ownMetadataKeys.includes(value))) {
+        if (![injectableKey, controllerKey, middlewareKey, guardKey, dispatcherKey, webSocketKey].some((value) => ownMetadataKeys.includes(value))) {
             throw Error("Missing dependency declaration, please check @Injectable() used on dependency(ies).");
         }
         // Initialize dependencies injection

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import "reflect-metadata";
-export type { TRouteModel } from "./entities";
+export type { THttpRouteModel } from "./entities";
 export * from "./decorators";
 export * from "./hooks";
 export * from "./http";

package/dist/interfaces/index.d.ts

@@ -4,3 +4,4 @@ export type { IDispatcher } from "./dispatcher";
 export type { IGuard } from "./guard";
 export type { IMiddleware } from "./middleware";
 export type { IModule } from "./module";
+export type { IWebSocket } from "./webSocket";

package/dist/interfaces/webSocket.d.ts

@@ -0,0 +1,2 @@
+export interface IWebSocket<T = any> {
+}

package/dist/interfaces/webSocket.js

@@ -0,0 +1 @@
+export {};

package/dist/keys/index.d.ts

@@ -1,4 +1,5 @@
 export declare const argumentsKey: unique symbol;
+export declare const webSocketEventArgumentsKey: unique symbol;
 export declare const configKey: unique symbol;
 export declare const controllerKey: unique symbol;
 export declare const dispatcherKey: unique symbol;
@@ -8,7 +9,15 @@ export declare const injectKey: unique symbol;
 export declare const injectableKey: unique symbol;
 export declare const middlewareKey: unique symbol;
 export declare const moduleKey: unique symbol;
-export declare const controllerRouteZodSchemaKey: unique symbol;
+export declare const zodSchemaKey: unique symbol;
+export declare const webSocketKey: unique symbol;
+export declare const webSocketEventKey: unique symbol;
+export declare const webSocketServerArgsKey: unique symbol;
+export declare const webSocketConnectionArgsKey: unique symbol;
+export declare const webSocketMessageArgsKey: unique symbol;
+export declare const webSocketCloseCodeArgsKey: unique symbol;
+export declare const webSocketCloseReasonArgsKey: unique symbol;
+export declare const httpServerArgsKey: unique symbol;
 export declare const requestHeadersArgsKey: unique symbol;
 export declare const requestHeaderArgsKey: unique symbol;
 export declare const requestBodyArgsKey: unique symbol;

package/dist/keys/index.js

@@ -1,4 +1,5 @@
 export const argumentsKey = Symbol("__bool:arguments__");
+export const webSocketEventArgumentsKey = Symbol("__bool:webSocketEventArguments__");
 export const configKey = Symbol("__bool:config__");
 export const controllerKey = Symbol("__bool:controller__");
 export const dispatcherKey = Symbol("__bool:dispatcher__");
@@ -8,15 +9,23 @@ export const injectKey = Symbol("__bool:inject__");
 export const injectableKey = Symbol("__bool:injectable__");
 export const middlewareKey = Symbol("__bool:middleware__");
 export const moduleKey = Symbol("__bool:module__");
-export const controllerRouteZodSchemaKey = Symbol("__bool:controller.route.zodSchema__");
-export const requestHeadersArgsKey = Symbol("__bool:arguments:requestHeaders__");
-export const requestHeaderArgsKey = Symbol("__bool:arguments:requestHeader__");
-export const requestBodyArgsKey = Symbol("__bool:arguments:requestBody__");
-export const paramsArgsKey = Symbol("__bool:arguments:params__");
-export const paramArgsKey = Symbol("__bool:arguments:param__");
-export const queryArgsKey = Symbol("__bool:arguments:query__");
-export const requestArgsKey = Symbol("__bool:arguments:request__");
-export const responseHeadersArgsKey = Symbol("__bool:arguments:responseHeaders__");
-export const contextArgsKey = Symbol("__bool:arguments:context__");
-export const routeModelArgsKey = Symbol("__bool:arguments:routeModel__");
-export const responseBodyArgsKey = Symbol("__bool:arguments:responseBody__");
+export const zodSchemaKey = Symbol("__bool:zodSchema__");
+export const webSocketKey = Symbol("__bool:webSocket__");
+export const webSocketEventKey = Symbol("__bool:webSocket:event__");
+export const webSocketServerArgsKey = Symbol("__bool:webSocketArguments:server__");
+export const webSocketConnectionArgsKey = Symbol("__bool:webSocketArguments:connection__");
+export const webSocketMessageArgsKey = Symbol("__bool:webSocketArguments:message__");
+export const webSocketCloseCodeArgsKey = Symbol("__bool:webSocketArguments:closeCode__");
+export const webSocketCloseReasonArgsKey = Symbol("__bool:webSocketArguments:closeReason__");
+export const httpServerArgsKey = Symbol("__bool:httpArguments:server__");
+export const requestHeadersArgsKey = Symbol("__bool:httpArguments:requestHeaders__");
+export const requestHeaderArgsKey = Symbol("__bool:httpArguments:requestHeader__");
+export const requestBodyArgsKey = Symbol("__bool:httpArguments:requestBody__");
+export const paramsArgsKey = Symbol("__bool:httpArguments:params__");
+export const paramArgsKey = Symbol("__bool:httpArguments:param__");
+export const queryArgsKey = Symbol("__bool:httpArguments:query__");
+export const requestArgsKey = Symbol("__bool:httpArguments:request__");
+export const responseHeadersArgsKey = Symbol("__bool:httpArguments:responseHeaders__");
+export const contextArgsKey = Symbol("__bool:httpArguments:context__");
+export const routeModelArgsKey = Symbol("__bool:httpArguments:routeModel__");
+export const responseBodyArgsKey = Symbol("__bool:httpArguments:responseBody__");

package/dist/ultils/colors.d.ts

@@ -0,0 +1,30 @@
+type AnsiOptions = {
+    color?: keyof typeof ansiColors;
+    backgroundColor?: keyof typeof backgroundColors;
+    bold?: boolean;
+    underline?: boolean;
+};
+declare const ansiColors: Readonly<{
+    black: 30;
+    red: 31;
+    green: 32;
+    yellow: 33;
+    blue: 34;
+    magenta: 35;
+    cyan: 36;
+    white: 37;
+    gray: 90;
+}>;
+declare const backgroundColors: Readonly<{
+    black: 40;
+    red: 41;
+    green: 42;
+    yellow: 43;
+    blue: 44;
+    magenta: 45;
+    cyan: 46;
+    white: 47;
+    gray: 100;
+}>;
+export declare const ansiText: (text: string, options?: AnsiOptions) => string;
+export {};

package/dist/ultils/colors.js

@@ -0,0 +1,41 @@
+const ansiColors = Object.freeze({
+    black: 30,
+    red: 31,
+    green: 32,
+    yellow: 33,
+    blue: 34,
+    magenta: 35,
+    cyan: 36,
+    white: 37,
+    gray: 90
+});
+const backgroundColors = Object.freeze({
+    black: 40,
+    red: 41,
+    green: 42,
+    yellow: 43,
+    blue: 44,
+    magenta: 45,
+    cyan: 46,
+    white: 47,
+    gray: 100
+});
+export const ansiText = (text, options = {}) => {
+    const { color, backgroundColor, bold, underline } = options;
+    let ansiCode = "";
+    if (bold) {
+        ansiCode += "\x1b[1m"; // Mã ANSI cho in đậm
+    }
+    if (underline) {
+        ansiCode += "\x1b[4m"; // Mã ANSI cho gạch chân
+    }
+    if (color && ansiColors[color]) {
+        ansiCode += `\x1b[${ansiColors[color]}m`;
+    }
+    // Màu nền
+    if (backgroundColor && backgroundColors[backgroundColor]) {
+        ansiCode += `\x1b[${backgroundColors[backgroundColor]}m`;
+    }
+    // Kết quả với reset
+    return `${ansiCode}${text}\x1b[0m`;
+};

package/dist/ultils/index.d.ts

@@ -1 +1,3 @@
 export * from "./asyncFunction";
+export * from "./colors";
+export * from "./socket";

package/dist/ultils/index.js

@@ -1 +1,3 @@
 export * from "./asyncFunction";
+export * from "./colors";
+export * from "./socket";

package/dist/ultils/socket.d.ts

@@ -0,0 +1 @@
+export declare const isWebSocketUpgrade: (request: Request) => boolean;

package/dist/ultils/socket.js

@@ -0,0 +1,7 @@
+export const isWebSocketUpgrade = (request) => {
+    const headers = request.headers;
+    const method = request.method;
+    const upgrade = headers.get("upgrade")?.toLowerCase() || "";
+    const connection = headers.get("connection")?.toLowerCase() || "";
+    return method === "GET" && upgrade?.toLowerCase() === "websocket" && connection?.toLowerCase().includes("upgrade");
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@bool-ts/core",
-    "version": "1.7.16",
+    "version": "1.8.0",
     "description": "",
     "main": "dist/index.js",
     "scripts": {
@@ -18,14 +18,15 @@
     },
     "homepage": "https://github.com/BoolTS/core#readme",
     "dependencies": {
-        "colors": "^1.4.0",
-        "qs": "^6.13.0",
+        "@bool-ts/date-time": "^1.0.0",
+        "qs": "^6.13.1",
         "reflect-metadata": "^0.2.2",
-        "zod": "^3.23.8"
+        "zod": "^3.24.1"
     },
     "devDependencies": {
         "@types/bun": "latest",
-        "@types/qs": "^6.9.16",
-        "typescript": "^5.6.2"
-    }
+        "@types/qs": "^6.9.17",
+        "typescript": "^5.7.2"
+    },
+    "private": "false"
 }

package/src/decorators/controller.ts

@@ -1,6 +1,7 @@
-import type { IController } from "../interfaces/controller";
+import type { IController } from "../interfaces";
+import type { THttpMetadata } from "./http";
+
 import { controllerHttpKey, controllerKey } from "../keys";
-import { type THttpMetadata } from "./http";
 
 export type TControllerMetadata = Required<{
     prefix: string;
@@ -8,10 +9,10 @@ export type TControllerMetadata = Required<{
 }>;
 
 export const Controller =
-    (prefix: string) =>
+    (prefix?: string) =>
     <T extends { new (...args: any[]): IController }>(target: T) => {
         const metadata: TControllerMetadata = {
-            prefix: !prefix.startsWith("/") ? `/${prefix}` : prefix,
+            prefix: !prefix?.startsWith("/") ? `/${prefix || ""}` : prefix,
             httpMetadata: [...(Reflect.getOwnMetadata(controllerHttpKey, target.constructor) || [])]
         };
 

package/src/decorators/dispatcher.ts

@@ -1,4 +1,5 @@
-import type { IDispatcher } from "../interfaces/dispatcher";
+import type { IDispatcher } from "../interfaces";
+
 import { dispatcherKey } from "../keys";
 
 export type TDispatcherMetadata = undefined;

package/src/decorators/guard.ts

@@ -1,4 +1,5 @@
 import type { IGuard } from "../interfaces";
+
 import { guardKey } from "../keys";
 
 export type TGuardMetadata = undefined;

package/src/decorators/http.ts

@@ -4,15 +4,15 @@ export type TRoute = {
     path: string;
     httpMethod: "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS";
     methodName: string;
-    descriptor: PropertyDescriptor;
+    descriptor: TypedPropertyDescriptor<any>;
 };
 
 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)) {
+    (target: Object, methodName: string | symbol, descriptor: TypedPropertyDescriptor<any>) => {
+        if (!(descriptor?.value instanceof Function)) {
             throw Error(`${method} decorator only use for class method.`);
         }
 

package/src/decorators/index.ts

@@ -18,6 +18,14 @@ export { Inject } from "./inject";
 export { Injectable } from "./injectable";
 export { Middleware } from "./middleware";
 export { Module } from "./module";
+export { WebSocket } from "./webSocket";
+export {
+    WebSocketCloseCode,
+    WebSocketCloseReason,
+    WebSocketConnection,
+    WebSocketServer
+} from "./webSocketArguments";
+export { WebSocketEvent } from "./webSocketEvent";
 export { ZodSchema } from "./zodSchema";
 
 export type { TArgumentsMetadata } from "./arguments";
@@ -27,3 +35,5 @@ export type { TGuardMetadata } from "./guard";
 export type { THttpMetadata } from "./http";
 export type { TMiddlewareMetadata } from "./middleware";
 export type { TModuleMetadata, TModuleOptions } from "./module";
+export type { TWebSocketMetadata } from "./webSocket";
+export type { TWebSocketEventHandlerMetadata, TWebSocketEventMetadata } from "./webSocketEvent";

package/src/decorators/middleware.ts

@@ -1,4 +1,5 @@
 import type { IMiddleware } from "../interfaces";
+
 import { middlewareKey } from "../keys";
 
 export type TMiddlewareMetadata = undefined;

package/src/decorators/module.ts

@@ -1,5 +1,6 @@
-import type { IModule } from "../interfaces/module";
-import { controllerKey, dispatcherKey, guardKey, injectableKey, middlewareKey, moduleKey } from "../keys";
+import type { IModule } from "../interfaces";
+
+import { controllerKey, dispatcherKey, guardKey, injectableKey, middlewareKey, moduleKey, webSocketKey } from "../keys";
 
 type TInstances = Array<new (...args: any[]) => any>;
 type TLoaders<TConfig extends {} = {}> = Record<
@@ -17,6 +18,7 @@ export type TModuleOptions<TConfig extends {} = {}> =
           guards: TInstances;
           controllers: TInstances;
           dispatchers: TInstances;
+          webSockets: TInstances;
       }>
     | undefined;
 
@@ -30,13 +32,14 @@ export type TModuleMetadata<TConfig extends {} = {}> =
           guards: TInstances;
           controllers: TInstances;
           dispatchers: TInstances;
+          webSockets: 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 || {};
+        const { middlewares, guards, dispatchers, controllers, dependencies, webSockets } = args || {};
 
         if (middlewares) {
             for (let i = 0; i < middlewares.length; i++) {
@@ -78,6 +81,14 @@ export const Module =
             }
         }
 
+        if (webSockets) {
+            for (let i = 0; i < webSockets.length; i++) {
+                if (!Reflect.getOwnMetadataKeys(webSockets[i]).includes(webSocketKey)) {
+                    throw Error(`${webSockets[i].name} is not a websocket gateway.`);
+                }
+            }
+        }
+
         Reflect.defineMetadata(moduleKey, args, target);
     };
 

package/src/decorators/webSocket.ts

@@ -0,0 +1,81 @@
+import type { Server } from "bun";
+import type { IWebSocket } from "../interfaces";
+import type { TWebSocketEventMetadata } from "./webSocketEvent";
+
+import { webSocketEventKey, webSocketKey } from "../keys";
+
+export type TWebSocketHttpRouteMetadata = {
+    path: string;
+    httpMethod: "GET" | "POST";
+    methodName: symbol;
+    descriptor: PropertyDescriptor;
+};
+
+export type TWebSocketUpgradeData = {
+    pathname: string;
+    method: string;
+    query: Record<string, unknown>;
+};
+
+export type TWebSocketHttpMetadata = TWebSocketHttpRouteMetadata[];
+
+export type TWebSocketMetadata = Required<{
+    prefix: string;
+    events: TWebSocketEventMetadata;
+    http: TWebSocketHttpMetadata;
+}>;
+
+const upgradeHandlerSymbol = Symbol("__bool:webSocket.upgrade__");
+
+const upgradeHandler = (server: Server, request: Request, query: Record<string, unknown>) => {
+    const url = new URL(request.url);
+
+    return server.upgrade<TWebSocketUpgradeData>(request, {
+        data: {
+            method: request.method.toUpperCase(),
+            pathname: url.pathname,
+            query: query
+        }
+    });
+};
+
+export const WebSocket =
+    (
+        args?: Partial<{
+            prefix: string;
+        }>
+    ) =>
+    <T extends { new (...args: any[]): IWebSocket }>(target: T) => {
+        const { prefix } = args || {};
+
+        target.prototype[upgradeHandlerSymbol] = upgradeHandler;
+
+        const descriptor = Object.getOwnPropertyDescriptor(target.prototype, upgradeHandlerSymbol);
+
+        const httpMetadata: TWebSocketHttpMetadata = !descriptor
+            ? []
+            : [
+                  {
+                      path: "/",
+                      httpMethod: "GET",
+                      methodName: upgradeHandlerSymbol,
+                      descriptor: descriptor
+                  },
+                  {
+                      path: "/",
+                      httpMethod: "POST",
+                      methodName: upgradeHandlerSymbol,
+                      descriptor: descriptor
+                  }
+              ];
+
+        const metadata: TWebSocketMetadata = {
+            prefix: !prefix?.startsWith("/") ? `/${prefix || ""}` : prefix,
+            events: Reflect.getOwnMetadata(webSocketEventKey, target) || {},
+            http: httpMetadata
+        };
+
+        Reflect.defineMetadata(webSocketKey, metadata, target);
+    };
+
+export default WebSocket;

package/src/decorators/webSocketArguments.ts

@@ -0,0 +1,144 @@
+import {
+    webSocketCloseCodeArgsKey,
+    webSocketCloseReasonArgsKey,
+    webSocketConnectionArgsKey,
+    webSocketEventArgumentsKey,
+    webSocketMessageArgsKey,
+    webSocketServerArgsKey
+} from "../keys";
+
+export type TWebsocketArgumentsMetadata =
+    | {
+          index: number;
+          type: typeof webSocketConnectionArgsKey;
+      }
+    | {
+          index: number;
+          type: typeof webSocketMessageArgsKey;
+      }
+    | {
+          index: number;
+          type: typeof webSocketServerArgsKey;
+      }
+    | {
+          index: number;
+          type: typeof webSocketCloseCodeArgsKey;
+      }
+    | {
+          index: number;
+          type: typeof webSocketCloseReasonArgsKey;
+      };
+
+export type TWebsocketArgumentsMetadataGroup = Record<string, TWebsocketArgumentsMetadata>;
+
+export const WebSocketConnection =
+    () => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+        if (!methodName) {
+            return;
+        }
+
+        const webSocketEventArgumentsMetadata: TWebsocketArgumentsMetadataGroup =
+            Reflect.getOwnMetadata(webSocketEventArgumentsKey, target.constructor, methodName) ||
+            {};
+
+        webSocketEventArgumentsMetadata[`argumentIndexes.${parameterIndex}`] = {
+            index: parameterIndex,
+            type: webSocketConnectionArgsKey
+        } satisfies Extract<
+            TWebsocketArgumentsMetadata,
+            {
+                type: typeof webSocketConnectionArgsKey;
+            }
+        >;
+
+        Reflect.defineMetadata(
+            webSocketEventArgumentsKey,
+            webSocketEventArgumentsMetadata,
+            target.constructor,
+            methodName
+        );
+    };
+
+export const WebSocketServer =
+    () => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+        if (!methodName) {
+            return;
+        }
+
+        const webSocketEventArgumentsMetadata: TWebsocketArgumentsMetadataGroup =
+            Reflect.getOwnMetadata(webSocketEventArgumentsKey, target.constructor, methodName) ||
+            {};
+
+        webSocketEventArgumentsMetadata[`argumentIndexes.${parameterIndex}`] = {
+            index: parameterIndex,
+            type: webSocketServerArgsKey
+        } satisfies Extract<
+            TWebsocketArgumentsMetadata,
+            {
+                type: typeof webSocketServerArgsKey;
+            }
+        >;
+
+        Reflect.defineMetadata(
+            webSocketEventArgumentsKey,
+            webSocketEventArgumentsMetadata,
+            target.constructor,
+            methodName
+        );
+    };
+
+export const WebSocketCloseCode =
+    () => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+        if (!methodName) {
+            return;
+        }
+
+        const webSocketEventArgumentsMetadata: TWebsocketArgumentsMetadataGroup =
+            Reflect.getOwnMetadata(webSocketEventArgumentsKey, target.constructor, methodName) ||
+            {};
+
+        webSocketEventArgumentsMetadata[`argumentIndexes.${parameterIndex}`] = {
+            index: parameterIndex,
+            type: webSocketCloseCodeArgsKey
+        } satisfies Extract<
+            TWebsocketArgumentsMetadata,
+            {
+                type: typeof webSocketCloseCodeArgsKey;
+            }
+        >;
+
+        Reflect.defineMetadata(
+            webSocketEventArgumentsKey,
+            webSocketEventArgumentsMetadata,
+            target.constructor,
+            methodName
+        );
+    };
+
+export const WebSocketCloseReason =
+    () => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => {
+        if (!methodName) {
+            return;
+        }
+
+        const webSocketEventArgumentsMetadata: TWebsocketArgumentsMetadataGroup =
+            Reflect.getOwnMetadata(webSocketEventArgumentsKey, target.constructor, methodName) ||
+            {};
+
+        webSocketEventArgumentsMetadata[`argumentIndexes.${parameterIndex}`] = {
+            index: parameterIndex,
+            type: webSocketCloseReasonArgsKey
+        } satisfies Extract<
+            TWebsocketArgumentsMetadata,
+            {
+                type: typeof webSocketCloseReasonArgsKey;
+            }
+        >;
+
+        Reflect.defineMetadata(
+            webSocketEventArgumentsKey,
+            webSocketEventArgumentsMetadata,
+            target.constructor,
+            methodName
+        );
+    };

package/src/decorators/webSocketEvent.ts

@@ -0,0 +1,56 @@
+import type {
+    TWebsocketArgumentsMetadata,
+    TWebsocketArgumentsMetadataGroup
+} from "./webSocketArguments";
+
+import { webSocketEventArgumentsKey, webSocketEventKey } from "../keys";
+
+export type TWebSocketEventHandlerMetadata = Required<{
+    methodName: string;
+    descriptor: PropertyDescriptor;
+}> &
+    Partial<{
+        arguments: Record<string, TWebsocketArgumentsMetadata>;
+    }>;
+
+export type TWebSocketEventMetadata = Record<
+    "open" | "close" | "message" | "drain" | "ping" | "pong",
+    TWebSocketEventHandlerMetadata
+>;
+
+/**
+ *
+ * @param path
+ * @returns
+ */
+export const WebSocketEvent =
+    (eventName: "open" | "close" | "message" | "drain" | "ping" | "pong") =>
+    (target: Object, methodName: string, descriptor: PropertyDescriptor) => {
+        if (!(descriptor.value instanceof Function)) {
+            throw Error("WebSocketEvent decorator only use for class's method.");
+        }
+
+        const webSocketEventArgumentsMetadata: TWebsocketArgumentsMetadataGroup | undefined =
+            Reflect.getOwnMetadata(webSocketEventArgumentsKey, target.constructor, methodName);
+
+        const webSocketEventMetadata: TWebSocketEventHandlerMetadata = Object.freeze({
+            methodName: methodName,
+            descriptor: descriptor,
+            arguments: webSocketEventArgumentsMetadata
+        });
+
+        const webSocketMetadata: TWebSocketEventMetadata = {
+            ...(Reflect.getOwnMetadata(webSocketEventKey, target.constructor) || undefined),
+            [eventName]: webSocketEventMetadata
+        };
+
+        Reflect.defineMetadata(
+            webSocketEventKey,
+            webSocketEventMetadata,
+            target.constructor,
+            methodName
+        );
+        Reflect.defineMetadata(webSocketEventKey, webSocketMetadata, target.constructor);
+    };
+
+export default WebSocket;