nolo-cli 0.1.40 → 0.1.42

package/create/space/content/updateContentCategoryAction.ts

@@ -0,0 +1,154 @@
+// 文件路径: create/space/actions/updateContentCategoryAction.ts (或你的实际路径)
+
+import type { SpaceId } from "../../space/types"; // 确认类型路径
+import type { SpaceData } from "../../../app/types";
+import { selectUserId } from "../../../auth/authSlice"; // 确认导入路径
+import { createSpaceKey } from "../../space/spaceKeys"; // 确认导入路径
+import { read, patch } from "../../../database/dbSlice"; // 确认导入路径
+import type { AppDispatch, RootState } from "../../../app/store"; // 假设 store 类型路径
+import { checkSpaceMembership } from "../utils/permissions"; // 导入权限检查函数
+// --- 导入常量 ---
+import { UNCATEGORIZED_ID } from "../../space/constants"; // 导入代表 UI 未分类容器的常量
+
+/**
+ * 异步 Action Thunk，用于更新指定内容的分类。
+ * - 如果目标是未分类区域 (通过 UNCATEGORIZED_ID 标识)，则移除内容的 categoryId 属性。
+ * - 如果目标是有效分类，则设置内容的 categoryId 为该分类 ID。
+ */
+export const updateContentCategoryAction = async (
+  // --- 修改: 输入类型明确为 string，代表目标容器 ID ---
+  //   这个 ID 可以是真实的分类 ID，也可以是 UNCATEGORIZED_ID 常量
+  input: { spaceId: SpaceId; contentKey: string; categoryId: string },
+  thunkAPI: { dispatch: AppDispatch; getState: () => RootState } // 使用明确类型
+): Promise<{ spaceId: SpaceId; updatedSpaceData: SpaceData }> => {
+  // --- 重命名 categoryId 为 targetContainerId 以更清晰地表达其含义 ---
+  const { spaceId, contentKey, categoryId: targetContainerId } = input;
+  const { dispatch, getState } = thunkAPI;
+  const state = getState();
+  const userId = selectUserId(state);
+
+  // --- 基本输入验证 ---
+  if (!userId) {
+    throw new Error("User is not logged in.");
+  }
+  if (
+    !contentKey ||
+    typeof contentKey !== "string" ||
+    contentKey.trim() === ""
+  ) {
+    throw new Error("Invalid contentKey provided.");
+  }
+  // targetContainerId 必须是字符串 (普通分类 ID 或 UNCATEGORIZED_ID)
+  if (typeof targetContainerId !== "string") {
+    // 如果允许 null/undefined，需要调整类型和后续逻辑
+    // 但基于拖拽目标通常是字符串 ID，这里强制为 string
+    throw new Error("Invalid target container ID provided (must be a string).");
+  }
+
+  const spaceKey = createSpaceKey.space(spaceId);
+  let spaceData: SpaceData | null = null;
+  try {
+    spaceData = await dispatch(read({
+      dbKey: spaceKey
+    })).unwrap();
+  } catch (readError: any) {
+    console.error(
+      `[updateContentCategoryAction] Failed to read space data for key ${spaceKey}:`,
+      readError
+    );
+    throw new Error(
+      `无法加载空间数据: ${spaceId}, 原因: ${readError.message || "未知错误"}`
+    );
+  }
+
+  // --- 权限和存在性检查 ---
+  try {
+    checkSpaceMembership(spaceData, userId); // 使用权限检查函数
+  } catch (permissionError: any) {
+    throw new Error(`权限不足，无法修改内容分类: ${permissionError.message}`);
+  }
+
+  const currentContent = spaceData?.contents?.[contentKey]; // 获取当前内容
+  if (!currentContent) {
+    console.warn(
+      `[updateContentCategoryAction] Content ${contentKey} not found in space ${spaceId}.`
+    );
+    throw new Error("Content not found");
+  }
+
+  // --- 检查目标分类的有效性 (如果不是移到未分类) ---
+  // 仅当目标不是 UNCATEGORIZED_ID 常量时，才需要验证目标分类是否存在
+  if (targetContainerId !== UNCATEGORIZED_ID) {
+    if (!spaceData.categories?.[targetContainerId]) {
+      // 目标分类不存在或无效 (值为 null)
+      console.warn(
+        `[updateContentCategoryAction] Target category ${targetContainerId} not found or invalid in space ${spaceId}. Cannot move content.`
+      );
+      throw new Error("Target category not found or is invalid");
+      // 也可以选择不抛错，直接忽略本次操作，但抛错更明确
+    }
+    // 如果目标分类有效，则继续
+  }
+  // 如果目标是 UNCATEGORIZED_ID，则无需检查分类是否存在
+
+  // --- 构造 Patch Changes 对象 (核心修改) ---
+  const now = Date.now(); // 使用 number 时间戳
+
+  // 1. 确定要在 patch 中使用的 categoryId 值
+  //    - 如果目标是未分类容器，使用 null 指令来删除属性
+  //    - 否则，使用目标容器 ID (也就是目标分类 ID)
+  const categoryIdValueForPatch =
+    targetContainerId === UNCATEGORIZED_ID ? null : targetContainerId;
+
+  // 2. 检查内容当前的 categoryId 是否真的需要改变
+  //    - 获取当前内容的 categoryId (可能是 undefined)
+  const currentCategoryId = currentContent.categoryId;
+  //    - 比较目标 patch 值与当前值
+  //    - 注意: 如果当前是 undefined 且目标 patch 值是 null，也视为不需要改变（已经是未分类）
+  let needsUpdate = true;
+  if (categoryIdValueForPatch === null && currentCategoryId === undefined) {
+    needsUpdate = false; // 已经是未分类，无需发送 patch 删除指令
+  } else if (categoryIdValueForPatch === currentCategoryId) {
+    needsUpdate = false; // 目标分类与当前分类相同
+  }
+
+  // 3. 如果确实需要更新，才构造 changes 对象
+  let changes: Partial<Pick<SpaceData, "contents" | "updatedAt">> | null = null; // 初始化为 null
+  if (needsUpdate) {
+    changes = {
+      contents: {
+        // 使用动态键更新指定的 contentKey
+        [contentKey]: {
+          // --- 修改: 使用计算出的 categoryIdValueForPatch ---
+          categoryId: categoryIdValueForPatch, // null 或 目标分类 ID
+          updatedAt: now, // 更新内容的 updatedAt
+        },
+      },
+      updatedAt: now, // 更新顶层的 updatedAt
+    };
+  } else {
+    console.log(
+      `[updateContentCategoryAction] No category change needed for ${contentKey}. Skipping patch.`
+    );
+    // 如果不需要更新，直接返回当前数据即可
+    return { spaceId, updatedSpaceData: spaceData };
+  }
+
+  // --- 执行 Patch 更新 (仅在需要更新时执行) ---
+  let updatedSpaceData: SpaceData;
+  try {
+    // 只有当 changes 不为 null 时才 dispatch patch
+    updatedSpaceData = await dispatch(
+      patch({ dbKey: spaceKey, changes: changes! }) // 使用非空断言，因为已检查
+    ).unwrap();
+  } catch (patchError: any) {
+    console.error(
+      `[updateContentCategoryAction] Failed to patch space data for key ${spaceKey}:`,
+      patchError
+    );
+    throw new Error(`更新内容分类失败: ${patchError.message || "未知错误"}`);
+  }
+
+  // --- 返回结果 ---
+  return { spaceId, updatedSpaceData };
+};

