nolo-cli 0.1.23 → 0.1.29

package/create/space/category/categoryActions.ts

@@ -0,0 +1,427 @@
+// store/space/actions/categoryActions.ts
+
+import { asyncThunkCreator, type PayloadAction } from "@reduxjs/toolkit";
+import { ulid } from "ulid";
+import type { AppDispatch, RootState } from "../../../app/store";
+import type { Category, SpaceContent, SpaceData, ULID } from "../../../app/types";
+import { selectUserId } from "../../../auth/authSlice";
+import { createSpaceKey } from "../../space/spaceKeys";
+import { patch, read } from "../../../database/dbSlice";
+import { UNCATEGORIZED_ID } from "../constants";
+import { selectCurrentSpaceId } from "../spaceSlice";
+import type { SpaceState } from "../spaceSlice";
+import { checkSpaceMembership } from "../utils/permissions";
+import {
+  normalizeCollapsedCategories,
+  writeStoredCollapsedCategories,
+} from "../spaceCollapsedState";
+
+type Create = ReturnType<typeof asyncThunkCreator<SpaceState>>;
+
+/**
+ * 创建与分类（Category）相关的所有 Reducer 和 Async Thunks
+ * @param create - 由 buildCreateSlice 提供的创建器对象
+ */
+export const createCategoryActions = (create: Create) => ({
+  // --- Regular Reducers ---
+
+  /**
+   * (新增) 从持久化存储中水合分类的折叠状态
+   */
+  hydrateCollapsedCategories: create.reducer(
+    (state: SpaceState, action: PayloadAction<Record<string, boolean>>) => {
+      state.collapsedCategories = normalizeCollapsedCategories(action.payload);
+    }
+  ),
+
+  // --- Async Thunks ---
+
+  /**
+   * 批量切换所有分类的折叠状态，并持久化到本地
+   */
+  setAllCategoriesCollapsed: create.asyncThunk(
+    async (
+      input: { spaceId?: string; collapsed: boolean },
+      thunkAPI: { dispatch: AppDispatch; getState: () => RootState }
+    ): Promise<Record<string, boolean>> => {
+      const { getState } = thunkAPI;
+      const rootState = getState();
+
+      // 优先使用传入的 spaceId，否则获取当前活动空间
+      const spaceId = input.spaceId || selectCurrentSpaceId(rootState);
+      if (!spaceId) throw new Error("无法切换折叠状态：没有活动的空间。");
+
+      // 获取当前空间的所有分类 ID（包括已删除标签以外的所有分类）
+      const { currentSpace } = rootState.space;
+      const categoryIds = currentSpace?.categories
+        ? Object.keys(currentSpace.categories)
+        : [];
+      // 始终包含“未分类”
+      categoryIds.push(UNCATEGORIZED_ID);
+
+      // 构造新的折叠状态映射
+      const collapsedCategories: Record<string, boolean> = {};
+      categoryIds.forEach((id) => {
+        collapsedCategories[id] = input.collapsed;
+      });
+
+      if (typeof window !== "undefined") {
+        writeStoredCollapsedCategories(
+          spaceId,
+          collapsedCategories,
+          window.localStorage,
+        );
+      }
+
+      return collapsedCategories;
+    },
+    {
+      fulfilled: (state, action) => {
+        // 合并返回的折叠状态，保持与持久化一致
+        state.collapsedCategories = {
+          ...state.collapsedCategories,
+          ...action.payload,
+        };
+      },
+      rejected: (state, action) => {
+        console.error("批量切换分类折叠状态失败:", action.error.message);
+      },
+    }
+  ),
+
+  /**
+   * 切换单个分类的折叠状态，并持久化存储。
+   * 直接使用当前激活的 spaceId，无需外部传入。
+   */
+  toggleCategoryCollapse: create.asyncThunk(
+    async (
+      input: { categoryId: string },
+      thunkAPI: { dispatch: AppDispatch; getState: () => RootState }
+    ): Promise<Record<string, boolean>> => {
+      const { getState } = thunkAPI;
+      const { categoryId } = input;
+      const rootState = getState();
+
+      // 获取当前空间 ID
+      const spaceId = selectCurrentSpaceId(rootState);
+      if (!spaceId) throw new Error("无法切换折叠状态：没有活动的空间。");
+      if (!categoryId) throw new Error("无效的分类ID。");
+
+      // 计算新的折叠状态
+      const defaultCollapsed = categoryId !== UNCATEGORIZED_ID;
+      const isCurrentlyCollapsed =
+        rootState.space.collapsedCategories[categoryId] ?? defaultCollapsed;
+      const newCollapsedState = !isCurrentlyCollapsed;
+      const collapsedCategories = {
+        ...rootState.space.collapsedCategories,
+        [categoryId]: newCollapsedState,
+      };
+
+      if (typeof window !== "undefined") {
+        writeStoredCollapsedCategories(
+          spaceId,
+          collapsedCategories,
+          window.localStorage,
+        );
+      }
+
+      return collapsedCategories;
+    },
+    {
+      fulfilled: (state, action) => {
+        state.collapsedCategories = {
+          ...state.collapsedCategories,
+          ...action.payload,
+        };
+      },
+      rejected: (state, action) => {
+        console.error("切换分类折叠状态失败:", action.error.message);
+      },
+    }
+  ),
+
+  /**
+   * 添加新分类
+   */
+  addCategory: create.asyncThunk(
+    async (
+      input: {
+        spaceId?: string;
+        name: string;
+        categoryId?: string;
+        order?: number;
+      },
+      thunkAPI: { dispatch: AppDispatch; getState: () => RootState }
+    ): Promise<{ spaceId: ULID; updatedSpaceData: SpaceData }> => {
+      const { spaceId: inputSpaceId, name, categoryId, order } = input;
+      const { dispatch, getState } = thunkAPI;
+      const rootState = getState();
+
+      const spaceId = inputSpaceId || selectCurrentSpaceId(rootState);
+      if (!spaceId) {
+        throw new Error("无法添加分类：未选择当前空间且未提供空间 ID。");
+      }
+      const currentUserId = selectUserId(rootState);
+      if (!currentUserId) throw new Error("User is not logged in.");
+
+      if (!name.trim()) {
+        throw new Error("无效的分类名称。");
+      }
+
+      const spaceKey = createSpaceKey.space(spaceId);
+      const spaceData: SpaceData = await dispatch(read({
+        dbKey: spaceKey
+      })).unwrap();
+      checkSpaceMembership(spaceData, currentUserId);
+
+      const newCategoryId = categoryId || ulid();
+      if (spaceData.categories?.[newCategoryId]) {
+        throw new Error(`分类 ID "${newCategoryId}" 已存在。`);
+      }
+
+      const existingValidCategories = spaceData.categories
+        ? Object.values(spaceData.categories).filter(Boolean)
+        : [];
+      const finalOrder =
+        typeof order === "number" ? order : existingValidCategories.length;
+
+      const nowISO = new Date().toISOString();
+      const newCategory: Category = {
+        name: name.trim(),
+        order: finalOrder,
+        updatedAt: nowISO,
+      };
+
+      const updatedSpaceData = await dispatch(
+        patch({
+          dbKey: spaceKey,
+          changes: {
+            categories: { [newCategoryId]: newCategory },
+            updatedAt: nowISO,
+          },
+        })
+      ).unwrap();
+
+      return { spaceId, updatedSpaceData };
+    },
+    {
+      fulfilled: (state, action) => {
+        if (state.currentSpaceId === action.payload.spaceId) {
+          state.currentSpace = action.payload.updatedSpaceData;
+        }
+      },
+    }
+  ),
+
+  /**
+    * 删除单个分类
+    */
+  deleteCategory: create.asyncThunk(
+    async (
+      input: { categoryId: string; spaceId: ULID },
+      thunkAPI: { dispatch: AppDispatch; getState: () => RootState }
+    ): Promise<{
+      spaceId: ULID;
+      updatedSpaceData: SpaceData;
+      collapsedCategories: Record<string, boolean>;
+    }> => {
+      const { categoryId, spaceId } = input;
+      const { dispatch, getState } = thunkAPI;
+      const rootState = getState();
+      const currentUserId = selectUserId(rootState);
+
+      if (!currentUserId) throw new Error("User is not logged in.");
+      if (!categoryId.trim()) throw new Error("无效的 categoryId。");
+
+      const spaceKey = createSpaceKey.space(spaceId);
+      const spaceData: SpaceData = await dispatch(read({
+        dbKey: spaceKey
+      })).unwrap();
+      checkSpaceMembership(spaceData, currentUserId);
+
+      if (!spaceData?.categories?.[categoryId]) {
+        throw new Error("指定的分类不存在或已被删除。");
+      }
+
+      const nowISO = new Date().toISOString();
+      const changes: Partial<
+        Pick<SpaceData, "categories" | "contents" | "updatedAt">
+      > = {
+        categories: { [categoryId]: null },
+        updatedAt: nowISO,
+      };
+
+      if (spaceData.contents) {
+        const contentsPatch: Record<string, Partial<SpaceContent> | null> = {};
+        let contentsChanged = false;
+        for (const key in spaceData.contents) {
+          if (spaceData.contents[key]?.categoryId === categoryId) {
+            contentsPatch[key] = {
+              categoryId: null,
+              updatedAt: nowISO,
+            };
+            contentsChanged = true;
+          }
+        }
+        if (contentsChanged) changes.contents = contentsPatch;
+      }
+
+      const updatedSpaceData = await dispatch(
+        patch({ dbKey: spaceKey, changes })
+      ).unwrap();
+
+      const collapsedCategories = { ...rootState.space.collapsedCategories };
+      delete collapsedCategories[categoryId];
+      if (typeof window !== "undefined") {
+        writeStoredCollapsedCategories(
+          spaceId,
+          collapsedCategories,
+          window.localStorage,
+        );
+      }
+
+      return { spaceId, updatedSpaceData, collapsedCategories };
+    },
+    {
+      fulfilled: (state, action) => {
+        if (state.currentSpaceId === action.payload.spaceId) {
+          state.currentSpace = action.payload.updatedSpaceData;
+          state.collapsedCategories = action.payload.collapsedCategories;
+        }
+      },
+    }
+  ),
+
+  /**
+   * 修改分类名称
+   */
+  updateCategoryName: create.asyncThunk(
+    async (
+      input: { spaceId: ULID; categoryId: string; name: string },
+      thunkAPI: { dispatch: AppDispatch; getState: () => RootState }
+    ): Promise<{ spaceId: ULID; updatedSpaceData: SpaceData }> => {
+      const { spaceId, categoryId, name } = input;
+      const { dispatch, getState } = thunkAPI;
+      const currentUserId = selectUserId(getState());
+
+      if (!currentUserId) throw new Error("User is not logged in.");
+      if (!categoryId.trim()) throw new Error("无效的 categoryId。");
+      const trimmedName = name.trim();
+      if (!trimmedName) throw new Error("分类名称不能为空或仅包含空格。");
+
+      const spaceKey = createSpaceKey.space(spaceId);
+      const spaceData: SpaceData = await dispatch(read({
+        dbKey: spaceKey
+      })).unwrap();
+      checkSpaceMembership(spaceData, currentUserId);
+
+      const existingCategory = spaceData.categories?.[categoryId];
+      if (!existingCategory) {
+        throw new Error("指定的分类不存在。");
+      }
+
+      const nowISO = new Date().toISOString();
+      const changes = {
+        categories: {
+          [categoryId]: {
+            ...existingCategory,
+            name: trimmedName,
+            updatedAt: nowISO,
+          },
+        },
+        updatedAt: nowISO,
+      };
+
+      const updatedSpaceData = await dispatch(
+        patch({ dbKey: spaceKey, changes })
+      ).unwrap();
+
+      return { spaceId, updatedSpaceData };
+    },
+    {
+      fulfilled: (state, action) => {
+        if (state.currentSpaceId === action.payload.spaceId) {
+          state.currentSpace = action.payload.updatedSpaceData;
+        }
+      },
+    }
+  ),
+
+  /**
+   * 重新排序分类
+   */
+  reorderCategories: create.asyncThunk(
+    async (
+      input: { spaceId: ULID; sortedCategoryIds: string[] },
+      thunkAPI: { dispatch: AppDispatch; getState: () => RootState }
+    ): Promise<{ spaceId: ULID; updatedSpaceData: SpaceData }> => {
+      const { spaceId, sortedCategoryIds } = input;
+      const { dispatch, getState } = thunkAPI;
+      const stateRoot = getState();
+
+      const currentUserId = selectUserId(stateRoot);
+      if (!currentUserId) {
+        throw new Error("User is not logged in.");
+      }
+      if (!Array.isArray(sortedCategoryIds)) {
+        throw new Error(
+          "Invalid sortedCategoryIds provided: must be an array."
+        );
+      }
+
+      const spaceKey = createSpaceKey.space(spaceId);
+      const spaceData: SpaceData = await dispatch(read({
+        dbKey: spaceKey
+      })).unwrap();
+      checkSpaceMembership(spaceData, currentUserId);
+
+      if (
+        !spaceData.categories ||
+        Object.keys(spaceData.categories).length === 0
+      ) {
+        return { spaceId, updatedSpaceData: spaceData };
+      }
+
+      const nowISO = new Date().toISOString();
+      const currentCategories = spaceData.categories;
+      const updatedCategoriesChanges: Record<string, Category | null> = {};
+      let hasValidChanges = false;
+
+      sortedCategoryIds.forEach((catId, index) => {
+        const existingCategory = currentCategories[catId];
+        if (existingCategory) {
+          updatedCategoriesChanges[catId] = {
+            ...existingCategory,
+            order: index,
+            updatedAt: nowISO,
+          };
+          if (existingCategory.order !== index) {
+            hasValidChanges = true;
+          }
+        }
+      });
+
+      if (!hasValidChanges) {
+        return { spaceId, updatedSpaceData: spaceData };
+      }
+
+      const changes = {
+        categories: updatedCategoriesChanges,
+        updatedAt: nowISO,
+      };
+
+      const updatedSpaceData = await dispatch(
+        patch({ dbKey: spaceKey, changes })
+      ).unwrap();
+
+      return { spaceId, updatedSpaceData };
+    },
+    {
+      fulfilled: (state, action) => {
+        if (state.currentSpaceId === action.payload.spaceId) {
+          state.currentSpace = action.payload.updatedSpaceData;
+        }
+      },
+    }
+  ),
+});

