@abtnode/blocklet-services 1.16.39-beta-20250215-130252-43410928 → 1.16.39-beta-20250218-132815-6baaf20e

package/api/services/notification/notification-queue.js

@@ -0,0 +1,671 @@
+const createQueue = require('@abtnode/core/lib/util/queue');
+const { validateNotification } = require('@blocklet/sdk/lib/validators/notification');
+const states = require('@abtnode/core/lib/states');
+const JWT = require('@arcblock/jwt');
+const md5 = require('@abtnode/util/lib/md5');
+const {
+  NODE_MODES,
+  EVENTS,
+  NOTIFICATION_SEND_CHANNEL,
+  NOTIFICATION_SEND_STATUS,
+  NOTIFICATION_SEND_FAILED_REASON,
+} = require('@abtnode/constant');
+const get = require('lodash/get');
+const uniqBy = require('lodash/uniqBy');
+const { getWalletDid } = require('@blocklet/meta/lib/did-utils');
+const { getBlockletInfo } = require('../../cache');
+const { updateNotificationSendStatus } = require('../../socket/channel/did');
+const eventHub =
+  process.env.NODE_ENV === 'test' ? require('@arcblock/event-hub/single') : require('@arcblock/event-hub');
+
+const logger = require('../../libs/logger')('notification');
+
+const createNotificationQueue = (name, options, handler) => {
+  if (!handler || typeof handler !== 'function') {
+    throw new Error('Handler is required');
+  }
+  return createQueue({
+    name,
+    model: states.job,
+    daemon: true,
+    options: {
+      maxRetries: 3,
+      retryDelay: 10 * 1000,
+      maxTimeout: 60 * 1000, // throw timeout error after 1 minutes
+      ...(options ?? {}),
+    },
+    onJob: async (job) => {
+      await handler(job);
+    },
+  });
+};
+
+const init = ({ node, notificationService }) => {
+  const webhookState = states.webhook;
+
+  const getServerWebhooks = async () => {
+    const webhookList = (await webhookState.list()) ?? [];
+    return webhookList.flatMap((item) =>
+      item.params.filter((param) => param.name === 'url').map((param) => ({ type: item.type, url: param.value }))
+    );
+  };
+
+  /**
+   * wallet 推送队列
+   */
+  const walletPushQueue = createNotificationQueue(
+    'send-notification-wallet',
+    {
+      maxRetries: 1,
+      retryDelay: 0,
+    },
+    async (job) => {
+      const { receiver, notification, sender, options } = job;
+
+      if (!receiver) {
+        logger.error('Invalid receiver', { did: receiver });
+        throw new Error('Invalid receiver');
+      }
+
+      const nodeInfo = await node.getNodeInfo({ useCache: true });
+
+      if (nodeInfo.mode !== NODE_MODES.DEBUG) {
+        try {
+          await validateNotification(notification);
+        } catch (error) {
+          logger.error('Failed to validate notification', { error });
+          // 抛出错误，阻止后续执行
+          throw error;
+        }
+      }
+
+      if (sender.type === 'server' && !sender.token) {
+        sender.token = JWT.sign(sender.appDid, sender.appSk);
+      }
+
+      // 发送钱包通知
+      await notificationService.sendToApp.exec({
+        sender,
+        receiver,
+        notification,
+        options,
+      });
+    }
+  );
+
+  /**
+   * Push Kit 推送队列
+   */
+  const pushKitPushQueue = createNotificationQueue('send-notification-push', {}, async (job) => {
+    const { notification, receiver, sender } = job;
+
+    if (!receiver) {
+      logger.error('Invalid receiver', { did: receiver });
+      throw new Error('Invalid receiver');
+    }
+
+    const nodeInfo = await node.getNodeInfo({ useCache: true });
+
+    if (nodeInfo.mode !== NODE_MODES.DEBUG) {
+      try {
+        await validateNotification(notification);
+      } catch (error) {
+        logger.error('Failed to validate notification', { error });
+        // 抛出错误，阻止后续执行
+        throw error;
+      }
+    }
+
+    if (sender.type === 'server' && !sender.token) {
+      sender.token = JWT.sign(sender.appDid, sender.appSk);
+    }
+
+    // 发送 push kit 通知
+    await notificationService.sendToPush.exec({
+      sender,
+      receiver,
+      notification,
+    });
+  });
+
+  /**
+   * email 推送队列
+   */
+  const emailPushQueue = createNotificationQueue(
+    'send-notification-email',
+    {
+      maxRetries: 1,
+      retryDelay: 0,
+      maxTimeout: 60 * 1000,
+      id: (job) => (job ? md5(`${job.email}_${job.notificationId}`) : ''),
+      enableScheduledJob: true,
+    },
+    async (job) => {
+      const { input, email } = job;
+      if (!input) {
+        logger.error('Job input is missing or invalid', { notificationId: job.notificationId });
+        throw new Error('Job input is missing or invalid');
+      }
+
+      if (!email) {
+        logger.error('Email address is missing. Unable to send email notification', {
+          notificationId: job.notificationId,
+        });
+        throw new Error('Email address is missing. Unable to send email notification');
+      }
+
+      const { notification, sender, teamDid, receivers = [], userInfo } = input;
+
+      if (!userInfo) {
+        logger.error('Invalid receiver', { dids: userInfo.did });
+        throw new Error('Invalid receiver');
+      }
+
+      const nodeInfo = await node.getNodeInfo({ useCache: true });
+
+      if (nodeInfo.mode !== NODE_MODES.DEBUG) {
+        try {
+          await validateNotification(notification);
+        } catch (error) {
+          logger.error('Failed to validate notification', { error });
+          // 抛出错误，阻止后续执行
+          throw error;
+        }
+      }
+
+      if (sender.type === 'server' && !sender.token) {
+        sender.token = JWT.sign(sender.appDid, sender.appSk);
+      }
+
+      let wallet;
+
+      if (sender.type !== 'server') {
+        const blockletInfo = await getBlockletInfo({ did: teamDid, node });
+        wallet = blockletInfo.wallet;
+      }
+      const now = Math.floor(Date.now() / 1000);
+      const unsubscribeToken = JWT.signV2(wallet.address, wallet.secretKey, {
+        userDid: userInfo.did,
+        channel: 'email',
+        exp: String(now + 30 * 24 * 60 * 60), // 30 days
+      });
+      notificationService.sendToMail.exec({
+        sender,
+        receiver: email,
+        notification: {
+          ...notification,
+          appInfo: {
+            ...(notification.appInfo || {}),
+            receivers: receivers.length > 0 ? receivers : [userInfo.did],
+            unsubscribeToken,
+            userInfo: {
+              did: userInfo.did,
+              fullName: userInfo.fullName,
+            },
+          },
+        },
+      });
+    }
+  );
+
+  /**
+   * webhook 推送队列
+   */
+  const webhookQueue = createNotificationQueue(
+    'send-notification-webhook',
+    {
+      maxRetries: 3,
+      retryDelay: 10 * 1000,
+      maxTimeout: 5 * 60 * 1000, // throw timeout error after 5 minutes
+      id: (job) => (job ? md5(`${job.url}_${job.notificationId}`) : ''),
+      enableScheduledJob: true,
+    },
+    async (job) => {
+      const { input } = job;
+      if (!input) {
+        logger.error('Invalid job', { url: job.url });
+        throw new Error('Invalid job');
+      }
+
+      const { notification, webhook, sender, receivers = [] } = input;
+
+      if (!receivers.length) {
+        logger.error('Invalid receiver', { dids: receivers });
+        throw new Error('Invalid receiver');
+      }
+
+      const nodeInfo = await node.getNodeInfo({ useCache: true });
+
+      if (nodeInfo.mode !== NODE_MODES.DEBUG) {
+        try {
+          await validateNotification(notification);
+        } catch (error) {
+          logger.error('Failed to validate notification', { error });
+          // 抛出错误，阻止后续执行
+          throw error;
+        }
+      }
+
+      if (!webhook || !webhook.url) {
+        logger.error('Invalid webhook', { webhook });
+        throw new Error('Invalid webhook');
+      }
+
+      if (sender.type === 'server' && !sender.token) {
+        sender.token = JWT.sign(sender.appDid, sender.appSk);
+      }
+
+      notificationService.sendToWebhook.exec({
+        sender,
+        receiver: receivers,
+        notification: {
+          ...notification,
+          appInfo: {
+            ...(notification.appInfo || {}),
+            webhooks: [webhook],
+          },
+        },
+      });
+    }
+  );
+
+  const insertToEmailPushQueue = (props, nodeInfo, emailMap) => {
+    const { channels, notification, sender, userInfo, teamDid } = props;
+
+    const commonParams = {
+      node,
+      teamDid: teamDid ?? nodeInfo.did,
+      notificationId: notification.id,
+    };
+
+    const emailEnabled = get(userInfo, 'extra.notifications.email', true);
+
+    const email = userInfo?.email;
+
+    const receiverDid = getWalletDid(userInfo) || userInfo.did;
+
+    const channelEnabled = emailEnabled && channels.includes(NOTIFICATION_SEND_CHANNEL.EMAIL);
+
+    const { receivers, pushUser } = emailMap.get(email) || { receivers: [], pushUser: {} };
+
+    const pushUserDid = getWalletDid(pushUser) || pushUser.did;
+
+    // 如果 receivers 中已经存在 receiverDid，并且 pushUserDid 和 receiverDid 不一致，则不发送
+    if (receivers.includes(receiverDid) && pushUserDid !== receiverDid) {
+      return;
+    }
+
+    if (channelEnabled && email) {
+      const _userInfo = {
+        did: receiverDid,
+        fullName: userInfo.fullName,
+      };
+      // 这里可以根据 email 获取到需要发送的 userInfo 和 receivers
+      emailPushQueue.push({
+        job: {
+          email,
+          notificationId: notification.id,
+          input: {
+            notification,
+            sender,
+            teamDid,
+            receivers,
+            userInfo: _userInfo,
+          },
+        },
+        delay: 5,
+      });
+    } else {
+      updateNotificationSendStatus({
+        ...commonParams,
+        receivers: receivers.length > 0 ? receivers : [receiverDid],
+        channel: NOTIFICATION_SEND_CHANNEL.EMAIL,
+        status: NOTIFICATION_SEND_STATUS.FAILED,
+        failedReason:
+          !emailEnabled || !email
+            ? NOTIFICATION_SEND_FAILED_REASON.USER_DISABLED
+            : NOTIFICATION_SEND_FAILED_REASON.CHANNEL_DISABLED,
+      });
+    }
+  };
+
+  const insertToWebhookPushQueue = async (props, nodeInfo, webhookMap) => {
+    const { channels, notification, sender, userInfo, teamDid } = props;
+
+    const receiverDid = getWalletDid(userInfo) || userInfo.did;
+
+    const commonParams = {
+      node,
+      teamDid: teamDid ?? nodeInfo.did,
+      notificationId: notification.id,
+    };
+
+    const isServer = teamDid === nodeInfo.did;
+
+    let webhooks = get(userInfo, 'extra.webhooks', []);
+    if (isServer) {
+      webhooks = await getServerWebhooks();
+    }
+
+    const webhookList = uniqBy(webhooks, 'url')
+      .map((webhook) => {
+        const { url, type } = webhook;
+        const { receivers, pushUser } = webhookMap.get(url) || {
+          type: type ?? 'api',
+          receivers: [],
+          pushUser: {},
+        };
+        const pushUserDid = getWalletDid(pushUser) || pushUser.did;
+        if (receivers.includes(receiverDid) && pushUserDid !== receiverDid) {
+          return false;
+        }
+        return {
+          url,
+          type,
+          receivers,
+          pushUser,
+        };
+      })
+      .filter(Boolean);
+
+    if (webhookList.length > 0 && channels.includes(NOTIFICATION_SEND_CHANNEL.WEBHOOK)) {
+      for (const webhook of webhookList) {
+        const { url, type, receivers } = webhook;
+        webhookQueue.push({
+          job: {
+            url,
+            notificationId: notification.id,
+            input: {
+              notification,
+              sender,
+              receivers: receivers.length > 0 ? receivers : [receiverDid],
+              webhook: {
+                url,
+                type,
+              },
+            },
+          },
+          delay: 5,
+        });
+      }
+    } else {
+      // eslint-disable-next-line no-lonely-if
+      if (webhookList.length > 0) {
+        const webhookParams = {};
+
+        for (const { url, type, receivers } of webhookList) {
+          webhookParams[url] = {
+            type,
+            sendAt: new Date(),
+            status: NOTIFICATION_SEND_STATUS.FAILED,
+            failedReason: NOTIFICATION_SEND_FAILED_REASON.CHANNEL_DISABLED,
+          };
+
+          // eslint-disable-next-line no-await-in-loop
+          await updateNotificationSendStatus({
+            ...commonParams,
+            receivers: receivers.length > 0 ? receivers : [receiverDid],
+            channel: NOTIFICATION_SEND_CHANNEL.WEBHOOK,
+            status: NOTIFICATION_SEND_STATUS.FAILED,
+            webhookParams: { [url]: webhookParams[url] },
+          });
+        }
+      }
+    }
+  };
+
+  const insertToPushKitPushQueue = (props, nodeInfo) => {
+    const { channels, notification, sender, userInfo, teamDid, options = {} } = props;
+
+    const receiverDid = getWalletDid(userInfo) || userInfo.did;
+
+    const commonParams = {
+      node,
+      teamDid: teamDid ?? nodeInfo.did,
+      notificationId: notification.id,
+    };
+    const pushEnabled = get(userInfo, 'extra.notifications.push', true);
+    if (pushEnabled && channels.includes(NOTIFICATION_SEND_CHANNEL.PUSH)) {
+      pushKitPushQueue.push({
+        notification,
+        sender,
+        options,
+        receiver: receiverDid,
+      });
+    } else {
+      updateNotificationSendStatus({
+        ...commonParams,
+        receivers: [receiverDid],
+        channel: NOTIFICATION_SEND_CHANNEL.PUSH,
+        status: NOTIFICATION_SEND_STATUS.FAILED,
+        failedReason: !pushEnabled
+          ? NOTIFICATION_SEND_FAILED_REASON.CHANNEL_DISABLED
+          : NOTIFICATION_SEND_FAILED_REASON.USER_DISABLED,
+      });
+    }
+  };
+
+  const insertToWalletPushQueue = (props, nodeInfo) => {
+    const { channels, notification, sender, userInfo, teamDid, options = {} } = props;
+
+    const receiverDid = getWalletDid(userInfo) || userInfo.did;
+
+    const commonParams = {
+      node,
+      teamDid: teamDid ?? nodeInfo.did,
+      notificationId: notification.id,
+    };
+
+    const walletEnabled = get(userInfo, 'extra.notifications.wallet', true);
+    if (walletEnabled && channels.includes(NOTIFICATION_SEND_CHANNEL.WALLET)) {
+      walletPushQueue.push({
+        notification,
+        sender,
+        options,
+        receiver: receiverDid,
+      });
+    } else {
+      updateNotificationSendStatus({
+        ...commonParams,
+        receivers: [receiverDid],
+        channel: NOTIFICATION_SEND_CHANNEL.WALLET,
+        status: NOTIFICATION_SEND_STATUS.FAILED,
+        failedReason: !walletEnabled
+          ? NOTIFICATION_SEND_FAILED_REASON.CHANNEL_DISABLED
+          : NOTIFICATION_SEND_FAILED_REASON.USER_DISABLED,
+      });
+    }
+  };
+
+  const insertToNotificationReceiver = async (nodeInfo, userInfo, teamDid, notificationId, channels) => {
+    const receiverDid = getWalletDid(userInfo) || userInfo.did;
+
+    const receiverInstance = {
+      receiver: receiverDid,
+      notificationId,
+    };
+
+    const emailEnabled = get(userInfo, 'extra.notifications.email', true);
+    const email = userInfo?.email;
+
+    if (emailEnabled && email && channels.includes(NOTIFICATION_SEND_CHANNEL.EMAIL)) {
+      receiverInstance.email = email;
+    }
+    const isServer = teamDid === nodeInfo.did;
+
+    let webhooks = get(userInfo, 'extra.webhooks', []);
+    if (isServer) {
+      webhooks = await getServerWebhooks();
+    }
+    const webhookMap = new Map();
+    webhooks.forEach((webhook) => {
+      if (!webhookMap.has(webhook.url)) {
+        webhookMap.set(webhook.url, webhook.type ?? 'api');
+      }
+    });
+
+    if (webhookMap.size > 0 && channels.includes(NOTIFICATION_SEND_CHANNEL.WEBHOOK)) {
+      receiverInstance.webhookUrls = Array.from(webhookMap.keys()).join('#');
+    }
+
+    await node.createNotificationReceiver({
+      teamDid,
+      receiverInstance,
+    });
+  };
+
+  /**
+   * job 格式
+   * {
+   *   channels: 需要发送到的 channels,
+   *   notification: {},
+   *   receivers: 接收的 receiver 列表
+   * }
+   */
+  const queue = createNotificationQueue('notification-receivers', {}, async (job) => {
+    const { teamDid, channels, receiver, sender, notification, nodeInfo, userInfo, emailMap, webhookMap, ...rest } =
+      job;
+
+    try {
+      if (!userInfo) {
+        logger.error('Invalid receiver user', { receiver });
+        throw new Error('Invalid receiver user');
+      }
+
+      if (!job.pushOnly) {
+        // 如果添加失败，那么需要终止执行推送
+        await insertToNotificationReceiver(nodeInfo, userInfo, teamDid, notification.id, channels);
+      }
+
+      const baseParams = {
+        ...rest,
+        teamDid,
+        channels,
+        receiver,
+        sender,
+        notification,
+        userInfo,
+        nodeInfo,
+      };
+      // 每个渠道之间的推送不会影响
+      // 添加到 wallet 推送队列
+      try {
+        insertToWalletPushQueue(baseParams, nodeInfo);
+      } catch (error) {
+        logger.error('Failed to insert to wallet push queue', { error });
+      }
+      // 添加到 push 推送队列
+      try {
+        insertToPushKitPushQueue(baseParams, nodeInfo);
+      } catch (error) {
+        logger.error('Failed to insert to push kit push queue', { error });
+      }
+
+      // 添加到 email 推送队列
+      try {
+        insertToEmailPushQueue(baseParams, nodeInfo, emailMap);
+      } catch (error) {
+        logger.error('Failed to insert to email push queue', { error });
+      }
+
+      //
+      try {
+        insertToWebhookPushQueue(baseParams, nodeInfo, webhookMap);
+      } catch (error) {
+        logger.error('Failed to insert to webhook push queue', { error });
+      }
+    } catch (error) {
+      logger.error('Failed to create notification receiver', { error });
+    }
+  });
+
+  // 监听 notification_create 事件
+  eventHub.on(EVENTS.NOTIFICATION_CREATE_QUEUED, async (data) => {
+    // Only first worker process handle blocklet event
+    try {
+      if (process.env.NODE_ENV !== 'test' && process.env.NODE_APP_INSTANCE !== '0') {
+        return;
+      }
+      if (!data.notification) {
+        logger.error('Invalid notification', { data });
+        return;
+      }
+      const nodeInfo = await node.getNodeInfo({ useCache: true });
+      if (nodeInfo.mode !== NODE_MODES.DEBUG) {
+        try {
+          await validateNotification(data.notification);
+        } catch (error) {
+          logger.error('Failed to validate notification', { error });
+          // 抛出错误，阻止后续执行
+          throw error;
+        }
+      }
+
+      // 按照 receiver 添加到推送队列
+      const { receivers, teamDid, channels, ...rest } = data;
+      const sender = data.sender ?? {
+        appDid: nodeInfo.did,
+        appSk: nodeInfo.sk,
+        type: 'server',
+      };
+
+      const isServer = teamDid === nodeInfo.did;
+
+      const users = await node.getNotificationReceivers({
+        teamDid,
+        userDids: receivers,
+        enableConnectedAccounts: true,
+      });
+
+      const webhookMap = new Map();
+      const emailMap = new Map();
+      const serverWebhooks = await getServerWebhooks();
+
+      users.forEach((userInfo) => {
+        const receiverDid = getWalletDid(userInfo) || userInfo.did;
+
+        // 获取 email 列表
+        const { email } = userInfo;
+        const enabledEmail = get(userInfo, 'extra.notifications.email', true);
+        if (enabledEmail && email) {
+          const emailEntry = emailMap.get(email) || { receivers: [], pushUser: userInfo };
+          emailEntry.receivers = [...emailEntry.receivers, receiverDid];
+          emailEntry.pushUser = userInfo;
+          emailMap.set(email, emailEntry);
+        }
+
+        // 获取 webhook 列表
+        const webhooks = isServer ? serverWebhooks : get(userInfo, 'extra.webhooks', []);
+        webhooks.forEach((webhook) => {
+          const webhookEntry = webhookMap.get(webhook.url) || {
+            type: webhook.type ?? 'api',
+            receivers: [],
+            pushUser: userInfo,
+          };
+          webhookEntry.receivers = [...webhookEntry.receivers, receiverDid];
+          webhookEntry.pushUser = userInfo;
+          webhookMap.set(webhook.url, webhookEntry);
+        });
+      });
+
+      users.forEach((userInfo) => {
+        const receiverDid = getWalletDid(userInfo) || userInfo.did;
+        queue.push({
+          ...rest,
+          teamDid,
+          channels,
+          receiver: receiverDid,
+          sender,
+          nodeInfo,
+          userInfo,
+          emailMap,
+          webhookMap,
+        });
+      });
+    } catch (error) {
+      logger.error('Failed to create notification receiver', { error });
+    }
+  });
+};
+
+module.exports = { init };