@arcblock/event-hub 1.21.3 → 1.22.1

package/lib/rpc.js

@@ -0,0 +1,121 @@
+/* eslint-disable no-console */
+const axon = require('axon');
+const Message = require('amp-message');
+const { randomUUID } = require('crypto');
+
+class Client extends axon.Socket {
+  /**
+   * @param {number} port
+   * @param {string} host
+   */
+  constructor(port, host = '127.0.0.1') {
+    super();
+    this.port = port;
+    this.host = host;
+    this.online = false;
+    this.connectPromise = null;
+    // reqId -> { resolve, reject, to, errorPrefix? }
+    this.inflight = new Map();
+
+    this.on('connect', () => {
+      this.online = true;
+    });
+    this.on('reconnect attempt', () => {
+      this.online = false;
+    });
+    this.on('disconnect', () => {
+      this.online = false;
+    });
+    this.on('error', () => {
+      /* no-op */
+    });
+  }
+
+  onmessage() {
+    return (buf) => {
+      try {
+        const msg = new Message(buf);
+        console.log('==debug==', msg);
+        const [event, data] = msg.args;
+
+        if (data && typeof data === 'object' && data.reqId) {
+          const entry = this.inflight.get(data.reqId);
+          if (entry) {
+            clearTimeout(entry.to);
+            this.inflight.delete(data.reqId);
+            if (data.ok === false) {
+              entry.reject(
+                new Error(entry.errorPrefix ? `${entry.errorPrefix}: ${data.error}` : data.error || 'request failed')
+              );
+            } else {
+              entry.resolve(data.data);
+            }
+            return; // 已消费
+          }
+        }
+        this.emit(event, data);
+      } catch (e) {
+        console.error('[axon] decode error', e);
+      }
+    };
+  }
+
+  sendEvent(event, data) {
+    const buf = this.pack([event, data]);
+    const s = this.socks[0];
+    if (s && s.writable) s.write(buf);
+    else throw new Error('axon socket not writable/connected');
+  }
+
+  async ensureOnline() {
+    if (!this.port || !this.host) {
+      throw new Error('PORT and HOST must be set via constructor: new Client(port, host)');
+    }
+    if (!this.connectPromise) {
+      this.connectPromise = new Promise((resolve, reject) => {
+        this.connect(this.port, this.host, (err) => (err ? reject(err) : resolve(this)));
+      });
+    }
+    await this.connectPromise;
+    if (this.online) return this;
+    // 等到重连完成
+    await new Promise((r) => this.once('connect', r));
+    return this;
+  }
+
+  /**
+   * 通用 RPC：发送 event，等待响应（默认只按 reqId 匹配）
+   * @param {string} event           例如 'pm2/start'
+   * @param {object} payload         发送为 { reqId, payload }
+   * @param {object} [opts]
+   * @param {number} [opts.timeoutMs=120000]
+   * @param {string} [opts.respEvent]  // 可选：仅用于调试；匹配靠 reqId，不强依赖此项
+   * @param {string} [opts.errorPrefix] // 统一错误前缀
+   * @returns {Promise<any>}
+   */
+  async rpc(event, payload = {}, { timeoutMs = 120000, respEvent, errorPrefix } = {}) {
+    await this.ensureOnline();
+    const reqId = randomUUID();
+
+    return new Promise((resolve, reject) => {
+      const to = setTimeout(() => {
+        this.inflight.delete(reqId);
+        reject(new Error(`${errorPrefix || 'request'} timeout`));
+      }, timeoutMs);
+
+      this.inflight.set(reqId, { resolve, reject, to, errorPrefix });
+
+      this.sendEvent(event, { reqId, payload });
+
+      if (respEvent) {
+        const once = (data) => {
+          if (!data || data.reqId !== reqId) return;
+          this.off(respEvent, once);
+        };
+        this.on(respEvent, once);
+      }
+    });
+  }
+}
+
+module.exports = Client;

package/lib/server.js

@@ -1,23 +1,82 @@
 /* eslint-disable no-console */
 const axon = require('axon');
 const Message = require('amp-message');
-
 const JWT = require('@arcblock/jwt');
-
 const { EVENT_AUTH, EVENT_AUTH_FAIL } = require('./constant');
 
 const getDid = (jwt) => jwt.iss.replace(/^did:abt:/, '');
 
