nolo-cli 0.1.23 → 0.1.29

package/share/server/tableReplication.ts

@@ -0,0 +1,351 @@
+import serverDb from "../../database/server/db";
+import { rowKey } from "../../database/keys";
+import { noloWriteRequest } from "../../database/requests";
+import { isTombstoneRecord } from "../../database/tombstones";
+import { readShareByDbKey } from "./helpers";
+
+type BootstrapArgs = {
+  shareDbKey: string;
+  shareRecord: any;
+  tableDbKey: string;
+  tableOwnerId: string;
+  originServer: string;
+  replicaServers: string[];
+  thunkApi: any;
+  putRecordToServer?: (
+    server: string,
+    dbKey: string,
+    data: any
+  ) => Promise<{ ok: boolean; status?: number; detail?: string }>;
+  loadOriginTableSnapshot?: (
+    tableDbKey: string
+  ) => Promise<{ tableMeta: any; rows: any[] }>;
+  patchShareMeta?: (
+    shareDbKey: string,
+    changes: Record<string, unknown>
+  ) => Promise<void>;
+  resetReplicaTable?: (
+    server: string,
+    tableDbKey: string
+  ) => Promise<{ ok: boolean; status?: number; detail?: string }>;
+};
+
+type MutationArgs = {
+  mutation: {
+    kind: "write" | "patch" | "delete";
+    dbKey: string;
+    data?: any;
+    dataType: string;
+    tenantId: string;
+    tableId: string;
+  };
+  originServer: string;
+  replicaServers: string[];
+  findActiveLiveShare: (tenantId: string, tableId: string) => Promise<any | null>;
+  putMutationToReplica: (
+    server: string,
+    mutation: MutationArgs["mutation"]
+  ) => Promise<{ ok: boolean; status?: number; detail?: string }>;
+  reconcileReplicaTable: (args: {
+    shareDbKey: string;
+    tableDbKey?: string;
+    tableOwnerId?: string;
+    replicaServers: string[];
+  }) => Promise<void>;
+  patchShareMeta: (
+    shareDbKey: string,
+    changes: Record<string, unknown>
+  ) => Promise<void>;
+};
+
+const defaultPatchShareMeta = async (
+  shareDbKey: string,
+  changes: Record<string, unknown>
+) => {
+  const shareRecord = await readShareByDbKey(shareDbKey);
+  if (!shareRecord || isTombstoneRecord(shareRecord)) return;
+  await serverDb.put(shareDbKey, {
+    ...shareRecord,
+    meta: {
+      ...(shareRecord.meta ?? {}),
+      ...changes,
+    },
+  });
+};
+
+const normalizeOrigin = (value: unknown) =>
+  typeof value === "string" && value.trim()
+    ? value.trim().replace(/\/+$/, "")
+    : "";
+
+export const getShareReplicaServers = (shareRecord: any): string[] =>
+  Array.isArray(shareRecord?.meta?.replicaServers)
+    ? shareRecord.meta.replicaServers
+        .filter((server: unknown): server is string => typeof server === "string")
+        .map((server) => server.trim().replace(/\/+$/, ""))
+        .filter(Boolean)
+    : [];
+
+export const isLiveTableShareRecord = (shareRecord: any, tableDbKey?: string): boolean =>
+  shareRecord?.type === "table" &&
+  (shareRecord?.data?.mode === "live" || shareRecord?.meta?.mode === "live") &&
+  (tableDbKey == null ||
+    shareRecord?.meta?.tableDbKey === tableDbKey ||
+    shareRecord?.data?.tableDbKey === tableDbKey);
+
+export const patchShareMeta = defaultPatchShareMeta;
+
+export async function findActiveLiveShareByTable(
+  tenantId: string,
+  tableId: string
+): Promise<(Record<string, unknown> & { dbKey: string }) | null> {
+  const tableDbKey = `meta-${tenantId}-${tableId}`;
+  for await (const [dbKey, value] of serverDb.iterator({
+    gte: "share-",
+    lte: "share-\uffff",
+  })) {
+    if (isLiveTableShareRecord(value, tableDbKey)) {
+      return {
+        ...value,
+        dbKey: String(dbKey),
+      };
+    }
+  }
+  return null;
+}
+
+const defaultLoadOriginTableSnapshot = async (tableDbKey: string) => {
+  const tableMeta = await serverDb.get(tableDbKey);
+  const tenantId =
+    typeof tableMeta?.tenantId === "string" ? tableMeta.tenantId : "";
+  const tableId = typeof tableMeta?.tableId === "string" ? tableMeta.tableId : "";
+  const rows: any[] = [];
+
+  if (tenantId && tableId) {
+    const { gte, lte } = rowKey.range(tenantId, tableId);
+    for await (const [, value] of serverDb.iterator({ gte, lte })) {
+      if (!value?.deletedAt) {
+        rows.push(value);
+      }
+    }
+  }
+
+  return { tableMeta, rows };
+};
+
+const defaultPutRecordToServer = async (
+  server: string,
+  dbKey: string,
+  data: any,
+  thunkApi: any
+) => {
+  const ok = await noloWriteRequest(
+    server,
+    {
+      data,
+      customKey: dbKey,
+      userId:
+        typeof data?.userId === "string"
+          ? data.userId
+          : typeof data?.tenantId === "string"
+            ? data.tenantId
+            : undefined,
+    },
+    thunkApi?.getState?.() ?? {}
+  );
+  return { ok };
+};
+
+export async function bootstrapReplicatedTable(
+  args: BootstrapArgs
+): Promise<{
+  replicatedServers: string[];
+  failedServers: string[];
+  lastReplicationAt: number;
+}> {
+  const loadOriginTableSnapshot =
+    args.loadOriginTableSnapshot ?? defaultLoadOriginTableSnapshot;
+  const patchShareMeta = args.patchShareMeta ?? defaultPatchShareMeta;
+  const snapshot = await loadOriginTableSnapshot(args.tableDbKey);
+  const failedServers: string[] = [];
+  const lastReplicationAt = Date.now();
+
+  if (!snapshot.tableMeta?.dbKey) {
+    await patchShareMeta(args.shareDbKey, {
+      replicaServers: args.replicaServers,
+      replicationDirtyAt: lastReplicationAt,
+      lastReplicationError: `bootstrap failed: missing table meta for ${args.tableDbKey}`,
+    });
+    return {
+      replicatedServers: [],
+      failedServers: [...args.replicaServers],
+      lastReplicationAt,
+    };
+  }
+
+  for (const server of args.replicaServers) {
+    const putRecordToServer =
+      args.putRecordToServer ??
+      ((targetServer: string, dbKey: string, data: any) =>
+        defaultPutRecordToServer(targetServer, dbKey, data, args.thunkApi));
+    if (args.resetReplicaTable) {
+      const resetResult = await args.resetReplicaTable(server, args.tableDbKey);
+      if (!resetResult.ok) {
+        failedServers.push(server);
+        continue;
+      }
+    }
+
+    const metaResult = await putRecordToServer(
+      server,
+      snapshot.tableMeta.dbKey,
+      snapshot.tableMeta
+    );
+    if (!metaResult.ok) {
+      failedServers.push(server);
+      continue;
+    }
+
+    for (const row of snapshot.rows) {
+      const rowResult = await putRecordToServer(server, row.dbKey, row);
+      if (!rowResult.ok) {
+        failedServers.push(server);
+        break;
+      }
+    }
+  }
+
+  await patchShareMeta(args.shareDbKey, {
+    replicaServers: args.replicaServers,
+    lastReplicationAt,
+    ...(failedServers.length > 0
+      ? {
+          replicationDirtyAt: Date.now(),
+          lastReplicationError: `bootstrap failed: ${failedServers.join(", ")}`,
+        }
+      : {
+          replicationDirtyAt: null,
+          lastReplicationError: null,
+        }),
+  });
+
+  return {
+    replicatedServers: args.replicaServers.filter(
+      (server) => !failedServers.includes(server)
+    ),
+    failedServers,
+    lastReplicationAt,
+  };
+}
+
+export async function reconcileReplicaTable(args: {
+  shareDbKey: string;
+  tableDbKey: string;
+  tableOwnerId: string;
+  originServer?: string;
+  replicaServers: string[];
+  thunkApi: any;
+  putRecordToServer?: (
+    server: string,
+    dbKey: string,
+    data: any
+  ) => Promise<{ ok: boolean; status?: number; detail?: string }>;
+  loadOriginTableSnapshot?: (
+    tableDbKey: string
+  ) => Promise<{ tableMeta: any; rows: any[] }>;
+  patchShareMeta?: (
+    shareDbKey: string,
+    changes: Record<string, unknown>
+  ) => Promise<void>;
+  resetReplicaTable?: (
+    server: string,
+    tableDbKey: string
+  ) => Promise<{ ok: boolean; status?: number; detail?: string }>;
+}) {
+  await bootstrapReplicatedTable({
+    shareDbKey: args.shareDbKey,
+    shareRecord: null,
+    tableDbKey: args.tableDbKey,
+    tableOwnerId: args.tableOwnerId,
+    originServer: args.originServer ?? "",
+    replicaServers: args.replicaServers,
+    thunkApi: args.thunkApi,
+    putRecordToServer: args.putRecordToServer,
+    loadOriginTableSnapshot: args.loadOriginTableSnapshot,
+    patchShareMeta: args.patchShareMeta,
+    resetReplicaTable: args.resetReplicaTable,
+  });
+}
+
+export async function replicateSharedTableMutation(args: MutationArgs) {
+  const activeShare = await args.findActiveLiveShare(
+    args.mutation.tenantId,
+    args.mutation.tableId
+  );
+  if (!activeShare) return;
+
+  const originServer = normalizeOrigin(
+    activeShare.meta?.originServer ?? activeShare.data?.originServer
+  );
+  if (originServer && originServer !== normalizeOrigin(args.originServer)) {
+    return;
+  }
+
+  const replicaServers =
+    args.replicaServers.length > 0
+      ? args.replicaServers
+      : getShareReplicaServers(activeShare).filter(
+          (server) => server !== normalizeOrigin(args.originServer)
+        );
+
+  if (replicaServers.length === 0) {
+    return;
+  }
+
+  if (activeShare.meta?.replicationDirtyAt) {
+    const tableDbKey =
+      typeof activeShare.meta?.tableDbKey === "string"
+        ? activeShare.meta.tableDbKey
+        : typeof activeShare.data?.tableDbKey === "string"
+          ? activeShare.data.tableDbKey
+          : "";
+    const tableOwnerId =
+      typeof activeShare.meta?.tableOwnerId === "string"
+        ? activeShare.meta.tableOwnerId
+        : typeof activeShare.data?.tableOwnerId === "string"
+          ? activeShare.data.tableOwnerId
+          : typeof activeShare.meta?.authorId === "string"
+            ? activeShare.meta.authorId
+            : "";
+    await args.reconcileReplicaTable({
+      shareDbKey: activeShare.dbKey,
+      tableDbKey,
+      tableOwnerId,
+      replicaServers,
+    });
+  }
+
+  const failedServers: string[] = [];
+  for (const server of replicaServers) {
+    const result = await args.putMutationToReplica(server, args.mutation);
+    if (!result.ok) {
+      failedServers.push(server);
+    }
+  }
+
+  await args.patchShareMeta(
+    activeShare.dbKey,
+    failedServers.length > 0
+      ? {
+          replicationDirtyAt: Date.now(),
+          lastReplicationError: `replica write failed: ${failedServers.join(
+            ", "
+          )}`,
+        }
+      : {
+          lastReplicationAt: Date.now(),
+          replicationDirtyAt: null,
+          lastReplicationError: null,
+        }
+  );
+}

