nolo-cli 0.1.39 → 0.1.41

package/create/space/deleteSpaceAction.ts

@@ -0,0 +1,276 @@
+import { selectUserId } from "../../auth/authSlice";
+import { createSpaceKey } from "../space/spaceKeys";
+import { read, remove, patch } from "../../database/dbSlice";
+import { deleteDbKey } from "../../app/hooks/deleteDbKey";
+import {
+  persistDefaultSpacePreference,
+  readDefaultSpaceIdPreference,
+} from "../../app/settings/defaultSpacePreference";
+import {
+  isAgentKey,
+  isAppKey,
+  isDialogKey,
+  isFileKey,
+  isPageKey,
+  isTableMetaKey,
+  splitKey,
+} from "../../database/keys";
+import { normalizeSpaceId } from "./spaceKeys";
+
+// 定义ThunkAPI的通用类型（根据redux-thunk的用法）
+interface ThunkAPI {
+  dispatch: (action: any) => any;
+  getState: () => any; // 如果有RootState类型，可替换为RootState
+}
+
+export type DeleteSpaceStrategy =
+  | "delete-space-only"
+  | "move-owned-to-all"
+  | "delete-owned-content";
+
+type DeleteSpaceArgs =
+  | string
+  | {
+      spaceId: string;
+      strategy?: DeleteSpaceStrategy;
+    };
+
+const getCurrentUserId = (state: any): string => selectUserId(state);
+
+const fetchSpaceData = async (
+  spaceId: string,
+  dispatch: ThunkAPI["dispatch"]
+) => {
+  const spaceKey = createSpaceKey.space(spaceId);
+  try {
+    return await dispatch(read({
+      dbKey: spaceKey
+    })).unwrap();
+  } catch (error) {
+    console.warn(`Failed to read space ${spaceId}:`, error);
+    return undefined;
+  }
+};
+
+const checkOwnerPermission = (spaceData: any | undefined, userId: string) => {
+  if (spaceData && spaceData.ownerId !== userId) {
+    throw new Error("Only owner can delete space");
+  }
+};
+
+const deleteSpaceData = async (
+  spaceId: string,
+  dispatch: ThunkAPI["dispatch"]
+) => {
+  const spaceKey = createSpaceKey.space(spaceId);
+  try {
+    await dispatch(remove(spaceKey)).unwrap();
+  } catch (error) {
+    console.warn(`Failed to delete space ${spaceId}:`, error);
+  }
+};
+
+const deleteAllMembers = async (
+  spaceData: any | undefined,
+  spaceId: string,
+  dispatch: ThunkAPI["dispatch"]
+) => {
+  if (spaceData?.members) {
+    for (const memberId of spaceData.members) {
+      const memberKey = createSpaceKey.member(memberId, spaceId);
+      await dispatch(remove(memberKey))
+        .unwrap()
+        .catch((err) =>
+          console.warn(
+            `Failed to delete member ${memberId} for space ${spaceId}:`,
+            err
+          )
+        );
+    }
+  }
+};
+
+const deleteCurrentUserMember = async (
+  userId: string,
+  spaceId: string,
+  dispatch: ThunkAPI["dispatch"]
+) => {
+  const currentUserMemberKey = createSpaceKey.member(userId, spaceId);
+  await dispatch(remove(currentUserMemberKey))
+    .unwrap()
+    .catch((err) =>
+      console.warn(
+        `Failed to delete member key for user ${userId} in space ${spaceId}:`,
+        err
+      )
+    );
+};
+
+const clearDefaultSpacePreferenceIfNeeded = async (
+  userId: string,
+  spaceId: string,
+  dispatch: ThunkAPI["dispatch"]
+) => {
+  const defaultSpaceId = await readDefaultSpaceIdPreference(dispatch, userId);
+  if (defaultSpaceId && normalizeSpaceId(defaultSpaceId) === normalizeSpaceId(spaceId)) {
+    await persistDefaultSpacePreference(dispatch, userId, null);
+  }
+};
+
+const clearDeletedMemberDefaultSpacePreferences = async (
+  userIds: string[],
+  spaceId: string,
+  dispatch: ThunkAPI["dispatch"]
+) => {
+  const uniqueUserIds = Array.from(new Set(userIds.filter(Boolean)));
+  for (const userId of uniqueUserIds) {
+    await clearDefaultSpacePreferenceIfNeeded(userId, spaceId, dispatch);
+  }
+};
+
+const resolveDeleteArgs = (
+  input: DeleteSpaceArgs
+): { spaceId: string; strategy: DeleteSpaceStrategy } => {
+  if (typeof input === "string") {
+    return { spaceId: input, strategy: "delete-space-only" };
+  }
+  return {
+    spaceId: input.spaceId,
+    strategy: input.strategy ?? "delete-space-only",
+  };
+};
+
+const isOwnedByUser = (entityKey: string, entity: any, userId: string): boolean => {
+  if (!entityKey || !userId) return false;
+
+  const keyParts = splitKey(entityKey);
+  const keyedOwner = keyParts[1];
+
+  if (
+    (isDialogKey(entityKey) ||
+      isPageKey(entityKey) ||
+      isFileKey(entityKey) ||
+      isTableMetaKey(entityKey)) &&
+    keyedOwner === userId
+  ) {
+    return true;
+  }
+
+  if ((isAgentKey(entityKey) || isAppKey(entityKey)) && entity?.userId === userId) {
+    return true;
+  }
+
+  if (entity?.tenantId === userId || entity?.userId === userId || entity?.ownerId === userId) {
+    return true;
+  }
+
+  return false;
+};
+
+const nextUpdatedAt = (entity: any): string => {
+  const source =
+    entity?.updatedAt ??
+    entity?.updated_at ??
+    entity?.createdAt ??
+    entity?.created ??
+    Date.now();
+  const timestamp =
+    typeof source === "number" ? source : Date.parse(String(source)) || Date.now();
+  return new Date(Math.max(Date.now(), timestamp + 1)).toISOString();
+};
+
+const listSpaceEntities = async (
+  spaceData: any | undefined,
+  dispatch: ThunkAPI["dispatch"]
+) => {
+  const results: Array<{ entityKey: string; entity: any }> = [];
+  const contents = Object.values(spaceData?.contents ?? {}).filter(Boolean) as Array<{
+    contentKey?: string;
+  }>;
+
+  for (const item of contents) {
+    const entityKey = typeof item.contentKey === "string" ? item.contentKey : "";
+    if (!entityKey) continue;
+
+    let entity: any = null;
+    try {
+      entity = await dispatch(read({ dbKey: entityKey })).unwrap();
+    } catch {
+      entity = null;
+    }
+
+    results.push({ entityKey, entity });
+  }
+
+  return results;
+};
+
+const clearEntitySpaceIds = async (
+  entities: Array<{ entityKey: string; entity: any }>,
+  dispatch: ThunkAPI["dispatch"]
+) => {
+  await Promise.all(
+    entities
+      .filter(({ entity }) => entity && typeof entity === "object")
+      .map(({ entityKey, entity }) =>
+      dispatch(
+        patch({
+          dbKey: entityKey,
+          changes: {
+            spaceId: null,
+            updatedAt: nextUpdatedAt(entity),
+          },
+        })
+      ).unwrap()
+      )
+  );
+};
+
+const deleteOwnedEntities = async (
+  ownedEntities: Array<{ entityKey: string; entity: any }>,
+  dispatch: ThunkAPI["dispatch"]
+) => {
+  for (const { entityKey } of ownedEntities) {
+    await dispatch(deleteDbKey(entityKey));
+  }
+};
+
+export const deleteSpaceAction = async (
+  input: DeleteSpaceArgs,
+  thunkAPI: ThunkAPI
+) => {
+  const { dispatch, getState } = thunkAPI;
+  const { spaceId, strategy } = resolveDeleteArgs(input);
+  const userId = getCurrentUserId(getState());
+  const spaceData = await fetchSpaceData(spaceId, dispatch);
+
+  checkOwnerPermission(spaceData, userId);
+
+  if (spaceData && strategy !== "delete-space-only") {
+    const allEntities = await listSpaceEntities(spaceData, dispatch);
+    const ownedEntities = allEntities.filter(({ entityKey, entity }) =>
+      isOwnedByUser(entityKey, entity, userId)
+    );
+    const unownedEntities = allEntities.filter(
+      ({ entityKey, entity }) => !isOwnedByUser(entityKey, entity, userId)
+    );
+
+    if (strategy === "move-owned-to-all") {
+      await clearEntitySpaceIds(allEntities, dispatch);
+    } else if (strategy === "delete-owned-content") {
+      await deleteOwnedEntities(ownedEntities, dispatch);
+      await clearEntitySpaceIds(unownedEntities, dispatch);
+    }
+  }
+
+  await deleteSpaceData(spaceId, dispatch);
+  await deleteAllMembers(spaceData, spaceId, dispatch);
+  await deleteCurrentUserMember(userId, spaceId, dispatch);
+  await clearDeletedMemberDefaultSpacePreferences(
+    [userId, ...(Array.isArray(spaceData?.members) ? spaceData.members : [])],
+    spaceId,
+    dispatch
+  );
+
+  return { spaceId, strategy };
+};

