nolo-cli 0.1.39 → 0.1.41

package/database/actions/readRequestManager.ts

@@ -0,0 +1,120 @@
+const DEFAULT_MISS_COOLDOWN_MS = 2000;
+const DEFAULT_LOCAL_HIT_REVALIDATE_COOLDOWN_MS = 1500;
+const DEFAULT_MISS_CACHE_MAX_SIZE = 1000;
+
+export class ReadRequestManager {
+  private readonly inFlightReads = new Map<string, Promise<any>>();
+  private readonly recentMisses = new Map<string, number>();
+  private readonly recentLocalHitRevalidations = new Map<string, number>();
+
+  constructor(
+    private readonly options: {
+      missCooldownMs?: number;
+      missCacheMaxSize?: number;
+      localHitRevalidateCooldownMs?: number;
+    } = {}
+  ) {}
+
+  private get missCooldownMs() {
+    return this.options.missCooldownMs ?? DEFAULT_MISS_COOLDOWN_MS;
+  }
+
+  private get missCacheMaxSize() {
+    return this.options.missCacheMaxSize ?? DEFAULT_MISS_CACHE_MAX_SIZE;
+  }
+
+  private get localHitRevalidateCooldownMs() {
+    return (
+      this.options.localHitRevalidateCooldownMs ??
+      DEFAULT_LOCAL_HIT_REVALIDATE_COOLDOWN_MS
+    );
+  }
+
+  getInFlight(dbKey: string) {
+    return this.inFlightReads.get(dbKey);
+  }
+
+  setInFlight(dbKey: string, promise: Promise<any>) {
+    this.inFlightReads.set(dbKey, promise);
+  }
+
+  clearInFlight(dbKey: string, promise: Promise<any>) {
+    if (this.inFlightReads.get(dbKey) === promise) {
+      this.inFlightReads.delete(dbKey);
+    }
+  }
+
+  clearMiss(dbKey: string) {
+    this.recentMisses.delete(dbKey);
+  }
+
+  getRetryInMs(dbKey: string, now: number) {
+    const missUntil = this.recentMisses.get(dbKey);
+    if (typeof missUntil !== "number") return null;
+    if (missUntil <= now) {
+      this.recentMisses.delete(dbKey);
+      return null;
+    }
+    return missUntil - now;
+  }
+
+  markMiss(dbKey: string, now: number, cooldownMs = this.missCooldownMs) {
+    this.recentMisses.set(dbKey, now + cooldownMs);
+    this.cleanupMisses(now);
+  }
+
+  getLocalHitRevalidateInMs(dbKey: string, now: number) {
+    const nextAllowedAt = this.recentLocalHitRevalidations.get(dbKey);
+    if (typeof nextAllowedAt !== "number") return null;
+    if (nextAllowedAt <= now) {
+      this.recentLocalHitRevalidations.delete(dbKey);
+      return null;
+    }
+    return nextAllowedAt - now;
+  }
+
+  markLocalHitRevalidated(
+    dbKey: string,
+    now: number,
+    cooldownMs = this.localHitRevalidateCooldownMs
+  ) {
+    this.recentLocalHitRevalidations.set(dbKey, now + cooldownMs);
+    this.cleanupLocalHitRevalidations(now);
+  }
+
+  private cleanupExpiringMap(map: Map<string, number>, now: number) {
+    for (const [key, expiresAt] of Array.from(map.entries())) {
+      if (expiresAt <= now) {
+        map.delete(key);
+      }
+    }
+
+    if (map.size <= this.missCacheMaxSize) return;
+    const overflow = map.size - this.missCacheMaxSize;
+    const keys = Array.from(map.keys());
+    for (let i = 0; i < overflow; i += 1) {
+      const key = keys[i];
+      if (key) map.delete(key);
+    }
+  }
+
+  cleanupMisses(now: number) {
+    this.cleanupExpiringMap(this.recentMisses, now);
+  }
+
+  cleanupLocalHitRevalidations(now: number) {
+    this.cleanupExpiringMap(this.recentLocalHitRevalidations, now);
+  }
+
+  // test helper
+  getMissCacheSize() {
+    return this.recentMisses.size;
+  }
+
+  // test helper
+  getLocalHitRevalidationCacheSize() {
+    return this.recentLocalHitRevalidations.size;
+  }
+}
+
+export const readRequestManager = new ReadRequestManager();

package/database/actions/readResolution.ts

