nolo-cli 0.1.39 → 0.1.41

package/database/actions/write.ts

@@ -0,0 +1,146 @@
+// 文件路径: database/actions/write.ts
+
+import type { AppThunkApi } from "../../app/store";
+import { getRuntimeServerContext } from "../runtimeServerContext";
+import { DataType } from "../../create/types";
+import { normalizeTimeFields, logger } from "./common";
+import {
+  resolveAuthorityReplicationServers,
+  scheduleWriteReplication,
+} from "./replication";
+import { toast } from "../../app/utils/toast";
+
+const SPACE_MEMBER_PREFIX = "space-member-";
+
+const getMemberUserIdFromSpaceMemberKey = (dbKey: string): string | null => {
+  if (!dbKey.startsWith(SPACE_MEMBER_PREFIX)) return null;
+  const rest = dbKey.slice(SPACE_MEMBER_PREFIX.length);
+  const lastDash = rest.lastIndexOf("-");
+  if (lastDash <= 0) return null;
+  return rest.slice(0, lastDash);
+};
+
+// 辅助函数：保存到本地 DB
+const saveToClientDb = async (
+  clientDb: any,
+  dbKey: string,
+  data: 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, data);
+    logger.debug({ dbKey }, "Data saved successfully to local database.");
+  } catch (err: any) {
+    logger.error({ err, dbKey }, "Failed to save data to local database");
+    throw new Error(`Local database put failed for ${dbKey}: ${err.message}`);
+  }
+};
+
+/**
+ * Write Action: 写入新数据项。
+ * 1. 验证数据类型。
+ * 2. 规范化数据（添加时间戳、dbKey、userId）。
+ * 3. 保存数据到本地数据库。
+ * 4. 若在线，异步将完整数据写入所有服务器。
+ */
+export const writeAction = async (
+  writeConfig: { data: any; customKey: string; userId?: string },
+  thunkApi: AppThunkApi
+): Promise<any> => {
+  const { db: clientDb } = thunkApi.extra;
+  if (!clientDb) {
+    throw new Error("Client database instance is required in writeAction");
+  }
+
+  const state = thunkApi.getState();
+  const { currentServer, syncServers, currentUserId } =
+    getRuntimeServerContext(state);
+
+  const { data, customKey } = writeConfig;
+  const userId = writeConfig.userId || currentUserId;
+  const isSpaceMemberRecord = customKey.startsWith(SPACE_MEMBER_PREFIX);
+  const recordUserId = isSpaceMemberRecord
+    ? data.userId || getMemberUserIdFromSpaceMemberKey(customKey) || userId
+    : userId;
+
+  // 1. 基础参数校验
+  if (!data || !customKey) {
+    const errorMsg =
+      "Invalid arguments for writeAction: data and customKey are required.";
+    logger.error(errorMsg, { writeConfig });
+    toast.error(errorMsg);
+    throw new Error(errorMsg);
+  }
+
+  // 2. 类型校验（保持原有行为：非法类型只告警，不阻塞）
+  const VALID_TYPES = [
+    DataType.MSG,
+    DataType.CYBOT,
+    DataType.DOC,
+    DataType.DIALOG,
+    DataType.NOTIFICATION,
+    DataType.TOKEN,
+    DataType.TRANSACTION,
+    DataType.SPACE,
+    DataType.SETTING,
+    DataType.TABLE,
+    DataType.TABLE_ROW,
+    DataType.EMAIL,
+  ];
+  if (!data.type || !VALID_TYPES.includes(data.type)) {
+    logger.warn(
+      `Invalid data type "${data.type}" for writeAction with key ${customKey}. Proceeding anyway.`
+    );
+  }
+
+  try {
+    // 3. 规范化数据（时间字段 / dbKey / userId）
+    const willSaveData = normalizeTimeFields({
+      ...data,
+      dbKey: customKey,
+      userId: recordUserId,
+    });
+
+    // 4. 本地保存
+    await saveToClientDb(clientDb, customKey, willSaveData);
+
+    // 5. 计算远程服务器列表（currentServer + syncServers，带去重 + 离线判断）
+    const servers = resolveAuthorityReplicationServers({
+      currentServer,
+      syncServers,
+      dbKey: customKey,
+      record: willSaveData,
+      state,
+    });
+
+    const serverWriteConfig = {
+      data: willSaveData,
+      customKey,
+      userId: recordUserId,
+    };
+
+    // 6. 后台异步同步到远程（若在线且有可用服务器）
+    if (servers.length > 0) {
+      logger.debug(
+        `[writeAction] Initiating background sync for key: ${customKey} to ${servers.length} servers.`
+      );
+      scheduleWriteReplication(servers, serverWriteConfig, state);
+    } else {
+      logger.warn(
+        "[writeAction] No available servers, data only saved locally.",
+        { customKey }
+      );
+    }
+
+    return willSaveData;
+  } catch (error: any) {
+    const errorMessage = `Write action failed for ${customKey}: ${error?.message || "Unknown error"
+      }`;
+    logger.error("[writeAction] Error:", error);
+    toast.error(`Failed to save data for ${customKey}.`);
+    throw new Error(errorMessage);
+  }
+};

