nolo-cli 0.1.40 → 0.1.41

package/create/space/spaceAccess.ts

@@ -0,0 +1,182 @@
+import type { SpaceData, SpaceMemberWithSpaceInfo } from "../../app/types";
+import { getIsDesktopApp } from "../../app/utils/env";
+import { createSpaceKey, normalizeSpaceId } from "../space/spaceKeys";
+import { fetchFromServer } from "../../database/actions/common";
+import { NOLO_CLUSTER_SERVERS, normalizeKnownServerOrigin } from "../../database/config";
+import { isTombstoneRecord } from "../../database/tombstones";
+
+export interface SpaceRemoteAuth {
+  token: string | null;
+  userId: string | null;
+  servers: string[];
+}
+
+export interface RemoteMembershipFetchResult {
+  ok: boolean;
+  server?: string;
+  memberships: SpaceMemberWithSpaceInfo[];
+}
+
+const normalizeServerOrigin = (server: unknown): string | null => {
+  return normalizeKnownServerOrigin(server);
+};
+
+const isLocalServerOrigin = (server: string): boolean =>
+  /^https?:\/\/(?:localhost|127\.0\.0\.1|0\.0\.0\.0|nolotus\.local)(?::\d+)?$/i.test(server);
+
+const resolveSpaceRemoteServers = (state: any): string[] => {
+  const currentServer = normalizeServerOrigin(state?.settings?.currentServer);
+  const normalized = [
+    currentServer,
+    ...(Array.isArray(state?.settings?.syncServers)
+      ? state.settings.syncServers
+      : []),
+  ]
+    .map(normalizeServerOrigin)
+    .filter((server): server is string => !!server);
+
+  if (!getIsDesktopApp()) {
+    return Array.from(new Set(normalized));
+  }
+
+  const remoteServers = normalized.filter((server) => !isLocalServerOrigin(server));
+  if (currentServer && isLocalServerOrigin(currentServer)) {
+    return Array.from(new Set([...NOLO_CLUSTER_SERVERS, ...remoteServers]));
+  }
+  if (remoteServers.length === 0) {
+    remoteServers.push(...NOLO_CLUSTER_SERVERS);
+  }
+
+  return Array.from(new Set(remoteServers));
+};
+
+export const selectSpaceRemoteAuth = (state: any): SpaceRemoteAuth => ({
+  token: state?.auth?.currentToken ?? null,
+  userId: state?.auth?.currentUser?.userId ?? null,
+  servers: resolveSpaceRemoteServers(state),
+});
+
+export const spaceListsUser = (spaceData: any, userId: string): boolean => {
+  if (!spaceData || isTombstoneRecord(spaceData)) return false;
+  if (spaceData.ownerId === userId) return true;
+  return Array.isArray(spaceData.members) && spaceData.members.includes(userId);
+};
+
+export const membershipBelongsToUser = (
+  membership: SpaceMemberWithSpaceInfo,
+  userId: string
+): boolean => !membership.userId || membership.userId === userId;
+
+export const fetchRemoteUserSpaceMemberships = async (
+  server: string,
+  token: string | null,
+  userId: string,
+  timeoutMs = 5000
+): Promise<RemoteMembershipFetchResult> => {
+  if (!token) return { ok: false, memberships: [] };
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(`${server}/rpc/getUserSpaceMemberships`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ userId }),
+      signal: controller.signal,
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      console.error(
+        `Failed to fetch memberships from ${server}: ${response.statusText}`
+      );
+      return { ok: false, memberships: [] };
+    }
+    const data = await response.json();
+    return {
+      ok: true,
+      server,
+      memberships: Array.isArray(data) ? data : [],
+    };
+  } catch (error) {
+    clearTimeout(timeoutId);
+    console.error(`Error fetching memberships from ${server}:`, error);
+    return { ok: false, memberships: [] };
+  }
+};
+
+export const fetchRemoteSpace = async (
+  server: string,
+  token: string | null,
+  spaceId: string
+): Promise<SpaceData | null> => {
+  try {
+    const space = await fetchFromServer(
+      server,
+      createSpaceKey.space(normalizeSpaceId(spaceId)),
+      token ?? undefined
+    );
+    return space && typeof space === "object" ? (space as SpaceData) : null;
+  } catch {
+    return null;
+  }
+};
+
+export const hasActiveRemoteMembership = async (
+  server: string,
+  token: string,
+  userId: string,
+  spaceId: string
+): Promise<boolean> => {
+  const result = await fetchRemoteUserSpaceMemberships(server, token, userId);
+  if (!result.ok) return false;
+  const normalizedSpaceId = normalizeSpaceId(spaceId);
+  return result.memberships.some((membership) => {
+    const membershipSpaceId =
+      typeof membership?.spaceId === "string"
+        ? normalizeSpaceId(membership.spaceId)
+        : "";
+    return (
+      membershipSpaceId === normalizedSpaceId &&
+      membershipBelongsToUser(membership, userId) &&
+      !isTombstoneRecord(membership)
+    );
+  });
+};
+
+export const fetchAuthoritativeRemoteSpace = async ({
+  servers,
+  token,
+  userId,
+  spaceId,
+}: {
+  servers: string[];
+  token: string;
+  userId: string;
+  spaceId: string;
+}): Promise<SpaceData | null> => {
+  const normalizedSpaceId = normalizeSpaceId(spaceId);
+  for (const server of servers) {
+    const space = await fetchRemoteSpace(server, token, normalizedSpaceId);
+    if (!space) continue;
+    if (!spaceListsUser(space, userId)) {
+      throw new Error(`Current user is not a member of space: ${normalizedSpaceId}`);
+    }
+    if (space.ownerId !== userId) {
+      const hasMembership = await hasActiveRemoteMembership(
+        server,
+        token,
+        userId,
+        normalizedSpaceId
+      );
+      if (!hasMembership) {
+        throw new Error(
+          `Current user has no active membership for space: ${normalizedSpaceId}`
+        );
+      }
+    }
+    return space;
+  }
+  return null;
+};

