nolo-cli 0.1.13 → 0.1.14

package/database/server/writeAuthority.ts

@@ -0,0 +1,133 @@
+const TWO_PART_USER_KEYS = new Set(["settings", "profile"]);
+const OWNER_IN_SECOND_SEGMENT_PREFIXES = new Set([
+  "dialog",
+  "page",
+  "doc",
+  "email",
+  "file",
+  "meta",
+  "row",
+  "agent",
+  "cybot",
+  "app",
+  "notification",
+  "token",
+  "image",
+]);
+
+export const resolveKeyOwnerId = (dbKey: string): string | null => {
+  if (!dbKey || typeof dbKey !== "string") return null;
+
+  const parts = dbKey.split("-");
+  if (parts.length === 2 && TWO_PART_USER_KEYS.has(parts[1])) {
+    return parts[0] || null;
+  }
+
+  if (parts[0] === "user" && parts[1] === "pref" && parts.length >= 4) {
+    return parts[2] || null;
+  }
+
+  if (
+    parts[0] === "space" &&
+    (parts[1] === "setting" || parts[1] === "member") &&
+    parts.length >= 4
+  ) {
+    return parts[2] || null;
+  }
+
+  if (
+    parts[0] === "token" &&
+    parts[1] === "stats" &&
+    parts[2] === "day" &&
+    parts[3] === "user" &&
+    parts.length >= 6
+  ) {
+    return parts[4] || null;
+  }
+
+  if (parts[0] === "dialog" && parts[2] === "msg") {
+    return null;
+  }
+
+  if (parts[0] === "email" && parts.length >= 3) {
+    return parts.slice(1, -1).join("-") || null;
+  }
+
+  if (OWNER_IN_SECOND_SEGMENT_PREFIXES.has(parts[0]) && parts.length >= 3) {
+    if (parts[1] === "pub") {
+      return null;
+    }
+    return parts[1] || null;
+  }
+
+  return null;
+};
+
+export const resolveWriteAuthority = ({
+  dbKey,
+  actionUserId,
+  existingRecord,
+}: {
+  dbKey: string;
+  actionUserId?: string | null;
+  existingRecord?: any;
+}) => {
+  const keyOwnerId = resolveKeyOwnerId(dbKey);
+  const recordOwnerId =
+    (typeof existingRecord?.ownerId === "string" && existingRecord.ownerId) ||
+    (typeof existingRecord?.userId === "string" && existingRecord.userId) ||
+    null;
+  const isKeyOwner =
+    Boolean(actionUserId) && Boolean(keyOwnerId) && keyOwnerId === actionUserId;
+  const isRecordOwner =
+    Boolean(actionUserId) &&
+    Boolean(recordOwnerId) &&
+    recordOwnerId === actionUserId;
+  const isMember =
+    Boolean(actionUserId) &&
+    Array.isArray(existingRecord?.members) &&
+    existingRecord.members.includes(actionUserId);
+
+  return {
+    keyOwnerId,
+    recordOwnerId,
+    isAllowed: Boolean(isKeyOwner || isRecordOwner || isMember),
+    isKeyOwner,
+    isRecordOwner,
+    isMember,
+  };
+};
+
+export const canWriteRecord = ({
+  dbKey,
+  actionUserId,
+  record,
+}: {
+  dbKey: string;
+  actionUserId?: string | null;
+  record?: any;
+}) => {
+  const { keyOwnerId, recordOwnerId, isAllowed } = resolveWriteAuthority({
+    dbKey,
+    actionUserId,
+    existingRecord: record,
+  });
+
+  if (keyOwnerId && recordOwnerId && keyOwnerId !== recordOwnerId) {
+    return {
+      keyOwnerId,
+      recordOwnerId,
+      isAllowed: false,
+    };
+  }
+
+  return {
+    keyOwnerId,
+    recordOwnerId,
+    isAllowed:
+      isAllowed ||
+      (Boolean(actionUserId) &&
+        !keyOwnerId &&
+        !recordOwnerId),
+  };
+};

