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

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

@@ -0,0 +1,198 @@
+const { withoutTrailingSlash } = require('ufo');
+const logger = require('@abtnode/logger')('@abtnode/core:api:team:store');
+const ensureServerEndpoint = require('@abtnode/util/lib/ensure-server-endpoint');
+
+const StoreUtil = require('../../util/store');
+
+const sanitizeUrl = (url) => {
+  if (!url) {
+    throw new Error('Registry URL should not be empty');
+  }
+
+  return url.trim();
+};
+
+/**
+ * Add store
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {string} params.url - Store URL
+ * @param {string} params.scope - Scope
+ * @param {Object} context
+ * @returns {Promise<Object>}
+ */
+// eslint-disable-next-line no-unused-vars
+async function addStore(api, { teamDid, url, scope = '' }, context) {
+  logger.info('add store', { teamDid, url, scope });
+
+  const sanitized = withoutTrailingSlash(await StoreUtil.getStoreUrl(url));
+  const storeList = await api.teamManager.getStoreList(teamDid);
+  const exists = storeList.some((x) => {
+    if (x.url === sanitized) {
+      if (!x.scope) {
+        return true;
+      }
+
+      return x.scope === scope;
+    }
+
+    return false;
+  });
+
+  if (exists) {
+    throw new Error(`Blocklet Store already exist: ${sanitized}`);
+  }
+
+  const store = await StoreUtil.getStoreMeta(sanitized);
+
+  storeList.push({ ...store, scope, url: sanitized, protected: false });
+
+  return api.teamManager.updateStoreList(teamDid, storeList);
+}
+
+/**
+ * Add endpoint
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {string} params.url - Endpoint URL
+ * @param {Object} context
+ * @returns {Promise<Object>}
+ */
+async function addEndpoint(api, { teamDid, url }, context) {
+  const userDid = context?.user?.did;
+  const { endpoint, appPid, appName, appDescription } = await ensureServerEndpoint(url);
+  const endpointList = await api.teamManager.getEndpointList(teamDid);
+
+  if (!appPid) {
+    throw new Error('current url not blocklet url');
+  }
+
+  if (!endpoint) {
+    throw new Error('current url not blocklet url');
+  }
+
+  const index = endpointList.findIndex((x) => x.id === appPid);
+  if (index !== -1) {
+    endpointList[index].url = url;
+  } else {
+    endpointList.push({ id: appPid, appName, appDescription, scope: userDid, url, endpoint, protected: false });
+  }
+
+  return api.teamManager.updateEndpointList(teamDid, endpointList);
+}
+
+/**
+ * Delete endpoint
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {string} params.did - Endpoint DID
+ * @param {string} params.projectId - Project ID
+ * @param {Object} context
+ * @returns {Promise<Object>}
+ */
+async function deleteEndpoint(api, { teamDid, did, projectId }, context) {
+  const endpointList = await api.teamManager.getEndpointList(teamDid);
+
+  const index = endpointList.findIndex((x) => x.id === did);
+  if (index === -1) {
+    throw new Error(`Blocklet Endpoint does not exist: ${did}`);
+  }
+  endpointList.splice(index, 1);
+
+  if (projectId) {
+    const { projectState } = await api.teamManager.getProjectState(teamDid);
+    await projectState.deleteConnectedEndpoint({ projectId, endpointId: did, createdBy: context?.user?.did });
+  }
+
+  return api.teamManager.updateEndpointList(teamDid, endpointList);
+}
+
+/**
+ * Check if store exists
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {string} params.url - Store URL
+ * @param {string} params.scope - Scope
+ * @param {Object} context
+ * @returns {Promise<boolean>}
+ */
+async function existsStore(api, { teamDid, url, scope }, context) {
+  const sanitized = withoutTrailingSlash(await StoreUtil.getStoreUrl(url));
+  const storeList = await api.teamManager.getStoreList(teamDid);
+  const did = context?.user?.did;
+  const exists = storeList.some((x) => {
+    if (x.url !== sanitized) {
+      return false;
+    }
+    if (x.scope && x.scope === did) {
+      return true;
+    }
+    if (!x.scope || x.scope === 'studio') {
+      return true;
+    }
+    return x.scope === scope;
+  });
+
+  return exists;
+}
+
+/**
+ * Delete store
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {string} params.url - Store URL
+ * @param {string} params.projectId - Project ID
+ * @param {string} params.scope - Scope
+ * @param {Object} context
+ * @returns {Promise<Object>}
+ */
+// eslint-disable-next-line no-unused-vars
+async function deleteStore(api, { teamDid, url, projectId, scope }, context) {
+  logger.info('delete registry', { url });
+  const sanitized = sanitizeUrl(url);
+
+  const storeList = await api.teamManager.getStoreList(teamDid);
+  let storeIndex;
+  if (scope) {
+    storeIndex = storeList.findIndex((x) => {
+      if (x.protected) {
+        return false;
+      }
+      return x.url === sanitized && x.scope === scope;
+    });
+    if (storeIndex === -1) {
+      throw new Error(`No permission to delete the Store registry: ${sanitized}`);
+    }
+  } else {
+    storeIndex = storeList.findIndex((x) => x.url === sanitized && !x.scope);
+    if (storeIndex === -1) {
+      throw new Error(`Store registry does not exist: ${sanitized}`);
+    }
+  }
+
+  if (projectId && scope) {
+    const { projectState } = await api.teamManager.getProjectState(teamDid);
+    const store = await StoreUtil.getStoreMeta(sanitized);
+    await projectState.deleteConnectedStore({
+      projectId,
+      storeId: store.id,
+      createdBy: scope === 'studio' ? null : context?.user?.did,
+    });
+  }
+  storeList.splice(storeIndex, 1);
+  return api.teamManager.updateStoreList(teamDid, storeList);
+}
+
+module.exports = {
+  sanitizeUrl,
+  addStore,
+  addEndpoint,
+  deleteEndpoint,
+  existsStore,
+  deleteStore,
+};

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

