@abtnode/core 1.17.8-beta-20260109-075740-5f484e08 → 1.17.8-beta-20260113-015027-32a1cec4

package/lib/api/team/notification-manager.js

@@ -0,0 +1,189 @@
+const { EVENTS } = require('@abtnode/constant');
+
+/**
+ * Get notification
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {Object} context
+ * @returns {Promise<Object>}
+ */
+async function getNotification(api, { teamDid, ...rest }, context) {
+  const notificationState = await api.getNotificationState(teamDid);
+  return notificationState.findPaginated({ teamDid, ...rest }, context);
+}
+
+/**
+ * Get notification by ID
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {string} params.id - Notification ID
+ * @returns {Promise<Object>}
+ */
+async function getNotificationById(api, { teamDid, id }) {
+  const notificationState = await api.getNotificationState(teamDid);
+  const notification = await notificationState.findNotification({ id });
+  return notification;
+}
+
+/**
+ * Get notifications unread count
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {string} params.receiver - Receiver DID
+ * @param {Object} context
+ * @returns {Promise<number>}
+ */
+async function getNotificationsUnreadCount(api, { teamDid, receiver }, context) {
+  const notificationState = await api.getNotificationState(teamDid);
+  return notificationState.getUnreadCount({ receiver }, context);
+}
+
+/**
+ * Create notification receiver
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {Object} params.receiverInstance - Receiver instance
+ * @param {Object} context
+ * @returns {Promise<Object>}
+ */
+async function createNotificationReceiver(api, { teamDid, receiverInstance, ...rest }, context) {
+  const notificationState = await api.getNotificationState(teamDid);
+  return notificationState.createNotificationReceiver({ receiverInstance, ...rest }, context);
+}
+
+/**
+ * Mark all notifications as read
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {Object} context
+ * @returns {Promise<Object>}
+ */
+async function markAllNotificationsAsRead(api, { teamDid, ...rest }, context) {
+  const notificationState = await api.getNotificationState(teamDid);
+  const result = await notificationState.makeAllAsRead(rest, context);
+  const { numAffected, notificationIds, effectRows } = result;
+  api.teamManager.emitReadNotification(teamDid, {
+    readCount: numAffected,
+    notificationIds,
+    receiver: rest.receiver,
+    effectRows,
+  });
+  return result;
+}
+
+/**
+ * Update notification status
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {Array} params.receivers - Receivers
+ * @param {string} params.notificationId - Notification ID
+ * @param {Object} params.updates - Updates
+ * @returns {Promise<number>}
+ */
+async function updateNotificationStatus(api, { teamDid, receivers, notificationId, updates }) {
+  const notificationState = await api.getNotificationState(teamDid);
+  const result = await notificationState.updateStatus({ receivers, notificationId, updates, teamDid });
+  // 发送状态更新的通知给前端，使用通用节流函数
+  if (result > 0 && teamDid && !api.teamManager.isNodeTeam(teamDid)) {
+    const throttledEmit = api.getThrottledEmit(teamDid);
+    if (throttledEmit) {
+      throttledEmit(EVENTS.NOTIFICATION_BLOCKLET_UPDATE, {
+        teamDid,
+        notificationId,
+      });
+    }
+  }
+  return result;
+}
+
+/**
+ * Read notifications
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {Object} context
+ * @returns {Promise<number>}
+ */
+async function readNotifications(api, { teamDid, ...rest }, context) {
+  const notificationState = await api.getNotificationState(teamDid);
+  const { numAffected, effectRows } = await notificationState.read({ teamDid, ...rest }, context);
+  api.teamManager.emitReadNotification(teamDid, {
+    readCount: numAffected,
+    receiver: rest.receiver,
+    notificationIds: rest.notificationIds ?? [],
+    effectRows,
+  });
+  return numAffected;
+}
+
+/**
+ * Unread notifications
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {Object} context
+ * @returns {Promise<Object>}
+ */
+async function unreadNotifications(api, { teamDid, ...rest }, context) {
+  const notificationState = await api.getNotificationState(teamDid);
+  return notificationState.unread({ teamDid, ...rest }, context);
+}
+
+/**
+ * Get notification send log
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {Object} context
+ * @returns {Promise<Object>}
+ */
+async function getNotificationSendLog(api, { teamDid, ...rest }, context) {
+  const notificationState = await api.getNotificationState(teamDid);
+  return notificationState.getNotificationSendLog({ ...rest }, context);
+}
+
+/**
+ * Get notification components
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {Object} context
+ * @returns {Promise<Object>}
+ */
+async function getNotificationComponents(api, { teamDid, ...rest }, context) {
+  const notificationState = await api.getNotificationState(teamDid);
+  return notificationState.getNotificationComponents({ ...rest }, context);
+}
+
+/**
+ * Get receivers
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {Object} context
+ * @returns {Promise<Object>}
+ */
+async function getReceivers(api, { teamDid, ...rest }, context) {
+  const notificationState = await api.getNotificationState(teamDid);
+  return notificationState.getNotificationReceivers({ ...rest }, context);
+}
+
+module.exports = {
+  getNotification,
+  getNotificationById,
+  getNotificationsUnreadCount,
+  createNotificationReceiver,
+  markAllNotificationsAsRead,
+  updateNotificationStatus,
+  readNotifications,
+  unreadNotifications,
+  getNotificationSendLog,
+  getNotificationComponents,
+  getReceivers,
+};