package/database/sqliteDb.ts

@@ -0,0 +1,46 @@
+// 文件路径: packages/database/sqliteDb.ts
+import { Database } from "bun:sqlite";
+import { getDbFilePath } from "./utils/dbPath";
+
+const userDatabases = new Map<string, Database>();
+
+/**
+ * 获取指定用户的 SQLite 数据库实例。
+ * 如果该用户的数据库实例尚未打开，则会创建并打开它。
+ * @param userId 用户的唯一 ID。
+ * @returns 对应用户的 SQLite 数据库实例。
+ */
+export function getSqliteDb(userId: string): Database {
+  let dbInstance = userDatabases.get(userId);
+
+  if (!dbInstance) {
+    const dbPath = getDbFilePath(userId);
+
+    dbInstance = new Database(dbPath, { create: true });
+
+    // WAL 模式：更适合高并发读写
+    dbInstance.exec("PRAGMA journal_mode = WAL;");
+
+    userDatabases.set(userId, dbInstance);
+
+    console.log(`SQLite Database connected for user ${userId}: ${dbPath}`);
+  }
+
+  return dbInstance;
+}
+
+/**
+ * 关闭所有已打开的用户 SQLite 数据库连接。
+ * 由应用入口在优雅关机时统一调用。
+ */
+export function closeAllUserSqliteDbs() {
+  console.log("Closing all user-specific SQLite database connections...");
+  for (const [userId, db] of userDatabases.entries()) {
+    try {
+      db.close(false);
+      console.log(`Closed DB for user ${userId}.`);
+    } catch (e) {
+      console.error(`Error closing DB for user ${userId}:`, e);
+    }
+  }
+}

package/database/table/deleteTable.ts

@@ -0,0 +1,120 @@
+// 文件: database/table/deleteTable.ts
+
+import {
+  idxKey,
+  isTableMetaKey,
+  rowKey,
+  SEPARATOR,
+  createKey,
+} from "database/keys";
+
+export interface KeyValueDB {
+  iterator: (opts: {
+    gte?: string;
+    lte?: string;
+    keys?: boolean;
+    values?: boolean;
+  }) => AsyncIterable<[string, unknown]>;
+  del: (key: string) => Promise<void>;
+  batch?: (ops: { type: "del"; key: string }[]) => Promise<void>;
+}
+
+export interface DeleteTableResult {
+  processingIds: string[];
+}
+
+/**
+ * 从 meta key 中解析 tenantId / tableId
+ * 约定：meta-{tenantId}-{tableId}
+ */
+const parseMetaKey = (metaDbKey: string) => {
+  if (!isTableMetaKey(metaDbKey)) {
+    throw new Error(
+      `deleteTable 预期传入的是表 meta key（meta-{tenantId}-{tableId}），收到: ${metaDbKey}`
+    );
+  }
+
+  const [, tenantId, tableId] = metaDbKey.split(SEPARATOR);
+  return { tenantId, tableId };
+};
+
+/**
+ * 扫描一个范围内的所有 key（只取 key，不取 value）
+ */
+const collectKeysInRange = async (
+  db: KeyValueDB,
+  range: { gte: string; lte: string }
+): Promise<string[]> => {
+  const keys: string[] = [];
+
+  let iterator = (db as any).iterator({
+    gte: range.gte,
+    lte: range.lte,
+    keys: true,
+    values: false,
+  });
+
+  if (iterator && typeof iterator.then === 'function') {
+    iterator = await iterator;
+  }
+
+  for await (const [key] of iterator) {
+    keys.push(key as string);
+  }
+
+  return keys;
+};
+
+/**
+ * 删除一整张表：
+ * - 入参是表的 meta key：meta-{tenantId}-{tableId}
+ * - 删除：
+ *   1) 所有行：row-{tenantId}-{tableId}-{rowId}
+ *   2) 所有索引：idx-{tenantId}-{tableId}-{indexName}-{indexKey}-{rowId}
+ *   3) 所有视图：view-{tenantId}-{tableId}-{viewId}
+ *   5) meta 本身：meta-{tenantId}-{tableId}
+ */
+export const deleteTable = async (
+  db: KeyValueDB,
+  metaDbKey: string
+): Promise<DeleteTableResult> => {
+  const { tenantId, tableId } = parseMetaKey(metaDbKey);
+
+  const keysToDelete = new Set<string>();
+  // 先把 meta 自己加进去
+  keysToDelete.add(metaDbKey);
+
+  // 1) 收集所有行 key
+  const rowRange = rowKey.range(tenantId, tableId);
+  const rowKeys = await collectKeysInRange(db, rowRange);
+  rowKeys.forEach((k) => keysToDelete.add(k));
+
+  // 2) 收集所有索引 key
+  const indexRange = idxKey.prefix(tenantId, tableId);
+  const indexKeys = await collectKeysInRange(db, indexRange);
+  indexKeys.forEach((k) => keysToDelete.add(k));
+
+  // 3) 收集所有视图 key：view-{tenantId}-{tableId}-{viewId}
+  const viewPrefix = createKey("view", tenantId, tableId, "");
+  const viewKeys = await collectKeysInRange(db, {
+    gte: viewPrefix,
+    lte: viewPrefix + "\uffff",
+  });
+  viewKeys.forEach((k) => keysToDelete.add(k));
+
+  const processingIds = Array.from(keysToDelete);
+
+  // 5) 批量删除
+  if (typeof db.batch === "function") {
+    await db.batch(
+      processingIds.map((key) => ({
+        type: "del" as const,
+        key,
+      }))
+    );
+  } else {
+    await Promise.all(processingIds.map((key) => db.del(key)));
+  }
+
+  return { processingIds };
+};