package/create/space/spaceCollapsedState.ts

@@ -0,0 +1,54 @@
+import { UNCATEGORIZED_ID } from "./constants";
+
+type StorageLike = Pick<Storage, "getItem" | "setItem">;
+
+const SPACE_COLLAPSE_STORAGE_PREFIX = "space-collapsed-categories:";
+
+export const normalizeCollapsedCategories = (
+  value: unknown,
+): Record<string, boolean> => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+
+  const entries = Object.entries(value).filter(
+    ([key, collapsed]) => typeof key === "string" && typeof collapsed === "boolean",
+  );
+  return Object.fromEntries(entries);
+};
+
+const storageKeyForSpace = (spaceId: string) =>
+  `${SPACE_COLLAPSE_STORAGE_PREFIX}${spaceId}`;
+
+export const readStoredCollapsedCategories = (
+  spaceId: string,
+  storage: StorageLike | null | undefined,
+): Record<string, boolean> => {
+  if (!spaceId || !storage) return {};
+
+  try {
+    const raw = storage.getItem(storageKeyForSpace(spaceId));
+    if (!raw) return { [UNCATEGORIZED_ID]: false };
+    return normalizeCollapsedCategories(JSON.parse(raw));
+  } catch (error) {
+    console.warn("[Space] 读取分类折叠状态失败:", error);
+    return {};
+  }
+};
+
+export const writeStoredCollapsedCategories = (
+  spaceId: string,
+  collapsedCategories: Record<string, boolean>,
+  storage: StorageLike | null | undefined,
+) => {
+  if (!spaceId || !storage) return;
+
+  try {
+    storage.setItem(
+      storageKeyForSpace(spaceId),
+      JSON.stringify(normalizeCollapsedCategories(collapsedCategories)),
+    );
+  } catch (error) {
+    console.warn("[Space] 保存分类折叠状态失败:", error);
+  }
+};

package/create/space/spaceKeys.ts

