@venok/websocket 2.1.0-next.1

package/dist/websocket/finder.js

@@ -0,0 +1,57 @@
+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/finder.ts
+import { isUndefined } from "@venok/core";
+import { MESSAGE_METADATA, PARAM_ARGS_METADATA } from "../constants.js";
+import { WsParamtype } from "../enums/ws-paramtype.js";
+
+class GatewayFinder {
+  metadataScanner;
+  constructor(metadataScanner) {
+    this.metadataScanner = metadataScanner;
+  }
+  getGatewayHandlers(instance, prototype) {
+    const instancePrototype = isUndefined(prototype) ? Object.getPrototypeOf(instance) : prototype;
+    return this.metadataScanner.getAllMethodNames(instancePrototype).reduce((acc, method) => {
+      const route = this.exploreMethod(instance, instancePrototype, method);
+      if (route)
+        acc.push(route);
+      return acc;
+    }, []);
+  }
+  exploreMethod(instance, prototype, methodName) {
+    const prototypeCallback = prototype[methodName];
+    const message = Reflect.getMetadata(MESSAGE_METADATA, prototypeCallback);
+    if (isUndefined(message))
+      return null;
+    const isAckHandledManually = this.hasAckDecorator(prototype, methodName);
+    return { pattern: message, methodName, isAckHandledManually };
+  }
+  hasAckDecorator(instancePrototype, methodName) {
+    const paramsMetadata = Reflect.getMetadata(PARAM_ARGS_METADATA, instancePrototype.constructor, methodName);
+    if (!paramsMetadata)
+      return false;
+    const metadataKeys = Object.keys(paramsMetadata);
+    return metadataKeys.some((key) => {
+      const type = +key.split(":")[0];
+      return type === WsParamtype.ACK;
+    });
+  }
+}
+export {
+  GatewayFinder
+};

package/dist/websocket/module.js

@@ -0,0 +1,34 @@
+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/module.ts
+import { IntegrationModule } from "@venok/integration";
+import { Module } from "@venok/core";
+import { WebsocketConfig } from "../websocket/config.js";
+import { WebsocketExplorerService } from "../websocket/explorer.js";
+import { WebsocketStarterModule } from "../websocket/starter-module.js";
+import { WebsocketConfigurableModuleClass } from "../websocket/configurable-module.js";
+class WebsocketModule extends WebsocketConfigurableModuleClass {
+}
+WebsocketModule = __legacyDecorateClassTS([
+  Module({
+    imports: [IntegrationModule],
+    providers: [WebsocketConfig, WebsocketExplorerService, WebsocketStarterModule]
+  })
+], WebsocketModule);
+export {
+  WebsocketModule
+};

package/dist/websocket/params-factory.js

@@ -0,0 +1,41 @@
+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/params-factory.ts
+import { isFunction } from "@venok/core";
+import { WsParamtype } from "../enums/ws-paramtype.js";
+
+class WsParamsFactory {
+  exchangeKeyForValue(type, data, args) {
+    if (!args)
+      return null;
+    switch (type) {
+      case WsParamtype.SOCKET:
+        return args[0];
+      case WsParamtype.PAYLOAD:
+        return data ? args[1]?.[data] : args[1];
+      case WsParamtype.ACK:
+        return args.find((arg) => isFunction(arg));
+      case WsParamtype.PATTERN:
+        return args[args.length - 1];
+      default:
+        return null;
+    }
+  }
+}
+export {
+  WsParamsFactory
+};

package/dist/websocket/starter-module.js

