nolo-cli 0.1.40 → 0.1.42

package/render/table/createTableAction.ts

@@ -0,0 +1,274 @@
+// 文件: render/table/createTableAction.ts
+
+import { formatISO } from "date-fns";
+import { ulid } from "ulid";
+import i18n from "../../app/i18n/client";
+
+import type { RootState, AppDispatch } from "../../app/store";
+import { selectUserId } from "../../auth/authSlice";
+import {
+  addContentToSpace,
+  selectCurrentSpaceId,
+} from "../../create/space/spaceSlice";
+import { write } from "../../database/dbSlice";
+import { metaKey, rowKey } from "../../database/keys";
+import { DataType } from "../../create/types";
+
+import type {
+  TableColumn,
+  TableColumnType,
+  CreateTableColumnInput,
+  TableMeta,
+} from "./types";
+
+/**
+ * 创建表时的输入参数：
+ * - spaceId        可选：不传则用当前 Space
+ * - title          可选：不传用默认文案（表显示名）
+ * - description    可选：表用途说明（包括每行代表什么，给人和 AI 看）
+ * - tags           可选：关键词标签列表（由 Agent 自动填比较合理）
+ * - categoryId     可选：Space 内分类
+ * - columns        可选：表字段定义（对象数组）
+ *   - 不传或为空时，自动使用默认两列：
+ *     1) title / 标题（主字段）
+ *     2) note  / 备注
+ * - withDefaultRows 可选：是否创建两行示例数据
+ */
+export interface CreateTableArgs {
+  spaceId?: string;
+  title?: string;
+  purpose?: string;
+  description?: string;
+  tags?: string[];
+  categoryId?: string;
+  columns?: CreateTableColumnInput[];
+  withDefaultRows?: boolean;
+}
+
+// 默认列定义：标题 + 备注
+const DEFAULT_COLUMNS: Omit<TableColumn, "id">[] = [
+  {
+    name: "title",
+    label: "标题",
+    type: "text",
+    description: "这一行记录的主题或名称。",
+    isPrimary: true,
+    required: true,
+  },
+  {
+    name: "note",
+    label: "备注",
+    type: "text",
+    description: "对该条目的补充说明。",
+    required: false,
+  },
+];
+
+/**
+ * 将 CreateTableColumnInput[] 归一化成 TableColumn[]
+ * - 为每一列生成 id
+ * - 清洗 name / label / type / description / isPrimary / required / options
+ * - 如果结果为空，则使用 DEFAULT_COLUMNS
+ */
+const normalizeColumns = (
+  inputColumns: CreateTableColumnInput[] | undefined
+): TableColumn[] => {
+  const base = Array.isArray(inputColumns) ? inputColumns : [];
+
+  const normalized: TableColumn[] = base
+    .map((c) => {
+      if (!c || typeof c.name !== "string") return null;
+      const name = c.name.trim();
+      if (!name) return null;
+
+      const col: TableColumn = {
+        id: c.id && typeof c.id === "string" && c.id.trim() ? c.id.trim() : ulid(),
+        name,
+      };
+
+      if (typeof c.label === "string" && c.label.trim()) {
+        col.label = c.label.trim();
+      }
+
+      if (typeof c.type === "string") {
+        col.type = c.type as TableColumnType;
+      }
+
+      if (typeof c.description === "string" && c.description.trim()) {
+        col.description = c.description.trim();
+      }
+
+      if (typeof c.isPrimary === "boolean") {
+        col.isPrimary = c.isPrimary;
+      }
+
+      if (typeof c.required === "boolean") {
+        col.required = c.required;
+      }
+
+      if (Array.isArray(c.options)) {
+        const opts = c.options
+          .map((opt) => (typeof opt === "string" ? opt.trim() : ""))
+          .filter(Boolean);
+        if (opts.length) {
+          col.options = opts;
+        }
+      }
+
+      return col;
+    })
+    .filter(Boolean) as TableColumn[];
+
+  if (normalized.length > 0) {
+    // 确保有一个主字段：如果没有 isPrimary，就把第一列设为主字段
+    if (!normalized.some((c) => c.isPrimary)) {
+      normalized[0].isPrimary = true;
+    }
+    return normalized;
+  }
+
+  // 未提供列时，使用默认：标题 + 备注
+  return DEFAULT_COLUMNS.map((c) => ({
+    ...c,
+    id: ulid(),
+  }));
+};
+
+/**
+ * 类似 createPageAction：
+ * 1) 基于当前 userId 生成 tableId + metaKey
+ * 2) 写入 TABLE meta
+ * 3) 可选：写入两行 TABLE_ROW 默认数据
+ * 4) 如果有 spaceId（或当前 Space），自动 addContentToSpace
+ * 5) 返回 dbKey（路由用）
+ */
+export const createTableAction = async (
+  {
+    spaceId: customSpaceId,
+    title: customTitle,
+    purpose: customPurpose,
+    description: customDescription,
+    tags: customTags,
+    categoryId,
+    columns,
+    withDefaultRows = true,
+  }: CreateTableArgs = {},
+  { dispatch, getState }: { dispatch: AppDispatch; getState: () => RootState }
+): Promise<string> => {
+  const state = getState();
+  const userId = selectUserId(state);
+  if (!userId) throw new Error("User ID not found.");
+
+  // Important:
+  // View-mode-based scoping belongs to the UI entry layer (currently the sidebar-top
+  // create button), not to this action.
+  // This action preserves explicit caller intent:
+  // - prefer `spaceId` when a caller passes it;
+  // - otherwise fall back to the current selected space only.
+  const spaceId = customSpaceId ?? selectCurrentSpaceId(state);
+
+  const tableId = ulid();
+
+  const now = new Date();
+  const nowIso = formatISO(now);
+
+  const dbKey = metaKey(userId, tableId);
+
+  const defaultTitle = i18n.t("table:defaultTitle", {
+    defaultValue: "新建表格",
+  });
+  const title = customTitle?.trim() || defaultTitle;
+
+  const purpose = customPurpose?.trim() || undefined;
+  const description = customDescription?.trim() || undefined;
+  const tags =
+    Array.isArray(customTags) && customTags.length
+      ? customTags
+        .map((t) => (typeof t === "string" ? t.trim() : ""))
+        .filter(Boolean)
+      : undefined;
+
+  // 1) 归一化列定义
+  const finalColumns: TableColumn[] = normalizeColumns(columns);
+
+  // 2) 写入表 meta（TABLE）
+  const tableMeta: TableMeta = {
+    dbKey,
+    tenantId: userId,
+    tableId,
+    spaceId: spaceId ?? null,
+    displayName: title,
+    purpose,
+    description,
+    tags,
+    schemaVersion: 1,
+    columns: finalColumns,
+    views: [], // 后续可以在 UI 中新增视图
+    triggers: [], // 后续可以在 UI/配置中新增触发器
+    aiConfig: undefined,
+    createdAt: nowIso,
+    updatedAt: nowIso,
+    type: DataType.TABLE,
+  };
+
+  await dispatch(
+    write({
+      data: tableMeta,
+      customKey: dbKey,
+    })
+  ).unwrap();
+
+  // 3) 可选：写入两行默认数据（TABLE_ROW）
+  if (withDefaultRows) {
+    const defaultRows = [
+      {
+        title: "示例一",
+        note: "你可以在这里记录任何内容，例如任务、想法或配置项。",
+      },
+      {
+        title: "示例二",
+        note: '双击单元格开始编辑，右上角可以添加字段和行。',
+      },
+    ];
+
+    await Promise.all(
+      defaultRows.map(async (values) => {
+        const { dbKey: rowKeyStr, rowId } = rowKey.create(userId, tableId);
+
+        const row = {
+          dbKey: rowKeyStr,
+          tenantId: userId,
+          tableId,
+          rowId,
+          createdAt: nowIso,
+          updatedAt: nowIso,
+          type: DataType.TABLE_ROW as const,
+          ...values,
+        };
+
+        await dispatch(
+          write({
+            data: row,
+            customKey: rowKeyStr,
+          })
+        ).unwrap();
+      })
+    );
+  }
+
+  // 4) 如果在某个 Space 中，把表挂到 Space.contents（关键点）
+  if (spaceId) {
+    await dispatch(
+      addContentToSpace({
+        spaceId,
+        contentKey: dbKey,
+        type: DataType.TABLE, // ContentType 里要有 "table"
+        title,
+        categoryId,
+      })
+    ).unwrap();
+  }
+
+  // 5) 返回 dbKey，用于路由跳转 /meta-{tenantId}-{tableId}
+  return dbKey;
+};

