@abtnode/blocklet-services 1.16.39-beta-20250215-130252-43410928 → 1.16.39-beta-20250218-110004-a308c501

package/api/socket/channel/did.js

@@ -1,31 +1,34 @@
-const {
-  validateReceiver,
-  validateNotification,
-  validateMessage,
-  NOTIFICATION_TYPES,
-} = require('@blocklet/sdk/lib/validators/notification');
+const { validateNotification, validateMessage } = require('@blocklet/sdk/lib/validators/notification');
 const { Joi } = require('@arcblock/validator');
-const { NODE_MODES, NOTIFICATION_SEND_STATUS, NOTIFICATION_SEND_FAILED_REASON } = require('@abtnode/constant');
-const { getWalletDid } = require('@blocklet/sdk/lib/did');
+const {
+  NODE_MODES,
+  NOTIFICATION_SEND_STATUS,
+  NOTIFICATION_SEND_FAILED_REASON,
+  NOTIFICATION_SEND_CHANNEL,
+} = require('@abtnode/constant');
 const JWT = require('@arcblock/jwt');
-const pMap = require('p-map');
-const uniqBy = require('lodash/uniqBy');
 const uniq = require('lodash/uniq');
-const get = require('lodash/get');
-const pLimit = require('p-limit');
 
 const logger = require('../../libs/logger')('notification');
-const { ensureSenderApp, getSenderServer, parseNotification, broadcast, EVENTS } = require('../util');
+const { ensureSenderApp, getSenderServer, parseNotification, EVENTS } = require('../util');
 const states = require('../../state');
-const { validateEmail, sendEmail } = require('../../libs/email');
+const { sendEmail } = require('../../libs/email');
 const { sendPush } = require('../../libs/push-kit');