package/database/authority/ownerKey.ts

@@ -0,0 +1,80 @@
+const USER_OWNED_SECOND_SEGMENT_PREFIXES = new Set([
+  "agent",
+  "cybot",
+  "dialog",
+  "page",
+  "doc",
+  "notification",
+  "email",
+  "meta",
+  "row",
+  "view",
+  "file",
+  "job",
+]);
+
+const PUBLIC_OWNER_SENTINELS = new Set(["pub", "id", "stats", "index"]);
+
+const cleanSegment = (value: string | undefined): string | null => {
+  const trimmed = typeof value === "string" ? value.trim() : "";
+  return trimmed.length > 0 ? trimmed : null;
+};
+
+const normalizeCandidateOwners = (
+  candidateOwnerUserIds: Array<string | null | undefined> | undefined
+): string[] => {
+  const out: string[] = [];
+  for (const candidate of candidateOwnerUserIds ?? []) {
+    const normalized = cleanSegment(candidate ?? undefined);
+    if (!normalized || PUBLIC_OWNER_SENTINELS.has(normalized)) continue;
+    if (!out.includes(normalized)) out.push(normalized);
+  }
+  return out.sort((left, right) => right.length - left.length);
+};
+
+export const resolveCandidateOwnerFromKeyRemainder = (
+  remainder: string,
+  candidateOwnerUserIds: Array<string | null | undefined> | undefined
+): string | null => {
+  const normalizedRemainder = cleanSegment(remainder);
+  if (!normalizedRemainder) return null;
+
+  for (const candidate of normalizeCandidateOwners(candidateOwnerUserIds)) {
+    if (
+      normalizedRemainder === candidate ||
+      normalizedRemainder.startsWith(`${candidate}-`)
+    ) {
+      return candidate;
+    }
+  }
+
+  return null;
+};
+
+export const parseOwnerUserIdFromDbKey = (
+  dbKey: string,
+  options: {
+    candidateOwnerUserIds?: Array<string | null | undefined>;
+  } = {}
+): string | null => {
+  const normalized = cleanSegment(dbKey);
+  if (!normalized) return null;
+
+  const [prefix] = normalized.split("-");
+  if (!prefix) return null;
+  if (!USER_OWNED_SECOND_SEGMENT_PREFIXES.has(prefix)) return null;
+
+  const ownerAndRest = normalized.slice(prefix.length + 1);
+  const candidateOwner = resolveCandidateOwnerFromKeyRemainder(
+    ownerAndRest,
+    options.candidateOwnerUserIds
+  );
+  if (candidateOwner) return candidateOwner;
+
+  const [owner] = ownerAndRest.split("-");
+  const ownerUserId = cleanSegment(owner);
+  if (!ownerUserId) return null;
+  if (PUBLIC_OWNER_SENTINELS.has(ownerUserId)) return null;
+
+  return ownerUserId;
+};

package/database/authority/recordAuthority.ts