package/database/tenantPlacement.ts

@@ -0,0 +1,57 @@
+// 文件路径: database/tenantPlacement.ts
+
+import { chooseServersByKey } from "./fileRing";
+
+/**
+ * 当前 tenant（用户 / 组织）的副本个数：
+ *
+ * - TENANT_REPLICA_COUNT = 2:
+ *   表示每个 tenant 至少分布在 2 台服务器上（例如 main + us）。
+ *
+ * 后续如果要提高容灾能力，可以改为 3，
+ * 但是建议不要轻易降低（否则会破坏“至少两台机器有数据”的假设）。
+ */
+export const TENANT_REPLICA_COUNT = 2;
+
+/**
+ * 基于 tenantId（通常为 userId）为某个 tenant 选择服务器集合。
+ *
+ * 目标：
+ * - 同一个 tenant 的所有数据（结构化 + 文件）尽量落在同一组服务器上；
+ * - 至少 TENANT_REPLICA_COUNT 台服务器；
+ * - currentServer 若在 allServers 中，强制包含在结果中（早期可以保证 main 一定在内）。
+ *
+ * 参数：
+ * - allServers: 由 currentServer + syncServers 去重后得到的服务器列表。
+ * - currentServer: 当前前端所连接的主服务器（可以为 null/undefined）。
+ * - tenantId: 租户 ID，当前你可以直接用 userId。
+ *
+ * 返回：
+ * - servers: 用于写入该 tenant 数据的服务器列表。
+ */
+export const planServersForTenant = (
+    allServers: string[],
+    currentServer: string | null | undefined,
+    tenantId: string | null | undefined
+): string[] => {
+    const uniqueServers = Array.from(new Set(allServers)).filter(Boolean);
+    if (!uniqueServers.length) return [];
+
+    const key = tenantId && tenantId.trim() ? tenantId.trim() : "default-tenant";
+
+    // 基于 tenantId 进行 hash ring 分布
+    const fromRing = chooseServersByKey(
+        uniqueServers,
+        key,
+        TENANT_REPLICA_COUNT
+    );
+
+    const set = new Set(fromRing);
+
+    // 强制包含 currentServer（若其在配置中）
+    if (currentServer && uniqueServers.includes(currentServer)) {
+        set.add(currentServer);
+    }
+
+    return Array.from(set);
+};