-const { getBlockletInfo } = require('../../cache');
-const { nanoid } = require('../../util');
 
 const CHANNEL_FIELD_MAP = {
-  wallet: ['walletSendStatus', 'walletSendAt', 'walletSendFailedReason', 'walletSendRecord'],
-  pushKit: ['pushKitSendStatus', 'pushKitSendAt', 'pushKitSendFailedReason', 'pushKitSendRecord'],
-  email: ['emailSendStatus', 'emailSendAt', 'emailSendFailedReason', 'emailSendRecord'],
+  [NOTIFICATION_SEND_CHANNEL.WALLET]: [
+    'walletSendStatus',
+    'walletSendAt',
+    'walletSendFailedReason',
+    'walletSendRecord',
+  ],
+  [NOTIFICATION_SEND_CHANNEL.PUSH]: [
+    'pushKitSendStatus',
+    'pushKitSendAt',
+    'pushKitSendFailedReason',
+    'pushKitSendRecord',
+  ],
+  [NOTIFICATION_SEND_CHANNEL.EMAIL]: ['emailSendStatus', 'emailSendAt', 'emailSendFailedReason', 'emailSendRecord'],
 };
 
 const updateNotificationSendStatus = async ({
@@ -41,7 +44,7 @@ const updateNotificationSendStatus = async ({
   if (!node || !notificationId || !receivers.length) {
     return undefined;
   }
-  if (channel === 'webhook' && Object.keys(webhookParams).length > 0) {
+  if (channel === NOTIFICATION_SEND_CHANNEL.WEBHOOK && Object.keys(webhookParams).length > 0) {
     const updateParams = {
       receivers,
       teamDid,
@@ -100,427 +103,86 @@ const updateNotificationSendStatus = async ({
  * @param {ABTNode} options.node
  * @param {WsServer} options.wsServer
  */
-const sendToUserDid = async ({ sender, receiver: rawDid, notification, options, node, wsServer }) => {
+const sendToUserDid = async ({ sender, receiver: rawDid, notification, options, node }) => {
   // FIXME: @zhanghan 默认不应该有 push（仅在测试阶段加上），后期需要移除
-  const { keepForOfflineUser = true, channels = ['app', 'email', 'webhook', 'push'] } = options || {};
+  const { channels = ['app', 'email', 'webhook', 'push'], ...rest } = options || {};
+
   if (channels.length === 0) {
     return;
   }
-
-  const teamDid = notification?.appInfo?.did || sender.appDid;
-
-  // 要判断是否是 role Did
-  const userDids = Array.isArray(rawDid) ? rawDid : [rawDid];
-
-  const receivers = await node.getNotificationReceivers({ teamDid, userDids, enableConnectedAccounts: true });
-  const receiver = receivers.map((r) => r.did);
-
-  let receiverPushDidList = [];
-  let notEnabledPushReceiverList = [];
-  let receiverAppDidList = [];
-  let notEnabledAppReceiverList = [];
-  let receiverEmailList = [];
-  let notEnabledEmailReceiverList = [];
-  let webhookList = [];
-
-  const webhookSenders = new Map();
-
-  await pMap(receivers, async (user) => {
-    const walletEnabled = get(user, 'extra.notifications.wallet', true);
-    const emailEnabled = get(user, 'extra.notifications.email', true);
-    const pushEnabled = get(user, 'extra.notifications.push', true);
-    const webhooks = get(user, 'extra.webhooks', []);
-
-    const receiverDid = getWalletDid(user) || user.did;
-    const receiverEmail = user?.email;
-    if (!walletEnabled) {
-      notEnabledAppReceiverList.push(receiverDid);
-    }
-    if (!pushEnabled) {
-      notEnabledPushReceiverList.push(receiverDid);
-    }
-    if (!emailEnabled) {
-      notEnabledEmailReceiverList.push(receiverDid);
-    }
-
-    if (receiverDid && (walletEnabled || pushEnabled)) {
-      try {
-        await validateReceiver(receiverDid);
-        if (walletEnabled) {
-          receiverAppDidList.push(receiverDid);
-        }
-        if (pushEnabled) {
-          receiverPushDidList.push(receiverDid);
-        }
-      } catch (error) {
-        logger.error(`Skip invalid did receiver: ${receiverDid}`, { error });
-      }
-    }
-    if (receiverEmail && emailEnabled) {
-      try {
-        await validateEmail(receiverEmail);
-        receiverEmailList.push({
-          email: receiverEmail,
-          locale: user?.locale || 'en',
-          did: receiverDid,
-          fullName: user?.fullName,
-          avatar: user?.avatar,
-        });
-      } catch (error) {
-        logger.error(`Skip invalid email receiver: ${receiverEmail}`, { error });
-      }
-    } else {
-      notEnabledEmailReceiverList.push(receiverDid);
-    }
-
-    if (Array.isArray(webhooks)) {
-      webhookList.push(...webhooks.filter((x) => x.type && x.url));
-    }
-  });
-
-  if (
-    receiverAppDidList.length === 0 &&
-    receiverEmailList.length === 0 &&
-    receiverPushDidList.length === 0 &&
-    webhookList.length === 0
-  ) {
-    throw new Error('Invalid receiver');
-  }
+  const teamDid = sender.appDid;
 
   const nodeInfo = await node.getNodeInfo({ useCache: true });
 
-  const isServer = teamDid === nodeInfo.did;
-
   if (nodeInfo.mode !== NODE_MODES.DEBUG) {
-    await validateNotification(notification);
+    try {
+      await validateNotification(notification);
+    } catch (error) {
+      logger.error('Failed to validate notification', { error });
+      // 抛出错误，阻止后续执行
+      throw error;
+    }
   }
 
-  // parse sender
-  const senderInfo = await ensureSenderApp({ sender, node, nodeInfo });
-
-  // parse notification
-  const notifications = parseNotification(notification, senderInfo);
-
-  // uniq receivers
-  receiverPushDidList = uniq(receiverPushDidList);
-  receiverAppDidList = uniq(receiverAppDidList);
-  receiverEmailList = uniqBy(receiverEmailList, 'email');
-  webhookList = uniqBy(webhookList, 'url');
-
-  notEnabledAppReceiverList = uniq(notEnabledAppReceiverList);
-  notEnabledPushReceiverList = uniq(notEnabledPushReceiverList);
-  notEnabledEmailReceiverList = uniq(notEnabledEmailReceiverList);
-
-  const disabledChannelReceivers = [
-    [notEnabledAppReceiverList, 'wallet'],
-    [notEnabledPushReceiverList, 'pushKit'],
-    [notEnabledEmailReceiverList, 'email'],
-  ];
-
-  let wallet;
-
-  if (sender.type !== 'server') {
-    const blockletInfo = await getBlockletInfo({ did: teamDid, node });
-    wallet = blockletInfo.wallet;
+  if (!sender.token) {
+    throw new Error('Invalid sender: token empty');
   }
 
-  const _teamDid = isServer ? nodeInfo.did : teamDid;
+  const notifications = Array.isArray(notification) ? notification : [notification];
 
-  // send notification
   await Promise.all(
-    notifications.map(async (data) => {
-      let doc = null;
-      const isSaveSkipped = data.type?.toLowerCase() === 'passthrough';
-      if (data.id && !isSaveSkipped) {
-        doc = await node.getNotificationById({
-          teamDid: _teamDid,
-          id: data.id,
-        });
-      }
-      if (!data.id && !isServer && sender.type !== 'server' && !isSaveSkipped) {
-        doc = await node.createNotification({
-          teamDid,
-          ...data,
-          receiver,
-          componentDid: sender.componentDid,
-          // 这两个字段用于 socket 通知
-          entityType: 'blocklet',
-          entityId: sender.appDid,
-          source: 'component',
-          ignorePush: true,
-        });
-      }
-
-      // 为消息添加一个ID，wallet钱包接受消息会使用这个字段
-      data.id = data.id || doc?.id || nanoid();
-      const commonParams = {
-        node,
-        teamDid: _teamDid,
-        notificationId: doc?.id,
-      };
+    notifications.map((_notification) => {
+      const pushOnly = ['passthrough', 'connect', 'hi'].includes(_notification.type?.toLowerCase());
 
-      // 更新用户未开启渠道状态
-      disabledChannelReceivers.forEach(([_receivers, channel]) => {
-        // 向用户对应的渠道发送消息但是用户没有开启对应渠道；属于发送失败
-        updateNotificationSendStatus({
-          ...commonParams,
-          receivers: _receivers,
-          channel,
-          status: NOTIFICATION_SEND_STATUS.FAILED,
-          failedReason: NOTIFICATION_SEND_FAILED_REASON.CHANNEL_DISABLED,
-        });
+      return node.createNotification({
+        teamDid,
+        notification: _notification,
+        receiver: rawDid,
+        componentDid: sender.componentDid,
+        // 这两个字段用于 socket 通知
+        entityType: notification.entityType || 'blocklet',
+        entityId: notification.entityId || sender.appDid,
+        source: notification.source || 'component',
+        channels,
+        sender,
+        options: { ...rest },
+        pushOnly,
       });
-
-      // 发送钱包消息
-      if (channels.includes('app')) {
-        for (const receiverDid of receiverAppDidList) {
-          broadcast(wsServer, receiverDid, EVENTS.MESSAGE, data, async (count) => {
-            if (count <= 0 && keepForOfflineUser) {
-              logger.error('Online client was not found', { userDid: receiverDid });
-              await states.message.insert({ did: receiverDid, event: EVENTS.MESSAGE, data });
-              updateNotificationSendStatus({
-                ...commonParams,
-                receivers: [receiverDid],
-                channel: 'wallet',
-                status: NOTIFICATION_SEND_STATUS.FAILED,
-                failedReason: NOTIFICATION_SEND_FAILED_REASON.NOT_ONLINE,
-              });
-            } else {
-              updateNotificationSendStatus({
-                ...commonParams,
-                receivers: [receiverDid],
-                channel: 'wallet',
-                status: NOTIFICATION_SEND_STATUS.SENT,
-              });
-            }
-          });
-        }
-      } else {
-        updateNotificationSendStatus({
-          ...commonParams,
-          receivers: receiverAppDidList,
-          channel: 'wallet',
-          status: NOTIFICATION_SEND_STATUS.FAILED,
-          failedReason: NOTIFICATION_SEND_FAILED_REASON.CHANNEL_DISABLED,
-        });
-      }
-
-      if (channels.includes('push')) {
-        // 发送 pushKit
-        // 目前保持发送消息跟钱包能收到的消息是一致的（会包含组件的启停通知）
-        sendPush(receiverPushDidList, data, { teamDid, node })
-          .then((res) => {
-            updateNotificationSendStatus({
-              ...commonParams,
-              receivers: receiverPushDidList,
-              channel: 'pushKit',
-              status: res ? NOTIFICATION_SEND_STATUS.SENT : NOTIFICATION_SEND_STATUS.FAILED,
-              failedReason: res ? null : NOTIFICATION_SEND_FAILED_REASON.CHANNEL_UNAVAILABLE,
-            });
-          })
-          .catch((err) => {
-            // 即使失败也不应该导致程序异常，还是需要发送其他渠道
-            logger.error('Failed to send pushKit', { error: err });
-            updateNotificationSendStatus({
-              ...commonParams,
-              receivers: receiverPushDidList,
-              channel: 'pushKit',
-              status: NOTIFICATION_SEND_STATUS.FAILED,
-              failedReason: err.message,
-            });
-          });
-      } else {
-        updateNotificationSendStatus({
-          ...commonParams,
-          receivers: receiverPushDidList,
-          channel: 'pushKit',
-          status: NOTIFICATION_SEND_STATUS.FAILED,
-          failedReason: NOTIFICATION_SEND_FAILED_REASON.CHANNEL_DISABLED,
-        });
-      }
-
-      // Do not send email for component activities
-      // server 的通知暂不支持发送邮箱
-      // 不建议通过这种方式禁止发送消息，要根据传入的 channel 判断
-      if (data.source !== 'app' && sender.type !== 'server') {
-        // 发送邮件消息
-        // NOTICE: 目前只有 notification 的通知能够发送邮件，并且 type 可能为 undefined
-        if (channels.includes('email')) {
-          if ([undefined, NOTIFICATION_TYPES.NOTIFICATION].includes(data.type)) {
-            const limit = pLimit(10);
-            const sendEmailList = receiverEmailList.map((receiverItem) => {
-              return limit(async () => {
-                try {
-                  const now = Math.floor(Date.now() / 1000);
-                  const userDid = receiverItem?.did;
-                  const unsubscribeToken = userDid
-                    ? JWT.signV2(wallet.address, wallet.secretKey, {
-                        userDid,
-                        channel: 'email',
-                        // 30 days
-                        exp: String(now + 30 * 24 * 60 * 60),
-                      })
-                    : null;
-                  const res = await sendEmail(receiverItem.email, data, {
-                    teamDid,
-                    node,
-                    locale: receiverItem.locale,
-                    unsubscribeToken,
-                    userInfo: {
-                      did: userDid,
-                      fullName: receiverItem.fullName,
-                      // NOTICE: 将来可能还需要头像，先保留该代码
-                      // avatar: getUserAvatarUrl(receiverItem.avatar, blocklet),
-                    },
-                  });
-                  updateNotificationSendStatus({
-                    ...commonParams,
-                    receivers: [userDid],
-                    channel: 'email',
-                    status: res ? NOTIFICATION_SEND_STATUS.SENT : NOTIFICATION_SEND_STATUS.FAILED,
-                    failedReason: res ? null : NOTIFICATION_SEND_FAILED_REASON.CHANNEL_UNAVAILABLE,
-                  });
-                } catch (error) {
-                  logger.error('Failed to send email');
-                  updateNotificationSendStatus({
-                    ...commonParams,
-                    receivers: [receiverItem?.did],
-                    channel: 'email',
-                    status: NOTIFICATION_SEND_STATUS.FAILED,
-                    failedReason: error.message,
-                  });
-                }
-              });
-            });
-            Promise.all(sendEmailList);
-          }
-        } else {
-          updateNotificationSendStatus({
-            ...commonParams,
-            receivers: receiverEmailList.map((item) => item.did),
-            channel: 'email',
-            status: NOTIFICATION_SEND_STATUS.FAILED,
-            failedReason: NOTIFICATION_SEND_FAILED_REASON.CHANNEL_DISABLED,
-          });
-        }
-
-        if (channels.includes('webhook') && !isSaveSkipped) {
-          // 发送 webhook
-          for (const webhook of webhookList) {
-            let webhookSender = webhookSenders.get(webhook.type);
-            if (!webhookSender) {
-              webhookSender = node.getMessageSender(webhook.type);
-              webhookSenders.set(webhook.type, webhookSender);
-            }
-
-            const webhookParams = {
-              [webhook.url]: {
-                type: webhook.type ?? 'api',
-                sendAt: new Date(),
-              },
-            };
-
-            webhookSender
-              .sendNotification(webhook.url, data)
-              .then((res) => {
-                webhookParams[webhook.url] = {
-                  ...webhookParams[webhook.url],
-                  status: res ? NOTIFICATION_SEND_STATUS.SENT : NOTIFICATION_SEND_STATUS.FAILED,
-                  failedReason: res ? '' : NOTIFICATION_SEND_FAILED_REASON.CHANNEL_UNAVAILABLE,
-                };
-                updateNotificationSendStatus({
-                  ...commonParams,
-                  receivers: receivers.map((item) => item.did),
-                  channel: 'webhook',
-                  webhookParams,
-                });
-              })
-              .catch((err) => {
-                logger.error('Failed to send webhook', { error: err });
-                webhookParams[webhook.url] = {
-                  ...webhookParams[webhook.url],
-                  status: NOTIFICATION_SEND_STATUS.FAILED,
-                  failedReason: err.message,
-                };
-                updateNotificationSendStatus({
-                  ...commonParams,
-                  receivers: receivers.map((item) => item.did),
-                  channel: 'webhook',
-                  webhookParams,
-                });
-              });
-          }
-        } else {
-          // eslint-disable-next-line no-lonely-if
-          if (webhookList.length > 0) {
-            const webhookParams = {};
-            for (const webhook of webhookList) {
-              webhookParams[webhook.url] = {
-                type: webhook.type ?? 'url',
-                sendAt: new Date(),
-                status: NOTIFICATION_SEND_STATUS.FAILED,
-                failedReason: NOTIFICATION_SEND_FAILED_REASON.CHANNEL_DISABLED,
-              };
-            }
-            updateNotificationSendStatus({
-              ...commonParams,
-              receivers: receivers.map((item) => item.did),
-              channel: 'webhook',
-              webhookParams,
-            });
-          }
-        }
-      } else {
-        updateNotificationSendStatus({
-          ...commonParams,
-          receivers: receiverEmailList.map((item) => item.did),
-          channel: 'email',
-          status: NOTIFICATION_SEND_STATUS.FAILED,
-          failedReason: NOTIFICATION_SEND_FAILED_REASON.CHANNEL_DISABLED,
-        });
-        if (webhookList.length > 0) {
-          const webhookParams = {};
-          for (const webhook of webhookList) {
-            webhookParams[webhook.url] = {
-              type: webhook.type ?? 'url',
-              sendAt: new Date(),
-              status: NOTIFICATION_SEND_STATUS.FAILED,
-              failedReason: NOTIFICATION_SEND_FAILED_REASON.CHANNEL_DISABLED,
-            };
-          }
-          updateNotificationSendStatus({
-            ...commonParams,
-            receivers: receivers.map((item) => item.did),
-            channel: 'webhook',
-            webhookParams,
-          });
-        }
-      }
     })
   );
 };
 
 // server send notification to app
-const sendToAppDid = async ({ event, sender, notification, receiver, appDid, data, node, wsServer }) => {
+const sendToAppDid = async ({ event, sender, notification, receiver, appDid, data, node, options, wsServer }) => {
   if (notification && sender) {
+    const { keepForOfflineUser = true } = options || {};
     const teamDid = sender.appDid;
     const { id } = notification;
+    if (Array.isArray(receiver)) {
+      throw new Error('Invalid receiver: 1 receiver each time');
+    }
+    if (Array.isArray(notification)) {
+      throw new Error('Invalid notification: 1 message each time');
+    }
     const nodeInfo = await node.getNodeInfo({ useCache: true });
-    const isServer = teamDid === nodeInfo.did;
-    wsServer.broadcast(receiver, EVENTS.MESSAGE, notification, {}, ({ count } = {}) => {
-      if (!isServer) {
-        updateNotificationSendStatus({
-          node,
-          teamDid,
-          notificationId: id,
-          receivers: [receiver],
-          channel: 'wallet',
-          status: count > 0 ? NOTIFICATION_SEND_STATUS.SENT : NOTIFICATION_SEND_STATUS.FAILED,
-          failedReason: count > 0 ? null : NOTIFICATION_SEND_FAILED_REASON.NOT_ONLINE,
-        });
-      }
-      if (count <= 0) {
+    // parse notification
+    const senderInfo = await ensureSenderApp({ sender, node, nodeInfo });
+    // parse notification
+    const [payload] = parseNotification({ ...notification }, senderInfo);
+
+    wsServer.broadcast(receiver, EVENTS.MESSAGE, payload, {}, async ({ count } = {}) => {
+      updateNotificationSendStatus({
+        node,
+        teamDid,
+        notificationId: id,
+        receivers: [receiver],
+        channel: NOTIFICATION_SEND_CHANNEL.WALLET,
+        status: count > 0 ? NOTIFICATION_SEND_STATUS.SENT : NOTIFICATION_SEND_STATUS.FAILED,
+        failedReason: count > 0 ? null : NOTIFICATION_SEND_FAILED_REASON.NOT_ONLINE,
+      });
+      if (count <= 0 && keepForOfflineUser) {
         logger.error('Online client was not found', { userDid: receiver });
+        await states.message.insert({ did: receiver, event: EVENTS.MESSAGE, data: payload });
       }
     });
     return;
@@ -625,6 +287,7 @@ const sendToWebhook = async ({ sender, receiver, notification, node }) => {
   const teamDid = sender.appDid;
   const { id, appInfo, ...rest } = notification;
   const webhooks = appInfo?.webhooks ?? [];
+  const receivers = Array.isArray(receiver) ? receiver : [receiver];
   if (!webhooks.length) {
     throw new Error('Invalid webhook: empty');
   }
@@ -643,67 +306,71 @@ const sendToWebhook = async ({ sender, receiver, notification, node }) => {
   const notifications = parseNotification({ id, ...rest }, senderInfo);
   const webhookSenderMap = new Map();
 
-  return Promise.all(
-    webhooks.map(async (webhook) => {
-      let webhookSender = webhookSenderMap.get(webhook.type);
-      if (!webhookSender) {
-        webhookSender = node.getMessageSender(webhook.type);
-        webhookSenderMap.set(webhook.type, webhookSender);
-      }
-      const webhookParams = {
-        [webhook.url]: {
-          type: webhook.type ?? 'api',
-          sendAt: new Date(),
-        },
+  // eslint-disable-next-line no-unreachable-loop
+  for (const webhook of webhooks) {
+    let webhookSender = webhookSenderMap.get(webhook.type);
+    if (!webhookSender) {
+      webhookSender = node.getMessageSender(webhook.type);
+      webhookSenderMap.set(webhook.type, webhookSender);
+    }
+    const webhookParams = {
+      [webhook.url]: {
+        type: webhook.type ?? 'api',
+        sendAt: new Date(),
+      },
+    };
+    try {
+      // eslint-disable-next-line no-await-in-loop
+      const res = await webhookSender.sendNotification(webhook.url, notifications[0]);
+      webhookParams[webhook.url] = {
+        ...webhookParams[webhook.url],
+        status: res ? NOTIFICATION_SEND_STATUS.SENT : NOTIFICATION_SEND_STATUS.FAILED,
+        failedReason: res ? '' : NOTIFICATION_SEND_FAILED_REASON.CHANNEL_UNAVAILABLE,
       };
-      try {
-        const res = await webhookSender.sendNotification(webhook.url, notifications[0]);
-        webhookParams[webhook.url] = {
-          ...webhookParams[webhook.url],
-          status: res ? NOTIFICATION_SEND_STATUS.SENT : NOTIFICATION_SEND_STATUS.FAILED,
-          failedReason: res ? '' : NOTIFICATION_SEND_FAILED_REASON.CHANNEL_UNAVAILABLE,
-        };
-        await updateNotificationSendStatus({
-          node,
-          teamDid,
-          notificationId: id,
-          receivers: [receiver],
-          channel: 'webhook',
-          webhookParams,
-        });
-        return res;
-      } catch (error) {
-        logger.error('Failed to send webhook', { error });
-        webhookParams[webhook.url] = {
-          ...webhookParams[webhook.url],
-          status: NOTIFICATION_SEND_STATUS.FAILED,
-          failedReason: error.message,
-        };
-        updateNotificationSendStatus({
-          node,
-          teamDid,
-          notificationId: id,
-          receivers: [receiver],
-          channel: 'webhook',
-          webhookParams,
-        });
-        const err = new Error('Failed to send webhook');
-        err.details = error;
-        throw err;
-      }
-    })
-  );
+      // eslint-disable-next-line no-await-in-loop
+      await updateNotificationSendStatus({
+        node,
+        teamDid,
+        notificationId: id,
+        receivers,
+        channel: NOTIFICATION_SEND_CHANNEL.WEBHOOK,
+        webhookParams,
+      });
+      return res;
+    } catch (error) {
+      logger.error('Failed to send webhook', { error });
+      webhookParams[webhook.url] = {
+        ...webhookParams[webhook.url],
+        status: NOTIFICATION_SEND_STATUS.FAILED,
+        failedReason: error.message,
+      };
+      // eslint-disable-next-line no-await-in-loop
+      await updateNotificationSendStatus({
+        node,
+        teamDid,
+        notificationId: id,
+        receivers,
+        channel: NOTIFICATION_SEND_CHANNEL.WEBHOOK,
+        webhookParams,
+      });
+      const err = new Error('Failed to send webhook');
+      err.details = error;
+      throw err;
+    }
+  }
+  return undefined;
 };
 
 /**
  * app send email to user
+ * receiver: email
  */
 const emailSchema = Joi.string().email().required();
 const sendToMail = async ({ sender, receiver, notification, options, node }) => {
   const teamDid = sender.appDid;
   const { id, appInfo, ...rest } = notification;
 
-  const receiverDid = appInfo?.receiverDid;
+  const { receiverDid, receivers: sameEmailReceivers = [], unsubscribeToken, userInfo = {} } = appInfo || {};
 
   const receivers = uniq(Array.isArray(receiver) ? receiver : [receiver]).filter(Boolean);
   if (receivers.length === 0) {
@@ -722,7 +389,7 @@ const sendToMail = async ({ sender, receiver, notification, options, node }) =>
   if (!notification.title) {
     throw new Error('Invalid notification: title empty');
   }
-  if (!notification.body && notification.type !== NOTIFICATION_TYPES.FEED) {
+  if (!notification.body && notification.type !== 'feed') {
     throw new Error('Invalid notification: body empty');
   }
 
@@ -745,21 +412,26 @@ const sendToMail = async ({ sender, receiver, notification, options, node }) =>
         teamDid: sender.appDid,
         node,
         locale,
+        ...(unsubscribeToken ? { unsubscribeToken } : {}),
+        ...(userInfo ? { userInfo } : {}),
       });
     })
   );
   return results.map((item) => {
-    if (!isServer && receiverDid) {
+    if (!isServer && (receiverDid || sameEmailReceivers.length > 0)) {
       updateNotificationSendStatus({
         node,
         teamDid,
         notificationId: id,
-        receivers: [receiverDid],
-        channel: 'email',
+        receivers: sameEmailReceivers.length > 0 ? sameEmailReceivers : [receiverDid],
+        channel: NOTIFICATION_SEND_CHANNEL.EMAIL,
         status: item.status === 'rejected' ? NOTIFICATION_SEND_STATUS.FAILED : NOTIFICATION_SEND_STATUS.SENT,
         ...(item.status === 'rejected'
           ? {
-              failedReason: item.reason instanceof Error ? item.reason?.message : item.reason,
+              failedReason:
+                item.reason instanceof Error
+                  ? item.reason?.message
+                  : item.reason || NOTIFICATION_SEND_FAILED_REASON.CHANNEL_UNAVAILABLE,
             }
           : {}),
       });
@@ -800,7 +472,7 @@ const sendToPush = async ({ sender, receiver, notification, options, node }) =>
 
   const senderInfo = await ensureSenderApp({ sender, node, nodeInfo });
 
-  const notifications = parseNotification(notification, senderInfo);
+  const notifications = parseNotification({ ...notification }, senderInfo);
 
   const { locale = 'en' } = options || {};
   return sendPush(receivers, notifications[0], {
@@ -815,7 +487,7 @@ const sendToPush = async ({ sender, receiver, notification, options, node }) =>
           teamDid,
           notificationId: id,
           receivers,
-          channel: 'pushKit',
+          channel: NOTIFICATION_SEND_CHANNEL.PUSH,
           status: res ? NOTIFICATION_SEND_STATUS.SENT : NOTIFICATION_SEND_STATUS.FAILED,
           failedReason: res ? null : NOTIFICATION_SEND_FAILED_REASON.CHANNEL_UNAVAILABLE,
         });
@@ -829,7 +501,7 @@ const sendToPush = async ({ sender, receiver, notification, options, node }) =>
         teamDid,
         notificationId: id,
         receivers,
-        channel: 'pushKit',
+        channel: NOTIFICATION_SEND_CHANNEL.PUSH,
         status: NOTIFICATION_SEND_STATUS.FAILED,
         failedReason: err.message,
       });
@@ -846,4 +518,5 @@ module.exports = {
   sendToPush,
   emailSchema,
   sendToWebhook,
+  updateNotificationSendStatus,
 };