package/create/space/changeSpaceAction.ts

@@ -0,0 +1,36 @@
+import { normalizeSpaceId } from "./spaceKeys";
+import { SpaceData } from "../../app/types";
+import { fetchSpaceSidebarStateAction } from "./fetchSpaceSidebarStateAction";
+import { fetchSpaceAction } from "./fetchSpaceAction";
+
+interface ChangeSpaceResponse {
+  spaceId: string;
+  spaceData: SpaceData;
+  sidebarState: { collapsedCategories: Record<string, boolean> };
+}
+
+export const changeSpaceAction = async (
+  spaceId: string,
+  thunkAPI: any,
+): Promise<ChangeSpaceResponse> => {
+  const normalizedSpaceId = normalizeSpaceId(spaceId);
+
+  const results = await Promise.allSettled([
+    fetchSpaceAction({ spaceId: normalizedSpaceId, fresh: true }, thunkAPI),
+    fetchSpaceSidebarStateAction(normalizedSpaceId, thunkAPI),
+  ]);
+
+  const spaceResult = results[0];
+  if (spaceResult.status === "rejected" || !spaceResult.value?.spaceData) {
+    throw new Error("空间不存在或加载失败");
+  }
+  const spaceData = spaceResult.value.spaceData as SpaceData;
+
+  let sidebarState = { collapsedCategories: {} };
+  const sidebarStateResult = results[1];
+  if (sidebarStateResult.status === "fulfilled") {
+    sidebarState = sidebarStateResult.value;
+  }
+
+  return { spaceId: normalizedSpaceId, spaceData, sidebarState };
+};

