nolo-cli 0.1.12 → 0.1.14

package/database/actions/remove.ts

@@ -0,0 +1,94 @@
+// 文件路径: src/database/actions/delete.ts
+
+import type { AppThunkApi } from "app/store";
+import { getRuntimeServerContext } from "database/runtimeServerContext";
+
+import { fetchFromClientDb } from "./common";
+import { deleteFileFromIndexedDb } from "../fileStorage";
+import {
+  scheduleDeleteReplication,
+} from "./replication";
+import { buildTombstoneRecord } from "../tombstones";
+
+/**
+ * removeAction:
+ * 1. 先删除本地 IndexedDB 中的记录（如果存在）
+ * 2. 再异步并行通知所有远程服务器删除该记录
+ *
+ * - 服务器列表来源：
+ *   - 当前服务器：settings.currentServer
+ *   - 备份服务器：settings.syncServers
+ *   - getAllServers 负责去重 + 离线检测（offline 时返回 []）
+ */
+export const removeAction = async (
+  payload: string | { dbKey: string; preferredServerOrigin?: string | null },
+  thunkApi: AppThunkApi
+): Promise<{ dbKey: string }> => {
+  const { db: clientDb } = thunkApi.extra;
+  const dbKey = typeof payload === "string" ? payload : payload.dbKey;
+  const preferredServerOrigin =
+    typeof payload === "string" ? undefined : payload.preferredServerOrigin;
+
+  if (!clientDb) {
+    throw new Error("Client database is undefined in removeAction");
+  }
+
+  const state = thunkApi.getState();
+  const { currentServer, syncServers } = getRuntimeServerContext(state);
+
+  console.log("[removeAction] START", {
+    dbKey,
+    preferredServerOrigin,
+    currentServer,
+    syncServers,
+    hasToken: Boolean(state?.auth?.currentToken),
+  });
+
+  // 1) 先查本地是否有这条数据
+  const localData = await fetchFromClientDb(clientDb, dbKey);
+  const hadLocalData = Boolean(localData);
+
+  // 2) local mutation 只依赖本地真相；远端删除由 replication helper 负责后台收敛。
+  console.log("[removeAction] replication inputs", {
+    currentServer,
+    syncServers,
+    preferredServerOrigin,
+    hadLocalData,
+  });
+
+  // 3) 如果本地存在，则先写 tombstone 到本地。
+  // Recent / My Content 是多源 merge，直接物理删除本地会丢失“删除胜出”证据，
+  // 老版本远端返回的活记录会在下一轮 merge 时再次回流。
+  const nowIso = new Date().toISOString();
+  if (localData) {
+    if (localData.id && typeof localData.id === "string") {
+      void deleteFileFromIndexedDb(localData.id).catch((err) => {
+        console.warn("[removeAction] Failed to delete associated file:", localData.id, err);
+      });
+    }
+    await clientDb.put(dbKey, buildTombstoneRecord(localData, nowIso));
+  } else {
+    // 本地无数据（仅存于远端），写最小 tombstone 防止远端记录在 merge 时回流
+    await clientDb.put(dbKey, buildTombstoneRecord({ dbKey }, nowIso));
+  }
+
+  // 4) local-first 产品语义：本地 tombstone 立即成功，远端删除异步收敛。
+  // 这样离线/弱网时删除也能成立，UI 可立刻移除内容；远端复制后续自行收敛。
+  scheduleDeleteReplication({
+    currentServer,
+    syncServers,
+    preferredServerOrigin,
+    dbKey,
+    state,
+    onResult: (result) => {
+      if (result.failed.length > 0) {
+        console.warn("[removeAction] Server delete failures after local tombstone:", result.failed);
+      }
+    },
+    onError: (err) => {
+      console.warn("[removeAction] Background server delete error:", err);
+    },
+  });
+
+  return { dbKey };
+};

package/database/actions/replication.ts