package/lib/api/team/oauth-manager.js

@@ -0,0 +1,60 @@
+/**
+ * Get OAuth clients
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {Object} params.paging - Paging options
+ * @returns {Promise<Object>}
+ */
+async function getOAuthClients(api, { teamDid, paging }) {
+  const { oauthClientState } = await api.teamManager.getOAuthState(teamDid);
+  return oauthClientState.list(paging);
+}
+
+/**
+ * Delete OAuth client
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {string} params.clientId - Client ID
+ * @returns {Promise<Object>}
+ */
+async function deleteOAuthClient(api, { teamDid, clientId }) {
+  const { oauthClientState } = await api.teamManager.getOAuthState(teamDid);
+  return oauthClientState.remove({ clientId });
+}
+
+/**
+ * Create OAuth client
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {Object} params.input - OAuth client input
+ * @param {Object} context
+ * @returns {Promise<Object>}
+ */
+async function createOAuthClient(api, { teamDid, input }, context) {
+  const { oauthClientState } = await api.teamManager.getOAuthState(teamDid);
+  return oauthClientState.create(input, context);
+}
+
+/**
+ * Update OAuth client
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {Object} params.input - OAuth client input
+ * @param {Object} context
+ * @returns {Promise<Object>}
+ */
+async function updateOAuthClient(api, { teamDid, input }, context) {
+  const { oauthClientState } = await api.teamManager.getOAuthState(teamDid);
+  return oauthClientState.update(input, context);
+}
+
+module.exports = {
+  getOAuthClients,
+  deleteOAuthClient,
+  createOAuthClient,
+  updateOAuthClient,
+};

package/lib/api/team/org-crud-manager.js