@@ -0,0 +1,67 @@
+import { parseOwnerUserIdFromDbKey } from "./ownerKey";
+import {
+  normalizeAuthorityServerOrigin,
+  resolveUserAuthorityServer,
+  type UserAuthorityRegistry,
+} from "./userAuthorityRegistry";
+
+export type RecordAuthorityInput = {
+  dbKey: string;
+  record?: Record<string, unknown> | null;
+  currentUserId?: string | null;
+  currentServer?: string | null;
+  userAuthorityRegistry?: UserAuthorityRegistry | null;
+};
+
+export type RecordAuthorityResolution = {
+  ownerUserId: string | null;
+  authorityServer: string | null;
+  serverOrigin: string | null;
+};
+
+const normalizeUserId = (value: unknown): string | null => {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+};
+
+const getRegistryOwnerCandidates = (
+  registry: UserAuthorityRegistry | null | undefined
+): string[] =>
+  registry && typeof registry === "object" && !Array.isArray(registry)
+    ? Object.keys(registry)
+    : [];
+
+export const resolveRecordAuthority = ({
+  dbKey,
+  record,
+  currentUserId,
+  currentServer,
+  userAuthorityRegistry,
+}: RecordAuthorityInput): RecordAuthorityResolution => {
+  const ownerUserId =
+    parseOwnerUserIdFromDbKey(dbKey, {
+      candidateOwnerUserIds: [
+        normalizeUserId(record?.userId),
+        normalizeUserId(currentUserId),
+        ...getRegistryOwnerCandidates(userAuthorityRegistry),
+      ],
+    }) ?? normalizeUserId(record?.userId);
+  const serverOrigin = normalizeAuthorityServerOrigin(record?.serverOrigin);
+  const explicitAuthority = normalizeAuthorityServerOrigin(record?.authorityServer);
+  const registryAuthority = resolveUserAuthorityServer({
+    ownerUserId,
+    registry: userAuthorityRegistry,
+  });
+  const currentUserAuthority =
+    ownerUserId && ownerUserId === normalizeUserId(currentUserId)
+      ? normalizeAuthorityServerOrigin(currentServer)
+      : null;
+
+  return {
+    ownerUserId,
+    authorityServer:
+      explicitAuthority ?? registryAuthority ?? currentUserAuthority ?? serverOrigin,
+    serverOrigin,
+  };
+};

package/database/authority/userAuthorityRegistry.ts

@@ -0,0 +1,54 @@
+export type UserAuthorityRegistryEntry =
+  | string
+  | {
+      authorityServer?: unknown;
+      homeServer?: unknown;
+      primaryServer?: unknown;
+      servers?: unknown;
+    };
+
+export type UserAuthorityRegistry = Record<string, UserAuthorityRegistryEntry>;
+
+export const normalizeAuthorityServerOrigin = (value: unknown): string | null => {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim().replace(/\/+$/, "");
+  return /^https?:\/\//i.test(trimmed) ? trimmed : null;
+};
+
+const normalizeUserId = (value: unknown): string | null => {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+};
+
+const readEntryAuthorityServer = (
+  entry: UserAuthorityRegistryEntry | undefined
+): string | null => {
+  if (typeof entry === "string") {
+    return normalizeAuthorityServerOrigin(entry);
+  }
+  if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+    return null;
+  }
+
+  return (
+    normalizeAuthorityServerOrigin(entry.authorityServer) ??
+    normalizeAuthorityServerOrigin(entry.homeServer) ??
+    normalizeAuthorityServerOrigin(entry.primaryServer)
+  );
+};
+
+export const resolveUserAuthorityServer = ({
+  ownerUserId,
+  registry,
+}: {
+  ownerUserId?: string | null;
+  registry?: UserAuthorityRegistry | null;
+}): string | null => {
+  const normalizedOwner = normalizeUserId(ownerUserId);
+  if (!normalizedOwner || !registry || typeof registry !== "object") {
+    return null;
+  }
+
+  return readEntryAuthorityServer(registry[normalizedOwner]);
+};

package/database/client/fetchUserData.ts