@@ -0,0 +1,65 @@
+const SEPARATOR = "-";
+const SPACE_PREFIX = "space";
+const SPACE_PREFIX_WITH_SEPARATOR = `${SPACE_PREFIX}${SEPARATOR}`;
+
+export const normalizeSpaceId = (spaceId: string) => {
+  if (!spaceId) return spaceId;
+  return spaceId.startsWith(SPACE_PREFIX_WITH_SEPARATOR)
+    ? spaceId.slice(SPACE_PREFIX_WITH_SEPARATOR.length)
+    : spaceId;
+};
+
+export const createSpaceKey = {
+  // 空间基础信息的key
+  space: (spaceId: string) => {
+    return [SPACE_PREFIX, normalizeSpaceId(spaceId)].join(SEPARATOR);
+  },
+
+  // 空间成员的key
+  member: (userId: string, spaceId: string) => {
+    return [SPACE_PREFIX, "member", userId, normalizeSpaceId(spaceId)].join(
+      SEPARATOR
+    );
+  },
+
+  // 查询用户所在的所有空间的范围
+  memberRange: (userId: string) => {
+    return {
+      start: [SPACE_PREFIX, "member", userId, ""].join(SEPARATOR),
+      end: [SPACE_PREFIX, "member", userId, "\uffff"].join(SEPARATOR),
+    };
+  },
+
+  /**
+   * 预留：未来若出现“按用户、按空间、且必须跨设备同步”的空间级偏好，
+   * 统一使用这个 key family。当前产品主链不要依赖它。
+   */
+  setting: (userId: string, spaceId: string) => {
+    return [SPACE_PREFIX, "setting", userId, normalizeSpaceId(spaceId)].join(
+      SEPARATOR
+    );
+  },
+
+  /**
+   * 预留：未来如确实需要批量读取空间级远端偏好，再使用这个范围。
+   */
+  settingRange: (userId: string) => {
+    return {
+      start: [SPACE_PREFIX, "setting", userId, ""].join(SEPARATOR),
+      end: [SPACE_PREFIX, "setting", userId, "\uffff"].join(SEPARATOR),
+    };
+  },
+
+  // 从成员key中提取空间key
+  spaceFromMember: (memberKey: string) => {
+    const parts = memberKey.split(SEPARATOR);
+    const spaceId = parts[parts.length - 1];
+    return [SPACE_PREFIX, spaceId].join(SEPARATOR);
+  },
+
+  // 从成员key中提取空间ID
+  spaceIdFromMember: (memberKey: string) => {
+    const parts = memberKey.split(SEPARATOR);
+    return parts[parts.length - 1];
+  },
+};

package/create/space/spaceSlice.ts