package/create/space/content/updateContentTitleAction.ts

@@ -0,0 +1,151 @@
+import type { SpaceContent, SpaceData, ULID } from "../../../app/types";
+import { createSpaceKey } from "../../space/spaceKeys";
+import { read, patch } from "../../../database/dbSlice";
+import { renameTable } from "../../../render/table/tableSlice";
+import { SEPARATOR } from "../../../database/keys";
+
+const notifyUserDataUpdated = () => {
+  if (
+    typeof window !== "undefined" &&
+    typeof window.dispatchEvent === "function" &&
+    typeof window.Event === "function"
+  ) {
+    window.dispatchEvent(new window.Event("nolo-user-data-updated"));
+  }
+};
+
+const buildContentRecordTitleChanges = (
+  content: SpaceContent,
+  title: string,
+  updatedAt: string
+) => {
+  const changes: Record<string, unknown> = { title, updatedAt };
+  if (content.type === "app") {
+    changes.name = title;
+  }
+  return changes;
+};
+
+export const updateContentTitleAction = async (
+  input: {
+    spaceId: ULID;
+    contentKey: string;
+    title: string;
+    skillSummary?: SpaceContent["skillSummary"];
+    sourceServerOrigin?: string | null;
+  },
+  thunkAPI: any
+): Promise<{ spaceId: ULID; updatedSpaceData: SpaceData }> => {
+  const { spaceId, contentKey, title, skillSummary, sourceServerOrigin } = input;
+  const { dispatch } = thunkAPI;
+
+  if (
+    !contentKey ||
+    typeof contentKey !== "string" ||
+    contentKey.trim() === ""
+  ) {
+    throw new Error("Invalid contentKey provided.");
+  }
+  if (title === undefined || title === null || typeof title !== "string") {
+    throw new Error("Invalid title provided.");
+  }
+  if (title.trim() === "") {
+    throw new Error("Title cannot be empty.");
+  }
+
+  const spaceKey = createSpaceKey.space(spaceId);
+  let spaceData: SpaceData | null = null;
+  try {
+    spaceData = await dispatch(read({
+      dbKey: spaceKey,
+      preferredServerOrigin: sourceServerOrigin,
+    })).unwrap();
+  } catch (readError) {
+    throw new Error(`无法加载空间数据: ${spaceId}`);
+  }
+
+  if (!spaceData) {
+    throw new Error("Space not found");
+  }
+
+  const content = spaceData.contents?.[contentKey];
+  if (!content) {
+    throw new Error("Content not found in space");
+  }
+
+  const trimmedTitle = title.trim();
+  const now = new Date().toISOString();
+
+  const changes = {
+    contents: {
+      [contentKey]: {
+        ...spaceData.contents[contentKey],
+        title: trimmedTitle,
+        updatedAt: now,
+        ...(skillSummary !== undefined ? { skillSummary } : {}),
+      },
+    },
+    updatedAt: now,
+  };
+
+  let updatedSpaceData: SpaceData;
+  try {
+    updatedSpaceData = await dispatch(
+      patch({
+        dbKey: spaceKey,
+        changes,
+        preferredServerOrigin: sourceServerOrigin,
+      })
+    ).unwrap();
+  } catch (patchError: any) {
+    throw new Error(`更新内容标题失败: ${patchError.message || "未知错误"}`);
+  }
+
+  // Also patch the individual content record so that sidebar "recent" items
+  // (loaded via useUserData from individual records) pick up the new title
+  // after a page refresh.  Without this, only the space's contents map is
+  // updated while the standalone record retains the stale title.
+  try {
+    await dispatch(
+      patch({
+        dbKey: contentKey,
+        changes: buildContentRecordTitleChanges(content, trimmedTitle, now),
+        preferredServerOrigin: sourceServerOrigin,
+      })
+    ).unwrap();
+    notifyUserDataUpdated();
+  } catch (contentPatchError) {
+    // Non-fatal: the space data is already updated; the individual record
+    // may not exist for some content types or the patch may fail due to
+    // permission issues. Log but don't block the title update.
+    console.warn(
+      "[updateContentTitle] Failed to sync title to individual content record:",
+      contentPatchError
+    );
+  }
+
+  // If it's a table, also sync with TableMeta
+  if (contentKey.startsWith("meta-")) {
+    const parts = contentKey.split(SEPARATOR);
+    if (parts.length >= 3) {
+      const tableId = parts[parts.length - 1];
+      const tenantId = parts.slice(1, parts.length - 1).join(SEPARATOR);
+
+      try {
+        await dispatch(
+          renameTable({
+            tenantId,
+            tableId,
+            newName: trimmedTitle,
+          })
+        ).unwrap();
+      } catch (tableError) {
+        console.error("Failed to sync title to TableMeta:", tableError);
+        // We don't throw here to avoid failing the whole space update
+      }
+    }
+  }
+
+  return { spaceId, updatedSpaceData };
+
+};