@@ -0,0 +1,100 @@
+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/starter-module.ts
+import { Inject, Injectable } from "@venok/core";
+import { distinctUntilChanged, isObservable, mergeAll, of } from "rxjs";
+import { fromPromise } from "rxjs/internal/observable/innerFrom";
+import { WebsocketExplorerService } from "../websocket/explorer.js";
+import { WebSocketGateway } from "../decorators/gateway.decorator.js";
+import { WebsocketConfig } from "../websocket/config.js";
+import { WEBSOCKET_APP_OPTIONS } from "../websocket/configurable-module.js";
+import {
+  VENOK_WS_ADAPTER_BIND_CLIENT_CONNECT,
+  VENOK_WS_ADAPTER_BIND_CLIENT_DISCONNECT,
+  VENOK_WS_ADAPTER_BIND_MESSAGE_HANDLERS,
+  VENOK_WS_ADAPTER_LISTEN
+} from "../symbols.js";
+class WebsocketStarterModule {
+  options;
+  websocketExplorerService;
+  websocketConfig;
+  constructor(options, websocketExplorerService, websocketConfig) {
+    this.options = options;
+    this.websocketExplorerService = websocketExplorerService;
+    this.websocketConfig = websocketConfig;
+  }
+  onApplicationBootstrap() {
+    const adapter = this.websocketConfig.getAdapter();
+    adapter[VENOK_WS_ADAPTER_LISTEN]({ mainHttpServerPort: this.options.httpPort || 0 });
+  }
+  async beforeApplicationShutdown() {
+    const adapter = this.websocketConfig.getAdapter();
+    await adapter.closeAll();
+  }
+  onModuleInit() {
+    this.websocketExplorerService.explore(WebSocketGateway.KEY).forEach((gateway) => this.bindGateway(gateway));
+    const adapter = this.websocketConfig.getAdapter();
+    adapter.setMainServerApplyCallback(this.options.attachMainWebsocketServerToHttpServerCallback);
+  }
+  bindGateway(gateway) {
+    const adapter = this.websocketConfig.getAdapter();
+    const { connection, disconnect, init, server } = gateway.observableServer;
+    if (gateway.afterInit)
+      init.subscribe(gateway.afterInit);
+    if (gateway.handleConnect) {
+      connection.pipe(distinctUntilChanged((prev, curr) => prev && curr && prev[0] === curr[0])).subscribe(gateway.handleConnect);
+    }
+    if (gateway.handleDisconnect) {
+      disconnect.pipe(distinctUntilChanged()).subscribe(gateway.handleDisconnect);
+    }
+    const handler = this.getConnectionHandler(gateway.handlers, disconnect, connection);
+    adapter[VENOK_WS_ADAPTER_BIND_CLIENT_CONNECT](server, handler);
+  }
+  getConnectionHandler(handlers, disconnect, connection) {
+    const adapter = this.websocketConfig.getAdapter();
+    return (...args) => {
+      const [client] = args;
+      connection.next(args);
+      this.subscribeMessages(client, handlers);
+      adapter[VENOK_WS_ADAPTER_BIND_CLIENT_DISCONNECT](client, (...disconnectArgs) => disconnect.next(disconnectArgs));
+    };
+  }
+  subscribeMessages(client, handlers) {
+    const adapter = this.websocketConfig.getAdapter();
+    adapter[VENOK_WS_ADAPTER_BIND_MESSAGE_HANDLERS](client, handlers, (data) => fromPromise(this.pickResult(data)).pipe(mergeAll()));
+  }
+  async pickResult(deferredResult) {
+    const result = await deferredResult;
+    if (isObservable(result))
+      return result;
+    if (result instanceof Promise)
+      return fromPromise(result);
+    return of(result);
+  }
+}
+WebsocketStarterModule = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyDecorateParamTS(0, Inject(WEBSOCKET_APP_OPTIONS)),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof Required === "undefined" ? Object : Required,
+    typeof WebsocketExplorerService === "undefined" ? Object : WebsocketExplorerService,
+    typeof WebsocketConfig === "undefined" ? Object : WebsocketConfig
+  ])
+], WebsocketStarterModule);
+export {
+  WebsocketStarterModule
+};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@venok/websocket",
+  "version": "2.1.0-next.1",
+  "description": "",
+  "author": "shiz-ceo",
+  "homepage": "",
+  "main": "index.js",
+  "types": "./index.d.ts",
+  "type": "module",
+  "files": [
+    "package.json",
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.cjs"
+      },
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/venokjs/venok.git",
+    "directory": "packages/websocket"
+  },
+  "scripts": {
+    "test": "bun test ./test/"
+  },
+  "peerDependencies": {
+    "@venok/core": "2.0.1",
+    "@venok/integration": "2.0.1",
+    "reflect-metadata": "^0.2.2",
+    "rxjs": "^7.8.1"
+  },
+  "dependencies": {
+    "object-hash": "^3.0.0"
+  },
+  "devDependencies": {
+    "@types/object-hash": "^3.0.6"
+  }
+}