@venok/websocket 2.1.0-next.1

package/dist/index.d.ts

@@ -0,0 +1,200 @@
+/**
+* Thanks for using Venloc Venok <3
+* https://github.com/venloc-tech/svm
+*/
+import * as _venok_core from '@venok/core';
+import { VenokParamsFactoryInterface, Type, PipeTransform, ExecutionContextHost, ArgumentsHost } from '@venok/core';
+import { ReplaySubject, Subject, Observable } from 'rxjs';
+import * as _venok_integration from '@venok/integration';
+
+type WebsocketGatewayHandlerMetadata = {
+    callback: (...args: any[]) => void;
+    pattern: string;
+    isAckHandledManually: boolean;
+};
+
+type WebsocketGatewayMetadata = {
+    port: number;
+    options: object;
+    handleConnect: Function | undefined;
+    handleDisconnect: Function | undefined;
+    afterInit: Function | undefined;
+    observableServer: EventStreamsHost;
+    handlers: WebsocketGatewayHandlerMetadata[];
+};
+
+type GatewayDefaultOptions = {
+    path?: string;
+};
+
+/**
+ * @publicApi
+ */
+interface EventStreamsHost<T = any> {
+    server: T;
+    init: ReplaySubject<T>;
+    connection: Subject<any>;
+    disconnect: Subject<any>;
+}
+
+declare class SocketsContainer {
+    private readonly eventStreamsHosts;
+    getAll(): Map<string | RegExp, EventStreamsHost>;
+    get<T extends Record<string, any> = any>(options: T): EventStreamsHost;
+    add<T extends Record<string, any> = any>(options: T, host: EventStreamsHost): void;
+    clear(): void;
+    private generateHashByOptions;
+}
+
+declare const VENOK_WS_ADAPTER_GET_OR_CREATE_SERVER: unique symbol;
+declare const VENOK_WS_ADAPTER_BIND_CLIENT_CONNECT: unique symbol;
+declare const VENOK_WS_ADAPTER_BIND_CLIENT_DISCONNECT: unique symbol;
+declare const VENOK_WS_ADAPTER_BIND_MESSAGE_HANDLERS: unique symbol;
+declare const VENOK_WS_ADAPTER_CREATE: unique symbol;
+declare const VENOK_WS_ADAPTER_LISTEN: unique symbol;
+
+declare abstract class AbstractWebsocketAdapter<Server = any, Client = any, Options extends Record<string, any> = any> {
+    protected socketsContainer: SocketsContainer;
+    protected mainServerApplyCallback: Function | null;
+    isAckSupported: boolean;
+    useCustomFactory: boolean;
+    setMainServerApplyCallback(fn: Function): void;
+    abstract getParamsFactory(): VenokParamsFactoryInterface;
+    abstract [VENOK_WS_ADAPTER_GET_OR_CREATE_SERVER](port: number, options: any): EventStreamsHost;
+    abstract [VENOK_WS_ADAPTER_BIND_CLIENT_CONNECT](server: Server, callback: Function): void;
+    abstract [VENOK_WS_ADAPTER_BIND_CLIENT_DISCONNECT](client: Client, callback: Function): void;
+    abstract [VENOK_WS_ADAPTER_BIND_MESSAGE_HANDLERS](client: Client, handlers: WebsocketGatewayHandlerMetadata[], transform: (data: any) => Observable<any>): void;
+    abstract [VENOK_WS_ADAPTER_CREATE](port: number, options?: Options): Server;
+    abstract close(server: Server): Promise<void>;
+    abstract closeAll(): Promise<void>;
+    abstract [VENOK_WS_ADAPTER_LISTEN](config: {
+        mainHttpServerPort: number;
+    }): void;
+}
+
+type WebsocketAppOptions = {
+    adapter: AbstractWebsocketAdapter;
+    httpPort?: number;
+    attachMainWebsocketServerToHttpServerCallback?: (...args: any[]) => void;
+};
+
+/**
+ * Decorator that marks a class as a Nest gateway that enables real-time, bidirectional
+ * and event-based communication between the browser and the server.
+ *
+ * @publicApi
+ */
+declare function WebSocketGateway(port?: number): ClassDecorator;
+declare function WebSocketGateway<T extends GatewayDefaultOptions = GatewayDefaultOptions>(options?: T): ClassDecorator;
+declare function WebSocketGateway<T extends GatewayDefaultOptions = GatewayDefaultOptions>(port?: number, options?: T): ClassDecorator;
+declare namespace WebSocketGateway {
+    var KEY: string;
+}
+
+/**
+ * WebSockets message body parameter decorator.
+ *
+ * @publicApi
+ */
+declare function MessageBody(): ParameterDecorator;
+/**
+ * WebSockets message body parameter decorator.
+ *
+ * Example:
+ * ```ts
+ * create(@MessageBody(new ValidationPipe()) createDto: CreateCatDto)
+ * ```
+ * @param pipes one or more pipes - either instances or classes - to apply to
+ * the bound parameter.
+ *
+ * @publicApi
+ */
+declare function MessageBody(...pipes: (Type<PipeTransform> | PipeTransform)[]): ParameterDecorator;
+/**
+ * WebSockets message body parameter decorator. Extracts a property from the
+ * message payload object. May also apply pipes to the bound parameter.
+ *
+ * For example, extracting all params:
+ * ```ts
+ * findMany(@MessageBody() ids: string[])
+ * ```
+ *
+ * For example, extracting a single param:
+ * ```ts
+ * create(@MessageBody('data') createDto: { data: string })
+ * ```
+ *
+ * For example, extracting a single param with pipe:
+ * ```ts
+ * create(@MessageBody('data', new ValidationPipe()) createDto: { data: string })
+ * ```
+ * @param propertyKey name of single property to extract from the message payload
+ * @param pipes one or more pipes - either instances or classes - to apply to
+ * the bound parameter.
+ *
+ * @publicApi
+ */
+declare function MessageBody(propertyKey: string | number, ...pipes: (Type<PipeTransform> | PipeTransform)[]): ParameterDecorator;
+
+/**
+ * Attaches native Web Socket Server to a given property.
+ *
+ * @publicApi
+ */
+declare const WebsocketServer: () => PropertyDecorator;
+
+/**
+ * @publicApi
+ */
+declare const Socket: () => ParameterDecorator;
+
+/**
+ * Subscribes to messages that fulfils chosen pattern.
+ *
+ * @publicApi
+ */
+declare const SubscribeMessage: _venok_core.ReflectableMethodDecorator<string, string>;
+
+declare class WsException extends Error {
+    private readonly error;
+    constructor(error: string | object);
+    initMessage(): void;
+    getError(): string | object;
+}
+
+declare class EventStreamsFactory {
+    static create<T = any>(server: T): EventStreamsHost<T>;
+}
+
+declare class WebsocketArgumentsHost extends ExecutionContextHost {
+    static create(context: ArgumentsHost): WebsocketArgumentsHost;
+    getClient<T>(): T;
+    getData<T>(): T;
+    getPattern(): string;
+}
+
+declare class WebsocketConfig<T extends AbstractWebsocketAdapter = AbstractWebsocketAdapter> {
+    private readonly options;
+    private adapter;
+    constructor(options: Required<WebsocketAppOptions>);
+    setAdapter(websocketAdapter: T): void;
+    getAdapter(): T;
+}
+
+declare const WebsocketConfigurableModuleClass: _venok_integration.ConfigurableModuleCls<WebsocketAppOptions, "register", "create", object>;
+
+declare class WebsocketModule extends WebsocketConfigurableModuleClass {
+}
+
+declare class WsParamsFactory implements VenokParamsFactoryInterface {
+    exchangeKeyForValue(type: number, data: string | undefined, args: [any, any, ...any, string]): any;
+}
+
+declare const MESSAGE_METADATA = "message";
+declare const GATEWAY_SERVER_METADATA = "websockets:is_socket";
+declare const GATEWAY_METADATA = "websockets:is_gateway";
+declare const PORT_METADATA = "port";
+declare const GATEWAY_OPTIONS = "websockets:gateway_options";
+declare const PARAM_ARGS_METADATA = "__routeArguments__";
+
+export { AbstractWebsocketAdapter, EventStreamsFactory, type EventStreamsHost, GATEWAY_METADATA, GATEWAY_OPTIONS, GATEWAY_SERVER_METADATA, type GatewayDefaultOptions, MESSAGE_METADATA, MessageBody, PARAM_ARGS_METADATA, PORT_METADATA, Socket, SubscribeMessage, VENOK_WS_ADAPTER_BIND_CLIENT_CONNECT, VENOK_WS_ADAPTER_BIND_CLIENT_DISCONNECT, VENOK_WS_ADAPTER_BIND_MESSAGE_HANDLERS, VENOK_WS_ADAPTER_CREATE, VENOK_WS_ADAPTER_GET_OR_CREATE_SERVER, VENOK_WS_ADAPTER_LISTEN, WebSocketGateway, type WebsocketAppOptions, WebsocketArgumentsHost, WebsocketConfig, type WebsocketGatewayHandlerMetadata, type WebsocketGatewayMetadata, WebsocketModule, WebsocketServer, WsException, WsParamsFactory };