@@ -0,0 +1,366 @@
+import { getAllServers } from "./common";
+import {
+  noloDeleteRequest,
+  noloPatchRequest,
+  noloUploadRequest,
+  noloWriteRequest,
+  syncWithServers,
+} from "../requests";
+import { planServersForTenant } from "../tenantPlacement";
+
+const isReadonlyPublicRecordKey = (dbKey: string): boolean =>
+  dbKey.startsWith("agent-pub-") || dbKey.startsWith("cybot-pub-");
+
+export const resolveReplicationServers = (
+  currentServer: string | undefined,
+  syncServers: string[] | undefined,
+  preferredServerOrigin?: string | null
+): string[] => getAllServers(currentServer, syncServers, preferredServerOrigin);
+
+export const scheduleWriteReplication = (
+  servers: string[],
+  request: { data: any; customKey: string; userId?: string },
+  state: any
+) => {
+  if (servers.length === 0) return;
+  Promise.resolve().then(async () => {
+    const [primaryServer, ...backupServers] = servers;
+    const primarySucceeded = await noloWriteRequest(primaryServer, request, state);
+
+    if (!primarySucceeded) {
+      console.warn(`Primary write sync failed for ${request.customKey} on ${primaryServer}`);
+    }
+
+    if (backupServers.length === 0) {
+      return;
+    }
+
+    syncWithServers(
+      backupServers,
+      (server, requestConfig, requestState, signal) =>
+        noloWriteRequest(server, requestConfig, requestState, signal, {
+          failureLogLevel: "info",
+        }),
+      `Backup write sync failed for ${request.customKey} on`,
+      request,
+      state
+    );
+  });
+};
+
+export const resolveTenantReplicationServers = ({
+  currentServer,
+  syncServers,
+  tenantId,
+}: {
+  currentServer: string | undefined;
+  syncServers: string[] | undefined;
+  tenantId: string | null | undefined;
+}): string[] => {
+  const allServers = resolveReplicationServers(currentServer, syncServers);
+  if (allServers.length === 0) {
+    return [];
+  }
+
+  return planServersForTenant(allServers, currentServer, tenantId);
+};
+
+export const scheduleExistingRecordReplication = ({
+  currentServer,
+  syncServers,
+  preferredServerOrigin,
+  dbKey,
+  localData,
+  state,
+}: {
+  currentServer: string | undefined;
+  syncServers: string[] | undefined;
+  preferredServerOrigin?: string | null;
+  dbKey: string;
+  localData: any;
+  state: any;
+}): string[] => {
+  if (isReadonlyPublicRecordKey(dbKey)) {
+    return [];
+  }
+
+  const servers = resolveReplicationServers(
+    currentServer,
+    syncServers,
+    preferredServerOrigin
+  );
+  if (servers.length === 0) {
+    return [];
+  }
+
+  scheduleWriteReplication(
+    servers,
+    {
+      data: localData,
+      customKey: dbKey,
+      userId:
+        typeof localData?.userId === "string"
+          ? localData.userId
+          : state?.auth?.currentUser?.userId,
+    },
+    state
+  );
+
+  return servers;
+};
+
+export const schedulePatchReplication = ({
+  servers,
+  dbKey,
+  changes,
+  state,
+  preferredServerOrigin,
+}: {
+  servers: string[];
+  dbKey: string;
+  changes: any;
+  state: any;
+  preferredServerOrigin?: string | null;
+}) => {
+  if (servers.length === 0) return;
+
+  Promise.resolve().then(async () => {
+    const primaryServer =
+      typeof preferredServerOrigin === "string" && preferredServerOrigin.trim().length > 0
+        ? preferredServerOrigin.trim().replace(/\/+$/, "")
+        : servers[0];
+    const backupServers = servers.filter(
+      (server) => server.replace(/\/+$/, "") !== primaryServer
+    );
+
+    const primarySucceeded = await noloPatchRequest(primaryServer, dbKey, changes, state, undefined, {
+      failureLogLevel: "warn",
+    });
+    if (!primarySucceeded) {
+      console.warn(`Primary patch sync failed for ${dbKey} on ${primaryServer}`);
+    }
+
+    if (backupServers.length > 0) {
+      syncWithServers(
+        backupServers,
+        (server, targetDbKey, nextChanges, requestState, signal) =>
+          noloPatchRequest(server, targetDbKey, nextChanges, requestState, signal, {
+            failureLogLevel: "info",
+          }),
+        `Backup patch sync failed for ${dbKey} on`,
+        dbKey,
+        changes,
+        state
+      );
+    }
+  });
+};
+
+export const scheduleConfiguredPatchReplication = ({
+  currentServer,
+  syncServers,
+  preferredServerOrigin,
+  dbKey,
+  changes,
+  state,
+}: {
+  currentServer: string | undefined;
+  syncServers: string[] | undefined;
+  preferredServerOrigin?: string | null;
+  dbKey: string;
+  changes: any;
+  state: any;
+}): string[] => {
+  const servers = resolveReplicationServers(
+    currentServer,
+    syncServers,
+    preferredServerOrigin
+  );
+
+  if (servers.length === 0) {
+    return [];
+  }
+
+  schedulePatchReplication({
+    servers,
+    dbKey,
+    changes,
+    state,
+    preferredServerOrigin,
+  });
+
+  return servers;
+};
+
+export const scheduleUploadReplication = ({
+  currentServer,
+  syncServers,
+  tenantId,
+  uploadConfig,
+  state,
+  excludeServers = [],
+}: {
+  currentServer: string | undefined;
+  syncServers: string[] | undefined;
+  tenantId: string | null | undefined;
+  uploadConfig: {
+    file: File;
+    metadata: any;
+    customKey: string;
+    userId?: string;
+  };
+  state: any;
+  excludeServers?: string[];
+}): string[] => {
+  const servers = resolveTenantReplicationServers({
+    currentServer,
+    syncServers,
+    tenantId,
+  });
+  const excluded = new Set(
+    excludeServers
+      .filter((server): server is string => typeof server === "string")
+      .map((server) => server.trim().replace(/\/+$/, ""))
+  );
+  const remainingServers = servers.filter(
+    (server) => !excluded.has(server.trim().replace(/\/+$/, ""))
+  );
+
+  if (remainingServers.length === 0) {
+    return [];
+  }
+
+  Promise.resolve().then(() => {
+    syncWithServers(
+      remainingServers,
+      noloUploadRequest,
+      `Upload sync failed for ${uploadConfig.customKey} on`,
+      uploadConfig,
+      state
+    );
+  });
+
+  return remainingServers;
+};
+
+export const uploadToCurrentServer = async ({
+  currentServer,
+  uploadConfig,
+  state,
+}: {
+  currentServer: string | undefined;
+  uploadConfig: {
+    file: File;
+    metadata: any;
+    customKey: string;
+    userId?: string;
+  };
+  state: any;
+}): Promise<boolean> => {
+  if (!currentServer) {
+    return false;
+  }
+
+  return noloUploadRequest(currentServer, uploadConfig, state);
+};
+
+export const deleteFromReplicationServers = async ({
+  servers,
+  dbKey,
+  deleteOptions = { type: "single" as const },
+  state,
+  preferredServerOrigin,
+}: {
+  servers: string[];
+  dbKey: string;
+  deleteOptions?: { type: "single" | "table" | "messages" };
+  state: any;
+  preferredServerOrigin?: string | null;
+}): Promise<{ succeeded: string[]; failed: string[] }> => {
+  if (!servers.length) {
+    return { succeeded: [], failed: [] };
+  }
+
+  const preferredServer =
+    typeof preferredServerOrigin === "string" && preferredServerOrigin.trim().length > 0
+      ? preferredServerOrigin.trim().replace(/\/+$/, "")
+      : null;
+  const remainingServers = preferredServer
+    ? servers.filter((server) => server.replace(/\/+$/, "") !== preferredServer)
+    : servers;
+  const succeeded: string[] = [];
+  const failed: string[] = [];
+
+  if (preferredServer) {
+    const ok = await noloDeleteRequest(preferredServer, dbKey, deleteOptions, state);
+    if (ok) {
+      succeeded.push(preferredServer);
+    } else {
+      failed.push(preferredServer);
+    }
+  }
+
+  if (remainingServers.length > 0) {
+    const results = await Promise.all(
+      remainingServers.map(async (server) => ({
+        server,
+        ok: await noloDeleteRequest(server, dbKey, deleteOptions, state),
+      }))
+    );
+    results.forEach(({ server, ok }) => {
+      if (ok) succeeded.push(server);
+      else failed.push(server);
+    });
+  }
+
+  return { succeeded, failed };
+};
+
+export const scheduleDeleteReplication = ({
+  currentServer,
+  syncServers,
+  preferredServerOrigin,
+  dbKey,
+  deleteOptions,
+  state,
+  onResult,
+  onError,
+}: {
+  currentServer: string | undefined;
+  syncServers: string[] | undefined;
+  preferredServerOrigin?: string | null;
+  dbKey: string;
+  deleteOptions?: { type: "single" | "table" | "messages" };
+  state: any;
+  onResult?: (result: { succeeded: string[]; failed: string[] }) => void;
+  onError?: (error: unknown) => void;
+}): string[] => {
+  const servers = resolveReplicationServers(
+    currentServer,
+    syncServers,
+    preferredServerOrigin
+  );
+
+  if (servers.length === 0) {
+    return [];
+  }
+
+  void Promise.resolve()
+    .then(() =>
+      deleteFromReplicationServers({
+        servers,
+        dbKey,
+        deleteOptions,
+        state,
+        preferredServerOrigin,
+      })
+    )
+    .then((result) => {
+      onResult?.(result);
+    })
+    .catch((error) => {
+      onError?.(error);
+    });
+
+  return servers;
+};