@@ -0,0 +1,61 @@
+import { getUserDataPrefixes } from "../queryPrefixes";
+
+interface FetchUserDataOptions {
+    includeDeleted?: boolean;
+}
+
+const attachQueriedKey = (key: string, value: any) => {
+    if (!value || typeof value !== "object") return value;
+    if (
+        typeof value.dbKey === "string" && value.dbKey.trim().length > 0
+    ) {
+        return value;
+    }
+    return {
+        ...value,
+        dbKey: key,
+    };
+};
+
+// 支持单类型或多类型查询
+// db should be passed from caller (e.g. thunk extra)
+export async function fetchUserData(
+    db: any,
+    types: string | string[],
+    userId: string,
+    options: FetchUserDataOptions = {}
+) {
+    const results: Record<string, any[]> = {};
+    const typeArray = Array.isArray(types) ? types : [types];
+    const includeDeleted = options.includeDeleted === true;
+
+    try {
+        for (const type of typeArray) {
+            const prefixes = getUserDataPrefixes(type, userId);
+            results[type] = [];
+            for (const prefix of prefixes) {
+                let iterator = db.iterator({
+                    gte: prefix,
+                    lte: `${prefix}\uffff`,
+                });
+
+                if (iterator && typeof iterator.then === "function") {
+                    iterator = await iterator;
+                }
+
+                // @ts-ignore - iterator compatibility
+                for await (const [key, value] of iterator) {
+                    const hydrated = attachQueriedKey(String(key), value);
+                    if (!hydrated) continue;
+                    if (!includeDeleted && hydrated.deletedAt) continue;
+                    results[type].push(hydrated);
+                }
+            }
+        }
+
+        return Array.isArray(types) ? results : results[types] ?? [];
+    } catch (error) {
+        console.error("Query error:", error);
+        throw error;
+    }
+}

package/database/dbActionThunks.ts

@@ -0,0 +1 @@
+export { readAndWait, patch, upsert, write } from "./dbSlice";

package/database/dbSlice.ts

@@ -0,0 +1,149 @@
+// 文件路径: database/dbSlice.ts
+
+import {
+  asyncThunkCreator,
+  buildCreateSlice,
+  createEntityAdapter,
+  type PayloadAction,
+} from "@reduxjs/toolkit";
+import type { RootState } from "../app/store";
+
+// Import actions
+import { removeAction } from "./actions/remove";
+import { readAction } from "./actions/read";
+import { readAndWaitAction } from "./actions/readAndWait";
+import { writeAction } from "./actions/write";
+import { patchAction } from "./actions/patch";
+import { upsertAction } from "./actions/upsert";
+import { uploadFileAction } from "./actions/upload";
+import { readFileContentAction } from "./actions/fileContent";
+import { shareResourceAction } from "../share/action";
+
+// Use dbKey as the entity's unique identifier
+export const dbAdapter = createEntityAdapter<any>({
+  selectId: (entity: any) => entity.dbKey,
+});
+
+// Selectors
+export const {
+  selectById,
+  selectEntities,
+  selectAll,
+  selectIds,
+  selectTotal,
+} = dbAdapter.getSelectors((state: RootState) => state.db);
+
+// Initial state
+const initialState = dbAdapter.getInitialState({});
+
+// Create slice with async thunks
+const createSliceWithThunks = buildCreateSlice({
+  creators: { asyncThunk: asyncThunkCreator },
+});
+
+// Slice definition
+const dbSlice = createSliceWithThunks({
+  name: "db",
+  initialState,
+  reducers: (create) => ({
+    // Async Thunks
+    read: create.asyncThunk(readAction, {
+      fulfilled: (state, action) => {
+        if (action.payload && Object.keys(action.payload).length > 0) {
+          dbAdapter.upsertOne(state, action.payload);
+        }
+      },
+    }),
+    readAndWait: create.asyncThunk(readAndWaitAction, {
+      fulfilled: (state, action) => {
+        if (action.payload && Object.keys(action.payload).length > 0) {
+          dbAdapter.upsertOne(state, action.payload);
+        }
+      },
+    }),
+    remove: create.asyncThunk(removeAction, {
+      fulfilled: (state, action) => {
+        const { dbKey } = action.payload;
+        if (dbKey) dbAdapter.removeOne(state, dbKey);
+      },
+    }),
+    write: create.asyncThunk(writeAction, {
+      fulfilled: (state, action) => {
+        if (
+          action.payload &&
+          action.payload.dbKey &&
+          Object.keys(action.payload).length > 0
+        ) {
+          dbAdapter.upsertOne(state, action.payload);
+        }
+      },
+    }),
+    patch: create.asyncThunk(patchAction, {
+      fulfilled: (state, action) => {
+        const { payload } = action;
+        if (payload && payload.dbKey && Object.keys(payload).length > 0) {
+          dbAdapter.upsertOne(state, payload);
+        }
+      },
+    }),
+    upsert: create.asyncThunk(upsertAction, {
+      fulfilled: (state, action) => {
+        if (
+          action.payload &&
+          action.payload.dbKey &&
+          Object.keys(action.payload).length > 0
+        ) {
+          dbAdapter.upsertOne(state, action.payload);
+        }
+      },
+    }),
+    // 文件上传（avatar / Slate / Space 等统一走这里）
+    upload: create.asyncThunk(uploadFileAction, {
+      fulfilled: (state, action) => {
+        const payload = action.payload;
+        if (payload && payload.dbKey && Object.keys(payload).length > 0) {
+          dbAdapter.upsertOne(state, payload);
+        }
+      },
+    }),
+    // 读取文件内容（优先本地 IndexedDB，无状态副作用）
+    readFileContent: create.asyncThunk(readFileContentAction, {
+      // fulfilled 时不修改 db state；由调用方通过 unwrap() 拿返回值使用
+    }),
+    share: create.asyncThunk(shareResourceAction, {
+      fulfilled: (state, action) => {
+        if (action.payload && action.payload.key) {
+          // We might want to store the shared object in local DB state too?
+          // writeAction already does it. This is just for return value.
+          // Actually, writeAction is dispatched inside shareResourceAction.
+          // Does writeAction update state? Yes.
+          // So here we might not need to do anything extra to state, 
+          // just define the thunk.
+        }
+      }
+    }),
+    // SSR 预取：服务端直接注入实体到 db slice，供首屏 hydrate 使用
+    upsertSSREntity: create.reducer((state, action: PayloadAction<any>) => {
+      if (action.payload && action.payload.dbKey) {
+        dbAdapter.upsertOne(state, action.payload);
+      }
+    }),
+  }),
+});
+
+// Export actions
+export const {
+  remove,
+  read,
+  readAndWait,
+  write,
+  patch,
+  upsert,
+  upload,
+  readFileContent,
+  share,
+  upsertSSREntity,
+} = dbSlice.actions;
+
+// Export the reducer
+export default dbSlice.reducer;

