@spacecorexdev/core 0.0.2 → 0.0.5

package/src/utils/CacheUserInfo.ts

@@ -0,0 +1,818 @@
+'use strict';
+
+/**
+ * Copyright (c) 2025 SPACECORE Co.,Ltd. All Rights Reserved.
+ * Author: brian.li
+ * Date: 2025-04-02 11:43
+ * Desc: 用户信息工具类 - 支持Dexie缓存
+ *
+ * @example 使用方法
+ *
+ * // 1. 获取当前登录用户信息
+ * import { CacheUserInfo } from './CacheUserInfo';
+ * const userInfo = await CacheUserInfo.getUserInfo({});
+ * console.log(userInfo?.nickname);
+ *
+ * // 2. 获取指定用户信息
+ * const userInfo = await CacheUserInfo.getUserInfo({ user_id: 'user123' });
+ *
+ * // 3. 强制刷新缓存（不使用缓存）
+ * const userInfo = await CacheUserInfo.getUserInfo({ user_id: 'user123', forceRefresh: true });
+ *
+ * // 4. 批量获取多个用户信息
+ * import { CacheUserInfo } from './CacheUserInfo';
+ * const userMap = await CacheUserInfo.getUserInfos({ userIds: ['user1', 'user2', 'user3'] });
+ * const user1Info = userMap.get('user1');
+ *
+ * // 5. 清除用户缓存
+ * import { CacheUserInfo } from './CacheUserInfo';
+ * await CacheUserInfo.clearUserCache();           // 清除所有缓存
+ * await CacheUserInfo.clearUserCache('user123');  // 清除指定用户缓存
+ *
+ * // 6. 获取缓存统计信息
+ * import { CacheUserInfo } from './CacheUserInfo';
+ * const stats = await CacheUserInfo.getCacheStats();
+ * console.log(`缓存数量: ${stats.count}`);
+ */
+
+import * as febs from 'febs-browser';
+import Dexie, { Table } from 'dexie';
+import { API } from "../api";
+import { AuthorizationHandler, ResponseCode } from "../api/_base";
+import { storage } from "./storage";
+
+/** 用户信息缓存时间（毫秒）24小时 */
+const CACHE_EXPIRATION_MS = 24 * 60 * 60 * 1000;
+
+/** 用户头像缓存数据结构 */
+interface UserAvatarCache {
+  id: string;
+  avatar: {
+    avatar: string | undefined;
+    avatar_small: string | undefined;
+    avatar_tick: number;
+  }
+  timestamp: number;
+}
+
+/** 用户信息缓存数据结构 */
+interface UserInfoCache {
+  id: string;
+  data: UserInfo;
+  timestamp: number;
+}
+
+/** 用户信息数据类型 */
+export interface UserInfo {
+  avatar?: {
+    avatar: string | undefined;
+    avatar_small: string | undefined;
+    avatar_tick: number;
+  };
+  phone: string;
+  nickname: string;
+  username: string;
+  id: string;
+  is_forbidden: boolean;
+  role_ids: string[];
+  isAdmin: boolean;
+  email: string;
+  /** 后端保存的可显示模块 JSON 字符串。 */
+  displayModules?: string;
+  title: string;
+  manager_id: string;
+  created_at: Date;
+  thirdPlatformInfo?: { platform_user_id: string; platform_type: string }[] | null;
+  unreadMessageCount?: number;
+  tick_avatar_self?: number;
+
+  departmentInfo?: UserDepartmentInfo;
+}
+
+export interface UserDepartmentInfo {
+  departments?: {
+    id: string;
+    name: string;
+    position?: string;
+  }[];
+  department_ids?: string[];
+  department_names?: string[];
+}
+
+/** Dexie 数据库类 */
+class UserInfoDatabase extends Dexie {
+  userCache!: Table<UserInfoCache, string>;
+
+  constructor() {
+    super('UserInfoDB');
+    this.version(1).stores({
+      userCache: 'id, timestamp'
+    });
+  }
+}class UserAvatarDatabase extends Dexie {
+  userCache!: Table<UserAvatarCache, string>;
+
+  constructor() {
+    super('UserAvatarDB');
+    this.version(1).stores({
+      userCache: 'id, timestamp'
+    });
+  }
+}
+
+/** 单例数据库实例 */
+const db = new UserInfoDatabase();
+const avatarDb = new UserAvatarDatabase();
+
+/**
+ * 从缓存获取用户头像
+ * @param userId 用户ID
+ * @returns 缓存的用户信息或null
+ */
+const getAvatarFromCache = async (userId: string): Promise<{
+    avatar: string | undefined;
+    avatar_small: string | undefined;
+    avatar_tick: number;
+  } | null> => {
+  try {
+    const cached = await avatarDb.userCache.get(userId);
+    if (cached) {
+      const now = Date.now();
+      if (now - cached.timestamp < CACHE_EXPIRATION_MS) {
+        return cached.avatar;
+      }
+      await avatarDb.userCache.delete(userId);
+    }
+    return null;
+  } catch (error) {
+    console.error('读取用户头像缓存失败:', error);
+    return null;
+  }
+};
+
+/**
+ * 从缓存获取用户信息
+ * @param userId 用户ID
+ * @returns 缓存的用户信息或null
+ */
+const getFromCache = async (userId: string): Promise<UserInfo | null> => {
+  try {
+    const cached = await db.userCache.get(userId);
+    if (cached) {
+      const now = Date.now();
+
+      // 检查头像缓存
+      const avatarCached = await avatarDb.userCache.get(userId);
+      if (avatarCached) {
+        // 检查头像缓存是否过期
+        if (now - avatarCached.timestamp < CACHE_EXPIRATION_MS) {
+          cached.data.avatar = avatarCached.avatar;
+        }
+        else {
+          // 头像缓存过期，清空头像
+          cached.data.avatar = undefined;
+          await avatarDb.userCache.delete(userId);
+        }
+      } else {
+        // 没有头像缓存，清空头像
+        cached.data.avatar = undefined;
+      }
+
+      if (now - cached.timestamp < CACHE_EXPIRATION_MS) {
+        return cached.data;
+      }
+      // 缓存过期，删除
+      await db.userCache.delete(userId);
+    }
+    return null;
+  } catch (error) {
+    console.error('读取用户缓存失败:', error);
+    return null;
+  }
+};
+
+/**
+ * 设置用户信息到缓存
+ * @param userId 用户ID
+ * @param data 用户信息
+ */
+const setAvatarToCache = async (userId: string, data: {
+  avatar: string | undefined;
+  avatar_small: string | undefined;
+  avatar_tick: number;
+}): Promise<void> => {
+  try {
+    // 缓存头像
+    if (data) {
+      await avatarDb.userCache.put({
+        id: userId,
+        avatar: data,
+        timestamp: Date.now()
+      });
+    }
+  } catch (error) {
+    console.error('写入用户头像缓存失败:', error);
+  }
+};
+
+/**
+ * 设置用户信息到缓存
+ * @param userId 用户ID
+ * @param data 用户信息
+ */
+const setToCache = async (userId: string, data: UserInfo): Promise<void> => {
+  try {
+    // 缓存头像
+    if (data.avatar) {
+      await avatarDb.userCache.put({
+        id: userId,
+        avatar: data.avatar,
+        timestamp: Date.now()
+      });
+    }
+    let avatar = data.avatar;
+    data.avatar = undefined;
+    await db.userCache.put({
+      id: userId,
+      data,
+      timestamp: Date.now()
+    });
+    // 恢复头像
+    data.avatar = avatar;
+  } catch (error) {
+    console.error('写入用户缓存失败:', error);
+  }
+};
+
+/**
+ * 批量从缓存获取用户信息
+ * @param userIds 用户ID数组
+ * @returns 缓存的用户信息映射表
+ */
+const getMultipleFromCache = async (userIds: string[]): Promise<Map<string, UserInfo>> => {
+  const result = new Map<string, UserInfo>();
+  try {
+    const cached = await db.userCache.bulkGet(userIds);
+    const now = Date.now();
+
+    for (let i = 0; i < userIds.length; i++) {
+      const item = cached[i];
+      if (item && now - item.timestamp < CACHE_EXPIRATION_MS) {
+        result.set(userIds[i], item.data);
+      }
+    }
+
+    const avatarCached = await avatarDb.userCache.bulkGet(userIds);
+
+    for (let i = 0; i < userIds.length; i++) {
+      const item = avatarCached[i];
+      if (!item) continue;
+      const user = result.get(item.id);
+      if (user && now - item.timestamp < CACHE_EXPIRATION_MS) {
+        user.avatar = item.avatar;
+      }
+    }
+  } catch (error) {
+    console.error('批量读取用户缓存失败:', error);
+  }
+  return result;
+};
+
+/**
+ * 批量设置用户信息到缓存
+ * @param users 用户信息数组
+ */
+const setMultipleToCache = async (users: { id: string; data: UserInfo }[]): Promise<void> => {
+  try {
+    const entries = users.map(u => ({
+      id: u.id,
+      data: u.data,
+      timestamp: Date.now()
+    }));
+    // 缓存头像
+    let avatarEntries = users.map(u => ({
+      id: u.id,
+      avatar: u.data.avatar,
+      timestamp: Date.now()
+    }));
+    // 过滤掉空头像
+    avatarEntries = avatarEntries.filter(e => e.avatar);
+
+    await avatarDb.userCache.bulkPut(avatarEntries as any);
+
+    entries.forEach(e => {
+      e.data.avatar = undefined;
+    });
+    await db.userCache.bulkPut(entries);
+  } catch (error) {
+    console.error('批量写入用户缓存失败:', error);
+  }
+};
+
+/**
+ * 获取所有有效缓存的用户信息
+ * @returns 缓存的用户信息映射表
+ */
+const getAllFromCache = async (): Promise<Map<string, UserInfo>> => {
+  const result = new Map<string, UserInfo>();
+  try {
+    const now = Date.now();
+    const all = await db.userCache.toArray();
+    for (const item of all) {
+      if (now - item.timestamp < CACHE_EXPIRATION_MS) {
+        // 检查头像缓存
+        const avatarCached = await avatarDb.userCache.get(item.id);
+        if (avatarCached && now - avatarCached.timestamp < CACHE_EXPIRATION_MS) {
+          item.data.avatar = avatarCached.avatar;
+        }
+        result.set(item.id, item.data);
+      } else {
+        // 清理过期缓存
+        await db.userCache.delete(item.id);
+      }
+    }
+  } catch (error) {
+    console.error('获取所有缓存失败:', error);
+  }
+  return result;
+};
+
+/**
+ * 清除所有用户缓存
+ */
+const clearCache = async (): Promise<void> => {
+  try {
+    await db.userCache.clear();
+    await avatarDb.userCache.clear();
+  } catch (error) {
+    console.error('清除用户缓存失败:', error);
+  }
+};
+
+/**
+ * 获取当前登录用户信息
+ * @param user_id 用户ID（可选，不传则获取当前登录用户）
+ * @param forceRefresh 是否强制刷新缓存（默认false，使用缓存）
+ * @returns 用户信息
+ */
+const getUserInfo = async (
+  {
+    user_id,
+    forceRefresh = false,
+    forceAvatar = false,
+  }: {
+    user_id?: string,
+    forceRefresh?: boolean,
+    forceAvatar?: boolean
+  }
+): Promise<UserInfo | null> => {
+
+  let r: any = {
+    code: ResponseCode.SUCCESS,
+    data: {
+      user_id,
+      isLogin: true,
+    }
+  };
+
+  let isLoginNetworkError = false;
+
+  if (!user_id) {
+    try {
+      r = await API.user.gateway.isLogin();
+    } catch (e) {
+      // 网络不可达 / 服务器宕机：视为"接口未知状态"，不清除会话 token（用户很可能仍有效），
+      // 也不向上抛错 —— 走下面的本地缓存降级逻辑，保证页面可正常渲染。
+      isLoginNetworkError = true;
+    }
+  }
+
+  // —— 接口网络异常：走纯本地缓存分支，不做任何清除 token / 跳登录的行为 ——
+  if (isLoginNetworkError) {
+    // 1) 从 bp.ss.user 拿本地上一次保存的 user 快照，优先对齐 Dexie
+    let localUserId: string | undefined;
+    try {
+      const rawUser = storage.namespace('bp.ss').get('user');
+      if (rawUser) {
+        const parsed = JSON.parse(rawUser) as UserInfo;
+        localUserId = parsed?.id;
+      }
+    } catch {
+      /* ignore parse error */
+    }
+
+    // 2) 如果未指定 user_id，就用 localStorage 中的当前用户 id 查 Dexie 缓存
+    const queryId = user_id ?? localUserId;
+    if (queryId) {
+      const cached = await getFromCache(queryId);
+      if (cached) {
+        // 补全头像
+        const av = await getUserAvatar({ user_id: queryId, forceRefresh: false, serverTick: cached.tick_avatar_self });
+        if (av) cached.avatar = av;
+        return cached;
+      }
+    }
+
+    // 3) 连 Dexie 也没有：如果本地 raw user 存在，直接用它兜底（至少能展示导航栏和用户名）
+    try {
+      const rawUser = storage.namespace('bp.ss').get('user');
+      if (rawUser) return JSON.parse(rawUser) as UserInfo;
+    } catch {
+      /* ignore */
+    }
+
+    return null;
+  }
+
+  if (r?.code === ResponseCode.SUCCESS && r.data?.isLogin) {
+    let userId = r.data?.user_id;
+    let isAdminFlag = r.data?.isAdmin || false;
+
+    // 从缓存获取用户
+    let cachedUserInfo = await getFromCache(userId);
+    if (forceRefresh || !cachedUserInfo) {
+      try {
+        let r = await API.user.user.getInfo({ id: userId });
+        if (r?.code == ResponseCode.SUCCESS) {
+
+          if (!user_id) {
+            storage.namespace('bp.ss').set('user', JSON.stringify(r.data));
+          }
+
+          const userInfo = {
+            ...r.data,
+          } as UserInfo;
+
+          // 写入缓存
+          if (userId) {
+            await setToCache(userId, userInfo);
+          }
+
+          try {
+            let avatar = await getUserAvatar({ user_id: userId, forceRefresh: forceAvatar, serverTick: r.data?.tick_avatar_self });
+            if (avatar) {
+              userInfo.avatar = avatar;
+            }
+          } catch {
+            // 头像接口失败不阻塞用户主信息返回
+          }
+
+          return userInfo;
+        } else if (cachedUserInfo) {
+          // 接口返回非 SUCCESS，但本地有缓存：降级返回缓存，避免页面进入空白态
+          return cachedUserInfo;
+        } else {
+          return null;
+        }
+      } catch (e) {
+        // getInfo 网络异常：有缓存就用缓存，否则返回 null 但不清除会话
+        if (cachedUserInfo) return cachedUserInfo;
+        // 至少返回本地 localStorage 里的 raw user 作为兜底
+        try {
+          const rawUser = storage.namespace('bp.ss').get('user');
+          if (rawUser) return JSON.parse(rawUser) as UserInfo;
+        } catch { /* ignore */ }
+        return null;
+      }
+    }
+
+    try {
+      let avatar = await getUserAvatar({ user_id: userId, forceRefresh: forceAvatar, serverTick: cachedUserInfo.tick_avatar_self });
+      if (avatar) {
+        cachedUserInfo.avatar = avatar;
+      }
+    } catch {
+      // 头像接口失败不阻塞用户返回
+    }
+    return cachedUserInfo;
+  } else {
+    AuthorizationHandler.clearStoreToken();
+    return null;
+  }
+}
+
+/**
+ * 获取用户信息头像
+ * @param user_id 用户ID（可选，不传则获取当前登录用户）
+ * @param forceRefresh 是否强制刷新缓存（默认false，使用缓存）
+ * @returns 用户信息头像
+ */
+const getUserAvatar = async (
+  {
+    user_id,
+    forceRefresh = false,
+    serverTick = Number.MAX_SAFE_INTEGER, // 服务器上最新的tick.
+  }: {
+    user_id?: string,
+    forceRefresh?: boolean,
+    serverTick?: number,
+  }
+): Promise<{
+  avatar: string | undefined;
+  avatar_small: string | undefined;
+  avatar_tick: number;
+} | undefined> => {
+
+  if (!user_id) {
+    return undefined;
+  }
+
+  // 从缓存获取用户头像
+  let cachedUserInfo = await getAvatarFromCache(user_id);
+
+  if (forceRefresh || !cachedUserInfo) {
+    const tickSelf = cachedUserInfo?.avatar_tick || -1;
+    if (tickSelf < serverTick) {
+      try {
+        let rAvatar = await API.user.user.getAvatar({ id: user_id, tick: tickSelf as any });
+        if (rAvatar?.code == ResponseCode.SUCCESS && tickSelf != rAvatar.data?.tick_self) {
+          cachedUserInfo = {
+            avatar: febs.string.isEmpty(rAvatar.data?.avatar) ? undefined : rAvatar.data?.avatar,
+            avatar_small: febs.string.isEmpty(rAvatar.data?.avatar_small) ? undefined : rAvatar.data?.avatar_small,
+            avatar_tick: rAvatar.data?.tick_self || -1
+          };
+          await setAvatarToCache(user_id, cachedUserInfo);
+        }
+      } catch {
+        // 头像接口网络/服务异常：直接返回缓存值，不向上抛出
+      }
+    }
+  }
+  
+  return cachedUserInfo || undefined;
+};
+
+const current = async (options?: { forceRefresh?: boolean }): Promise<UserInfo | null> => {
+  options = options || {forceRefresh: false};
+  return await getUserInfo(options);
+}
+
+/**
+ * 获取本地存储的当前登录用户ID
+ */
+const currentLocalUser = (): UserInfo | null => {
+  let user = storage.namespace('bp.ss').get('user');
+  if (user) {
+    return JSON.parse(user);
+  }
+  return null;
+}
+
+/**
+ * 批量获取多个用户信息;
+ * @param keywords 搜索关键词, 可选，与userIds不能同时提供.
+ * @param userIds 用户ID数组, length=0, 则获取前100个.
+ * @param forceRefresh 是否强制刷新缓存（默认false，使用缓存）
+ * @returns 用户信息映射表（key为用户ID，value为用户信息）
+ */
+const getUserInfos = async (
+  {
+    userIds,
+    keywords,
+    forceRefresh = false,
+  }:
+    {
+      userIds?: string[],
+      keywords?: string,
+      forceRefresh?: boolean,
+    }
+): Promise<Map<string, UserInfo>> => {
+  const result = new Map<string, UserInfo>();
+  if (!userIds) {
+    // 先检查缓存是否有100个用户
+    if (!forceRefresh && (!keywords || keywords.length === 0)) {
+      const cachedUsers = await getAllFromCache();
+      if (cachedUsers.size >= 100) {
+        const top100 = new Map<string, UserInfo>();
+        let count = 0;
+        for (const [id, info] of cachedUsers) {
+          if (count >= 100) break;
+
+          const avatar = await getUserAvatar({ user_id: id, forceRefresh: false, serverTick: info.tick_avatar_self });
+          info.avatar = avatar;
+          top100.set(id, info);
+          count++;
+        }
+        return top100;
+      }
+      return cachedUsers;
+    }
+
+    // 从API获取前100个用户
+    let listRes;
+    if (keywords && keywords.length > 0) {
+      listRes = await API.user.user.search({ pageNum: 1, pageSize: 100, keyword: keywords });
+      if (listRes?.code !== ResponseCode.SUCCESS) {
+        return result;
+      }
+    }
+    else {
+      listRes = await API.user.user.list({ pageNum: 1, pageSize: 100 });
+      if (listRes?.code !== ResponseCode.SUCCESS) {
+        return result;
+      }
+    }
+
+    const users = listRes.data?.list || [];
+    const userInfos: { id: string; data: UserInfo }[] = [];
+
+    for (const user of users) {
+      // const r3 = await API.user.role.listUserRoles({ user_id: user.id || '' });
+
+      const userInfo = {
+        ...user,
+      } as UserInfo;
+
+      result.set(user.id, userInfo);
+      userInfos.push({ id: user.id, data: userInfo });
+    }
+
+    // 写入缓存
+    if (userInfos.length > 0) {
+      await setMultipleToCache(userInfos);
+    }
+
+    // 批量获取只取小头像.
+    for (let i = 0; i < userInfos.length; i++) {
+      let avatar = await getUserAvatar({ user_id: userInfos[i].id, serverTick: userInfos[i].data.tick_avatar_self });
+      userInfos[i].data.avatar = avatar;
+    }
+
+    return result;
+  }
+
+  if (userIds.length == 0) {
+    return result;
+  }
+
+  // 去重
+  const uniqueIds = [...new Set(userIds)];
+
+  // 尝试从缓存获取
+  if (!forceRefresh) {
+    const cachedUsers = await getMultipleFromCache(uniqueIds);
+    cachedUsers.forEach((info, id) => {
+      result.set(id, info);
+    });
+  }
+
+  // 获取未缓存的用户ID
+  const uncachedIds = uniqueIds.filter(id => !result.has(id));
+
+  if (uncachedIds.length === 0) {
+    return result;
+  }
+
+  try {
+    let resUsers = await API.user.user.listByIds({ ids: JSON.stringify(uncachedIds) });
+    if (resUsers?.code != ResponseCode.SUCCESS) {
+      return result;
+    }
+    let users = resUsers.data?.list || [];
+
+    // 写入缓存
+    if (users.length > 0) {
+      let r = [];
+      for (const user of users) {
+        const userInfo = {
+          ...user,
+        } as UserInfo;
+        r.push({ id: user.id, data: userInfo });
+      }
+      await setMultipleToCache(r);
+    }
+
+    let userAvatarCache = [] as {
+      id: string;
+      avatar_small: string;
+      avatar_tick: number;
+    }[];
+
+    if (users.length > 0) {
+      for (const user of users) {
+        const avatar = await getUserAvatar({ user_id: user.id, serverTick: user.tick_avatar_self || -1 });
+        userAvatarCache.push({
+          id: user.id,
+          avatar_small: avatar?.avatar_small || '',
+          avatar_tick: user.tick_avatar_self || -1,
+        });
+      }
+    }
+
+    for (const user of users) {
+      const avatar = userAvatarCache.find(v => v.id == user.id);
+
+      const userInfo = {
+        ...user,
+        avatar: {
+          avatar: '',
+          avatar_small: avatar?.avatar_small || '',
+          avatar_tick: avatar?.avatar_tick || -1,
+        },
+      } as UserInfo;
+
+      // 获取用户角色
+      // const roleRes = await API.user.role.listUserRoles({ user_id: user.id });
+      // if (roleRes.code === ResponseCode.SUCCESS && roleRes.data?.length) {
+      //   userInfo.role_ids = roleRes.data.map((role) => role.id);
+      // }
+
+      result.set(user.id, userInfo);
+    }
+
+  } catch (error) {
+    console.error('批量获取用户信息失败:', error);
+  }
+
+  return result;
+};
+
+/**
+ * 清除指定用户的缓存
+ * @param userId 用户ID
+ */
+const clearUserCache = async (userId?: string): Promise<void> => {
+  if (userId) {
+    await db.userCache.delete(userId);
+  } else {
+    await clearCache();
+  }
+};
+
+/**
+ * 获取缓存统计信息
+ * @returns 缓存统计信息
+ */
+const getCacheStats = async (): Promise<{ count: number; oldest: number | null; newest: number | null }> => {
+  try {
+    const all = await db.userCache.toArray();
+    if (all.length === 0) {
+      return { count: 0, oldest: null, newest: null };
+    }
+    const timestamps = all.map(item => item.timestamp);
+    return {
+      count: all.length,
+      oldest: Math.min(...timestamps),
+      newest: Math.max(...timestamps)
+    };
+  } catch (error) {
+    console.error('获取缓存统计失败:', error);
+    return { count: 0, oldest: null, newest: null };
+  }
+};
+
+/**
+ * 用户信息缓存管理对象
+ * @description 提供用户信息的缓存读写、批量获取、缓存清除等功能
+ * @example
+ * import { CacheUserInfo } from './CacheUserInfo';
+ * const userInfo = await CacheUserInfo.getUserInfo({});
+ * const users = await CacheUserInfo.getUserInfos({ userIds: ['id1', 'id2'] });
+ * await CacheUserInfo.clearUserCache();
+ */
+export const CacheUserInfo = {
+  /**
+ * 从缓存获取用户信息
+ * @param userId 用户ID
+ * @returns 缓存的用户信息或null
+ */
+  getFromCache,
+  getAvatarFromCache,
+  /**
+ * 获取当前登录用户信息
+ * @param user_id 用户ID（可选，不传则获取当前登录用户）
+ * @param isAdmin 是否为管理员
+ * @param forceRefresh 是否强制刷新缓存（默认false，使用缓存）
+ * @returns 用户信息
+ */
+  getUserInfo,
+  getUserAvatar,
+  /**
+ * 获取当前登录角色
+ * @param forceRefresh 是否强制刷新缓存（默认false，使用缓存）
+ * @returns 用户信息
+ */
+  current,
+  /**
+ * 获取本地存储的当前登录用户信息
+ */
+  currentLocalUser,
+/**
+ * 批量获取多个用户信息;
+ * @param keywords 搜索关键词, 可选，与userIds不能同时提供.
+ * @param userIds 用户ID数组, length=0, 则获取前100个.
+ * @param forceRefresh 是否强制刷新缓存（默认false，使用缓存）
+ * @returns 用户信息映射表（key为用户ID，value为用户信息）
+ */
+  getUserInfos,
+  /**
+ * 清除指定用户的缓存
+ * @param userId 用户ID
+ */
+  clearUserCache,
+  /**
+   * 获取缓存统计信息
+   * @returns 缓存统计信息
+   */
+  getCacheStats,
+}