nolo-cli 0.1.40 → 0.1.42

package/create/space/member/fetchUserSpaceMembershipsAction.ts

@@ -0,0 +1,386 @@
+// 文件路径: app/spaces/fetchUserSpaceMembershipsAction.ts
+
+import type { AppThunkApi } from "../../../app/store";
+import type { SpaceMemberWithSpaceInfo } from "../../../app/types";
+import { createSpaceKey, normalizeSpaceId } from "../../space/spaceKeys";
+import {
+  fetchRemoteSpace,
+  fetchRemoteUserSpaceMemberships,
+  membershipBelongsToUser,
+  selectSpaceRemoteAuth,
+  spaceListsUser,
+} from "../../space/spaceAccess";
+import { DataType } from "../../types";
+import { API_ENDPOINTS } from "../../../database/config";
+import { readAction } from "../../../database/actions/read";
+import { isTombstoneRecord } from "../../../database/tombstones";
+
+type MembershipWithSource = SpaceMemberWithSpaceInfo & {
+  sourceServer?: string;
+  requiresRemoteSpaceVerification?: boolean;
+};
+
+const CONTENT_SPACE_RECOVERY_TYPES = [
+  DataType.APP,
+  DataType.DOC,
+  DataType.DIALOG,
+  DataType.IMAGE,
+  DataType.FILE,
+  DataType.TABLE,
+  DataType.AGENT,
+  DataType.CYBOT,
+] as const;
+
+const readLocalSpaceData = async (db: any, spaceId: string): Promise<any | null> => {
+  const normalizedSpaceId = normalizeSpaceId(spaceId);
+  const spaceKey = createSpaceKey.space(normalizedSpaceId);
+  try {
+    return (await db.get(spaceKey)) ?? null;
+  } catch {
+    return null;
+  }
+};
+
+const buildLocalMembershipPreview = async (
+  userId: string,
+  db: any,
+  memberships: SpaceMemberWithSpaceInfo[]
+): Promise<SpaceMemberWithSpaceInfo[]> => {
+  const preview = await Promise.all(
+    memberships.map(async (membership) => {
+      if (isTombstoneRecord(membership)) return null;
+      if (!membershipBelongsToUser(membership, userId)) return null;
+
+      const normalizedSpaceId = normalizeSpaceId(membership.spaceId);
+      const localSpaceData = await readLocalSpaceData(db, normalizedSpaceId);
+      if (localSpaceData && isTombstoneRecord(localSpaceData)) return null;
+      if (localSpaceData && !spaceListsUser(localSpaceData, userId)) return null;
+
+      return {
+        ...membership,
+        spaceId: normalizedSpaceId,
+      };
+    })
+  );
+
+  return preview.filter(
+    (membership): membership is SpaceMemberWithSpaceInfo => !!membership
+  );
+};
+
+/**
+ * 从本地 IndexedDB 获取数据
+ */
+const fetchLocal = async (
+  userId: string,
+  db: any
+): Promise<SpaceMemberWithSpaceInfo[]> => {
+  try {
+    const memberships: SpaceMemberWithSpaceInfo[] = [];
+    const prefix = `space-member-${userId}`;
+    let iterator = db.iterator({
+      gte: prefix,
+      lte: prefix + "\xff",
+    });
+
+    if (iterator && typeof iterator.then === 'function') {
+      iterator = await iterator;
+    }
+
+    for await (const [_, memberData] of iterator) {
+      if (
+        memberData &&
+        typeof memberData === "object" &&
+        memberData.spaceId &&
+        !isTombstoneRecord(memberData)
+      ) {
+        memberships.push(memberData);
+      }
+    }
+
+    return memberships;
+  } catch (error) {
+    console.error("Error fetching local memberships:", error);
+    return [];
+  }
+};
+
+const fetchRemoteContentSpaceIds = async (
+  server: string,
+  userId: string
+): Promise<string[]> => {
+  try {
+    const queryParams = new URLSearchParams({ limit: "200" });
+    const response = await fetch(
+      `${server}${API_ENDPOINTS.DATABASE}/query/${encodeURIComponent(userId)}?${queryParams}`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          type: [...CONTENT_SPACE_RECOVERY_TYPES],
+          includeDeleted: true,
+          summary: true,
+        }),
+      }
+    );
+    if (!response.ok) return [];
+    const data = await response.json();
+    const records = Array.isArray(data?.data?.data) ? data.data.data : [];
+    return records
+      .filter((record: any) => !isTombstoneRecord(record))
+      .map((record: any) =>
+        typeof record?.spaceId === "string" ? normalizeSpaceId(record.spaceId) : ""
+      )
+      .filter((spaceId: string) => spaceId.length > 0);
+  } catch {
+    return [];
+  }
+};
+
+const recoverMembershipsFromContentSpaces = async ({
+  servers,
+  token,
+  userId,
+  knownSpaceIds,
+}: {
+  servers: string[];
+  token: string | null;
+  userId: string;
+  knownSpaceIds: Set<string>;
+}): Promise<MembershipWithSource[]> => {
+  const candidateSpaceIds = new Set<string>();
+  await Promise.all(
+    servers.map(async (server) => {
+      const spaceIds = await fetchRemoteContentSpaceIds(server, userId);
+      spaceIds.forEach((spaceId) => {
+        if (!knownSpaceIds.has(spaceId)) {
+          candidateSpaceIds.add(spaceId);
+        }
+      });
+    })
+  );
+
+  const recovered: MembershipWithSource[] = [];
+  for (const spaceId of candidateSpaceIds) {
+    for (const server of servers) {
+      const remoteSpace = await fetchRemoteSpace(server, token, spaceId);
+      if (!spaceListsUser(remoteSpace, userId)) continue;
+      recovered.push({
+        userId,
+        spaceId,
+        spaceName:
+          typeof remoteSpace?.name === "string" && remoteSpace.name.trim()
+            ? remoteSpace.name
+            : spaceId,
+        role: remoteSpace?.ownerId === userId ? "owner" : "member",
+        joinedAt:
+          remoteSpace?.updatedAt ??
+          remoteSpace?.createdAt ??
+          Date.now(),
+        sourceServer: server,
+      } as MembershipWithSource);
+      break;
+    }
+  }
+  return recovered;
+};
+
+/**
+ * 获取用户的所有空间成员资格。
+ */
+export const fetchUserSpaceMembershipsAction = async (
+  userId: string,
+  thunkAPI: AppThunkApi
+): Promise<SpaceMemberWithSpaceInfo[]> => {
+  const state = thunkAPI.getState();
+  const db = thunkAPI.extra.db;
+  const { token, servers } = selectSpaceRemoteAuth(state);
+
+  const localMembershipsPromise = fetchLocal(userId, db);
+  const remoteResultsPromise = Promise.all(
+    servers.map((server) =>
+      fetchRemoteUserSpaceMemberships(server, token, userId)
+    )
+  );
+
+  const localMemberships = await localMembershipsPromise;
+  if (state.space?.memberSpaces === null && localMemberships.length > 0) {
+    const localPreview = await buildLocalMembershipPreview(
+      userId,
+      db,
+      localMemberships
+    );
+    thunkAPI.dispatch?.({
+      type: "space/hydrateMemberSpacesFromLocal",
+      payload: localPreview,
+    });
+  }
+
+  const remoteResults = await remoteResultsPromise;
+
+  const successfulRemoteResults = remoteResults.filter((result) => result.ok);
+  const successfulRemoteMemberships = successfulRemoteResults.flatMap(
+    (result) =>
+      result.memberships.map((membership) => ({
+        ...membership,
+        sourceServer: result.server,
+      }))
+  );
+  const hasSuccessfulRemoteFetch = successfulRemoteResults.length > 0;
+  const hasRemoteAuthority = !!token && servers.length > 0;
+
+  if (hasRemoteAuthority && !hasSuccessfulRemoteFetch) {
+    throw new Error(
+      `space_membership_remote_unavailable: unable to refresh memberships from ${servers.join(", ")}`
+    );
+  }
+
+  const remoteSpaceIds = new Set(
+    successfulRemoteMemberships.map((membership) =>
+      normalizeSpaceId(membership.spaceId)
+    )
+  );
+
+  const filteredLocalMemberships: MembershipWithSource[] = hasSuccessfulRemoteFetch
+    ? (
+      await Promise.all(
+        localMemberships.map(async (membership) => {
+          const normalizedSpaceId = normalizeSpaceId(membership.spaceId);
+
+          if (remoteSpaceIds.has(normalizedSpaceId)) {
+            return {
+              ...membership,
+              spaceId: normalizedSpaceId,
+            };
+          }
+
+          console.warn(
+            `[SpaceMembership] Membership missing from remote index, verifying space record: user=${userId}, spaceId=${normalizedSpaceId}`
+          );
+          return {
+            ...membership,
+            spaceId: normalizedSpaceId,
+            requiresRemoteSpaceVerification: true,
+          };
+        })
+      )
+    ).filter((membership): membership is MembershipWithSource => !!membership)
+    : localMemberships.map((membership) => ({
+      ...membership,
+      spaceId: normalizeSpaceId(membership.spaceId),
+    }));
+
+  const verifyActiveSpaceMembership = async (
+    membership: MembershipWithSource
+  ): Promise<SpaceMemberWithSpaceInfo | null> => {
+    if (isTombstoneRecord(membership)) return null;
+    if (!membershipBelongsToUser(membership, userId)) return null;
+
+    const normalizedSpaceId = normalizeSpaceId(membership.spaceId);
+    const localSpaceData = await readLocalSpaceData(db, normalizedSpaceId);
+    if (membership.sourceServer || membership.requiresRemoteSpaceVerification) {
+      if (localSpaceData && isTombstoneRecord(localSpaceData)) return null;
+      try {
+        const remoteSpaceServers = Array.from(
+          new Set(
+            [membership.sourceServer, ...servers].filter(
+              (server): server is string =>
+                typeof server === "string" && server.length > 0
+            )
+          )
+        );
+        let remoteSpace: any | null = null;
+        for (const server of remoteSpaceServers) {
+          remoteSpace = await fetchRemoteSpace(
+            server,
+            token,
+            normalizedSpaceId
+          );
+          if (remoteSpace) break;
+        }
+        if (!spaceListsUser(remoteSpace, userId)) return null;
+        const { requiresRemoteSpaceVerification, ...verifiedMembership } = membership;
+        return {
+          ...verifiedMembership,
+          spaceId: normalizedSpaceId,
+        };
+      } catch {
+        return null;
+      }
+    }
+
+    if (localSpaceData) {
+      return !spaceListsUser(localSpaceData, userId)
+        ? null
+        : {
+            ...membership,
+            spaceId: normalizedSpaceId,
+          };
+    }
+    if (!membership.sourceServer && servers.length === 0) {
+      return {
+        ...membership,
+        spaceId: normalizedSpaceId,
+      };
+    }
+
+    try {
+      const remoteSpace = await readAction(
+        {
+          dbKey: createSpaceKey.space(normalizedSpaceId),
+          preferredServerOrigin: membership.sourceServer,
+        },
+        thunkAPI
+      );
+      if (!spaceListsUser(remoteSpace, userId)) return null;
+      return {
+        ...membership,
+        spaceId: normalizedSpaceId,
+      };
+    } catch {
+      return null;
+    }
+  };
+
+  const activeMemberships = (
+    await Promise.all(
+      [...filteredLocalMemberships, ...successfulRemoteMemberships].map(
+        verifyActiveSpaceMembership
+      )
+    )
+  ).filter((membership): membership is SpaceMemberWithSpaceInfo => !!membership);
+
+  const knownSpaceIds = new Set(
+    [
+      ...filteredLocalMemberships,
+      ...successfulRemoteMemberships,
+      ...activeMemberships,
+    ].map((membership) => normalizeSpaceId(membership.spaceId))
+  );
+  const recoveredMemberships =
+    hasRemoteAuthority && hasSuccessfulRemoteFetch
+      ? await recoverMembershipsFromContentSpaces({
+        servers,
+        token,
+        userId,
+        knownSpaceIds,
+      })
+      : [];
+
+  const membershipMap = new Map<string, SpaceMemberWithSpaceInfo>();
+  [...activeMemberships, ...recoveredMemberships].forEach((membership) => {
+    const normalizedSpaceId = normalizeSpaceId(membership.spaceId);
+    const { sourceServer, ...visibleMembership } = membership as MembershipWithSource;
+    membershipMap.set(normalizedSpaceId, {
+      ...visibleMembership,
+      spaceId: normalizedSpaceId,
+    });
+  });
+
+  const finalMemberships = Array.from(membershipMap.values()).sort(
+    (a, b) => (b.joinedAt || 0) - (a.joinedAt || 0)
+  );
+  return finalMemberships;
+};