package/database/fileRing.ts

@@ -0,0 +1,51 @@
+// 文件路径: database/fileRing.ts
+
+/**
+ * 简单的 FNV-1a 32bit 字符串哈希
+ * - 稳定、实现简单，适合作为 hash ring 的排序依据
+ */
+const fnv1a32 = (str: string): number => {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < str.length; i++) {
+        hash ^= str.charCodeAt(i);
+        hash = (hash * 0x01000193) >>> 0; // 32bit
+    }
+    return hash >>> 0;
+};
+
+/**
+ * 通用服务器选择函数：
+ *
+ * 给定一组服务器和一个“key”（可以是 tenantId / userId / orgId / fileId …），
+ * 选择 replicaCount 个服务器作为该 key 的“归属服务器”。
+ *
+ * 规则：
+ * - 对每个 server 计算 hash(server + "::" + key)
+ * - 按 hash 升序排序
+ * - 取前 replicaCount 个
+ *
+ * 说明：
+ * - 这不是严格意义上的一致性哈希环，但分布效果 + 实现复杂度比较均衡；
+ * - 之后要支持更多服务器，只需要在配置中把新 server 加入列表即可，
+ *   这里不需要改代码。
+ */
+export const chooseServersByKey = (
+    allServers: string[],
+    key: string,
+    replicaCount: number
+): string[] => {
+    if (!allServers.length || replicaCount <= 0) return [];
+
+    const uniqueServers = Array.from(new Set(allServers)).filter((s) => !!s);
+    if (uniqueServers.length === 0) return [];
+
+    const scored = uniqueServers.map((server) => ({
+        server,
+        score: fnv1a32(`${server}::${key}`),
+    }));
+
+    scored.sort((a, b) => a.score - b.score);
+
+    const limit = Math.min(replicaCount, scored.length);
+    return scored.slice(0, limit).map((item) => item.server);
+};