@ekhein/sekiro-node-client 2.1.8 → 2.1.10

package/dist/main.d.ts

@@ -1,12 +1,16 @@
-export declare class SekiroClient {
+import { ErrorEvent, CloseEvent } from 'partysocket/ws.js';
+import { W3CWebSocket } from './utils/ws.util';
+export declare class SekiroClient extends W3CWebSocket {
+    readonly group: string;
+    readonly wsURL: string;
+    readonly clientId: string;
     private readonly logger;
     private readonly handlers;
-    private readonly ws;
-    constructor(concurrency?: number, group?: string, wsURL?: string);
-    private onOpen;
-    private onClose;
-    private onError;
-    private onData;
+    constructor(group?: string, wsURL?: string, clientId?: string);
+    onopen(event: Event): Promise<void>;
+    onclose(event: CloseEvent): Promise<void>;
+    onerror(event: ErrorEvent): Promise<void>;
+    onmessage(event: MessageEvent): Promise<void>;
     registerAction(action: {
         name: string;
         handler: Function;

package/dist/main.js

@@ -5,47 +5,50 @@ const crypto_1 = require("crypto");
 const result_util_1 = require("./utils/result.util");
 const logger_util_1 = require("./utils/logger.util");
 const ws_util_1 = require("./utils/ws.util");
-class SekiroClient {
-    logger = new logger_util_1.Logger();
+class SekiroClient extends ws_util_1.W3CWebSocket {
+    group;
+    wsURL;
+    clientId;
+    logger = new logger_util_1.Logger(this);
     handlers = new Map();
-    ws = new Map();
-    constructor(concurrency = 1, group = process.env.namespace, wsURL = process.env.sekiro) {
-        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 */
-        }
+    constructor(group = process.env.namespace, wsURL = process.env.SEKIRO_WS, clientId = (0, crypto_1.randomUUID)().replace(/-/g, "")) {
+        const register = new URL("/business-demo/register", wsURL);
+        register.searchParams.append("group", group);
+        register.searchParams.append("clientId", clientId);
+        super({ wsURL: register.href });
+        this.group = group;
+        this.wsURL = wsURL;
+        this.clientId = clientId;
     }
-    async onOpen(group, clientId, event) {
-        this.logger.info(group, clientId, "Connection established");
+    // @ts-expect-error
+    async onopen(event) {
+        this.logger.info("Connection Established");
     }
-    async onClose(group, clientId, event) {
-        this.logger.warn(group, clientId, "Connection closed");
+    // @ts-expect-error
+    async onclose(event) {
+        this.logger.warn("Connection Closed", event.code);
     }
-    async onError(group, clientId, event) {
-        this.logger.warn(group, clientId, "WebSocket error", event.message);
+    // @ts-expect-error
+    async onerror(event) {
+        this.logger.warn("WebSocket Error", event.message);
     }
-    async onData(group, clientId, event) {
-        this.logger.info(group, clientId, "Received request", event.data);
+    // @ts-expect-error
+    async onmessage(event) {
+        this.logger.info("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");
+                throw new Error("Handler Not Found");
             const body = await handler.call(this, request.params);
-            const pack = result_util_1.Result.success(request, body);
-            this.ws.get(clientId).send(pack);
+            const pack = body.jsonrpc
+                ? result_util_1.Result.success(request, body.result)
+                : result_util_1.Result.success(request, body);
+            this.send(pack);
         }
         catch (error) {
             const pack = result_util_1.Result.unknown(request, error.message);
-            this.ws.get(clientId).send(pack);
+            this.send(pack);
         }
     }
     async registerAction(action) {

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

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

package/dist/utils/logger.util.js

@@ -3,18 +3,19 @@ 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 = 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);
+        const template = (0, util_1.format)("[%s] [%s] [%s] [%s]", level, time, this.context.group, this.context.clientId);
         switch (level) {
             case "INFO":
-                console.info(base, ...args);
+                console.info(template, ...message);
                 break;
             case "WARN":
-                console.warn(base, ...args);
+                console.warn(template, ...message);
                 break;
         }
     }

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ekhein/sekiro-node-client",
-  "version": "2.1.8",
+  "version": "2.1.10",
   "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"
   }
 }