package/share/shareSlice.ts

@@ -0,0 +1,53 @@
+// 路径: share/shareSlice.ts
+// 职责：管理 Share 相关的 Redux 状态，支持 SSR 首屏预载
+
+import { createSlice, type PayloadAction } from "@reduxjs/toolkit";
+import type { ShareSummary } from ".//types";
+
+interface ShareState {
+  communityShares: {
+    loading: boolean;
+    error: string | null;
+    data: ShareSummary[];
+    nextCursor?: string;
+  };
+}
+
+const initialState: ShareState = {
+  communityShares: {
+    loading: false,
+    error: null,
+    data: [],
+    nextCursor: undefined,
+  },
+};
+
+const shareSlice = createSlice({
+  name: "share",
+  initialState,
+  reducers: {
+    /**
+     * SSR 首屏：服务端预取社区分享列表后注入，走 __PRELOADED_STATE__ 链路
+     */
+    setSSRCommunityShares: (
+      state,
+      action: PayloadAction<{ data: ShareSummary[]; nextCursor?: string }>
+    ) => {
+      state.communityShares.data = Array.isArray(action.payload.data)
+        ? action.payload.data
+        : [];
+      state.communityShares.nextCursor = action.payload.nextCursor;
+      state.communityShares.loading = false;
+      state.communityShares.error = null;
+    },
+  },
+});
+
+export const { setSSRCommunityShares } = shareSlice.actions;
+export default shareSlice.reducer;
+
+/** 读取 SSR 预载的社区分享列表 */
+export const selectSSRCommunityShares = (
+  state: any
+): { data: ShareSummary[]; nextCursor?: string } =>
+  state.share?.communityShares ?? { data: [], nextCursor: undefined };