@@ -0,0 +1,230 @@
+const pick = require('lodash/pick');
+const logger = require('@abtnode/logger')('@abtnode/core:api:team:tag');
+const { Joi } = require('@arcblock/validator');
+
+const taggingSchema = Joi.object({
+  tagId: Joi.number().required(),
+  taggableIds: Joi.array().items(Joi.string()).min(1).required().messages({
+    'any.required': 'Must specify tagging.taggableIds to create',
+    'array.base': 'taggableIds must be an array',
+    'array.min': 'taggableIds must contain at least one element',
+  }),
+  taggableType: Joi.string().required().messages({
+    'any.required': 'Must specify tagging.taggableType to create',
+    'string.base': 'taggableType must be a string',
+  }),
+});
+
+/**
+ * Create tagging
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {Object} params.tagging - Tagging data
+ * @returns {Promise<Array>}
+ */
+async function createTagging(api, { teamDid, tagging }) {
+  const state = await api.getTaggingState(teamDid);
+
+  const { error, value } = taggingSchema.validate(tagging, { stripUnknown: true });
+  if (error) {
+    throw new Error(error.details.map((d) => d.message).join('; '));
+  }
+
+  const fns = value.taggableIds.map(async (id) => {
+    const found = await state.findOne({ tagId: tagging.tagId, taggableId: id });
+    if (found) return found;
+
+    return state.insert({ tagId: tagging.tagId, taggableId: id, taggableType: tagging.taggableType });
+  });
+
+  const docs = await Promise.all(fns);
+  logger.info('tagging created successfully', { teamDid, tagging });
+  return docs;
+}
+
+/**
+ * Delete tagging
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {Object} params.tagging - Tagging data
+ * @returns {Promise<Array>}
+ */
+async function deleteTagging(api, { teamDid, tagging }) {
+  const { error, value } = taggingSchema.validate(tagging, { stripUnknown: true });
+  if (error) {
+    throw new Error(error.details.map((d) => d.message).join('; '));
+  }
+
+  const state = await api.getTaggingState(teamDid);
+
+  const { tagId, taggableIds } = value;
+  const fns = taggableIds.map((id) => {
+    return state.remove({ tagId, taggableId: id });
+  });
+
+  const docs = await Promise.all(fns);
+  logger.info('tagging deleted successfully', { teamDid, tagging });
+
+  return docs;
+}
+
+/**
+ * Get tag
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {Object} params.tag - Tag data
+ * @returns {Promise<Object>}
+ */
+async function getTag(api, { teamDid, tag }) {
+  const state = await api.getTagState(teamDid);
+  return state.findOne({ id: tag.id });
+}
+
+/**
+ * Create tag
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {Object} params.tag - Tag data
+ * @param {Object} context
+ * @returns {Promise<Object>}
+ */
+async function createTag(api, { teamDid, tag }, context = {}) {
+  if (!tag.title) {
+    throw new Error('Must specify tag.title to create');
+  }
+  if (!tag.color || !tag.color.match(/^#[0-9a-f]{6}$/i)) {
+    throw new Error('Must specify hex encoded tag.color to create');
+  }
+  if (!tag.slug) {
+    throw new Error('Must specify tag.slug to create');
+  }
+
+  const state = await api.getTagState(teamDid);
+  const tagData = pick(tag, ['title', 'description', 'color', 'slug', 'type', 'componentDid', 'parentId']);
+  tagData.createdBy = context.user.did;
+  tagData.updatedBy = context.user.did;
+  const doc = await state.insert(tagData);
+  logger.info('tags created successfully', { teamDid, tag });
+  return doc;
+}
+
+/**
+ * Update tag
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {Object} params.tag - Tag data
+ * @param {Object} context
+ * @returns {Promise<Object>}
+ */
+async function updateTag(api, { teamDid, tag }, context = {}) {
+  if (!tag.id) {
+    throw new Error('Must specify tag.id to update');
+  }
+
+  const keys = ['title', 'description', 'color', 'slug', 'type', 'componentDid', 'parentId'];
+  const tagData = Object.fromEntries(keys.map((key) => [key, tag[key] ?? null]));
+  tagData.updatedBy = context.user.did;
+
+  const state = await api.getTagState(teamDid);
+  const result = await state.updateById(tag.id, tagData);
+  logger.info('tags updated successfully', { teamDid, tag, result });
+  return state.findOne({ id: tag.id });
+}
+
+/**
+ * Delete tag
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {Object} params.tag - Tag data
+ * @param {number} params.moveTo - Move to tag id
+ * @returns {Promise<Object>}
+ */
+async function deleteTag(api, { teamDid, tag, moveTo }) {
+  if (!tag.id) {
+    throw new Error('Must specify tag.id to delete');
+  }
+
+  const state = await api.getTagState(teamDid);
+  const taggingState = await api.getTaggingState(teamDid);
+
+  if (moveTo) {
+    const records = await taggingState.find({ tagId: tag.id });
+    const checkPairs = records.map((r) => ({ taggableId: r.taggableId, taggableType: r.taggableType }));
+    const existing = await taggingState.find({ tagId: moveTo, $or: checkPairs });
+
+    const existingSet = new Set(existing.map((e) => `${e.taggableId}:${e.taggableType}`));
+    const toUpdate = [];
+    const toDelete = [];
+
+    for (const record of records) {
+      const key = `${record.taggableId}:${record.taggableType}`;
+      if (existingSet.has(key)) {
+        toDelete.push(record);
+        logger.info('tag already at moveTo, will delete record', { teamDid, tag, record });
+      } else {
+        toUpdate.push(record);
+      }
+    }
+
+    if (toUpdate.length > 0) {
+      await Promise.all(
+        toUpdate.map((record) =>
+          taggingState
+            .update(
+              { tagId: record.tagId, taggableId: record.taggableId, taggableType: record.taggableType },
+              { $set: { tagId: moveTo } }
+            )
+            .then(() => {
+              logger.info('tag moved successfully', { teamDid, tag, record, moveTo });
+            })
+        )
+      );
+    }
+
+    if (toDelete.length > 0) {
+      await Promise.all(
+        toDelete.map((record) =>
+          taggingState.remove(record).then(() => {
+            logger.info('tagging deleted successfully', { teamDid, tag, record });
+          })
+        )
+      );
+    }
+  }
+
+  const doc = await state.remove({ id: tag.id });
+  await taggingState.remove({ tagId: tag.id });
+  logger.info('tags deleted successfully', { teamDid, tag });
+  return doc;
+}
+
+/**
+ * Get tags
+ * @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 getTags(api, { teamDid, paging }) {
+  const state = await api.getTagState(teamDid);
+  const result = await state.paginate({}, { createdAt: -1 }, { pageSize: 20, ...paging });
+  return { tags: result.list, paging: result.paging };
+}
+
+module.exports = {
+  taggingSchema,
+  createTagging,
+  deleteTagging,
+  getTag,
+  createTag,
+  updateTag,
+  deleteTag,
+  getTags,
+};

package/lib/api/team/user-auth-manager.js

@@ -0,0 +1,132 @@
+const { joinURL } = require('ufo');
+const logger = require('@abtnode/logger')('@abtnode/core:api:team:user-auth');
+const { ROLES } = require('@abtnode/constant');
+const { TeamEvents } = require('@blocklet/constant');
+
+/**
+ * Send new member notification
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} user - User
+ * @param {Object} nodeInfo - Node info
+ * @returns {Promise<void>}
+ */
+async function sendNewMemberNotification(api, user, nodeInfo) {
+  if (nodeInfo.nodeOwner && user.did !== nodeInfo.nodeOwner.did) {
+    const actionPath = '/team/members';
+    const action = process.env.NODE_ENV === 'production' ? joinURL(nodeInfo.routing.adminPath, actionPath) : actionPath;
+    await api.teamManager.createNotification({
+      title: 'New member join',
+      description: `User with Name (${user.fullName}) and DID (${user.did}) has joined this server`,
+      entityType: 'node',
+      action,
+      entityId: user.did,
+      severity: 'success',
+    });
+  }
+}
+
+/**
+ * Login user
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {Object} params.user - User
+ * @param {boolean} params.notify - Send notification
+ * @param {boolean} params.force - Force login
+ * @returns {Promise<Object>}
+ */
+async function loginUser(api, { teamDid, user, notify = true, force = false }) {
+  const state = await api.getUserState(teamDid);
+  const nodeInfo = await api.node.read();
+
+  if (user.role === ROLES.OWNER) {
+    if (teamDid !== nodeInfo.did && !force) {
+      throw new Error('Cannot add user of owner role');
+    }
+    if (await state.count({ role: ROLES.OWNER })) {
+      throw new Error('The owner already exists');
+    }
+  }
+
+  const { _action, ...doc } = await state.loginUser(user);
+  if (_action === 'update') {
+    logger.info('user updated successfully', { teamDid, userDid: user.did });
+    api.emit(TeamEvents.userUpdated, { teamDid, user: doc });
+  } else if (_action === 'add') {
+    api.createDefaultOrgForUser({ teamDid, user });
+
+    if (teamDid === nodeInfo.did && nodeInfo.nodeOwner && user.did !== nodeInfo.nodeOwner.did && notify) {
+      await sendNewMemberNotification(api, user, nodeInfo);
+    }
+
+    logger.info('user added successfully', { teamDid, userDid: user.did, userPk: user.pk, userName: user.fullName });
+    api.emit(TeamEvents.userAdded, { teamDid, user: doc });
+  }
+  return doc;
+}
+
+/**
+ * Disconnect user account
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {Object} params.connectedAccount - Connected account
+ * @returns {Promise<Object>}
+ */
+async function disconnectUserAccount(api, { teamDid, connectedAccount }) {
+  const state = await api.getUserState(teamDid);
+  const result = await state.disconnectUserAccount(connectedAccount);
+
+  logger.info('user disconnect account successfully', {
+    teamDid,
+    connectedAccountDid: connectedAccount.did,
+    connectedAccountPk: connectedAccount.pk,
+    connectedAccountProvider: connectedAccount.provider,
+  });
+  return result;
+}
+
+/**
+ * Add user
+ * @param {Object} api - TeamAPI instance
+ * @param {Object} params
+ * @param {string} params.teamDid - Team DID
+ * @param {Object} params.user - User
+ * @param {boolean} params.force - Force add
+ * @returns {Promise<Object>}
+ */
+async function addUser(api, { teamDid, user, force = false }) {
+  const state = await api.getUserState(teamDid);
+
+  if (user.role === ROLES.OWNER) {
+    const nodeInfo = await api.node.read();
+
+    if (teamDid !== nodeInfo.did && !force) {
+      throw new Error('Cannot add user of owner role');
+    }
+
+    if (await state.count({ role: ROLES.OWNER })) {
+      throw new Error('The owner already exists');
+    }
+  }
+
+  const doc = await state.addUser(user);
+
+  logger.info('user added successfully', { teamDid, userDid: user.did, userPk: user.pk, userName: user.fullName });
+
+  const nodeInfo = await api.node.read();
+  if (teamDid === nodeInfo.did && nodeInfo.nodeOwner && user.did !== nodeInfo.nodeOwner.did) {
+    await sendNewMemberNotification(api, user, nodeInfo);
+  }
+
+  api.emit(TeamEvents.userAdded, { teamDid, user: doc });
+
+  return doc;
+}
+
+module.exports = {
+  sendNewMemberNotification,
+  loginUser,
+  disconnectUserAccount,
+  addUser,
+};

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

@@ -0,0 +1,78 @@
+/**
+ * User Manager - Orchestrates user management operations
+ *
+ * This module re-exports functionality from specialized sub-modules:
+ * - user-auth-manager.js: User authentication and login operations
+ * - user-query-manager.js: User query and search operations
+ * - user-social-manager.js: User follow, invite, and webhook operations
+ * - user-update-manager.js: User update and modification operations
+ */
+
+const { sendNewMemberNotification, loginUser, disconnectUserAccount, addUser } = require('./user-auth-manager');
+const {
+  getUsers,
+  getUsersCount,
+  getUsersCountPerRole,
+  getUser,
+  getConnectedAccount,
+  isEmailUsed,
+  isPhoneUsed,
+  getUserByDid,
+  isUserValid,
+  isPassportValid,
+  isConnectedAccount,
+  getOwner,
+} = require('./user-query-manager');
+const {
+  USER_RELATION_ACTIONS,
+  USER_RELATION_QUERIES,
+  userFollowAction,
+  getUserFollows,
+  getUserFollowStats,
+  checkFollowing,
+  getUserInvites,
+  createWebhookDisabledNotification,
+  updateWebHookState,
+} = require('./user-social-manager');
+const {
+  updateUser,
+  updateUserAddress,
+  updateUserTags,
+  removeUser,
+  updateUserApproval,
+  switchProfile,
+} = require('./user-update-manager');
+
+module.exports = {
+  USER_RELATION_ACTIONS,
+  USER_RELATION_QUERIES,
+  sendNewMemberNotification,
+  loginUser,
+  disconnectUserAccount,
+  addUser,
+  getUsers,
+  getUsersCount,
+  getUsersCountPerRole,
+  getUser,
+  getConnectedAccount,
+  isEmailUsed,
+  isPhoneUsed,
+  getUserByDid,
+  isUserValid,
+  isPassportValid,
+  isConnectedAccount,
+  getOwner,
+  userFollowAction,
+  getUserFollows,
+  getUserFollowStats,
+  checkFollowing,
+  getUserInvites,
+  createWebhookDisabledNotification,
+  updateWebHookState,
+  updateUser,
+  updateUserAddress,
+  updateUserTags,
+  removeUser,
+  updateUserApproval,
+  switchProfile,
+};