package/database/tombstones.ts

@@ -0,0 +1,52 @@
+export const getRecordTimestamp = (record: any): number => {
+  if (!record || typeof record !== "object") return 0;
+
+  const candidates = [
+    record.updatedAt,
+    record.updated_at,
+    record.createdAt,
+    record.created,
+    record?.meta?.createdAt,
+  ];
+
+  for (const candidate of candidates) {
+    if (typeof candidate === "number" && Number.isFinite(candidate) && candidate > 0) {
+      return candidate;
+    }
+    if (typeof candidate === "string" && candidate.trim()) {
+      const timestamp = Date.parse(candidate);
+      if (Number.isFinite(timestamp) && timestamp > 0) {
+        return timestamp;
+      }
+    }
+  }
+
+  return 0;
+};
+
+export const isTombstoneRecord = (record: any): boolean => {
+  if (!record || typeof record !== "object") return false;
+  const deletedAt = record.deletedAt;
+  if (typeof deletedAt === "string") return deletedAt.trim().length > 0;
+  return Boolean(deletedAt);
+};
+
+export const shouldReplaceWithNextRecord = (
+  nextRecord: any,
+  currentRecord: any
+): boolean => {
+  const nextTs = getRecordTimestamp(nextRecord);
+  const currentTs = getRecordTimestamp(currentRecord);
+
+  if (nextTs !== currentTs) return nextTs > currentTs;
+  return isTombstoneRecord(nextRecord) && !isTombstoneRecord(currentRecord);
+};
+
+export const buildTombstoneRecord = <T extends Record<string, any>>(
+  record: T,
+  nowIso: string
+): T & { deletedAt: string; updatedAt: string } => ({
+  ...record,
+  deletedAt: nowIso,
+  updatedAt: nowIso,
+});

package/database/userDataLoadDecision.ts

@@ -0,0 +1,17 @@
+export type UserDataLoadDecision = "load" | "skip" | "queue";
+
+export const getUserDataLoadDecision = ({
+  loading,
+  sameParams,
+  forceRefresh,
+}: {
+  loading: boolean;
+  sameParams: boolean;
+  forceRefresh?: boolean;
+}): UserDataLoadDecision => {
+  if (forceRefresh) {
+    return loading ? "queue" : "load";
+  }
+
+  return loading || sameParams ? "skip" : "load";
+};

package/database/userDataMerge.ts

