nolo-cli 0.1.45 → 0.1.46

package/create/space/member/fetchUserSpaceMembershipsAction.ts

@@ -1,386 +0,0 @@
-// 文件路径: 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

@@ -1,47 +0,0 @@
-// 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

@@ -1,67 +0,0 @@
-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

@@ -1,113 +0,0 @@
-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;
-};