package/create/space/fetchSpaceAction.ts

@@ -0,0 +1,70 @@
+import type { SpaceId } from "../space/types";
+import type { SpaceData } from "../../app/types";
+import { createSpaceKey, normalizeSpaceId } from "../space/spaceKeys";
+import {
+  fetchAuthoritativeRemoteSpace,
+  selectSpaceRemoteAuth,
+} from "../space/spaceAccess";
+
+type FetchSpaceInput = SpaceId | { spaceId: SpaceId; fresh?: boolean };
+
+export const fetchSpaceAction = async (
+  input: FetchSpaceInput,
+  thunkAPI: any
+): Promise<{ spaceId: SpaceId; spaceData: SpaceData }> => {
+  const rawSpaceId = typeof input === "string" ? input : input?.spaceId;
+  const fresh = typeof input === "object" && input !== null ? !!input.fresh : false;
+  const { dispatch } = thunkAPI;
+
+  if (!rawSpaceId) {
+    throw new Error("spaceId is required");
+  }
+
+  // Normalize ID for fetching
+  const spaceId = normalizeSpaceId(rawSpaceId);
+  const spaceKey = createSpaceKey.space(spaceId);
+
+  if (fresh) {
+    const { token, userId, servers } = selectSpaceRemoteAuth(thunkAPI.getState());
+    if (token && userId && servers.length > 0) {
+      const remoteSpace = await fetchAuthoritativeRemoteSpace({
+        servers,
+        token,
+        userId,
+        spaceId,
+      });
+      if (remoteSpace) return { spaceId, spaceData: remoteSpace };
+      throw new Error(`Space not found: ${spaceId}`);
+    }
+  }
+
+  const readSpace = async (dbKey: string): Promise<SpaceData | null> => {
+    try {
+      const { read, readAndWait } = await import("../../database/dbSlice");
+      if (fresh) {
+        return await dispatch(readAndWait(dbKey)).unwrap();
+      }
+      return await dispatch(
+        read({
+          dbKey,
+        })
+      ).unwrap();
+    } catch {
+      return null;
+    }
+  };
+
+  let spaceData: SpaceData | null = await readSpace(spaceKey);
+
+  // If not found, try the raw ID as a fallback (maybe stored with the prefix)
+  if (!spaceData && rawSpaceId !== spaceKey) {
+    spaceData = await readSpace(rawSpaceId);
+  }
+
+  if (!spaceData) {
+    throw new Error(`Space not found: ${spaceId}`);
+  }
+
+  // Ensure returned ID is normalized
+  return { spaceId, spaceData };
+};

