@abtnode/blocklet-services 1.8.1 → 1.8.2

package/api/index.js

@@ -181,6 +181,7 @@ module.exports = function createServer(node, serverOptions = {}) {
 
   // API: notification
   notificationService.sendToUser.attach(server);
+  notificationService.sendToAppChannel.attach(server);
 
   // Middleware: auth info
   server.use(authMiddlewares.bearerToken);

package/api/libs/auth.js

@@ -4,7 +4,7 @@ const joinUrl = require('url-join');
 const DiskStorage = require('@arcblock/did-auth-storage-nedb');
 const { WalletAuthenticator } = require('@arcblock/did-auth');
 const WalletHandlers = require('@blocklet/sdk/lib/wallet-handler');
-const sendNotification = require('@blocklet/sdk/lib/util/send-notification');
+const { sendToUser } = require('@blocklet/sdk/lib/util/send-notification');
 const { WELLKNOWN_SERVICE_PATH_PREFIX, NODE_SERVICES_PREFIX } = require('@abtnode/constant');
 
 const { getBlockletLogo } = require('../util');
@@ -62,11 +62,10 @@ module.exports = (node, opts) => {
     sendNotificationFn: async (connectedDid, message, { req }) => {
       const { wallet } = await req.getBlockletInfo();
       const sender = {
-        appId: wallet.address,
+        appDid: wallet.address,
         appSk: wallet.secretKey,
-        did: req.getBlockletDid(),
       };
-      return sendNotification(connectedDid, message, sender, process.env.ABT_NODE_SERVICE_PORT);
+      return sendToUser(connectedDid, message, sender, process.env.ABT_NODE_SERVICE_PORT);
     },
   };
 

package/api/routes/blocklet.js

@@ -133,6 +133,18 @@ module.exports = {
 
         await node.setBlockletInitialized({ did: blocklet.meta.did, owner: { did: userDid, pk } });
 
+        // 调用 store 管理公开实例
+        // 如果一个 blocklet 没有设置 公开实例，启动成功后不应给 store 发请求
+        const { publicToStore } = blocklet.settings;
+        if (publicToStore) {
+          try {
+            await handleInstanceInStore(blocklet, { userDid, publicToStore });
+          } catch (error) {
+            // 即使实例公开不成功，不能影响正常启动流程
+            logger.error('failed to send blocklet logo', { did: blocklet.meta.did, error });
+          }
+        }
+
         // create vc
         const vc = createPassportVC({
           issuerName: name,
@@ -174,20 +186,11 @@ module.exports = {
           node
         );
 
-        // 调用 store 管理公开实例
-        const { publicToStore } = blocklet.settings;
-        try {
-          await handleInstanceInStore(blocklet, { userDid, publicToStore });
-        } catch (error) {
-          // 即使实例公开不成功，不能影响正常启动流程
-          logger.error('failed to send blocklet logo', { did: blocklet.meta.did, error });
-        }
-
         // send vc to wallet
         const receiver = userDid;
         const token = JWT.sign(wallet.address, wallet.secretKey);
         const data = {
-          sender: { did: teamDid, token, appDid: wallet.address },
+          sender: { token, appDid: wallet.address },
           receiver,
           notification: {
             title: {

package/api/services/notification/channel/app-channel.js

@@ -0,0 +1,114 @@
+const get = require('lodash/get');
+
+const { CHANNEL_TYPE, parseChannel } = require('@blocklet/meta/lib/channel');
+const { validateNotification } = require('@blocklet/sdk/lib/validators/notification');
+const { NODE_MODES } = require('@abtnode/constant');
+
+const { ensureSender, parseNotification, broadcast, EVENTS } = require('../util');
+
+/**
+ *
+ * @param {ABTNode} node
+ * @param {{
+ *   {{
+ *     {String} did
+ *     {String} token
+ *   }} sender
+ *   {String} channel
+ *   {String} event
+ *   {Array|Object} notification
+ * }} payload
+ * @param {WsServer} wsServer
+ * @returns
+ */
+const sendToAppChannel = async ({
+  sender,
+  channel,
+  event = EVENTS.MESSAGE,
+  notification,
+  options,
+  node,
+  wsServer,
+} = {}) => {
+  const { socketId, socketDid } = options || {};
+
+  const channelInfo = parseChannel(channel);
+
+  if (channelInfo.type !== CHANNEL_TYPE.APP) {
+    throw new Error('Cannot send message to non-app channel');
+  }
+
+  const nodeInfo = await node.getNodeInfo();
+
+  // get socket match
+  const socketFilters = {};
+  if (socketId) {
+    socketFilters.id = socketId;
+  }
+  if (socketDid) {
+    socketFilters[`channel.${channel}.authInfo.did`] = socketDid;
+  }
+
+  // validate
+
+  if (nodeInfo.mode !== NODE_MODES.DEBUG) {
+    await validateNotification(notification);
+  }
+
+  // parse sender
+
+  const senderInfo = await ensureSender({ sender, node, nodeInfo });
+
+  if (channelInfo.appDid !== senderInfo.wallet.address) {
+    throw new Error('Cannot sent message to channel of other app');
+  }
+
+  // parse notification
+
+  const notifications = parseNotification(notification, senderInfo);
+
+  // send notification
+  notifications.forEach((data) => {
+    broadcast(wsServer, channel, event, data, { socketFilters });
+  });
+};
+
+const onAuthenticate = async ({ channel, node }) => {
+  const { appDid } = parseChannel(channel);
+
+  const exist = await node.hasBlocklet({ did: appDid });
+  if (!exist) {
+    throw new Error(`App does not exist: ${appDid}`);
+  }
+};
+
+const onJoin = async ({ socket, channel, wsServer }) => {
+  const { appDid } = parseChannel(channel);
+
+  const senderDid = get(socket, `channel.${channel}.authInfo.did`);
+
+  if (senderDid === appDid) {
+    return;
+  }
+
+  broadcast(
+    wsServer,
+    channel,
+    'hi',
+    {
+      sender: {
+        socketId: socket.id,
+        did: senderDid,
+      },
+    },
+    {
+      socketFilters: {
+        [`channel.${channel}.authInfo.did`]: appDid,
+      },
+    }
+  );
+};
+
+const onMessage = () => {};
+
+module.exports = { onAuthenticate, onJoin, onMessage, sendToAppChannel };

package/api/services/notification/channel/did-channel.js

@@ -0,0 +1,147 @@
+const {
+  validateReceiver,
+  validateNotification,
+  validateMessage,
+} = require('@blocklet/sdk/lib/validators/notification');
+const { NODE_MODES } = require('@abtnode/constant');
+
+// eslint-disable-next-line global-require
+const logger = require('@abtnode/logger')(`${require('../../../../package.json').name}:notification`);
+const { ensureSender, parseNotification, broadcast, EVENTS } = require('../util');
+const states = require('../../../state');
+
+/**
+ *
+ * @param {{
+ *   {{
+ *     did: String
+ *     token: String
+ *   }} sender
+ *   receiver: Array|String // user did
+ *   notification: Array|Object
+ *   options: Object
+ *   node: ABTNode
+ *   wsServer: WsServer
+ * }}
+ * @returns
+ */
+const sendToDid = async ({ sender, receiver, notification, options, node, wsServer }) => {
+  const { keepForOfflineUser = true } = options || {};
+
+  // validate
+
+  await validateReceiver(receiver);
+
+  const nodeInfo = await node.getNodeInfo();
+
+  if (nodeInfo.mode !== NODE_MODES.DEBUG) {
+    await validateNotification(notification);
+  }
+
+  // parse sender
+
+  const senderInfo = await ensureSender({ sender, node, nodeInfo });
+
+  // parse notification
+
+  const notifications = parseNotification(notification, senderInfo);
+
+  // parse receiver
+
+  const receivers = [].concat(receiver);
+
+  // send notification
+
+  receivers.forEach((did) => {
+    notifications.forEach((data) => {
+      broadcast(wsServer, did, EVENTS.MESSAGE, data, async (count) => {
+        if (count <= 0 && keepForOfflineUser) {
+          logger.info('Online client was not found', { userDid: did });
+          await states.message.insert({ did, event: EVENTS.MESSAGE, data });
+        }
+      });
+    });
+  });
+};
+
+const sendCachedMessages = async (wsServer, did) => {
+  try {
+    const messages = await states.message.find({ did });
+    if (!messages.length) {
+      return;
+    }
+
+    messages.forEach(({ did: channel, event, data }) => {
+      wsServer.broadcast(channel, event, data);
+    });
+
+    await states.message.remove({ did }, { multi: true });
+  } catch (error) {
+    logger.error('Error on sending cached messages', { error });
+  }
+};
+
+/**
+ * Receive message from channel
+ * @param {{
+ *   {WsServer} wsServer
+ *   {ABTNode} Node
+ *   {string} topic
+ *   {string} event
+ *   {Object} payload
+ * }}
+ * @returns
+ */
+const onMessage = async ({ channel: from, event = EVENTS.MESSAGE, payload: message, wsServer, node }) => {
+  if (event !== EVENTS.MESSAGE) {
+    throw new Error(`Invalid event. expect: "message". got: "${event}"`);
+  }
+
+  await validateMessage(message);
+
+  // validate receiver
+  const { receiver, ...data } = message;
+
+  const blocklet = await node.getBlocklet({ did: receiver.did, attachConfig: false });
+  if (!blocklet) {
+    const nodeInfo = await node.getNodeInfo();
+
+    // only throw error if receiver is a blocklet (not server)
+    if (nodeInfo.did !== receiver.did) {
+      throw new Error(`App is not installed in the server. receiver: ${receiver.did}`);
+    }
+  }
+
+  logger.info('send message to blocklet', { sender: from, receiver: receiver.did });
+  wsServer.broadcast(receiver.did, event, {
+    ...data,
+    sender: {
+      did: from,
+    },
+  });
+};
+
+const onJoin = async ({ channel: did, payload, wsServer, node }) => {
+  await sendCachedMessages(wsServer, did);
+
+  if (payload.message) {
+    await onMessage({
+      channel: did,
+      payload: payload.message,
+      wsServer,
+      node,
+    });
+  }
+};
+
+const onAuthenticate = async ({ channel, did, payload }) => {
+  if (did !== channel) {
+    throw new Error(`verified did and channel does not match. did: ${did}, channel: ${channel}`);
+  }
+
+  if (payload.message) {
+    await validateMessage(payload.message);
+  }
+};
+
+module.exports = { onAuthenticate, onJoin, onMessage, sendToDid };

package/api/services/notification/channel/get-hooks-by-channel.js

@@ -0,0 +1,18 @@
+const { CHANNEL_TYPE, parseChannel } = require('@blocklet/meta/lib/channel');
+
+const AppChannel = require('./app-channel');
+const DidChannel = require('./did-channel');
+
+const getHooksByChannel = (channel) => {
+  const { type } = parseChannel(channel);
+  if (type === CHANNEL_TYPE.DID) {
+    return DidChannel;
+  }
+  if (type === CHANNEL_TYPE.APP) {
+    return AppChannel;
+  }
+
+  throw new Error('Unknown channel type');
+};
+
+module.exports = getHooksByChannel;

package/api/services/notification/index.js

@@ -1,26 +1,19 @@
 /* eslint-disable arrow-parens */
 const JWT = require('@arcblock/jwt');
 const { WsServer } = require('@arcblock/ws');
-const uuid = require('uuid');
 const Cron = require('@abtnode/cron');
-const {
-  validateNotification,
-  validateReceiver,
-  validateMessage,
-} = require('@blocklet/sdk/lib/validators/notification');
 // eslint-disable-next-line global-require
 const logger = require('@abtnode/logger')(`${require('../../../package.json').name}:notification`);
-const { getTeamInfo } = require('@abtnode/auth/lib/auth');
-const { NODE_MODES } = require('@abtnode/constant');
 
 const states = require('../../state');
 const { PREFIXES } = require('../../util/constants');
 
-const getDid = (jwt) => jwt.iss.replace(/^did:abt:/, '');
+const { sendToAppChannel } = require('./channel/app-channel');
+const { sendToDid } = require('./channel/did-channel');
+const getHooksByChannel = require('./channel/get-hooks-by-channel');
+const { getDid } = require('./util');
 
-// todo: move to notification dir
-
-const authenticate = (req, cb) => {
+const authenticateConnect = (req, cb) => {
   const { searchParams } = new URL(req.url, `http://${req.headers.host || 'unknown'}`);
   const token = searchParams.get('token');
   const pk = searchParams.get('pk');
@@ -38,97 +31,7 @@ const authenticate = (req, cb) => {
   cb(null, { did: getDid(JWT.decode(token)) });
 };
 
-/**
- *
- * @param {ABTNode} node
- * @param {Object} payload
- *   {Object} sender: blocklet
- *     {String} sender.did: blocklet did
- *     {String} sender.token: for the verification
- *   {Array|String} receiver: user did
- *   {Array|Object} notification
- * @returns
- */
-const onSendToUser = async (node, payload, wsServer) => {
-  const { sender, receiver, notification, options } = payload;
-  const { keepForOfflineUser = true } = options || {};
-
-  await validateReceiver(receiver);
-
-  const nodeInfo = await node.getNodeInfo();
-
-  if (nodeInfo.mode !== NODE_MODES.DEBUG) {
-    await validateNotification(notification);
-  }
-
-  let senderInfo;
-  try {
-    senderInfo = await getTeamInfo({ node, nodeInfo, teamDid: sender.did });
-  } catch (err) {
-    if (err.message === 'Blocklet state must be an object') {
-      err.message = `Sender blocklet does not exist: ${sender.did}`;
-    }
-    throw err;
-  }
-
-  const { wallet, name } = senderInfo;
-  if (!JWT.verify(sender.token, wallet.publicKey)) {
-    throw new Error(`Invalid authentication token for sender blocklet: ${sender.did}`);
-  }
-
-  if (sender.appDid !== wallet.address) {
-    throw new Error(`Invalid app did, expected: ${wallet.address}, actual: ${sender.appDid}`);
-  }
-
-  // parse notifications
-
-  const notifications = [].concat(notification);
-
-  notifications.forEach((x) => {
-    x.id = uuid.v4();
-    x.sender = {
-      did: sender.appDid,
-      name,
-    };
-    x.createdAt = new Date();
-  });
-
-  // parse receivers
-
-  const receivers = [].concat(receiver);
-
-  // send notification
-
-  const EVENT_NAME = 'message';
-  const createTask = async (did, data) => {
-    try {
-      const count = await new Promise((resolve) => {
-        wsServer.broadcast(did, EVENT_NAME, data, ({ count: c } = {}) => {
-          resolve(c);
-        });
-      });
-
-      if (count <= 0 && keepForOfflineUser) {
-        logger.info('Online client was not found', { userDid: did });
-        await states.message.insert({ did, event: EVENT_NAME, data });
-      }
-    } catch (error) {
-      logger.error('Failed on broadcast message', { error });
-    }
-  };
-
-  const tasks = [];
-  receivers.forEach((did) => {
-    notifications.forEach((data) => {
-      tasks.push(createTask(did, data));
-    });
-  });
-
-  // FIXME: Enhance task reliability. e.g. resend after timeout or error; add message status: sent, received, staged
-  await Promise.allSettled(tasks);
-};
-
-const verify = async ({ topic, payload }) => {
+const authenticateJoinChannel = async ({ topic: channel, payload, node }) => {
   const did = getDid(JWT.decode(payload.token));
 
   // Support the web wallet to continue to run for one day
@@ -143,76 +46,45 @@ const verify = async ({ topic, payload }) => {
     throw new Error(`verify did failed: ${did}`);
   }
 
-  if (did !== topic) {
-    throw new Error(`verified did and topic does not match. did: ${did}, topic: ${topic}`);
-  }
-
-  if (payload.message) {
-    await validateMessage(payload.message);
-  }
-};
-
-const receiveMessage = async ({ topic, event, payload, wsServer, node }) => {
-  if (event !== 'message') {
-    throw new Error(`Invalid event. expect: "message". got: "${event}"`);
-  }
-
-  await validateMessage(payload);
-
-  const { receiver, ...data } = payload;
-
-  const blocklet = await node.getBlocklet({ did: receiver.did, attachConfig: false });
-  if (!blocklet) {
-    const nodeInfo = await node.getNodeInfo();
+  const hooks = getHooksByChannel(channel);
+  await hooks.onAuthenticate({ channel, did, payload, node });
 
-    // only log error if receiver is a blocklet (not server)
-    if (nodeInfo.did !== receiver.did) {
-      throw new Error(`App is not installed in the server. receiver: ${receiver.did}`);
-    }
-  }
+  const authInfo = { did };
 
-  logger.info('send message to blocklet', { sender: topic, receiver });
-  wsServer.broadcast(payload.receiver.did, 'message', {
-    ...data,
-    sender: {
-      did: topic,
-    },
-  });
+  return authInfo;
 };
 
-const sendCachedMessages = async (wsServer, payload) => {
-  try {
-    const did = getDid(JWT.decode(payload.token));
+const postJoinChannel = async ({ socket, topic: channel, payload, wsServer, node }) => {
+  logger.info('Subscribe notification success', { channel });
 
-    const messages = await states.message.find({ did });
-    if (!messages.length) {
-      return;
-    }
-
-    messages.forEach(({ did: d, event, data }) => {
-      wsServer.broadcast(d, event, data);
-    });
+  const hooks = getHooksByChannel(channel);
+  await hooks.onJoin({ socket, channel, payload, wsServer, node });
+};
 
-    await states.message.remove({ did }, { multi: true });
-  } catch (error) {
-    logger.error('Error on sending cached messages', { error });
-  }
+/**
+ * Receive message from channel
+ * @param {{
+ *   wsServer: WsServer
+ *   node: ABTNode
+ *   topic: String
+ *   event: String
+ *   payload: Object
+ * }}
+ * @returns
+ */
+const receiveMessage = async ({ socket, topic: channel, event, payload, wsServer, node }) => {
+  const hooks = getHooksByChannel(channel);
+  await hooks.onMessage({ socket, channel, event, payload, wsServer, node });
 };
 
 const init = ({ node }) => {
   // Create ws server
   const wsServer = new WsServer({
     logger,
-    authenticate,
+    authenticate: authenticateConnect,
     hooks: {
-      preJoinChannel: (param) => verify({ ...param, wsServer, node }),
-      postJoinChannel: async ({ topic, payload }) => {
-        logger.info('Subscribe notification success', { account: topic });
-        await sendCachedMessages(wsServer, payload);
-        if (payload.message) {
-          await receiveMessage({ topic, event: 'message', payload: payload.message, wsServer, node });
-        }
-      },
+      authenticateJoinChannel: (param) => authenticateJoinChannel({ ...param, wsServer, node }),
+      postJoinChannel: (param) => postJoinChannel({ ...param, wsServer, node }),
       receiveMessage: (param) => receiveMessage({ ...param, wsServer, node }),
     },
   });
@@ -234,9 +106,9 @@ const init = ({ node }) => {
     });
   }
 
-  const sendToUser = async (req, res) => {
+  const onSendToUser = async (req, res) => {
     try {
-      await onSendToUser(node, req.body.data, wsServer);
+      await sendToDid({ ...req.body.data, node, wsServer });
       res.status(200).send('');
     } catch (error) {
       logger.error('Send message to user failed', { error });
@@ -245,16 +117,40 @@ const init = ({ node }) => {
     }
   };
 
+  const onSendToAppChannel = async (req, res) => {
+    try {
+      await sendToAppChannel({ ...req.body.data, node, wsServer });
+      res.status(200).send('');
+    } catch (error) {
+      logger.error('Send message to channel failed', { error });
+      res.statusMessage = error.message;
+      res.status(400).send(error.message);
+    }
+  };
+
   // mount
   return {
     sendToUser: {
       attach: (app) => {
         PREFIXES.forEach((prefix) => {
-          app.post(`${prefix}/api/sendToUser`, sendToUser);
+          app.post(`${prefix}/api/send-to-user`, onSendToUser);
+
+          // backward compatible
+          app.post(`${prefix}/api/sendToUser`, onSendToUser);
         });
       },
-      exec: (data) => onSendToUser(node, data, wsServer),
+      exec: (data) => sendToDid({ ...data, node, wsServer }),
     },
+
+    sendToAppChannel: {
+      attach: (app) => {
+        PREFIXES.forEach((prefix) => {
+          app.post(`${prefix}/api/send-to-app-channel`, onSendToAppChannel);
+        });
+      },
+      exec: (data) => sendToAppChannel({ ...data, node, wsServer }),
+    },
+
     attach: (wsRouter) => {
       PREFIXES.forEach((prefix) => {
         wsRouter.use(`${prefix}/websocket`, wsServer.onConnect.bind(wsServer));