@@ -0,0 +1,125 @@
+const normalizeServerOrigin = (server: string): string =>
+  server.trim().replace(/\/+$/, "");
+
+const toComparableTimestamp = (data: any): number => {
+  if (!data || typeof data !== "object") return 0;
+
+  const updatedAtMs = new Date(data.updatedAt).getTime();
+  if (Number.isFinite(updatedAtMs) && updatedAtMs > 0) return updatedAtMs;
+
+  const createdAtMs = new Date(data.createdAt).getTime();
+  if (Number.isFinite(createdAtMs) && createdAtMs > 0) return createdAtMs;
+
+  const metaCreatedAt = Number(data?.meta?.createdAt);
+  if (Number.isFinite(metaCreatedAt) && metaCreatedAt > 0) return metaCreatedAt;
+
+  return 0;
+};
+
+export const partitionReadServers = ({
+  allServers,
+  preferredServerOrigin,
+}: {
+  allServers: string[];
+  preferredServerOrigin?: string | null;
+}): {
+  preferredServer: string | null;
+  fallbackServers: string[];
+  orderedServersForLocalHit: string[];
+} => {
+  const preferredServer =
+    typeof preferredServerOrigin === "string" &&
+    preferredServerOrigin.trim().length > 0
+      ? normalizeServerOrigin(preferredServerOrigin)
+      : null;
+
+  const fallbackServers = preferredServer
+    ? allServers.filter(
+        (server) => normalizeServerOrigin(server) !== preferredServer
+      )
+    : allServers;
+
+  return {
+    preferredServer,
+    fallbackServers,
+    orderedServersForLocalHit: preferredServer
+      ? [preferredServer, ...fallbackServers]
+      : fallbackServers,
+  };
+};
+
+export const compareRemoteRecordsByComparableTime = (
+  left: any,
+  right: any
+): number => toComparableTimestamp(left) - toComparableTimestamp(right);
+
+export const pickBestSettledRemoteRecord = ({
+  settledResults,
+  isBetterCandidate,
+}: {
+  settledResults: PromiseSettledResult<any>[];
+  isBetterCandidate: (current: any, latest: any) => boolean;
+}): { data: any; index: number } | null => {
+  const validResults = settledResults
+    .map((result, index) => ({
+      data: result.status === "fulfilled" ? result.value : null,
+      index,
+    }))
+    .filter((item) => item.data !== null && typeof item.data === "object");
+
+  if (validResults.length === 0) return null;
+
+  const latest = validResults.reduce((best, current) =>
+    isBetterCandidate(current.data, best.data) ? current : best
+  );
+
+  return { index: latest.index, data: latest.data };
+};
+
+export const shouldReplaceLocalWithRemoteRecord = ({
+  localData,
+  remoteData,
+  isRemoteNewer,
+}: {
+  localData: any;
+  remoteData: any;
+  isRemoteNewer: (remoteData: any, localData: any) => boolean;
+}): boolean => {
+  if (!remoteData || typeof remoteData !== "object") return false;
+  if (!localData || typeof localData !== "object") return true;
+  return isRemoteNewer(remoteData, localData);
+};
+
+export const shouldReplicateLocalRecord = ({
+  localData,
+  remoteData,
+  remoteTargetCount,
+}: {
+  localData: any;
+  remoteData: any;
+  remoteTargetCount: number;
+}): boolean =>
+  !!localData && !remoteData && remoteTargetCount > 0;
+
+const compactUniqueServers = (
+  servers: Array<string | null | undefined>
+): string[] => {
+  const out: string[] = [];
+  for (const server of servers) {
+    if (typeof server !== "string" || server.trim().length === 0) continue;
+    const normalized = normalizeServerOrigin(server);
+    if (!out.includes(normalized)) out.push(normalized);
+  }
+  return out;
+};
+
+export const planAuthorityReadServers = ({
+  allServers,
+  authorityServer,
+  serverOrigin,
+}: {
+  allServers: string[];
+  authorityServer?: string | null;
+  serverOrigin?: string | null;
+}): string[] =>
+  compactUniqueServers([authorityServer, serverOrigin, ...allServers]);

package/database/actions/remove.ts

@@ -0,0 +1,94 @@
+// 文件路径: src/database/actions/delete.ts
+
+import type { AppThunkApi } from "../../app/store";
+import { getRuntimeServerContext } from "../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 };
+};