package/database/actions/upload.ts

@@ -0,0 +1,174 @@
+// 文件路径: database/actions/upload.ts
+
+import { getRuntimeServerContext } from "database/runtimeServerContext";
+import { ulid } from "../utils/ulid";
+import { normalizeTimeFields, logger } from "./common";
+import { toast } from "app/utils/toast";
+import { saveFileToIndexedDb } from "../fileStorage";
+import { fileKey } from "../keys";
+import { scheduleUploadReplication, uploadToCurrentServer } from "./replication";
+import { DataType } from "create/types";
+import { resolveFileCategory } from "app/utils/fileUtils";
+
+/**
+ * 辅助函数：保存文件元数据到客户端数据库
+ */
+const saveToClientDb = async (
+  clientDb: any,
+  dbKey: string,
+  metadata: any
+): Promise<void> => {
+  if (!clientDb) {
+    logger.error({ dbKey }, "Client database is undefined in saveToClientDb");
+    throw new Error("Client database instance is required");
+  }
+
+  try {
+    await clientDb.put(dbKey, metadata);
+    logger.debug(
+      { dbKey },
+      "File metadata saved successfully to local database."
+    );
+  } catch (err: any) {
+    logger.error(
+      { err, dbKey },
+      "Failed to save file metadata to local database"
+    );
+    throw new Error(`Local database put failed for ${dbKey}: ${err.message}`);
+  }
+};
+
+/**
+ * Upload File Action: 上传文件并保存元数据。
+ *
+ * 设计要点：
+ * - 以 fileId 作为文件唯一 ID；
+ * - 本地 IndexedDB 完整缓存一份（离线可用）；
+ * - 按 tenantId（通常为 userId）通过 hash ring 选择若干服务器写入完整副本；
+ * - 服务器只需跑单机 fileService，不感知 ring/tenant。
+ *
+ * 将来扩容到几十台服务器：
+ * - 只需要在设置里增加/调整 syncServers 列表；
+ * - getAllServers + planServersForTenant 会自动把新节点纳入分布；
+ * - 无需修改业务调用代码。
+ */
+export const uploadFileAction = async (
+  uploadConfig: { file: File; customKey?: string; userId?: string },
+  thunkApi: any
+): Promise<any> => {
+  const { db: clientDb } = thunkApi.extra;
+  const state = thunkApi.getState();
+  const { currentServer, syncServers, currentUserId } =
+    getRuntimeServerContext(state);
+
+  const { file, customKey } = uploadConfig;
+  const userId = uploadConfig.userId || currentUserId;
+  // 1. 验证参数
+  if (!file) {
+    const errorMsg =
+      "Invalid arguments for uploadFileAction: file is required.";
+    logger.error(errorMsg, { uploadConfig });
+    toast.error(errorMsg);
+    throw new Error(errorMsg);
+  }
+
+  try {
+    // 2. 生成文件 ID 和文件名（fileId 将作为逻辑 ID，服务端会沿用）
+    const fileId = ulid();
+    const fileExtension = file.name.split(".").pop() || "";
+    const fileName = `${fileId}${fileExtension ? "." + fileExtension : ""}`;
+
+    // 决定最终的 dbKey (强制使用 file-userId-ulid 模式)
+    let finalDbKey = customKey;
+    if (!finalDbKey || !finalDbKey.startsWith("file-")) {
+      const actualUserId = userId || "unknown";
+      if (actualUserId === "unknown") {
+        console.warn("[uploadFileAction] User ID is unknown during upload. Key will be file-unknown.");
+      }
+      finalDbKey = fileKey.single(actualUserId, fileId);
+    }
+
+    // 3. 准备文件元数据（添加时间戳、dbKey、userId 等）
+    const fileMetadata = normalizeTimeFields({
+      id: fileId,
+      title: file.name,
+      originalName: file.name,
+      fileName,
+      filePath: "",
+      size: file.size,
+      mimeType: file.type || "application/octet-stream",
+      type: DataType.FILE,
+      fileCategory: resolveFileCategory({
+        mimeType: file.type,
+        fileName: file.name,
+      }),
+      dbKey: finalDbKey,
+      userId,
+    });
+
+    // 本地结构化元数据：key = finalDbKey（供 dbSlice 等使用）
+    await saveToClientDb(clientDb, finalDbKey, fileMetadata);
+
+    // 4. 将原始文件存入 IndexedDB / Native Storage
+    // 本地以 fileId 为 key 缓存内容（离线使用）
+    // 在 RN 环境下，saveFileToIndexedDb 实际上是存储文件路径引用
+    try {
+      await saveFileToIndexedDb(fileId, file);
+    } catch (err) {
+      logger.warn(
+        { err, fileId },
+        "[uploadFileAction] Failed to cache file locally."
+      );
+    }
+
+    // 5. 基于 tenantId（userId）为当前用户选择服务器集合，并在后台同步上传。
+    //    - 同一个用户的数据总是落在同一组服务器上
+    //    - 每个用户至少有固定副本数的服务器持有完整数据
+    const tenantId = userId || "default";
+    const uploadReplicationConfig = {
+      file,
+      metadata: fileMetadata,
+      customKey: finalDbKey,
+      userId,
+    };
+
+    const currentServerUploadSucceeded = await uploadToCurrentServer({
+      currentServer,
+      uploadConfig: uploadReplicationConfig,
+      state,
+    });
+    if (currentServer && !currentServerUploadSucceeded) {
+      throw new Error(`Primary upload failed on current server ${currentServer}`);
+    }
+
+    const serversToUse = scheduleUploadReplication({
+      currentServer,
+      syncServers,
+      tenantId,
+      uploadConfig: uploadReplicationConfig,
+      state,
+      excludeServers: currentServer ? [currentServer] : [],
+    });
+
+    if (!currentServer && !serversToUse.length) {
+      logger.warn(
+        "[uploadFileAction] No replication servers available, file metadata only saved locally.",
+        { finalDbKey, fileName, tenantId }
+      );
+      return fileMetadata;
+    }
+
+    logger.debug(
+      `[uploadFileAction] Uploaded primary copy for ${fileName} and scheduled background sync to ${serversToUse.length} additional servers.`,
+      { currentServer, serversToUse, tenantId }
+    );
+    // 8. 返回本地保存的元数据
+    return fileMetadata;
+  } catch (error: any) {
+    const errorMessage = `Upload action failed for ${customKey}: ${error?.message || "Unknown error"
+      }`;
+    logger.error({ error }, "[uploadFileAction] Error");
+    toast.error(`Failed to upload file for ${customKey}.`);
+    throw new Error(errorMessage);
+  }
+};