@@ -0,0 +1,95 @@
+import {
+  getRecordTimestamp,
+  isTombstoneRecord,
+  shouldReplaceWithNextRecord,
+} from "./tombstones";
+
+interface MergeableUserDataItem {
+  id?: string;
+  dbKey?: string;
+  contentKey?: string;
+  appKey?: string;
+  appId?: string;
+  [key: string]: any;
+}
+
+export const getUserDataItemTimestamp = (dataItem: MergeableUserDataItem): number =>
+  getRecordTimestamp(dataItem);
+
+const getItemKey = (item: MergeableUserDataItem): string | null => {
+  // dbKey 必须优先于 id：dbKey 是全局唯一的 "type-userId-id" 格式，
+  // 而 id 可能只是 ULID 短串，与本地 tombstone 的 dbKey 不匹配会导致
+  // merge 时 tombstone 无法覆盖远端活记录。
+  const candidates = [
+    typeof item.dbKey === "string" ? item.dbKey : undefined,
+    item.id,
+    typeof item.contentKey === "string" ? item.contentKey : undefined,
+    typeof item.appKey === "string" ? item.appKey : undefined,
+    typeof item.appId === "string" ? item.appId : undefined,
+  ];
+
+  for (const candidate of candidates) {
+    if (typeof candidate === "string" && candidate.trim().length > 0) {
+      return candidate;
+    }
+  }
+
+  return null;
+};
+
+export const mergeAndDedupUserData = (
+  localData: MergeableUserDataItem[],
+  remoteResults: any[],
+  options: { includeDeleted?: boolean } = {}
+): MergeableUserDataItem[] => {
+  const uniqueMap = new Map<string, MergeableUserDataItem>();
+
+  const mergeRecordMetadata = (
+    currentItem: MergeableUserDataItem,
+    nextItem: MergeableUserDataItem
+  ): MergeableUserDataItem => {
+    if (
+      typeof currentItem.serverOrigin !== "string" &&
+      typeof nextItem.serverOrigin === "string" &&
+      nextItem.serverOrigin.trim().length > 0
+    ) {
+      return {
+        ...currentItem,
+        serverOrigin: nextItem.serverOrigin,
+      };
+    }
+
+    return currentItem;
+  };
+
+  const addToMap = (item: MergeableUserDataItem) => {
+    const itemKey = getItemKey(item);
+    if (!itemKey) return;
+
+    const existing = uniqueMap.get(itemKey);
+    if (!existing) {
+      uniqueMap.set(itemKey, item);
+      return;
+    }
+
+    if (shouldReplaceWithNextRecord(item, existing)) {
+      uniqueMap.set(itemKey, item);
+      return;
+    }
+
+    uniqueMap.set(itemKey, mergeRecordMetadata(existing, item));
+  };
+
+  localData.forEach(addToMap);
+  remoteResults.forEach((result) => {
+    const items = result?.data?.data;
+    if (Array.isArray(items)) {
+      items.forEach(addToMap);
+    }
+  });
+
+  const merged = Array.from(uniqueMap.values());
+  return options.includeDeleted
+    ? merged
+    : merged.filter((item) => !isTombstoneRecord(item));
+};

package/database/userPreferenceRegister.ts

@@ -0,0 +1,108 @@
+import { DataType } from "create/types";
+import { ulid } from "database/utils/ulid";
+
+export const USER_PREFERENCE_NAMES = {
+  DEFAULT_SPACE: "space_default",
+  DEFAULT_AGENT: "agent_default",
+} as const;
+
+export type UserPreferenceName =
+  (typeof USER_PREFERENCE_NAMES)[keyof typeof USER_PREFERENCE_NAMES];
+
+export interface UserPreferenceRegisterRecord<T = unknown> {
+  type: DataType.SETTING;
+  registerType: "user_preference";
+  preferenceName: UserPreferenceName;
+  schemaVersion: 1;
+  userId: string;
+  value: T | null;
+  opId: string;
+  createdAt: number;
+  updatedAt: number;
+}
+
+const toTimestamp = (value: unknown): number => {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string") {
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : 0;
+  }
+  return 0;
+};
+
+const nextRegisterUpdatedAt = (previousRecord?: Partial<UserPreferenceRegisterRecord>) => {
+  const previousTimestamp = Math.max(
+    toTimestamp(previousRecord?.updatedAt),
+    toTimestamp(previousRecord?.createdAt)
+  );
+  return Math.max(Date.now(), previousTimestamp + 1);
+};
+
+export const buildUserPreferenceRegisterRecord = <T>({
+  userId,
+  preferenceName,
+  value,
+  previousRecord,
+}: {
+  userId: string;
+  preferenceName: UserPreferenceName;
+  value: T | null;
+  previousRecord?: Partial<UserPreferenceRegisterRecord<T>> | null;
+}): UserPreferenceRegisterRecord<T> => {
+  const updatedAt = nextRegisterUpdatedAt(previousRecord ?? undefined);
+
+  return {
+    type: DataType.SETTING,
+    registerType: "user_preference",
+    preferenceName,
+    schemaVersion: 1,
+    userId,
+    value,
+    opId: ulid(),
+    createdAt: toTimestamp(previousRecord?.createdAt) || updatedAt,
+    updatedAt,
+  };
+};
+
+export const readUserPreferenceRegisterValue = <T>(
+  record: any,
+  preferenceName: UserPreferenceName
+): T | null | undefined => {
+  if (!record || typeof record !== "object") return undefined;
+  if (record.registerType !== "user_preference") return undefined;
+  if (record.preferenceName !== preferenceName) return undefined;
+  if (!("value" in record)) return undefined;
+  return record.value as T | null;
+};
+
+export const buildDefaultAgentPreferenceRegisterRecord = ({
+  userId,
+  defaultAgentId,
+  previousRecord,
+}: {
+  userId: string;
+  defaultAgentId: string | null;
+  previousRecord?: Partial<UserPreferenceRegisterRecord<string>> | null;
+}) =>
+  buildUserPreferenceRegisterRecord<string>({
+    userId,
+    preferenceName: USER_PREFERENCE_NAMES.DEFAULT_AGENT,
+    value: defaultAgentId,
+    previousRecord,
+  });
+
+export const buildDefaultSpacePreferenceRegisterRecord = ({
+  userId,
+  defaultSpaceId,
+  previousRecord,
+}: {
+  userId: string;
+  defaultSpaceId: string | null;
+  previousRecord?: Partial<UserPreferenceRegisterRecord<string>> | null;
+}) =>
+  buildUserPreferenceRegisterRecord<string>({
+    userId,
+    preferenceName: USER_PREFERENCE_NAMES.DEFAULT_SPACE,
+    value: defaultSpaceId,
+    previousRecord,
+  });