package/create/space/member/memberThunks.ts

@@ -0,0 +1,47 @@
+// create/space/member/memberThunks.ts
+import { asyncThunkCreator } from "@reduxjs/toolkit";
+import type { SpaceState } from "../spaceSlice"; // Adjust path
+import { fetchUserSpaceMembershipsAction } from "./fetchUserSpaceMembershipsAction";
+import { addMemberAction } from "./addMemberAction";
+import { removeMemberAction } from "./removeMemberAction";
+
+type Create = ReturnType<typeof asyncThunkCreator<SpaceState>>;
+
+/**
+ * 创建与成员相关的 Async Thunks
+ * @param create - 由 buildCreateSlice 提供的创建器对象
+ */
+export const createMemberThunks = (create: Create) => ({
+  fetchUserSpaceMemberships: create.asyncThunk(
+    fetchUserSpaceMembershipsAction,
+    {
+      pending: (state) => {
+        state.loading = true;
+      },
+      fulfilled: (state, action) => {
+        state.memberSpaces = action.payload;
+        state.loading = false;
+      },
+      rejected: (state, action) => {
+        state.loading = false;
+        state.error = action.error.message;
+      },
+    }
+  ),
+
+  addMember: create.asyncThunk(addMemberAction, {
+    fulfilled: (state, action) => {
+      if (state.currentSpaceId === action.payload.spaceId) {
+        state.currentSpace = action.payload.updatedSpaceData;
+      }
+    },
+  }),
+
+  removeMember: create.asyncThunk(removeMemberAction, {
+    fulfilled: (state, action) => {
+      if (state.currentSpaceId === action.payload.spaceId) {
+        state.currentSpace = action.payload.updatedSpaceData;
+      }
+    },
+  }),
+});