package/render/table/deleteTableAction.ts

@@ -0,0 +1,193 @@
+// 文件路径: render/table/deleteTableAction.ts
+
+import type { RootState, AppDispatch } from "../../app/store";
+import { getRuntimeServerContext } from "../../database/runtimeServerContext";
+import { SEPARATOR, createKey } from "../../database/keys";
+import { scheduleDeleteReplication } from "../../database/actions/replication";
+import { buildTombstoneRecord } from "../../database/tombstones";
+
+export interface DeleteTableArgs {
+  dbKey: string; // 形如：meta-{tenantId}-{tableId}
+}
+
+/**
+ * 从表的 meta dbKey 中解析 tenantId / tableId
+ * 约定：meta-{tenantId}-{tableId}
+ */
+const parseMetaKey = (dbKey: string): { tenantId: string; tableId: string } => {
+  const parts = dbKey.split(SEPARATOR);
+  if (parts[0] !== "meta" || parts.length < 3) {
+    throw new Error(`非法表 key：${dbKey}`);
+  }
+  const tenantId = parts[1];
+  const tableId = parts.slice(2).join(SEPARATOR);
+  return { tenantId, tableId };
+};
+
+const collectEntriesByPrefix = async (
+  db: any,
+  prefix: string
+): Promise<Array<[string, unknown]>> => {
+  const entries: Array<[string, unknown]> = [];
+
+  for await (const [key, value] of db.iterator({
+    gte: prefix,
+    lte: prefix + "\uffff",
+  })) {
+    entries.push([key as string, value]);
+  }
+
+  return entries;
+};
+
+const belongsToTable = (
+  value: unknown,
+  tenantId: string,
+  tableId: string
+): value is Record<string, any> =>
+  Boolean(
+    value &&
+      typeof value === "object" &&
+      (value as any).tenantId === tenantId &&
+      (value as any).tableId === tableId
+  );
+
+const indexValueReferencesRows = (
+  value: unknown,
+  rowDbKeys: Set<string>,
+  rowIds: Set<string>
+): boolean => {
+  if (typeof value === "string") {
+    return rowDbKeys.has(value) || rowIds.has(value);
+  }
+  if (!value || typeof value !== "object") return false;
+  const candidate = value as Record<string, any>;
+  return (
+    (typeof candidate.dbKey === "string" && rowDbKeys.has(candidate.dbKey)) ||
+    (typeof candidate.rowDbKey === "string" &&
+      rowDbKeys.has(candidate.rowDbKey)) ||
+    (typeof candidate.rowId === "string" && rowIds.has(candidate.rowId))
+  );
+};
+
+/**
+ * 删除整张表（本地 + 同步服务器）：
+ *
+ * 本地：
+ *   1) 从 meta dbKey 中解析 tenantId / tableId
+ *   2) 给该表的所有行写 tombstone：row-{tenantId}-{tableId}-{rowId}
+ *   3) 删除该表的所有索引：idx-{tenantId}-{tableId}-...
+ *   4) 删除该表的所有视图：view-{tenantId}-{tableId}-{viewId}
+ *   6) 给表本身的 meta 写 tombstone：meta-{tenantId}-{tableId}
+ *
+ * 远端：
+ *   - 使用 syncWithServers + noloDeleteRequest，
+ *     调用后端统一 DELETE 接口：
+ *       DELETE /db/{metaDbKey}?type=table
+ *
+ * 说明：
+ *   - 当前实现假定：一张逻辑表严格属于单个 tenant：
+ *       对于任意 meta-{tenantId}-{tableId}，
+ *       所有行满足 row.tenantId === tenantId 且 row.tableId === tableId。
+ *   - 不做历史兼容处理，如有旧数据可通过清库 / 迁移脚本处理。
+ */
+export const deleteTableAction = async (
+  { dbKey }: DeleteTableArgs,
+  {
+    dispatch,
+    getState,
+    extra,
+  }: {
+    dispatch: AppDispatch;
+    getState: () => RootState;
+    extra: { db: any };
+  }
+): Promise<string> => {
+  const { db } = extra;
+  const state = getState();
+  const { currentServer, syncServers } = getRuntimeServerContext(state);
+
+  const { tenantId, tableId } = parseMetaKey(dbKey);
+
+  const nowIso = new Date().toISOString();
+
+  // 1) 本地收集所有行：row-{tenantId}-{tableId}-{rowId}
+  const rowPrefix = createKey("row", tenantId, tableId, "");
+  const rowEntries = (await collectEntriesByPrefix(db, rowPrefix)).filter(
+    ([, value]) => belongsToTable(value, tenantId, tableId)
+  );
+  const rowDbKeys = new Set(rowEntries.map(([key]) => key));
+  const rowIds = new Set(
+    rowEntries
+      .map(([, value]) => value.rowId)
+      .filter((rowId): rowId is string => typeof rowId === "string")
+  );
+
+  // 2) 本地收集所有索引 key：idx-{tenantId}-{tableId}-...
+  const idxPrefix = createKey("idx", tenantId, tableId, "");
+  const idxEntries = await collectEntriesByPrefix(db, idxPrefix);
+  const idxKeys = idxEntries
+    .filter(([, value]) =>
+      belongsToTable(value, tenantId, tableId) ||
+      indexValueReferencesRows(value, rowDbKeys, rowIds)
+    )
+    .map(([key]) => key);
+
+  // 3) 本地收集所有视图 key：view-{tenantId}-{tableId}-{viewId}
+  const viewPrefix = createKey("view", tenantId, tableId, "");
+  const viewEntries = await collectEntriesByPrefix(db, viewPrefix);
+  const viewKeys = viewEntries
+    .filter(([, value]) => belongsToTable(value, tenantId, tableId))
+    .map(([key]) => key);
+
+
+  const metaRecord =
+    typeof db.get === "function" ? await db.get(dbKey).catch(() => null) : null;
+
+  // 5) 需要物理删除的 key：索引 + 视图；meta/row 写 tombstone 参与多服务器合并。
+  const keysToDelete = Array.from(
+    new Set<string>([
+      ...idxKeys,
+      ...viewKeys,
+    ])
+  );
+
+  const putOps = [
+    ...(metaRecord && typeof metaRecord === "object"
+      ? [
+          {
+            type: "put" as const,
+            key: dbKey,
+            value: buildTombstoneRecord(metaRecord, nowIso),
+          },
+        ]
+      : []),
+    ...rowEntries.map(([key, value]) => ({
+      type: "put" as const,
+      key,
+      value: buildTombstoneRecord(value, nowIso),
+    })),
+  ];
+
+  if (keysToDelete.length > 0 || putOps.length > 0) {
+    const ops = [
+      ...putOps,
+      ...keysToDelete.map((key) => ({
+        type: "del" as const,
+        key,
+      })),
+    ];
+    await db.batch(ops);
+  }
+
+  // 6) local-first：本地先删除，远端整表删除在后台收敛。
+  scheduleDeleteReplication({
+    currentServer,
+    syncServers,
+    dbKey,
+    deleteOptions: { type: "table" as const },
+    state,
+  });
+
+  return dbKey;
+};