package/share/tableShareState.ts

@@ -0,0 +1,74 @@
+import { DataType } from "../create/types";
+import { createWebSharePath } from "./link";
+import { loadOwnerSharesAcrossServers } from "./loadOwnerShares";
+import type { ShareSummary } from "./types";
+
+export interface TableShareState {
+  tableDbKey: string;
+  matches: ShareSummary[];
+  currentShare: ShareSummary | null;
+  communityShare: ShareSummary | null;
+  isCommunityShared: boolean;
+  hasReplicationIssue: boolean;
+  shareUrl?: string;
+  communityShareUrl?: string;
+}
+
+const compareTableShares = (left: ShareSummary, right: ShareSummary) => {
+  const leftCommunity = left.visibility === "community";
+  const rightCommunity = right.visibility === "community";
+  if (leftCommunity !== rightCommunity) {
+    return leftCommunity ? -1 : 1;
+  }
+  return right.createdAt - left.createdAt;
+};
+
+export const isTableShareSummaryForDbKey = (
+  share: ShareSummary,
+  tableDbKey: string
+): boolean => {
+  if (share.type !== DataType.TABLE) return false;
+  return share.originalId === tableDbKey || share.tableDbKey === tableDbKey;
+};
+
+export const buildTableShareState = (
+  shares: ShareSummary[],
+  tableDbKey: string
+): TableShareState => {
+  const matches = shares
+    .filter((share) => isTableShareSummaryForDbKey(share, tableDbKey))
+    .sort(compareTableShares);
+  const currentShare = matches[0] ?? null;
+  const communityShare =
+    matches.find((share) => share.visibility === "community") ?? null;
+
+  return {
+    tableDbKey,
+    matches,
+    currentShare,
+    communityShare,
+    isCommunityShared: !!communityShare,
+    hasReplicationIssue: Number(communityShare?.replicationDirtyAt ?? 0) > 0,
+    ...(currentShare ? { shareUrl: createWebSharePath(currentShare.token) } : {}),
+    ...(communityShare
+      ? { communityShareUrl: createWebSharePath(communityShare.token) }
+      : {}),
+  };
+};
+
+export const loadTableShareState = async (args: {
+  servers: string[];
+  userId: string;
+  token: string;
+  tableDbKey: string;
+  pageSize?: number;
+}): Promise<TableShareState> => {
+  const shares = await loadOwnerSharesAcrossServers({
+    servers: args.servers,
+    userId: args.userId,
+    token: args.token,
+    ...(typeof args.pageSize === "number" ? { pageSize: args.pageSize } : {}),
+  });
+
+  return buildTableShareState(shares, args.tableDbKey);
+};