package/create/space/content/uploadAndAddFileToSpaceAction.ts

@@ -0,0 +1,98 @@
+
+import { ContentType, SpaceData } from "../../../app/types";
+import { uploadFileAction } from "../../../database/actions/upload";
+import { addContentAction } from "./addContentAction";
+import { toast } from "../../../app/utils/toast";
+import { resolveFileCategory } from "../../../app/utils/fileUtils";
+import { ulid } from "../../../database/utils/ulid";
+import { fileKey } from "../../../database/keys";
+import { selectUserId } from "../../../auth/authSlice";
+import { patch } from "../../../database/dbSlice";
+
+interface UploadAndAddFileToSpacePayload {
+    spaceId: string;
+    file: File;
+    categoryId?: string;
+}
+
+export const uploadAndAddFileToSpaceAction = async (
+    payload: UploadAndAddFileToSpacePayload,
+    thunkAPI: any
+): Promise<{ spaceId: string; updatedSpaceData: SpaceData; contentKey: string; fileId: string }> => {
+    const { spaceId, file, categoryId } = payload;
+    const { dispatch, getState } = thunkAPI;
+
+    // UserId retrieved from auth state
+    const state = getState();
+    const userId = selectUserId(state);
+
+    if (!userId) {
+        console.warn("[uploadAndAddFileToSpace] Warning: No userId found in state. Uploading as anonymous/unknown might cause issues.");
+    }
+
+    try {
+        // 生成一个确保唯一的 Key (file-userId-ulid)
+        const id = ulid();
+        const dbKey = fileKey.single(userId || "unknown", id);
+        const contentType = ContentType.FILE;
+        const fileCategory = resolveFileCategory({
+            mimeType: file.type,
+            fileName: file.name,
+        });
+
+        // 执行上传；uploadFileAction 当前只接受 file/customKey/userId。
+        const fileMetadata = await uploadFileAction(
+            { file, customKey: dbKey, userId },
+            thunkAPI
+        );
+
+        // 2. 添加到 Space Content
+        if (!fileMetadata) {
+            throw new Error("Upload failed, no metadata returned");
+        }
+
+        // 使用返回的 dbKey (file-userId-ulid) 作为 contentKey
+        const contentKey = fileMetadata.dbKey || dbKey;
+        const title = file.name;
+
+        // addContentAction is a raw async function, NOT a Redux action creator.
+        // It expects (payload, thunkAPI).
+        const result = await addContentAction({
+            spaceId,
+            contentKey,
+            title,
+            type: contentType,
+            fileCategory,
+            mimeType: file.type || undefined,
+            fileSize: Number.isFinite(file.size) ? file.size : undefined,
+            originalName: file.name,
+            categoryId,
+        }, thunkAPI);
+
+        await (dispatch as any)(
+            patch({
+                dbKey: contentKey,
+                changes: {
+                    title,
+                    spaceId,
+                    fileCategory,
+                    mimeType: file.type || undefined,
+                    fileSize: Number.isFinite(file.size) ? file.size : undefined,
+                    originalName: file.name,
+                },
+            })
+        ).unwrap();
+
+        if (typeof window !== "undefined") {
+            window.dispatchEvent(new Event("nolo-user-data-updated"));
+        }
+
+        toast.success("文件上传成功");
+        return { ...result, contentKey, fileId: fileMetadata.id };
+
+    } catch (error: any) {
+        console.error("Upload and add file error:", error);
+        toast.error(error.message || "上传文件失败");
+        throw error;
+    }
+};