package/database/utils/dbPath.ts

@@ -0,0 +1,47 @@
+// packages/database/utils/dbPath.ts (新建文件)
+import path from "path";
+import fs from "fs";
+
+// --- 路径计算和目录创建逻辑 ---
+
+// 使用 import.meta.dir 获取当前文件 (packages/database/utils/dbPath.ts) 的目录。
+const CURRENT_FILE_DIR = import.meta.dir;
+// => /path/to/BUN-NOLO/packages/database/utils
+
+// 构建项目根目录 (BUN-NOLO) 的绝对路径：
+// 从当前文件目录向上退三级 ('..', '..', '..')
+const PROJECT_ROOT = path.join(CURRENT_FILE_DIR, "..", "..", "..");
+// => /path/to/BUN-NOLO
+
+// 构建数据根目录的绝对路径：在项目根目录下找到 'data' 目录
+const DATA_BASE_DIRECTORY = path.join(PROJECT_ROOT, "data");
+// => /path/to/BUN-NOLO/data
+
+// 构建用户数据库文件的存放目录的绝对路径：在 'data' 目录下创建 'user_dbs'
+const USER_DATABASES_DIRECTORY = path.join(DATA_BASE_DIRECTORY, "user_dbs");
+// => /path/to/BUN-NOLO/data/user_dbs
+
+/**
+ * 辅助函数：确保指定目录存在。
+ * @param dirPath 要检查或创建的目录路径。
+ */
+function ensureDirectoryExists(dirPath: string) {
+  try {
+    fs.mkdirSync(dirPath, { recursive: true });
+  } catch (e: any) {
+    if (e.code !== "EEXIST") {
+      console.error(`Error creating directory ${dirPath}:`, e);
+      throw e;
+    }
+  }
+}
+
+/**
+ * 根据用户ID获取其专属SQLite数据库文件的完整路径。
+ * @param userId 用户的唯一ID。
+ * @returns 对应用户SQLite数据库文件的完整路径。
+ */
+export function getDbFilePath(userId: string): string {
+  ensureDirectoryExists(USER_DATABASES_DIRECTORY);
+  return path.join(USER_DATABASES_DIRECTORY, `${userId}.sqlite`);
+}

package/database/utils/ulid.native.ts

@@ -0,0 +1,6 @@
+import { monotonicFactory } from "ulid";
+
+// 简单的随机数生成器，虽然不加密安全，但在 RN 开发环境下够用了
+const prng = () => Math.random();
+
+export const ulid = monotonicFactory(prng);

package/database/utils/ulid.ts

@@ -0,0 +1 @@
+export { ulid } from "ulid";