package/dist/index.js

@@ -0,0 +1,18 @@
+// packages/websocket/src/index.ts
+import"reflect-metadata";
+
+export * from "./decorators/gateway.decorator.js";
+export * from "./decorators/message-body.decorator.js";
+export * from "./decorators/server.decorator.js";
+export * from "./decorators/socket.decorator.js";
+export * from "./decorators/subscribe-message.decorator.js";
+export * from "./exceptions/ws.exception.js";
+export * from "./helpers/event-stream-factory.helper.js";
+export * from "./interfaces/index.js";
+export * from "./websocket/adapter.js";
+export * from "./websocket/arguments-host.js";
+export * from "./websocket/config.js";
+export * from "./websocket/module.js";
+export * from "./websocket/params-factory.js";
+export * from "./constants.js";
+export * from "./symbols.js";

package/dist/interfaces/index.js

@@ -0,0 +1,4 @@
+// packages/websocket/src/interfaces/index.ts
+export * from "./websocket/index.js";
+export * from "./event-stream-host.interface.js";
+export * from "./options.interface.js";

package/dist/interfaces/websocket/index.js

@@ -0,0 +1,4 @@
+// packages/websocket/src/interfaces/websocket/index.ts
+export * from "./gateway-handler-metadata.interfcae.js";
+export * from "./gateway-metadata.interface.js";
+export * from "./gateway-options.interface.js";