package/create/space/fetchSpaceSidebarStateAction.ts

@@ -0,0 +1,26 @@
+import { normalizeSpaceId } from "./spaceKeys";
+import { readStoredCollapsedCategories } from "./spaceCollapsedState";
+
+interface FetchSpaceSidebarStateResponse {
+  collapsedCategories: Record<string, boolean>;
+}
+
+export const fetchSpaceSidebarStateAction = async (
+  spaceId: string,
+  thunkAPI: any,
+): Promise<FetchSpaceSidebarStateResponse> => {
+  const { dispatch, getState } = thunkAPI;
+  const normalizedSpaceId = normalizeSpaceId(spaceId);
+  void dispatch;
+  void getState;
+
+  return {
+    collapsedCategories:
+      typeof window === "undefined"
+        ? {}
+        : readStoredCollapsedCategories(
+            normalizedSpaceId,
+            window.localStorage,
+          ),
+  };
+};

package/create/space/loadDefaultSpaceAction.ts

@@ -0,0 +1,57 @@
+import type { RootState } from "../../app/store";
+import { readDefaultSpaceIdPreference } from "../../app/settings/defaultSpacePreference";
+
+import { changeSpace } from "./spaceSlice";
+import { readSpaceIfExists } from "./resolvePreferredSpaceId";
+
+export const loadDefaultSpaceAction = async (
+  userId: string | undefined,
+  thunkAPI
+): Promise<string | null> => {
+  const dispatch = thunkAPI.dispatch;
+  const state = thunkAPI.getState() as RootState;
+
+  if (state.space.currentSpaceId) {
+    return null;
+  }
+
+  const memberSpaces = state.space.memberSpaces;
+
+  try {
+    const defaultSpaceId = await readDefaultSpaceIdPreference(dispatch, userId);
+    const spaceIdToLoad = await readSpaceIfExists(dispatch, defaultSpaceId);
+
+    if (spaceIdToLoad) {
+      await dispatch(changeSpace(spaceIdToLoad)).unwrap();
+      return spaceIdToLoad;
+    }
+
+    if (memberSpaces === null) {
+      console.warn(
+        `[Space] Skipped default-space selection for ${userId}: memberships are still loading and no readable default-space register exists.`
+      );
+      return null;
+    }
+
+    // Fall back to first readable member space when no register exists (e.g. accounts
+    // created before the register migration)
+    for (const memberSpace of memberSpaces) {
+      const fallbackId = memberSpace?.spaceId;
+      const readableId = await readSpaceIfExists(dispatch, fallbackId);
+      if (readableId) {
+        console.info(
+          `[Space] No register for ${userId}, falling back to member space: ${readableId}`
+        );
+        await dispatch(changeSpace(readableId)).unwrap();
+        return readableId;
+      }
+    }
+
+    console.warn(
+      `[Space] Skipped default-space selection for ${userId}: no readable default-space register exists.`
+    );
+    return null;
+  } catch (error) {
+    throw error;
+  }
+};