+// 兼容 { reqId, payload } 或直接 payload
+function normalizeReq(input) {
+  if (input && typeof input === 'object' && ('payload' in input || 'reqId' in input)) {
+    const { reqId, payload } = input;
+    return { reqId, payload };
+  }
+  return { reqId: undefined, payload: input };
+}
+
+// 规范响应：默认 { ok: true, data }
+function normalizeRes(result) {
+  if (result && typeof result === 'object' && ('ok' in result || 'data' in result || 'error' in result)) {
+    return result;
+  }
+  return { ok: true, data: result };
+}
+
 class Server extends axon.Socket {
-  constructor() {
+  constructor(opts = {}) {
     super();
-    this.on('message', (event, data, sock) => {
-      const { channel } = sock;
+
+    this.jwt = opts?.jwt || JWT;
+
+    // 路由表：event -> { fn, authRequired }
+    this.handlers = new Map();
+
+    this.on('message', async (event, data, sock) => {
+      const route = this.handlers.get(event);
+
+      if (route) {
+        const { fn, authRequired } = route;
+        // 若该路由要求鉴权且当前连接未鉴权，则拒绝
+        if (authRequired && !sock.channel) {
+          console.error(`unauthenticated socket blocked for event "${event}"`);
+          return;
+        }
+
+        const { reqId, payload } = normalizeReq(data);
+
+        try {
+          const ctx = { sock, channel: sock.channel, event, server: this };
+          const result = await fn(payload, ctx);
+          const res = normalizeRes(result);
+          const replyEvent = `${event}:res`;
+
+          // 已鉴权：按 channel 投递；未鉴权：仅回当前 socket
+          if (sock.channel) {
+            this.send(replyEvent, { reqId, ...res }, sock.channel);
+          } else {
+            const buf = this.pack([replyEvent, { reqId, ...res }]);
+            if (sock.writable) sock.write(buf);
+          }
+        } catch (err) {
+          const replyEvent = `${event}:res`;
+          const payloadErr = { reqId, ok: false, error: err?.message || String(err) };
+          if (sock.channel) {
+            this.send(replyEvent, payloadErr, sock.channel);
+          } else {
+            const buf = this.pack([replyEvent, payloadErr]);
+            if (sock.writable) sock.write(buf);
+          }
+        }
+        return; // 路由事件已消费，不再广播
+      }
+
+      // 非路由事件：保持原有逻辑（必须已鉴权，否则跳过）
       if (!sock.channel) {
         console.error('skip message of unauthenticated socket');
         return;
       }
-      this.send(event, data, channel);
+      this.send(event, data, sock.channel);
     });
 
     this.on('connect', (socket) => {
@@ -43,14 +102,11 @@ class Server extends axon.Socket {
       const [event, data] = msg.args;
       if (event === EVENT_AUTH) {
         try {
-          // verify
           const { pk, token } = data;
-          if (!JWT.verify(token, pk)) {
+          if (!this.jwt.verify(token, pk)) {
             throw new Error('token verify failed');
           }
-
-          // set channel as did
-          const did = getDid(JWT.decode(token));
+          const did = getDid(this.jwt.decode(token));
           sock.channel = did;
         } catch (err) {
           console.error(err);
@@ -66,16 +122,25 @@ class Server extends axon.Socket {
 
   send(event, data, channel) {
     const { socks } = this;
-
     const buf = this.pack([event, data]);
 
-    for (let i = 0; i < socks.length; i++) {
-      const sock = socks[i];
-      if (sock.channel === channel) {
-        if (sock.writable) sock.write(buf);
+    for (const sock of socks) {
+      if (sock.channel === channel && sock.writable) {
+        sock.write(buf);
       }
     }
+    return this;
+  }
 
+  /**
+   * 注册路由
+   * @param {string} event
+   * @param {(payload:any, ctx:{sock:any, channel?:string, event:string, server:Server})=>any|Promise<any>} handler
+   * @param {{authRequired?: boolean}} [opts] - 默认 true；设为 false 则该事件免鉴权
+   */
+  register(event, handler, opts = {}) {
+    const authRequired = opts.authRequired !== false; // 默认 true
+    this.handlers.set(event, { fn: handler, authRequired });
     return this;
   }
 }

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.21.3",
+  "version": "1.22.1",
   "description": "A nodejs module for local and remote Inter Process Event",
   "main": "lib/index.js",
   "files": [
@@ -19,9 +19,9 @@
   "dependencies": {
     "amp-message": "~0.1.2",
     "axon": "^2.0.3",
-    "@arcblock/jwt": "1.21.3",
-    "@ocap/wallet": "1.21.3",
-    "@arcblock/did": "1.21.3"
+    "@arcblock/did": "1.22.1",
+    "@arcblock/jwt": "1.22.1",
+    "@ocap/wallet": "1.22.1"
   },
   "devDependencies": {
     "jest": "^29.7.0"