package/dist/symbols.js

@@ -0,0 +1,31 @@
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+
+// packages/websocket/src/symbols.ts
+var VENOK_WS_ADAPTER_GET_OR_CREATE_SERVER = Symbol("VENOK_WS_ADAPTER_GET_OR_CREATE_SERVER");
+var VENOK_WS_ADAPTER_BIND_CLIENT_CONNECT = Symbol("VENOK_WS_ADAPTER_BIND_CLIENT_CONNECT");
+var VENOK_WS_ADAPTER_BIND_CLIENT_DISCONNECT = Symbol("VENOK_WS_ADAPTER_BIND_CLIENT_DISCONNECT");
+var VENOK_WS_ADAPTER_BIND_MESSAGE_HANDLERS = Symbol("VENOK_WS_ADAPTER_BIND_MESSAGE_HANDLERS");
+var VENOK_WS_ADAPTER_CREATE = Symbol("VENOK_WS_ADAPTER_CREATE");
+var VENOK_WS_ADAPTER_LISTEN = Symbol("VENOK_WS_ADAPTER_LISTEN");
+export {
+  VENOK_WS_ADAPTER_LISTEN,
+  VENOK_WS_ADAPTER_GET_OR_CREATE_SERVER,
+  VENOK_WS_ADAPTER_CREATE,
+  VENOK_WS_ADAPTER_BIND_MESSAGE_HANDLERS,
+  VENOK_WS_ADAPTER_BIND_CLIENT_DISCONNECT,
+  VENOK_WS_ADAPTER_BIND_CLIENT_CONNECT
+};

package/dist/websocket/adapter.js

@@ -0,0 +1,31 @@
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+
+// packages/websocket/src/websocket/adapter.ts
+import { SocketsContainer } from "../websocket/container.js";
+
+class AbstractWebsocketAdapter {
+  socketsContainer = new SocketsContainer;
+  mainServerApplyCallback = null;
+  isAckSupported = false;
+  useCustomFactory = false;
+  setMainServerApplyCallback(fn) {
+    this.mainServerApplyCallback = fn;
+  }
+}
+export {
+  AbstractWebsocketAdapter
+};

package/dist/websocket/arguments-host.js

@@ -0,0 +1,39 @@
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+
+// packages/websocket/src/websocket/arguments-host.ts
+import { ExecutionContextHost } from "@venok/core";
+
+class WebsocketArgumentsHost extends ExecutionContextHost {
+  static create(context) {
+    const type = context.getType();
+    const websocketContext = new WebsocketArgumentsHost(context.getArgs());
+    websocketContext.setType(type);
+    return websocketContext;
+  }
+  getClient() {
+    return this.getArgByIndex(0);
+  }
+  getData() {
+    return this.getArgByIndex(1);
+  }
+  getPattern() {
+    return this.getArgByIndex(this.getArgs().length - 1);
+  }
+}
+export {
+  WebsocketArgumentsHost
+};