package/share/types.ts

@@ -0,0 +1,100 @@
+import { DataType } from "../create/types";
+
+export type ShareType =
+  | DataType.DOC
+  | DataType.DIALOG
+  | DataType.CYBOT
+  | DataType.IMAGE
+  | DataType.APP
+  | DataType.TABLE;
+
+export interface ShareMeta {
+  authorId: string;
+  authorName?: string;
+  authorAvatar?: string;
+  createdAt: number;
+  updatedAt?: number | string;
+  visibility: "private" | "community";
+  title: string;
+  description?: string;
+  originalId?: string;
+  mode?: "live";
+  coverImage?: string;
+  sourceAgentKey?: string;
+  sourceAgentName?: string;
+  /** Product entitlement source of truth for paid access */
+  productId?: string;
+  /** 被导入次数 */
+  importCount?: number;
+  /** 当前返回为锁定预览，未包含原始正文 */
+  previewLocked?: boolean;
+  /** 当前用户需要购买后才能获取原始内容 */
+  requiresPurchase?: boolean;
+  originServer?: string;
+  tableDbKey?: string;
+  tableOwnerId?: string;
+  replicaServers?: string[];
+  lastReplicationAt?: number;
+  replicationDirtyAt?: number;
+  lastReplicationError?: string;
+}
+
+export interface SharedObject {
+  type: ShareType;
+  version: number;
+  data: Record<string, unknown>;
+  meta: ShareMeta;
+  createdAt?: number | string;
+  updatedAt?: number | string;
+}
+
+export interface ShareSummary {
+  token: string;
+  type: ShareType;
+  title: string;
+  description?: string;
+  createdAt: number;
+  authorId: string;
+  authorName?: string;
+  authorAvatar?: string;
+  coverImage?: string;
+  coverImageUrl?: string;
+  agentKey?: string;
+  agentName?: string;
+  visibility?: "private" | "community";
+  originalId?: string;
+  mode?: "live";
+  originServer?: string;
+  tableDbKey?: string;
+  tableOwnerId?: string;
+  replicaServers?: string[];
+  lastReplicationAt?: number;
+  replicationDirtyAt?: number;
+  lastReplicationError?: string;
+  /** App URL — populated only for DataType.APP shares */
+  url?: string;
+  /** 被导入次数 */
+  importCount?: number;
+  /** 更新时间（毫秒时间戳） */
+  updatedAt?: number;
+}
+
+export const isShareType = (type: unknown): type is ShareType =>
+  type === DataType.DOC ||
+  type === DataType.DIALOG ||
+  type === DataType.CYBOT ||
+  type === DataType.IMAGE ||
+  type === DataType.APP ||
+  type === DataType.TABLE;
+
+export const SHARE_TYPE_LABELS: Record<ShareType, string> = {
+  [DataType.DOC]: "文章",
+  [DataType.DIALOG]: "对话",
+  [DataType.IMAGE]: "图片",
+  [DataType.CYBOT]: "AI",
+  [DataType.APP]: "应用",
+  [DataType.TABLE]: "表格",
+};
+
+export const getShareTypeLabel = (type: ShareType): string =>
+  SHARE_TYPE_LABELS[type] ?? "未知";