package/create/space/constants.ts

@@ -0,0 +1,8 @@
+// 文件路径: create/space/constants.ts (或你的实际路径)
+
+/**
+ * 代表“未分类”区域在 UI 拖拽交互中的唯一标识符。
+ * 注意：这 *不是* 存储在 SpaceContent.categoryId 中的值。
+ * 当内容未分类时，其 categoryId 属性会缺失或为 undefined。
+ */
+export const UNCATEGORIZED_ID = "__uncategorized_container__";

package/create/space/content/addContentAction.ts

@@ -0,0 +1,116 @@
+// 文件路径: create/space/actions/addContentAction.ts
+
+import type { SpaceId } from "../../space/types";
+import type { SpaceData, SpaceContent, ContentType, FileCategory } from "../../../app/types";
+import { selectUserId } from "../../../auth/authSlice";
+import { createSpaceKey } from "../../space/spaceKeys";
+import { read, patch } from "../../../database/dbSlice";
+import { checkSpaceMembership } from "../utils/permissions";
+import { UNCATEGORIZED_ID } from "../../space/constants";
+
+export interface AddContentRequest {
+  title: string;
+  type: ContentType;
+  contentKey: string;
+  fileCategory?: FileCategory;
+  mimeType?: string;
+  fileSize?: number;
+  originalName?: string;
+  categoryId?: string;
+  pinned?: boolean;
+  order?: number;
+  triggerType?: string;
+  skillSummary?: SpaceContent["skillSummary"];
+}
+
+export const addContentAction = async (
+  input: AddContentRequest & { spaceId: SpaceId },
+  thunkAPI: { dispatch: any; getState: () => any }
+): Promise<{ spaceId: SpaceId; updatedSpaceData: SpaceData }> => {
+  const {
+    spaceId,
+    title,
+    type,
+    contentKey,
+    fileCategory,
+    mimeType,
+    fileSize,
+    originalName,
+    categoryId: rawCategoryId,
+    pinned = false,
+    order,
+    triggerType,
+    skillSummary,
+  } = input;
+
+  const { dispatch, getState } = thunkAPI;
+  const userId = selectUserId(getState());
+
+  // 基本输入验证
+  if (!userId) throw new Error("User is not logged in.");
+  if (!contentKey || typeof contentKey !== "string" || contentKey.trim() === "")
+    throw new Error("Invalid contentKey provided.");
+  if (!title || typeof title !== "string" || title.trim() === "")
+    throw new Error("Invalid or empty title provided.");
+  if (!type || typeof type !== "string")
+    throw new Error("Invalid content type provided.");
+
+  // 读取 Space 数据
+  const spaceKey = createSpaceKey.space(spaceId);
+  const spaceData = await dispatch(read({
+    dbKey: spaceKey
+  })).unwrap();
+
+  // 权限检查
+  checkSpaceMembership(spaceData, userId);
+
+  // 检查 Content Key 是否已存在
+  if (spaceData.contents && spaceData.contents[contentKey]) {
+    throw new Error(`内容键 "${contentKey}" 已存在。`);
+  }
+
+  // 确定最终用于存储的 categoryId
+  let categoryIdForStorage: string | undefined;
+  if (
+    rawCategoryId &&
+    rawCategoryId !== "" &&
+    rawCategoryId !== UNCATEGORIZED_ID
+  ) {
+    if (spaceData.categories?.[rawCategoryId]) {
+      categoryIdForStorage = rawCategoryId;
+    }
+  }
+
+  // 构造新内容对象
+  const now = Date.now();
+  const newSpaceContent: SpaceContent = {
+    title: title.trim(),
+    type,
+    contentKey,
+    ...(fileCategory !== undefined ? { fileCategory } : {}),
+    ...(mimeType !== undefined ? { mimeType } : {}),
+    ...(fileSize !== undefined ? { fileSize } : {}),
+    ...(originalName !== undefined ? { originalName } : {}),
+    ...(categoryIdForStorage !== undefined && {
+      categoryId: categoryIdForStorage,
+    }),
+    pinned,
+    createdAt: now,
+    updatedAt: now,
+    ...(order !== undefined && typeof order === "number" && { order }),
+    ...(triggerType !== undefined && { triggerType }),
+    ...(skillSummary !== undefined ? { skillSummary } : {}),
+  };
+
+  // 准备并执行 Patch 更新
+  const changes = {
+    contents: { [contentKey]: newSpaceContent },
+    updatedAt: now,
+  };
+
+  const updatedSpaceData = await dispatch(
+    patch({ dbKey: spaceKey, changes })
+  ).unwrap();
+
+  return { spaceId, updatedSpaceData };
+};

