@ekhein/sekiro-node-client 2.1.7 → 2.1.9

package/dist/main.d.ts

@@ -1,12 +1,8 @@
-import { WebSocket } from 'partysocket';
-export declare class SekiroClient extends WebSocket {
-    readonly clientId: string;
-    readonly namespace: string;
-    readonly host: string;
-    readonly port: string;
+export declare class SekiroClient {
     private readonly logger;
     private readonly handlers;
-    constructor(clientId?: string, namespace?: string, host?: string, port?: string);
+    private readonly ws;
+    constructor(concurrency?: number, group?: string, wsURL?: string);
     private onOpen;
     private onClose;
     private onError;

package/dist/main.js

@@ -2,63 +2,50 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SekiroClient = void 0;
 const crypto_1 = require("crypto");
-const partysocket_1 = require("partysocket");
-const ws_1 = require("ws");
 const result_util_1 = require("./utils/result.util");
 const logger_util_1 = require("./utils/logger.util");
-class SekiroClient extends partysocket_1.WebSocket {
-    clientId;
-    namespace;
-    host;
-    port;
-    logger = new logger_util_1.Logger(this);
+const ws_util_1 = require("./utils/ws.util");
+class SekiroClient {
+    logger = new logger_util_1.Logger();
     handlers = new Map();
-    constructor(clientId = (0, crypto_1.randomUUID)().replace(/-/g, ""), namespace = process.env.namespace, host = process.env.SEKIRO_HOST, port = process.env.SEKIRO_PORT) {
-        super("ws://", [], {
-            debug: false,
-            maxEnqueuedMessages: -1,
-            WebSocket: class extends ws_1.WebSocket {
-                constructor() {
-                    const serve = new Array("ws://", host, ":", port).join("");
-                    const wsURL = new URL("/business-demo/register", serve);
-                    wsURL.searchParams.append("group", namespace);
-                    wsURL.searchParams.append("clientId", clientId);
-                    super(wsURL);
-                }
-            }
-        });
-        this.clientId = clientId;
-        this.namespace = namespace;
-        this.host = host;
-        this.port = port;
-        super.addEventListener("open", this.onOpen.bind(this));
-        super.addEventListener("message", this.onData.bind(this));
-        super.addEventListener("close", this.onClose.bind(this));
-        super.addEventListener("error", this.onError.bind(this));
+    ws = new Map();
+    constructor(concurrency = 1, group = process.env.namespace, wsURL = process.env.SEKIRO_WS) {
+        for (let i = 0; i < concurrency; i++) {
+            const register = new URL("/business-demo/register", wsURL);
+            const clientId = (0, crypto_1.randomUUID)().replace(/-/g, "");
+            register.searchParams.append("group", group);
+            register.searchParams.append("clientId", clientId);
+            const ws = new ws_util_1.W3CWebSocket({ wsURL: register.href });
+            ws.addEventListener("open", this.onOpen.bind(this, group, clientId));
+            ws.addEventListener("message", this.onData.bind(this, group, clientId));
+            ws.addEventListener("close", this.onClose.bind(this, group, clientId));
+            ws.addEventListener("error", this.onError.bind(this, group, clientId));
+            this.ws.set(clientId, ws); /* save to this */
+        }
     }
-    async onOpen(event) {
-        this.logger.info("Connection established");
+    async onOpen(group, clientId, event) {
+        this.logger.info(group, clientId, "Connection established");
     }
-    async onClose(event) {
-        this.logger.warn("Connection closed");
+    async onClose(group, clientId, event) {
+        this.logger.warn(group, clientId, "Connection closed");
     }
-    async onError(event) {
-        this.logger.warn("WebSocket error:", event.message);
+    async onError(group, clientId, event) {
+        this.logger.warn(group, clientId, "WebSocket error", event.message);
     }
-    async onData(event) {
-        this.logger.info("Received request", event.data);
+    async onData(group, clientId, event) {
+        this.logger.info(group, clientId, "Received request", event.data);
         const request = JSON.parse(event.data);
         try {
             const handler = this.handlers.get(request.action);
             if (!handler)
                 throw new Error("No handler for this action");
-            const data = await handler.call(this, request.params);
-            const pack = result_util_1.Result.success(request, data);
-            this.send(pack);
+            const body = await handler.call(this, request.params);
+            const pack = result_util_1.Result.success(request, body);
+            this.ws.get(clientId).send(pack);
         }
         catch (error) {
             const pack = result_util_1.Result.unknown(request, error.message);
-            this.send(pack);
+            this.ws.get(clientId).send(pack);
         }
     }
     async registerAction(action) {

package/dist/utils/logger.util.d.ts

@@ -1,9 +1,4 @@
 export declare class Logger {
-    private readonly context;
-    constructor(context: {
-        namespace: string;
-        clientId: string;
-    });
     private log;
     info(...message: any[]): void;
     warn(...message: any[]): void;

package/dist/utils/logger.util.js

@@ -3,21 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Logger = void 0;
 const util_1 = require("util");
 class Logger {
-    context;
-    constructor(context) {
-        this.context = context;
-    }
     log(level, message) {
         const time = new Date().toLocaleString();
-        const namespace = String(this.context.namespace);
-        const clientId = String(this.context.clientId);
+        const namespace = Array.from(message).at(0);
+        const clientId = Array.from(message).at(1);
+        const args = Array.from(message).slice(2);
         const base = (0, util_1.format)("[%s] [%s] [%s] [%s]", level, time, namespace, clientId);
         switch (level) {
             case "INFO":
-                console.info(base, ...message);
+                console.info(base, ...args);
                 break;
             case "WARN":
-                console.warn(base, ...message);
+                console.warn(base, ...args);
                 break;
         }
     }

package/dist/utils/ws.util.d.ts

@@ -0,0 +1,7 @@
+import { WebSocket } from 'partysocket';
+export declare class W3CWebSocket extends WebSocket {
+    constructor(options: {
+        wsURL: string;
+        headers?: Record<string, string>;
+    });
+}

package/dist/utils/ws.util.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.W3CWebSocket = void 0;
+const partysocket_1 = require("partysocket");
+const ws_1 = require("ws");
+class W3CWebSocket extends partysocket_1.WebSocket {
+    constructor(options) {
+        super(options.wsURL, [], {
+            debug: false,
+            maxEnqueuedMessages: -1,
+            WebSocket: class extends ws_1.WebSocket {
+                constructor(wsURL) {
+                    super(wsURL, options);
+                }
+            }
+        });
+    }
+}
+exports.W3CWebSocket = W3CWebSocket;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ekhein/sekiro-node-client",
-  "version": "2.1.7",
+  "version": "2.1.9",
   "license": "MIT",
   "author": "ekhein",
   "main": "./dist/main.js",
@@ -21,5 +21,8 @@
     "@types/node": "^22.15.18",
     "tsx": "^4.19.4",
     "typescript": "^5.8.3"
+  },
+  "publishConfig": {
+    "access": "public"
   }
 }