nolo-cli 0.1.44 → 0.1.46

package/create/space/deleteSpaceAction.ts

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

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

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

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

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