package/render/table/fetchAndCacheTableRows.ts

@@ -0,0 +1,174 @@
+import { DataType } from "../../create/types";
+import { rowKey } from "../../database/keys";
+
+const getRowTimestamp = (row: any): number => {
+  if (!row || typeof row !== "object") return 0;
+  const updatedAt = Date.parse(row.updatedAt ?? "");
+  if (Number.isFinite(updatedAt) && updatedAt > 0) return updatedAt;
+  const createdAt = Date.parse(row.createdAt ?? "");
+  return Number.isFinite(createdAt) && createdAt > 0 ? createdAt : 0;
+};
+
+const shouldReplaceMergedRow = (nextRow: any, currentRow: any): boolean => {
+  const nextTs = getRowTimestamp(nextRow);
+  const currentTs = getRowTimestamp(currentRow);
+  if (nextTs !== currentTs) return nextTs > currentTs;
+  return Boolean(nextRow?.deletedAt) && !currentRow?.deletedAt;
+};
+
+const mergeTableRows = (...rowLists: any[][]): any[] => {
+  const merged = new Map<string, any>();
+
+  for (const rowList of rowLists) {
+    for (const row of rowList) {
+      const dbKey = row?.dbKey;
+      if (!dbKey) continue;
+      const existing = merged.get(dbKey);
+      if (!existing || shouldReplaceMergedRow(row, existing)) {
+        merged.set(dbKey, row);
+      }
+    }
+  }
+
+  return Array.from(merged.values());
+};
+
+const loadLocalTableRows = async (
+  db: any,
+  tenantId: string,
+  tableId: string
+): Promise<any[]> => {
+  if (!db || typeof db.iterator !== "function") {
+    return [];
+  }
+
+  const rows: any[] = [];
+  const { gte, lte } = rowKey.range(tenantId, tableId);
+
+  try {
+    for await (const [, value] of db.iterator({ gte, lte })) {
+      if (value?.type === DataType.TABLE_ROW) {
+        rows.push(value);
+      }
+    }
+  } catch {
+    return [];
+  }
+
+  return rows;
+};
+
+const fetchTableRowsFromServer = async (
+  server: string,
+  tenantId: string,
+  tableId: string,
+  headers: Record<string, string>
+): Promise<any[]> => {
+  const res = await fetch(`${server}/rpc/listTableRows`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ tenantId, tableId }),
+  });
+
+  if (!res.ok) {
+    let msg = `加载表 ${tableId} 行失败（${res.status}）`;
+    try {
+      const err = await res.json();
+      if (err && typeof err.message === "string") {
+        msg = err.message;
+      }
+    } catch {
+      // ignore
+    }
+    throw new Error(msg);
+  }
+
+  const data = await res.json();
+  if (!Array.isArray(data)) {
+    throw new Error("服务器返回格式错误：预期为数组");
+  }
+  return data;
+};
+
+export const cacheMergedTableRows = async (db: any, mergedRows: any[]) => {
+  if (!db) return;
+
+  await Promise.all(
+    mergedRows.map(async (mergedRow: any) => {
+      if (!mergedRow?.dbKey) return;
+      try {
+        const localRow = await db.get(mergedRow.dbKey).catch(() => null);
+        if (!localRow) {
+          await db.put(mergedRow.dbKey, mergedRow);
+          return;
+        }
+
+        const serverTs = new Date(
+          mergedRow.updatedAt ?? mergedRow.createdAt ?? 0
+        ).getTime();
+        const localTs = new Date(
+          localRow.updatedAt ?? localRow.createdAt ?? 0
+        ).getTime();
+        const shouldOverwrite =
+          serverTs > localTs ||
+          (serverTs === localTs &&
+            Boolean(mergedRow.deletedAt) &&
+            !Boolean(localRow.deletedAt));
+
+        if (shouldOverwrite) {
+          await db.put(mergedRow.dbKey, mergedRow);
+        }
+      } catch {
+        // Ignore local cache errors.
+      }
+    })
+  );
+};
+
+export const fetchAndCacheTableRows = async ({
+  db,
+  tenantId,
+  tableId,
+  token,
+  remoteServers = [],
+}: {
+  db: any;
+  tenantId: string;
+  tableId: string;
+  token?: string | null;
+  remoteServers?: string[];
+}): Promise<any[]> => {
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+  };
+  if (token) {
+    headers.Authorization = `Bearer ${token}`;
+  }
+
+  const localRows = await loadLocalTableRows(db, tenantId, tableId);
+  const remoteResults = await Promise.allSettled(
+    remoteServers.map((server) =>
+      fetchTableRowsFromServer(server, tenantId, tableId, headers)
+    )
+  );
+
+  const fulfilledRemoteRows = remoteResults
+    .filter(
+      (result): result is PromiseFulfilledResult<any[]> =>
+        result.status === "fulfilled"
+    )
+    .map((result) => result.value);
+
+  if (fulfilledRemoteRows.length === 0 && localRows.length === 0) {
+    const firstFailure = remoteResults.find(
+      (result): result is PromiseRejectedResult =>
+        result.status === "rejected"
+    );
+    throw new Error(firstFailure?.reason?.message || "加载表行失败");
+  }
+
+  const mergedRows = mergeTableRows(localRows, ...fulfilledRemoteRows);
+  await cacheMergedTableRows(db, mergedRows);
+
+  return mergedRows.filter((row) => !row?.deletedAt);
+};