package/dist/websocket/config.js

@@ -0,0 +1,43 @@
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+
+// packages/websocket/src/websocket/config.ts
+import { Inject, Injectable } from "@venok/core";
+import { WEBSOCKET_APP_OPTIONS } from "../websocket/configurable-module.js";
+class WebsocketConfig {
+  options;
+  adapter;
+  constructor(options) {
+    this.options = options;
+    this.adapter = this.options.adapter;
+  }
+  setAdapter(websocketAdapter) {
+    this.adapter = websocketAdapter;
+  }
+  getAdapter() {
+    return this.adapter;
+  }
+}
+WebsocketConfig = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyDecorateParamTS(0, Inject(WEBSOCKET_APP_OPTIONS)),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof Required === "undefined" ? Object : Required
+  ])
+], WebsocketConfig);
+export {
+  WebsocketConfig
+};

package/dist/websocket/configurable-module.js

@@ -0,0 +1,26 @@
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+
+// packages/websocket/src/websocket/configurable-module.ts
+import { ConfigurableModuleBuilder } from "@venok/integration";
+var {
+  ConfigurableModuleClass: WebsocketConfigurableModuleClass,
+  MODULE_OPTIONS_TOKEN: WEBSOCKET_APP_OPTIONS
+} = new ConfigurableModuleBuilder().build();
+export {
+  WebsocketConfigurableModuleClass,
+  WEBSOCKET_APP_OPTIONS
+};

package/dist/websocket/container.js

@@ -0,0 +1,42 @@
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+
+// packages/websocket/src/websocket/container.ts
+import hash from "object-hash";
+
+class SocketsContainer {
+  eventStreamsHosts = new Map;
+  getAll() {
+    return this.eventStreamsHosts;
+  }
+  get(options) {
+    const uniqueToken = this.generateHashByOptions(options);
+    return this.eventStreamsHosts.get(uniqueToken);
+  }
+  add(options, host) {
+    const uniqueToken = this.generateHashByOptions(options);
+    this.eventStreamsHosts.set(uniqueToken, host);
+  }
+  clear() {
+    this.eventStreamsHosts.clear();
+  }
+  generateHashByOptions(options) {
+    return hash(options, { ignoreUnknown: true });
+  }
+}
+export {
+  SocketsContainer
+};

package/dist/websocket/context.js

@@ -0,0 +1,43 @@
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+
+// packages/websocket/src/websocket/context.ts
+import { STATIC_CONTEXT, VenokContextCreator } from "@venok/core";
+import { MESSAGE_METADATA } from "../constants.js";
+
+class WebsocketContextCreator extends VenokContextCreator {
+  create(instance, callback, methodName, metadataKey, paramsFactory, contextId = STATIC_CONTEXT, inquirerId, options = {
+    interceptors: true,
+    guards: true,
+    filters: false,
+    callback: undefined
+  }, contextType = "websocket") {
+    const moduleKey = this.getContextModuleKey(instance.constructor);
+    const targetPattern = this.reflectCallbackPattern(callback);
+    const result = super.create(instance, callback, methodName, metadataKey, paramsFactory, contextId, inquirerId, options, contextType);
+    const exceptionFilter = this.filtersContextCreator.create(instance, callback, moduleKey, contextId, inquirerId);
+    return async (...args) => {
+      args.push(targetPattern);
+      return await this.venokProxy.createProxy(result, exceptionFilter)(...args);
+    };
+  }
+  reflectCallbackPattern(callback) {
+    return Reflect.getMetadata(MESSAGE_METADATA, callback);
+  }
+}
+export {
+  WebsocketContextCreator
+};

package/dist/websocket/explorer.js