package/create/space/content/contentThunks.ts

@@ -0,0 +1,90 @@
+import { asyncThunkCreator } from "@reduxjs/toolkit";
+import { toast } from "../../../app/utils/toast";
+import type { SpaceState } from "../types";
+import { addContentAction } from "./addContentAction";
+import { deleteContentFromSpaceAction } from "./deleteContentFromSpaceAction";
+import { moveContentAction } from "./moveContentAction";
+import { updateContentTitleAction } from "./updateContentTitleAction";
+import { updateContentCategoryAction } from "./updateContentCategoryAction";
+import { deleteMultipleContentAction } from "./deleteMultipleContentAction"; // <-- 新增: 导入批量删除 Action
+import { uploadAndAddFileToSpaceAction } from "./uploadAndAddFileToSpaceAction";
+
+type Create = ReturnType<typeof asyncThunkCreator<SpaceState>>;
+
+/**
+ * 创建与内容相关的 Async Thunks
+ * @param create - 由 buildCreateSlice 提供的创建器对象
+ */
+export const createContentThunks = (create: Create) => ({
+  addContentToSpace: create.asyncThunk(addContentAction, {
+    fulfilled: (state, action) => {
+      const { spaceId, updatedSpaceData } = action.payload;
+      if (state.currentSpaceId === spaceId) {
+        state.currentSpace = updatedSpaceData;
+      }
+    },
+  }),
+
+  moveContentToSpace: create.asyncThunk(moveContentAction, {
+    fulfilled: (state, action) => {
+      const {
+        sourceSpaceId,
+        updatedSourceSpaceData,
+        targetSpaceId,
+        updatedTargetSpaceData,
+      } = action.payload;
+      if (state.currentSpaceId === sourceSpaceId && updatedSourceSpaceData) {
+        state.currentSpace = updatedSourceSpaceData;
+      }
+      if (state.currentSpaceId === targetSpaceId && updatedTargetSpaceData) {
+        state.currentSpace = updatedTargetSpaceData;
+      }
+    },
+  }),
+
+  deleteContentFromSpace: create.asyncThunk(deleteContentFromSpaceAction, {
+    fulfilled: (state, action) => {
+      const { spaceId, updatedSpaceData } = action.payload;
+      if (spaceId === state.currentSpaceId) {
+        state.currentSpace = updatedSpaceData;
+      }
+    },
+  }),
+
+  // --- 新增: 批量删除内容的 Thunk ---
+  deleteMultipleContent: create.asyncThunk(deleteMultipleContentAction, {
+    fulfilled: (state, action) => {
+      if (state.currentSpaceId === action.payload.spaceId) {
+        state.currentSpace = action.payload.updatedSpaceData;
+      }
+    },
+  }),
+
+  uploadAndAddFileToSpace: create.asyncThunk(uploadAndAddFileToSpaceAction, {
+    fulfilled: (state, action) => {
+      if (state.currentSpaceId === action.payload.spaceId) {
+        state.currentSpace = action.payload.updatedSpaceData;
+      }
+    }
+  }),
+  // --- 结束新增 ---
+
+  updateContentTitle: create.asyncThunk(updateContentTitleAction, {
+    fulfilled: (state, action) => {
+      if (state.currentSpaceId === action.payload.spaceId) {
+        state.currentSpace = action.payload.updatedSpaceData;
+      }
+    },
+    rejected: (_state, action) => {
+      toast.error(action.error.message || "标题保存失败");
+    },
+  }),
+
+  updateContentCategory: create.asyncThunk(updateContentCategoryAction, {
+    fulfilled: (state, action) => {
+      if (state.currentSpaceId === action.payload.spaceId) {
+        state.currentSpace = action.payload.updatedSpaceData;
+      }
+    },
+  }),
+});