package/database/actions/upsert.ts

@@ -0,0 +1,56 @@
+// src/database/actions/upsert.ts
+import { toast } from "app/utils/toast";
+import type { AppThunkApi } from "app/store";
+
+import { patchAction } from "./patch";
+import { readAction } from "./read";
+import { writeAction } from "./write";
+
+/**
+ * Upsert 数据协调器：根据数据是否存在，调度 patch 或 write 操作。
+ * 此操作本身不执行数据库读写或网络请求，而是委托给其他 async thunks。
+ *
+ * @param upsertConfig 包含 dbKey（必需）和 data（必需）的对象。
+ * @param thunkApi Redux Thunk API，包含 dispatch 和 getState。
+ * @returns Promise<any> 来自 patch或write操作成功后的数据对象。
+ * @throws 如果参数无效或调度的操作失败，则抛出错误。
+ */
+export const upsertAction = async (
+  upsertConfig: { dbKey: string; data: any },
+  thunkApi: AppThunkApi
+): Promise<any> => {
+  const { dbKey, data } = upsertConfig;
+
+  // 1. 参数验证
+  if (!dbKey || !data || typeof data !== "object") {
+    const errorMsg = "upsertAction 参数无效：dbKey 和 data 对象是必需的。";
+    toast.error(errorMsg);
+    throw new Error(errorMsg);
+  }
+
+  try {
+    // 2. 调用 readAction 检查数据是否存在于本地（通过 Redux Store 或 DB）
+    // 我们不关心 readAction 是否真的从网络读取，只关心它最终返回的结果。
+    const existingData = await readAction({ dbKey }, thunkApi);
+    let finalResult;
+
+    // 3. 根据是否存在数据，决定调度 patch 还是 write
+    if (existingData && Object.keys(existingData).length > 0) {
+      // **更新路径**：数据已存在，调度 patch action
+      // patch action 内部会处理 updatedAt、userId、本地写入和服务器同步
+      finalResult = await patchAction({ dbKey, changes: data }, thunkApi);
+    } else {
+      // **插入路径**：数据不存在，调度 write action
+      // write action 内部会处理 createdAt/updatedAt、userId、本地写入和服务器同步
+      finalResult = await writeAction({ data, customKey: dbKey }, thunkApi);
+    }
+
+    // 4. 返回最终执行成功的数据
+    return finalResult;
+  } catch (error: any) {
+    const errorMessage = `Upsert 协调操作失败 (dbKey: ${dbKey}): ${error.message || "未知错误"}`;
+    toast.error("数据保存失败，请稍后重试。");
+    // 重新抛出错误，以便 create.asyncThunk 能捕获到 rejected 状态
+    throw new Error(errorMessage, { cause: error });
+  }
+};