@@ -0,0 +1,118 @@
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+
+// packages/websocket/src/websocket/explorer.ts
+import { Inject, isFunction, isUndefined, Logger, MetadataScanner } from "@venok/core";
+import { ExplorerService } from "@venok/integration";
+import { GATEWAY_SERVER_METADATA, MESSAGE_METADATA } from "../constants.js";
+import { WebsocketContextCreator } from "../websocket/context.js";
+import { WsParamsFactory } from "../websocket/params-factory.js";
+import { WebsocketConfig } from "../websocket/config.js";
+import { GatewayFinder } from "../websocket/finder.js";
+import { InvalidSocketPortException } from "../errors/invalid-socket-port.exception.js";
+import { AckNotSupportedException } from "../errors/ack-not-supported.exception.js";
+import { WebsocketExceptionFiltersContext } from "../filters/context.js";
+import { VENOK_WS_ADAPTER_GET_OR_CREATE_SERVER } from "../symbols.js";
+class WebsocketExplorerService extends ExplorerService {
+  logger = new Logger(WebsocketExplorerService.name, { timestamp: true });
+  patternFinder = new GatewayFinder(new MetadataScanner);
+  paramsFactory;
+  onModuleInit() {
+    const adapter = this.websocketConfig.getAdapter();
+    this.paramsFactory = adapter.useCustomFactory ? adapter.getParamsFactory() : new WsParamsFactory;
+  }
+  getSettings() {
+    return {
+      contextType: "websocket",
+      isRequestScopeSupported: true,
+      exceptionsFilterClass: WebsocketExceptionFiltersContext,
+      contextCreatorClass: WebsocketContextCreator,
+      options: { guards: true, interceptors: true, filters: false }
+    };
+  }
+  filterProperties(wrapper, metadataKey) {
+    if (!wrapper.metatype)
+      return;
+    const gateway = this.get(metadataKey, wrapper.metatype);
+    if (!gateway)
+      return;
+    const port = gateway.getPort();
+    const options = gateway.getOptions();
+    if (!Number.isInteger(port) || port < 0)
+      throw new InvalidSocketPortException(port, wrapper.metatype);
+    this.logGateway(wrapper.instance, port);
+    const handlers = this.patternFinder.getGatewayHandlers(wrapper.instance).map((handler) => ({ ...handler, callback: this.createCallback(wrapper, handler.methodName) }));
+    if (!handlers.length)
+      return;
+    const adapter = this.websocketConfig.getAdapter();
+    if (!adapter.isAckSupported && handlers.some((metadata) => metadata.isAckHandledManually)) {
+      const metadata = handlers.find((metadata2) => metadata2.isAckHandledManually);
+      throw new AckNotSupportedException(wrapper.metatype, metadata.pattern);
+    }
+    let handleConnect = wrapper.instance.handleConnect;
+    if (handleConnect) {
+      Reflect.defineMetadata(MESSAGE_METADATA, "connect", wrapper.instance["handleConnect"]);
+      handleConnect = (rxjsArgs) => this.createCallback(wrapper, "handleConnect")(...rxjsArgs);
+    }
+    let handleDisconnect = wrapper.instance.handleConnection;
+    if (handleDisconnect) {
+      Reflect.defineMetadata(MESSAGE_METADATA, "disconnect", wrapper.instance["handleDisconnect"]);
+      handleDisconnect = (rxjsArgs) => this.createCallback(wrapper, "handleDisconnect")(...rxjsArgs);
+    }
+    const afterInit = wrapper.instance.afterInit;
+    const observableServer = adapter[VENOK_WS_ADAPTER_GET_OR_CREATE_SERVER](port, options);
+    this.assignServerToProperties(wrapper.instance, observableServer.server);
+    this.logHandler(wrapper.instance, port, handlers);
+    return {
+      port,
+      options,
+      handleConnect,
+      handleDisconnect,
+      afterInit,
+      observableServer,
+      handlers
+    };
+  }
+  assignServerToProperties(instance, server) {
+    for (const propertyKey in instance) {
+      if (isFunction(propertyKey))
+        continue;
+      const property = String(propertyKey);
+      const isServer = Reflect.getMetadata(GATEWAY_SERVER_METADATA, instance, property);
+      if (!isUndefined(isServer))
+        Reflect.set(instance, propertyKey, server);
+    }
+  }
+  logGateway(instance, port) {
+    const gatewayClassName = instance?.constructor?.name;
+    if (!gatewayClassName)
+      return;
+    this.logger.log(`${gatewayClassName} {${port}}:`);
+  }
+  logHandler(instance, port, handlers) {
+    const gatewayClassName = instance?.constructor?.name;
+    if (!gatewayClassName)
+      return;
+    handlers.forEach(({ pattern }) => this.logger.log(`Mapped {${gatewayClassName}:${port}, ${pattern}} handler`));
+  }
+}
+__legacyDecorateClassTS([
+  Inject(WebsocketConfig),
+  __legacyMetadataTS("design:type", typeof WebsocketConfig === "undefined" ? Object : WebsocketConfig)
+], WebsocketExplorerService.prototype, "websocketConfig", undefined);
+export {
+  WebsocketExplorerService
+};