package/create/space/member/addMemberAction.ts

@@ -0,0 +1,79 @@
+import type { ULID } from "../../../app/types";
+import type { MemberRole } from "../../../app/types";
+import type { SpaceData } from "../../../app/types";
+import { selectUserId } from "../../../auth/authSlice";
+import { createSpaceKey } from "../../space/spaceKeys";
+import { read, write } from "../../../database/dbSlice";
+import { SpaceMemberWithSpaceInfo } from "../../../app/types";
+import { DataType } from "../../types";
+
+/**
+ * 添加成员到空间
+ *
+ * 说明：
+ * 1. 当前用户必须为空间现有成员，才可以添加新成员；
+ * 2. 如果成员已存在则直接报错；
+ * 3. 更新 SpaceData.members 数组，同时为新成员创建 SpaceMemberWithSpaceInfo 数据。
+ */
+export const addMemberAction = async (
+  input: { spaceId: ULID; memberId: string; role?: MemberRole },
+  thunkAPI: any
+): Promise<{ spaceId: ULID; updatedSpaceData: SpaceData }> => {
+  const { spaceId, memberId, role = MemberRole.MEMBER } = input; // 默认角色为 MEMBER
+  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");
+  }
+  // 检查当前用户是否为该空间的成员
+  if (!spaceData.members.includes(currentUserId)) {
+    throw new Error("当前用户不是空间成员，无法添加成员");
+  }
+  // 检查待添加的成员是否已存在
+  if (spaceData.members.includes(memberId)) {
+    throw new Error("成员已存在");
+  }
+
+  // 更新 SpaceData
+  const updatedSpaceData: SpaceData = {
+    ...spaceData,
+    members: [...spaceData.members, memberId],
+    updatedAt: Date.now(),
+  };
+
+  // 写入更新后的 SpaceData
+  await dispatch(
+    write({ data: updatedSpaceData, customKey: spaceKey })
+  ).unwrap();
+
+  // 创建并写入新成员的 SpaceMemberWithSpaceInfo 数据
+  const now = Date.now();
+  const spaceMemberData: SpaceMemberWithSpaceInfo = {
+    userId: memberId,
+    role: role, // 使用传入的 role，默认为 MEMBER
+    joinedAt: now,
+    updatedAt: now, // 可选字段，初始化时设置为当前时间
+    spaceId: spaceId,
+    spaceName: spaceData.name,
+    ownerId: spaceData.ownerId,
+    visibility: spaceData.visibility,
+    type: DataType.SPACE, // 添加 type 字段
+  };
+
+  const spaceMemberKey = createSpaceKey.member(memberId, spaceId);
+  await dispatch(
+    write({
+      data: spaceMemberData,
+      customKey: spaceMemberKey,
+    })
+  ).unwrap();
+
+  return { spaceId, updatedSpaceData };
+};