@@ -0,0 +1,202 @@
+const logger = require('@abtnode/logger')('@abtnode/core:api:team:org-crud');
+const { CustomError } = require('@blocklet/error');
+const md5 = require('@abtnode/util/lib/md5');
+const { sanitizeTag } = require('@abtnode/util/lib/sanitize');
+
+const { createOrgValidators } = require('../../util/org');
+const { createOrgInputSchema, updateOrgInputSchema } = require('../../validators/org');
+const { getBlocklet } = require('../../util/blocklet');
+
+/**
+ * Issue org owner passport
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {Object} params.org - Org
+ * @returns {Promise<void>}
+ */
+async function issueOrgOwnerPassport(api, { teamDid, org }) {
+  try {
+    // 创建 org 的 owner passport, 并赋值给 owner
+    const roleName = md5(`${org.id}-owner`); // 避免 name 重复
+    await api.createRole({ teamDid, name: roleName, title: org.name, description: 'Owner', orgId: org.id });
+    await api.issuePassportToUser({
+      teamDid,
+      userDid: org.ownerDid,
+      role: roleName,
+      notification: {},
+    });
+  } catch (err) {
+    logger.error('Failed to create passport to org owner', { err, teamDid, org });
+  }
+}
+
+/**
+ * Create org
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {boolean} params.deferPassport - Defer passport
+ * @param {boolean} params.throwOnValidationError - Throw on validation error
+ * @param {Object} context
+ * @returns {Promise<Object>}
+ */
+async function createOrg(api, { teamDid, deferPassport = false, throwOnValidationError = true, ...rest }, context) {
+  try {
+    // 1. 对输入进行转义
+    const sanitizedOrg = {
+      ...rest,
+      description: sanitizeTag(rest.description || ''),
+      name: sanitizeTag(rest.name || ''),
+    };
+
+    const { error } = createOrgInputSchema.validate(sanitizedOrg);
+    if (error) {
+      throw new CustomError(400, error.message);
+    }
+
+    const state = await api.getOrgState(teamDid);
+    const blocklet = await getBlocklet({
+      did: teamDid,
+      states: api.states,
+      dataDirs: api.dataDirs,
+      useCache: true,
+    });
+    const checkedUserDid = rest.ownerDid || context.user.did || '';
+    const orgCount = await state.getOrgCountByUser(checkedUserDid);
+
+    const { veriftMaxOrgPerUser } = createOrgValidators(blocklet);
+
+    try {
+      veriftMaxOrgPerUser(orgCount); // 验证用户创建的 org 数量是否超过最大限制, 内部已经验证 org 是否开启
+    } catch (_error) {
+      if (throwOnValidationError) {
+        throw _error;
+      }
+      logger.warn('Failed to validate org creation', { error: _error, teamDid, orgCount });
+      return undefined;
+    }
+
+    const result = await state.create({ ...sanitizedOrg }, context);
+
+    // 创建 org 的 owner passport, 并赋值给 owner
+    if (!deferPassport) {
+      await issueOrgOwnerPassport(api, { teamDid, org: result });
+    } else {
+      const jobId = md5(`${teamDid}-${result.id}-${checkedUserDid}`);
+      api.passportIssueQueue.push(
+        {
+          action: 'issueOrgOwnerPassport',
+          entity: 'blocklet',
+          entityId: teamDid,
+          params: {
+            teamDid,
+            org: result,
+          },
+        },
+        jobId,
+        true
+      );
+    }
+
+    return result;
+  } catch (err) {
+    logger.error('Failed to create org', err, {
+      teamDid,
+      name: rest.name,
+      userDid: rest.ownerDid || context.user.did || '',
+    });
+    throw err;
+  }
+}
+
+/**
+ * Create default org for user
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {Object} params.user - User
+ * @returns {Promise<void>}
+ */
+async function createDefaultOrgForUser(api, { teamDid, user }) {
+  try {
+    // 创建失败不要影响主流程
+    await createOrg(
+      api,
+      {
+        teamDid,
+        name: user.fullName,
+        description: `this is a default org for ${user.fullName}`,
+        throwOnValidationError: false,
+      },
+      { user }
+    );
+  } catch (err) {
+    logger.error('Failed to create default org for user', { err, teamDid, user });
+  }
+}
+
+/**
+ * Update org
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {Object} params.org - Org
+ * @param {Object} context
+ * @returns {Promise<Object>}
+ */
+async function updateOrg(api, { teamDid, org }, context) {
+  try {
+    const sanitizedOrg = {
+      ...org,
+      description: sanitizeTag(org.description),
+      name: sanitizeTag(org.name),
+    };
+
+    const { error } = updateOrgInputSchema.validate(sanitizedOrg);
+    if (error) {
+      throw new CustomError(400, error.message);
+    }
+
+    const state = await api.getOrgState(teamDid);
+    return state.updateOrg({ org: sanitizedOrg }, context);
+  } catch (err) {
+    logger.error('Failed to update org', { err, teamDid });
+    throw err;
+  }
+}
+
+/**
+ * Delete org
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {string} params.id - Org ID
+ * @param {Object} context
+ * @returns {Promise<Object>}
+ */
+async function deleteOrg(api, { teamDid, id }, context) {
+  try {
+    const state = await api.getOrgState(teamDid);
+    // 要同时删除与 org 相关的 passport 和 邀请链接
+    const roles = await api.getRoles({ teamDid, orgId: id });
+    const result = await state.deleteOrg({ id }, context);
+    try {
+      await state.removeOrgRelatedData({ roles, orgId: id });
+    } catch (err) {
+      logger.error('Failed to remove org related data', { err, teamDid, roles, id });
+    }
+    return result;
+  } catch (err) {
+    logger.error('Failed to delete org', { err, teamDid, id });
+    throw err;
+  }
+}
+
+module.exports = {
+  issueOrgOwnerPassport,
+  createOrg,
+  createDefaultOrgForUser,
+  updateOrg,
+  deleteOrg,
+};

package/lib/api/team/org-manager.js

@@ -0,0 +1,56 @@
+/**
+ * Org Manager - Orchestrates organization management operations
+ *
+ * This module re-exports functionality from specialized sub-modules:
+ * - org-query-manager.js: Organization query operations
+ * - org-crud-manager.js: Organization CRUD operations
+ * - org-member-manager.js: Organization member management operations
+ * - org-resource-manager.js: Organization resource and notification operations
+ */
+
+const { getOrgs, getOrg, getOrgMembers, getOrgInvitableUsers } = require('./org-query-manager');
+const {
+  issueOrgOwnerPassport,
+  createOrg,
+  createDefaultOrgForUser,
+  updateOrg,
+  deleteOrg,
+} = require('./org-crud-manager');
+const {
+  addOrgMember,
+  updateOrgMember,
+  sendInvitationNotification,
+  getFederatedMasterBlockletInfo,
+  inviteMembersToOrg,
+  removeOrgMember,
+} = require('./org-member-manager');
+const {
+  getOrgResource,
+  addOrgResource,
+  removeOrgResource,
+  migrateOrgResource,
+  getNotificationStats,
+} = require('./org-resource-manager');
+
+module.exports = {
+  getOrgs,
+  getOrg,
+  createDefaultOrgForUser,
+  issueOrgOwnerPassport,
+  createOrg,
+  updateOrg,
+  deleteOrg,
+  addOrgMember,
+  updateOrgMember,
+  sendInvitationNotification,
+  getFederatedMasterBlockletInfo,
+  inviteMembersToOrg,
+  removeOrgMember,
+  getOrgMembers,
+  getOrgInvitableUsers,
+  getOrgResource,
+  addOrgResource,
+  removeOrgResource,
+  migrateOrgResource,
+  getNotificationStats,
+};