package/create/space/member/removeMemberAction.ts

@@ -0,0 +1,67 @@
+import type { ULID } from "../../../app/types";
+import type { SpaceData } from "../../../app/types";
+import { selectUserId } from "../../../auth/authSlice";
+import { createSpaceKey, normalizeSpaceId } from "../../space/spaceKeys";
+import { read, write, remove } from "../../../database/dbSlice"; // 使用 remove
+import {
+  persistDefaultSpacePreference,
+  readDefaultSpaceIdPreference,
+} from "../../../app/settings/defaultSpacePreference";
+
+/**
+ * 从空间中删除成员
+ *
+ * 说明：
+ * 1. 当前用户必须是该空间的 owner，才能进行删除操作；
+ * 2. 待删除的成员必须存在于空间中，否则直接报错；
+ * 3. 更新 SpaceData.members 数组，删除对应的 SpaceMemberWithSpaceInfo 数据，并更新 updatedAt 字段。
+ */
+export const removeMemberAction = async (
+  input: { spaceId: ULID; memberId: string },
+  thunkAPI: any
+): Promise<{ spaceId: ULID; updatedSpaceData: SpaceData }> => {
+  const { spaceId, memberId } = input;
+  const { dispatch, getState } = thunkAPI;
+  const state = getState();
+  const currentUserId = selectUserId(state);
+
+  const spaceKey = createSpaceKey.space(spaceId);
+  const spaceData: SpaceData | null = await dispatch(read({
+    dbKey: spaceKey
+  })).unwrap();
+
+  if (!spaceData) {
+    throw new Error("Space not found");
+  }
+
+  // 检查当前用户是否是 owner
+  if (spaceData.ownerId !== currentUserId) {
+    throw new Error("只有空间所有者才能删除成员");
+  }
+
+  // 检查待删除的成员是否存在
+  if (!spaceData.members.includes(memberId)) {
+    throw new Error("待删除的成员不存在");
+  }
+
+  // 更新 SpaceData，移除成员
+  const updatedSpaceData: SpaceData = {
+    ...spaceData,
+    members: spaceData.members.filter((id) => id !== memberId),
+    updatedAt: Date.now(),
+  };
+
+  // 删除对应的 SpaceMemberWithSpaceInfo 数据
+  const memberKey = createSpaceKey.member(memberId, spaceId);
+  await Promise.all([
+    dispatch(write({ data: updatedSpaceData, customKey: spaceKey })).unwrap(),
+    dispatch(remove(memberKey)).unwrap(), // 使用 remove 替代 del
+  ]);
+
+  const defaultSpaceId = await readDefaultSpaceIdPreference(dispatch, memberId);
+  if (defaultSpaceId && normalizeSpaceId(defaultSpaceId) === normalizeSpaceId(spaceId)) {
+    await persistDefaultSpacePreference(dispatch, memberId, null);
+  }
+
+  return { spaceId, updatedSpaceData };
+};