package/create/space/contentKeyUtils.ts

@@ -0,0 +1,117 @@
+import { ContentType } from "../../app/types";
+import { buildAppEditorPath } from "../../app/constants/appEditor";
+import { DataType } from "../types";
+import { normalizeSpaceId } from "./spaceKeys";
+
+const ROUTABLE_KEY_PREFIXES = [
+  "dialog-",
+  "page-",
+  "meta-",
+  "file-",
+  "image-",
+  "agent-",
+  "cybot-",
+  "task-",
+] as const;
+
+const hasRoutablePrefix = (contentKey: string): boolean =>
+  ROUTABLE_KEY_PREFIXES.some((prefix) => contentKey.startsWith(prefix));
+
+export const isAppContentKey = (contentKey: string): boolean =>
+  typeof contentKey === "string" && contentKey.startsWith("app-");
+
+export const normalizeAppRouteId = (contentKey: string): string =>
+  isAppContentKey(contentKey) ? contentKey : `app-${contentKey}`;
+
+export const resolveRoutableContentKey = (
+  contentKey: string,
+  type?: string,
+  userId?: string
+): string => {
+  if (!contentKey) return contentKey;
+
+  const normalizedType = type?.toLowerCase();
+
+  if (normalizedType === ContentType.APP || normalizedType === "app") {
+    return normalizeAppRouteId(contentKey);
+  }
+
+  if (hasRoutablePrefix(contentKey)) return contentKey;
+  if (!userId) return contentKey;
+
+  if (normalizedType === DataType.DIALOG || normalizedType === ContentType.DIALOG) {
+    return `${DataType.DIALOG}-${userId}-${contentKey}`;
+  }
+
+  if (normalizedType === DataType.DOC || normalizedType === ContentType.DOC) {
+    return `${DataType.DOC}-${userId}-${contentKey}`;
+  }
+
+  // 文件和图片的 dbKey 统一使用 file-{userId}-{fileId} 格式
+  if (normalizedType === DataType.FILE || normalizedType === ContentType.FILE ||
+      normalizedType === DataType.IMAGE || normalizedType === ContentType.IMAGE) {
+    return `file-${userId}-${contentKey}`;
+  }
+
+  return contentKey;
+};
+
+export const buildScopedPagePath = (
+  pageKey: string,
+  spaceId?: string | null
+): string => {
+  if (!spaceId) return `/${pageKey}`;
+  return `/space/${normalizeSpaceId(spaceId)}/${pageKey}`;
+};
+
+export const buildRoutableContentPath = ({
+  contentKey,
+  type,
+  userId,
+  spaceId,
+}: {
+  contentKey: string;
+  type?: string;
+  userId?: string;
+  spaceId?: string | null;
+}): string =>
+  buildScopedPagePath(
+    resolveRoutableContentKey(contentKey, type, userId),
+    spaceId
+  );
+
+export const isRoutableContentActive = ({
+  contentKey,
+  type,
+  userId,
+  spaceId,
+  activePageKey,
+  currentPath,
+}: {
+  contentKey: string;
+  type?: string;
+  userId?: string | null;
+  spaceId?: string | null;
+  activePageKey?: string;
+  currentPath: string;
+}): boolean => {
+  const routeContentKey = resolveRoutableContentKey(
+    contentKey,
+    type,
+    userId ?? undefined
+  );
+
+  if (activePageKey === contentKey || activePageKey === routeContentKey) {
+    return true;
+  }
+
+  if (
+    type?.toLowerCase() === ContentType.APP ||
+    isAppContentKey(contentKey)
+  ) {
+    const appEditorPath = buildAppEditorPath(normalizeAppRouteId(contentKey), spaceId);
+    return currentPath === appEditorPath;
+  }
+
+  return false;
+};