@@ -0,0 +1,328 @@
+import type { RootState } from "../../app/store";
+import { asyncThunkCreator, buildCreateSlice, createSelector } from "@reduxjs/toolkit";
+import { selectEntities } from "../../database/dbSlice";
+
+import { MemberRole, type SpaceContent, type SpaceMemberWithSpaceInfo } from "../../app/types";
+
+import { createCategoryActions } from "./category/categoryActions";
+import { createContentThunks } from "./content/contentThunks";
+import { createMemberThunks } from "./member/memberThunks";
+import { createSpaceThunks } from "./spaceThunks";
+import { SpaceState, type SpaceViewMode } from "./types";
+import { UNCATEGORIZED_ID } from "./constants";
+
+import { createSpaceKey } from "./spaceKeys";
+
+const createSliceWithThunks = buildCreateSlice({
+  creators: { asyncThunk: asyncThunkCreator },
+});
+
+const VIEW_MODE_STORAGE_KEY = "nolo-space-view-mode";
+
+const readStoredViewMode = (): SpaceViewMode => {
+  if (typeof window === "undefined") return "all";
+  try {
+    const stored = window.localStorage.getItem(VIEW_MODE_STORAGE_KEY);
+    return stored === "categories" ? "categories" : "all";
+  } catch {
+    return "all";
+  }
+};
+
+const initialState: SpaceState = {
+  currentSpaceId: null,
+  currentSpace: null,
+  memberSpaces: null,
+  loading: false,
+  initialized: false,
+  collapsedCategories: {},
+  viewMode: readStoredViewMode(),
+  dialogStatuses: {},
+  dialogEventTimestamps: {},
+  dialogTitles: {},
+  // 第一层网页体验：对话切走后仍可在 sidebar 感知其运行中/已完成。
+  // 多窗口/多 tab 的已读同步语义暂不在这里定义，等桌面端阶段统一设计。
+  unreadDialogIds: {},
+};
+
+const getSpaceUpdatedAt = (space: any): number => {
+  if (!space) return 0;
+  const value = space.updatedAt;
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string") {
+    const ts = Date.parse(value);
+    return Number.isFinite(ts) ? ts : 0;
+  }
+  return 0;
+};
+
+const nextUpdatedAt = (prev?: number | string): number => {
+  const prevTs =
+    typeof prev === "number"
+      ? prev
+      : typeof prev === "string"
+        ? Date.parse(prev) || 0
+        : 0;
+  return Math.max(Date.now(), prevTs + 1);
+};
+
+const getMembershipUpdatedAt = (space: any): number => {
+  if (!space) return 0;
+  const value =
+    space.spaceUpdatedAt ??
+    space.memberUpdatedAt ??
+    space.updatedAt ??
+    space.createdAt ??
+    space.joinedAt;
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string") {
+    const ts = Date.parse(value);
+    return Number.isFinite(ts) ? ts : 0;
+  }
+  return 0;
+};
+
+export const dedupeMemberSpacesById = <T extends { spaceId: string }>(
+  memberSpaces: T[]
+): T[] => {
+  const membershipMap = new Map<string, T>();
+  memberSpaces.forEach((space) => {
+    const prev = membershipMap.get(space.spaceId);
+    if (!prev || getMembershipUpdatedAt(space) >= getMembershipUpdatedAt(prev)) {
+      membershipMap.set(space.spaceId, space);
+    }
+  });
+  return Array.from(membershipMap.values());
+};
+
+const spaceSlice = createSliceWithThunks({
+  name: "space",
+  initialState,
+  reducers: (create) => ({
+    ...createSpaceThunks(create),
+    ...createCategoryActions(create),
+    ...createContentThunks(create),
+    ...createMemberThunks(create),
+
+    /** 重置 space 状态（切换用户时调用），清空旧用户数据 */
+    resetSpace: create.reducer((state) => {
+      state.currentSpaceId = null;
+      state.currentSpace = null;
+      state.memberSpaces = null;
+      state.collapsedCategories = {};
+      state.viewMode = "all";
+      state.initialized = false;
+      state.loading = false;
+      state.dialogStatuses = {};
+      state.dialogEventTimestamps = {};
+      state.dialogTitles = {};
+      state.unreadDialogIds = {};
+    }),
+
+    /** 切换侧边栏视图模式：全部 vs 分类 */
+    setViewMode: create.reducer<SpaceViewMode>((state, action) => {
+      state.viewMode = action.payload;
+    }),
+
+    /** 用本地缓存先恢复空间列表，远端校验完成后再由 fetchUserSpaceMemberships.fulfilled 覆盖。 */
+    hydrateMemberSpacesFromLocal: create.reducer<SpaceMemberWithSpaceInfo[]>(
+      (state, action) => {
+        if (state.memberSpaces !== null || action.payload.length === 0) return;
+        state.memberSpaces = dedupeMemberSpacesById(action.payload);
+      }
+    ),
+
+    /** 进入某个对话后清除其未读提示。
+     * 当前阶段只做“网页端切换不停止”的第一层体验：
+     * - 侧边栏能看到后台对话 done/failed 后有未读点
+     * - 真正的跨窗口/多 tab 已读同步，留到桌面端阶段再设计
+     */
+    markDialogRead: create.reducer<{ dialogId: string }>((state, action) => {
+      delete state.unreadDialogIds[action.payload.dialogId];
+    }),
+
+    /** 处理来自 SSE 的 space 实时事件，直接 patch Redux state，无需 re-fetch */
+    applySpaceEvent: create.reducer<{
+      type: string;
+      dialogId?: string;
+      dialogKey?: string;
+      title?: string;
+      status?: string;
+    }>((state, action) => {
+      const ev = action.payload;
+
+      if (ev.type === "dialog.created" && ev.dialogKey && ev.dialogId && ev.title) {
+        // 追加到当前 space 的 contents（侧边栏立即可见）
+        const now = nextUpdatedAt(state.dialogEventTimestamps[ev.dialogId]);
+        if (state.currentSpace) {
+          if (!state.currentSpace.contents) {
+            state.currentSpace.contents = {};
+          }
+          state.currentSpace.contents[ev.dialogKey] = {
+            title: ev.title,
+            type: "dialog" as any,
+            contentKey: ev.dialogKey,
+            pinned: false,
+            createdAt: now,
+            updatedAt: now,
+          };
+          state.currentSpace.updatedAt = now;
+        }
+        state.dialogStatuses[ev.dialogId] = "running";
+        state.dialogEventTimestamps[ev.dialogId] = now;
+        state.dialogTitles[ev.dialogId] = ev.title;
+        delete state.unreadDialogIds[ev.dialogId];
+      }
+
+      if (ev.type === "dialog.done" && ev.dialogId) {
+        state.dialogStatuses[ev.dialogId] = "done";
+        state.dialogEventTimestamps[ev.dialogId] = nextUpdatedAt(
+          state.dialogEventTimestamps[ev.dialogId]
+        );
+        state.unreadDialogIds[ev.dialogId] = true;
+      }
+
+      if (ev.type === "dialog.failed" && ev.dialogId) {
+        state.dialogStatuses[ev.dialogId] = "failed";
+        state.dialogEventTimestamps[ev.dialogId] = nextUpdatedAt(
+          state.dialogEventTimestamps[ev.dialogId]
+        );
+        state.unreadDialogIds[ev.dialogId] = true;
+      }
+    }),
+  }),
+});
+
+export const {
+  toggleCategoryCollapse,
+  setAllCategoriesCollapsed,
+  changeSpace,
+  addSpace,
+  deleteSpace,
+  updateSpace,
+  loadDefaultSpace,
+  fetchSpace,
+  addCategory,
+  deleteCategory,
+  updateCategoryName,
+  reorderCategories,
+  addContentToSpace,
+  moveContentToSpace,
+  deleteContentFromSpace,
+  deleteMultipleContent,
+  updateContentTitle,
+  updateContentCategory,
+  uploadAndAddFileToSpace,
+  fetchUserSpaceMemberships,
+  addMember,
+  removeMember,
+  fixSpace,
+  fetchSpaceSidebarState,
+  applySpaceEvent,
+  markDialogRead,
+  resetSpace,
+  setViewMode,
+  hydrateMemberSpacesFromLocal,
+} = spaceSlice.actions;
+
+const selectSpaceState = (state: RootState) => state.space;
+
+export const selectCurrentSpaceId = createSelector(
+  selectSpaceState,
+  (space) => space.currentSpaceId
+);
+
+export const selectCurrentSpace = createSelector(
+  [
+    selectSpaceState,
+    (state: RootState) => {
+      const spaceState = state.space;
+      if (!spaceState?.currentSpaceId) return undefined;
+      const dbKey = createSpaceKey.space(spaceState.currentSpaceId);
+      return selectEntities(state)[dbKey];
+    },
+  ],
+  (space, spaceEntity) => {
+    if (!space.currentSpaceId) return null;
+    if (!space.currentSpace) return spaceEntity || null;
+    if (!spaceEntity) return space.currentSpace;
+    return getSpaceUpdatedAt(spaceEntity) > getSpaceUpdatedAt(space.currentSpace)
+      ? spaceEntity
+      : space.currentSpace;
+  }
+);
+
+export const selectAllMemberSpaces = createSelector(
+  selectSpaceState,
+  (space) => {
+    const memberSpaces = dedupeMemberSpacesById(space.memberSpaces || []);
+    return [...memberSpaces].sort((a, b) => {
+      return getMembershipUpdatedAt(b) - getMembershipUpdatedAt(a);
+    });
+  }
+);
+
+export const selectOwnedMemberSpaces = createSelector(
+  selectAllMemberSpaces,
+  (memberSpaces) =>
+    memberSpaces.filter((space) => space.role === MemberRole.OWNER)
+);
+
+export interface CrossSpaceContentItem extends SpaceContent {
+  spaceId: string;
+  spaceName: string;
+}
+
+export const selectSpaceLoading = createSelector(
+  selectSpaceState,
+  (space) => space.loading
+);
+
+export const selectSpaceInitialized = createSelector(
+  selectSpaceState,
+  (space) => space.initialized
+);
+
+export const selectCollapsedCategories = createSelector(
+  selectSpaceState,
+  (space) => space.collapsedCategories
+);
+
+export const selectIsCategoryCollapsed = (categoryId: string) =>
+  createSelector(
+    selectCollapsedCategories,
+    (collapsed) => collapsed[categoryId] ?? categoryId !== UNCATEGORIZED_ID
+  );
+
+export const selectDialogStatuses = createSelector(
+  selectSpaceState,
+  (space) => space.dialogStatuses ?? {}
+);
+
+export const selectDialogEventTimestamps = createSelector(
+  selectSpaceState,
+  (space) => space.dialogEventTimestamps ?? {}
+);
+
+export const selectDialogTitles = createSelector(
+  selectSpaceState,
+  (space) => space.dialogTitles ?? {}
+);
+
+export const selectDialogStatus = (dialogId: string) =>
+  createSelector(selectDialogStatuses, (statuses) => statuses[dialogId]);
+
+export const selectUnreadDialogIds = createSelector(
+  selectSpaceState,
+  (space) => space.unreadDialogIds ?? {}
+);
+
+export const selectIsDialogUnread = (dialogId: string) =>
+  createSelector(selectUnreadDialogIds, (unreadMap) => unreadMap[dialogId] === true);
+
+export const selectViewMode = createSelector(
+  selectSpaceState,
+  (space) => space.viewMode
+);
+
+export default spaceSlice.reducer;