package/create/space/resolvePreferredSpaceId.ts

@@ -0,0 +1,113 @@
+import type { RootState } from "../../app/store";
+import { readDefaultSpaceIdPreference } from "../../app/settings/defaultSpacePreference";
+import { read, readAndWait } from "../../database/dbSlice";
+
+import { createSpaceKey } from "./spaceKeys";
+
+const isAbortError = (error: unknown): boolean =>
+  error instanceof DOMException
+    ? error.name === "AbortError"
+    : typeof error === "object" &&
+        error !== null &&
+        "name" in error &&
+        error.name === "AbortError";
+
+const isSuppressedMissError = (error: unknown): boolean =>
+  typeof error === "object" &&
+  error !== null &&
+  "message" in error &&
+  typeof error.message === "string" &&
+  (error.message.includes("temporarily suppressed") ||
+    error.message.includes("miss suppressed"));
+
+export const readSpaceIfExists = async (
+  dispatch: any,
+  spaceId?: string | null
+): Promise<string | null> => {
+  if (!spaceId) {
+    return null;
+  }
+
+  try {
+    const result = await dispatch(
+      read({
+        dbKey: createSpaceKey.space(spaceId),
+      })
+    ).unwrap();
+
+    if (result) {
+      return spaceId;
+    }
+  } catch (error) {
+    if (isAbortError(error)) {
+      throw error;
+    }
+
+    if (!isSuppressedMissError(error)) {
+      console.info(
+        `[resolvePreferredSpaceId] Optimistic read failed for ${spaceId}, retrying with readAndWait:`,
+        error
+      );
+    }
+  }
+
+  try {
+    const result = await dispatch(
+      readAndWait(createSpaceKey.space(spaceId))
+    ).unwrap();
+    return result ? spaceId : null;
+  } catch (error) {
+    if (isAbortError(error)) {
+      throw error;
+    }
+
+    console.info(
+      `[resolvePreferredSpaceId] Confirming space existence failed for ${spaceId}:`,
+      error
+    );
+    return null;
+  }
+};
+
+export const resolvePreferredSpaceId = async ({
+  dispatch,
+  getState,
+  userId,
+}: {
+  dispatch: any;
+  getState: () => RootState;
+  userId?: string | null;
+}): Promise<string | null> => {
+  const state = getState();
+
+  if (state.space.currentSpaceId) {
+    return state.space.currentSpaceId;
+  }
+
+  const candidates: string[] = [];
+  const pushCandidate = (spaceId?: string | null) => {
+    if (!spaceId) return;
+    if (candidates.includes(spaceId)) return;
+    candidates.push(spaceId);
+  };
+
+  pushCandidate(
+    await readDefaultSpaceIdPreference(
+      dispatch,
+      userId ?? state.auth?.currentUser?.userId ?? null
+    )
+  );
+
+  for (const memberSpace of state.space.memberSpaces || []) {
+    pushCandidate(memberSpace?.spaceId);
+  }
+
+  for (const candidate of candidates) {
+    const readableSpaceId = await readSpaceIfExists(dispatch, candidate);
+    if (readableSpaceId) {
+      return readableSpaceId;
+    }
+  }
+
+  return null;
+};