nolo-cli 0.1.29 → 0.1.31

package/database/server/authorityStoreConformance.ts

@@ -0,0 +1,209 @@
+import { describe, expect, it } from "bun:test";
+
+import type { AuthorityStore } from "./authorityStoreTypes";
+
+type FakeLevelOp = { type: "put" | "del"; key: string; value?: unknown };
+
+type FakeNotFoundError = Error & { notFound: true };
+
+const createNotFoundError = (): FakeNotFoundError => {
+  const error = new Error("NotFound") as FakeNotFoundError;
+  error.notFound = true;
+  return error;
+};
+
+export class FakeAuthorityBacking {
+  location = "/tmp/authority-conformance";
+  status = "closed";
+  private readonly data = new Map<string, unknown>();
+
+  async open() {
+    this.status = "open";
+  }
+
+  async close() {
+    this.status = "closed";
+  }
+
+  async get(key: string) {
+    if (!this.data.has(key)) {
+      throw createNotFoundError();
+    }
+    return this.data.get(key);
+  }
+
+  async put(key: string, value: unknown) {
+    this.data.set(key, value);
+  }
+
+  async del(key: string) {
+    this.data.delete(key);
+  }
+
+  batch(ops?: FakeLevelOp[]) {
+    if (Array.isArray(ops)) {
+      return Promise.resolve().then(async () => {
+        for (const op of ops) {
+          if (op.type === "put") {
+            await this.put(op.key, op.value);
+          } else {
+            await this.del(op.key);
+          }
+        }
+      });
+    }
+
+    const buffered: FakeLevelOp[] = [];
+    return {
+      put: (key: string, value: unknown) => {
+        buffered.push({ type: "put", key, value });
+      },
+      del: (key: string) => {
+        buffered.push({ type: "del", key });
+      },
+      write: async () => {
+        await this.batch(buffered);
+      },
+    };
+  }
+
+  async *iterator(options: {
+    gte?: string;
+    lte?: string;
+    lt?: string;
+    reverse?: boolean;
+  } = {}) {
+    const keys = Array.from(this.data.keys()).sort();
+    if (options.reverse) keys.reverse();
+    for (const key of keys) {
+      if (options.gte && key < options.gte) continue;
+      if (options.lte && key > options.lte) continue;
+      if (options.lt && key >= options.lt) continue;
+      yield [key, this.data.get(key)] as [string, unknown];
+    }
+  }
+}
+
+type CreateStore = () => Promise<{
+  backing: FakeAuthorityBacking;
+  store: AuthorityStore;
+}>;
+
+export function runAuthorityStoreConformanceSuite(
+  label: string,
+  createStore: CreateStore,
+  options: {
+    expectedLocation?: string;
+  } = {}
+) {
+  const expectedLocation =
+    options.expectedLocation ?? "/tmp/authority-conformance";
+
+  describe(label, () => {
+    it("preserves open/close status, location, and NotFound semantics", async () => {
+      const { store } = await createStore();
+
+      expect(store.status).toBe("closed");
+      expect(store.location).toBe(expectedLocation);
+
+      await store.open();
+      expect(store.status).toBe("open");
+
+      await expect(store.get("missing")).rejects.toMatchObject({
+        message: "NotFound",
+        notFound: true,
+      });
+
+      await store.close();
+      expect(store.status).toBe("closed");
+    });
+
+    it("supports direct put/get/del writes", async () => {
+      const { store } = await createStore();
+
+      await store.put("alpha", { value: 1 });
+      await store.put("beta", { value: 2 });
+
+      expect(await store.get("alpha")).toEqual({ value: 1 });
+      expect(await store.get("beta")).toEqual({ value: 2 });
+
+      await store.del("alpha");
+      await expect(store.get("alpha")).rejects.toMatchObject({
+        message: "NotFound",
+        notFound: true,
+      });
+    });
+
+    it("supports array-style batchWrite with mixed put/del operations", async () => {
+      const { store } = await createStore();
+
+      await store.batchWrite([
+        { type: "put", key: "alpha", value: 1 },
+        { type: "put", key: "beta", value: 2 },
+        { type: "del", key: "alpha" },
+      ]);
+
+      await expect(store.get("alpha")).rejects.toMatchObject({
+        message: "NotFound",
+        notFound: true,
+      });
+      expect(await store.get("beta")).toBe(2);
+    });
+
+    it("supports builder-style createBatch writes", async () => {
+      const { store } = await createStore();
+
+      await store.put("alpha", 1);
+
+      const batch = store.createBatch();
+      batch.put("beta", 2);
+      batch.del("alpha");
+      batch.put("gamma", 3);
+      await batch.write();
+
+      await expect(store.get("alpha")).rejects.toMatchObject({
+        message: "NotFound",
+        notFound: true,
+      });
+      expect(await store.get("beta")).toBe(2);
+      expect(await store.get("gamma")).toBe(3);
+    });
+
+    it("preserves ordered iterator range semantics", async () => {
+      const { store } = await createStore();
+
+      await store.put("a", 1);
+      await store.put("b", 2);
+      await store.put("c", 3);
+
+      const scanned: Array<[string, unknown]> = [];
+      for await (const entry of store.iterator({ gte: "a", lt: "c" })) {
+        scanned.push(entry);
+      }
+
+      expect(scanned).toEqual([
+        ["a", 1],
+        ["b", 2],
+      ]);
+    });
+
+    it("preserves reverse iterator semantics within a bounded range", async () => {
+      const { store } = await createStore();
+
+      await store.put("a", 1);
+      await store.put("b", 2);
+      await store.put("c", 3);
+
+      const scanned: string[] = [];
+      for await (const [key] of store.iterator({
+        gte: "a",
+        lte: "c",
+        reverse: true,
+      })) {
+        scanned.push(key);
+      }
+
+      expect(scanned).toEqual(["c", "b", "a"]);
+    });
+  });
+}

package/database/server/authorityStoreTypes.ts

@@ -0,0 +1,31 @@
+export type AuthorityBatchOperation =
+  | { type: "put"; key: string; value: unknown }
+  | { type: "del"; key: string };
+
+export type AuthorityIteratorOptions = {
+  gte?: string;
+  lte?: string;
+  lt?: string;
+  reverse?: boolean;
+};
+
+export interface AuthorityBatchWriter {
+  put(key: string, value: unknown): void;
+  del(key: string): void;
+  write(): Promise<void>;
+}
+
+export interface AuthorityStore {
+  readonly location?: string;
+  readonly status?: string;
+  open(): Promise<void>;
+  close(): Promise<void>;
+  get<T = any>(key: string): Promise<T>;
+  put(key: string, value: unknown): Promise<void>;
+  del(key: string): Promise<void>;
+  batchWrite(ops: AuthorityBatchOperation[]): Promise<void>;
+  createBatch(): AuthorityBatchWriter;
+  iterator(
+    options?: AuthorityIteratorOptions
+  ): AsyncIterableIterator<[string, unknown]>;
+}

package/database/server/coreDataProxy.ts

@@ -1,4 +1,4 @@
-import { classifyCoreDataKey } from "./coreDataOwnership";
+import { classifyCoreDataKey } from "./coreDataOwnership";
 
 const normalizeOrigin = (value: string | URL | null | undefined): string => {
   try {

package/database/server/dataHandlers.ts

@@ -1,5 +1,6 @@
 import { pino } from "pino";
-import serverDb from "./db";
+import { getServerAuthorityStore } from "./db";
+import { writeStoreOps } from "./storeBatchCompat";
 import { chargeTokenUsageWithLedger } from "../../auth/server/tokenUsageBilling";
 
 const logger = pino({ name: "dataHandlers" });
@@ -11,12 +12,18 @@ export const handleToken = async (
   customKey?: string,
   actionUserId?: string,
 ) => {
+  const store = getServerAuthorityStore();
   const isStatsKey = customKey.includes("token-stats");
-  await serverDb.put(customKey, data);
+  await store.put(customKey, data);
 
   if (!isStatsKey && data.cost && data.cost > 0) {
     try {
       const txId = `token-${customKey}`;
+      const billingStore = {
+        get: (key: string) => store.get(key),
+        batch: (ops: Array<{ type: "put"; key: string; value: unknown }>) =>
+          writeStoreOps(store, ops),
+      };
       logger.info({
         event: "token_split_ledger_charge_start",
         userId: data.userId,
@@ -24,7 +31,7 @@ export const handleToken = async (
         txId,
       });
       const chargeResult = await chargeTokenUsageWithLedger({
-        store: serverDb,
+        store: billingStore,
         userId: data.userId,
         tokenKey: customKey,
         tokenRecord: data,
@@ -77,9 +84,10 @@ export const handleToken = async (
 };
 
 export const handleCybot = async (data: any, res: any, customKey: string) => {
+  const store = getServerAuthorityStore();
   try {
-    await serverDb.put(customKey, data);
-    const savedData = await serverDb.get(customKey);
+    await store.put(customKey, data);
+    const savedData = await store.get(customKey);
 
     const isDataMatch = JSON.stringify(data) === JSON.stringify(savedData);
     if (!isDataMatch) {

package/database/server/db.ts

@@ -1,37 +1,17 @@
 // 文件路径: packages/database/server/db.ts
 
-import { Level } from "level";
-import path from "path";
-import fs from "fs";
 import { ensureDbOpen } from "./ensureDbOpen";
 import { resolveServerDbPath } from "./dbPath";
+import type { LegacyServerDb } from "./legacyServerDb";
+import type { AuthorityStore } from "./authorityStoreTypes";
+import { getOrCreateServerStoreRuntime } from "./serverStoreFactory";
 
 const DB_PATH = resolveServerDbPath();
 
-// 确保目录存在
-if (!fs.existsSync(path.dirname(DB_PATH))) {
-  fs.mkdirSync(path.dirname(DB_PATH), { recursive: true });
-}
-
 console.log("数据库配置:");
 console.log("- 当前工作目录:", process.cwd());
 console.log("- 数据库路径:", DB_PATH);
 
-// 安全 JSON 编码：解码失败时返回 null 而非抛异常，防止损坏记录导致进程崩溃
-const safeJsonEncoding = {
-  name: "safe-json",
-  format: "utf8" as const,
-  encode: (data: any) => JSON.stringify(data),
-  decode: (data: string) => {
-    try {
-      return JSON.parse(data);
-    } catch {
-      console.warn("[LevelDB] Corrupted value:", data?.substring?.(0, 60));
-      return null;
-    }
-  },
-};
-
 export function isServerDbLockError(error: unknown): boolean {
   const queue: unknown[] = [error];
   const seen = new Set<unknown>();
@@ -55,13 +35,11 @@ export function isServerDbLockError(error: unknown): boolean {
   return false;
 }
 
-// 单例实例：挂在 globalThis 上，--hot 模式下模块重新求值时复用同一实例，避免 LevelDB 锁冲突
-if (!(globalThis as any).__serverDb) {
-  (globalThis as any).__serverDb = new Level<string, any>(DB_PATH, {
-    valueEncoding: safeJsonEncoding,
-  });
-}
-const serverDb: Level<string, any> = (globalThis as any).__serverDb;
+const {
+  authorityStore,
+  serverDb,
+}: { authorityStore: AuthorityStore; serverDb: LegacyServerDb } =
+  getOrCreateServerStoreRuntime(DB_PATH);
 
 console.log("- LevelDB实际路径:", serverDb.location);
 
@@ -70,6 +48,9 @@ export default serverDb;
 
 // 具名导出：需要的时候可以引用
 export { serverDb };
+export function getServerAuthorityStore() {
+  return authorityStore;
+}
 
 /**
  * 确保数据库处于 open 状态。
@@ -77,11 +58,11 @@ export { serverDb };
  * - 其他状态：尝试 open，一旦失败抛错
  */
 export async function ensureServerDbOpen() {
-  const status = (serverDb as any).status;
+  const status = authorityStore.status;
   if (status === "open") return;
 
   try {
-    await ensureDbOpen(serverDb);
+    await ensureDbOpen(authorityStore);
     if (status !== "opening") {
       console.log("✅ LevelDB 已打开");
     }
@@ -106,11 +87,11 @@ export async function openServerDb() {
  * 优雅关机时关闭 DB
  */
 export async function closeServerDb() {
-  const status = (serverDb as any).status;
+  const status = authorityStore.status;
   if (status !== "open") return;
 
   try {
-    await serverDb.close();
+    await authorityStore.close();
     console.log("✅ LevelDB 已关闭");
   } catch (err) {
     console.error("❌ 关闭 LevelDB 失败:", err);

package/database/server/delete.ts

@@ -1,6 +1,6 @@
 // 文件: database/server/delete.ts
 
-import serverDb from "./db";
+import { getServerAuthorityStore } from "./db";
 import { DataType } from "../../create/types";
 import { deleteMessages } from "../../chat/messages/deleteMessages";
 import { deleteTable } from "../table/deleteTable";
@@ -15,13 +15,14 @@ import {
 } from "../keys";
 import { buildTombstoneRecord, isTombstoneRecord } from "../tombstones";
 import { canDeleteSpaceMemberRecord, parseSpaceMemberKey } from "./spaceMemberAuthority";
-import {
-  bootstrapReplicatedTable,
-  findActiveLiveShareByTable,
-  isLiveTableShareRecord,
-  patchShareMeta,
-  replicateSharedTableMutation,
-} from "../../share/server/tableReplication";
+import {
+  bootstrapReplicatedTable,
+  findActiveLiveShareByTable,
+  isLiveTableShareRecord,
+  patchShareMeta,
+  replicateSharedTableMutation,
+} from "../../share/server/tableReplication";
+import { createStoreBatch, writeStoreOps } from "./storeBatchCompat";
 
 type DeleteRequest = Request & {
   // 视你的路由库而定，这里假定有 params.id
@@ -48,7 +49,7 @@ const getRequestOrigin = (req: Request): string => {
   }
 };
 
-const getForwardHeaders = (req: any): Record<string, string> => {
+const getForwardHeaders = (req: any): Record<string, string> => {
   const headers: Record<string, string> = {
     "Content-Type": "application/json",
   };
@@ -62,14 +63,15 @@ const getForwardHeaders = (req: any): Record<string, string> => {
     headers.Authorization = authHeader;
   }
   return headers;
-};
-
-const findLiveTableSharesByDbKey = async (tableDbKey: string) => {
-  const shares: any[] = [];
-  for await (const [dbKey, value] of serverDb.iterator({
-    gte: "share-",
-    lte: "share-\uffff",
-  })) {
+};
+
+const findLiveTableSharesByDbKey = async (tableDbKey: string) => {
+  const store = getServerAuthorityStore();
+  const shares: any[] = [];
+  for await (const [dbKey, value] of store.iterator({
+    gte: "share-",
+    lte: "share-\uffff",
+  })) {
     if (
       isLiveTableShareRecord(value, tableDbKey)
     ) {
@@ -135,18 +137,33 @@ const canSystemUserDeletePublicCybot = (
   return isPublicCybotKey && isSystemUser;
 };
 
-const canSystemAdminDeleteCommunityShare = (
-  dbKey: string,
-  actionUserId: string | undefined,
-  data: any
+const canSystemAdminDeleteCommunityShare = (
+  dbKey: string,
+  actionUserId: string | undefined,
+  data: any
 ): boolean => {
   if (!isSystemAdmin(actionUserId)) return false;
-  if (!shareKey.isShareKey(dbKey)) return false;
-  return data?.meta?.visibility === "community";
-};
-
-export const handleDelete = async (req: DeleteRequest) => {
-  try {
+  if (!shareKey.isShareKey(dbKey)) return false;
+  return data?.meta?.visibility === "community";
+};
+
+const createDeleteCompatDb = (store = getServerAuthorityStore()) => ({
+  batch: (
+    ops?: Array<{ type: "put" | "del"; key: string; value?: unknown }>
+  ) => {
+    if (Array.isArray(ops)) {
+      return writeStoreOps(store, ops);
+    }
+    return createStoreBatch(store);
+  },
+  iterator: (options: { gte: string; lte: string }) => store.iterator(options),
+  del: (key: string) => store.del(key),
+});
+
+export const handleDelete = async (req: DeleteRequest) => {
+  const store = getServerAuthorityStore();
+  const deleteCompatDb = createDeleteCompatDb(store);
+  try {
     const authResult = await authenticateRequest(req);
     const actionUserId = authResult instanceof Response ? undefined : authResult.userId;
 
@@ -154,10 +171,10 @@ export const handleDelete = async (req: DeleteRequest) => {
     const url = new URL(req.url);
     const type = url.searchParams.get("type");
 
-    // 1. 删除消息的专用分支
-    if (type === "messages") {
-      try {
-        const result = await deleteMessages(serverDb, id);
+    // 1. 删除消息的专用分支
+    if (type === "messages") {
+      try {
+        const result = await deleteMessages(deleteCompatDb, id);
         return new Response(JSON.stringify(result), {
           status: 200,
           headers: CORS_HEADERS,
@@ -174,11 +191,11 @@ export const handleDelete = async (req: DeleteRequest) => {
     }
 
     // 1.5 删除整张表（meta + 所有行 + 所有索引）的专用分支
-    if (type === "table") {
-      // 先拿 meta 数据做权限校验
-      let meta;
-      try {
-        meta = await serverDb.get(id);
+    if (type === "table") {
+      // 先拿 meta 数据做权限校验
+      let meta;
+      try {
+        meta = await store.get(id);
       } catch (err: any) {
         if (err.notFound) {
           return new Response(JSON.stringify({ message: "Table already deleted", processingIds: [] }), {
@@ -209,10 +226,10 @@ export const handleDelete = async (req: DeleteRequest) => {
         );
       }
 
-      await propagateTableDeleteToReplicas(req, id);
-
-      // 真正执行整表删除
-      const { processingIds } = await deleteTable(serverDb, id);
+      await propagateTableDeleteToReplicas(req, id);
+
+      // 真正执行整表删除
+      const { processingIds } = await deleteTable(deleteCompatDb, id);
 
       return new Response(
         JSON.stringify({
@@ -226,10 +243,10 @@ export const handleDelete = async (req: DeleteRequest) => {
       );
     }
 
-    // 2. 删除通用数据（单 key 删除）
-    let data;
-    try {
-      data = await serverDb.get(id);
+    // 2. 删除通用数据（单 key 删除）
+    let data;
+    try {
+      data = await store.get(id);
     } catch (err: any) {
       if (err.notFound) {
         return new Response(
@@ -287,16 +304,16 @@ export const handleDelete = async (req: DeleteRequest) => {
           );
         }
 
-        // Share 记录 → 物理删除（主记录 + 所有索引键）；通用记录 → tombstone
-        if (isShareRecord) {
-          const indexes = shareKey.allIndexKeysFromShare(id, data);
-          const batch = serverDb.batch();
-          batch.del(id);
-          for (const ik of indexes) batch.del(ik);
-          await batch.write();
-        } else {
-          await serverDb.put(id, buildTombstoneRecord(data, new Date().toISOString()));
-        }
+        // Share 记录 → 物理删除（主记录 + 所有索引键）；通用记录 → tombstone
+        if (isShareRecord) {
+          const indexes = shareKey.allIndexKeysFromShare(id, data);
+          const batch = store.createBatch();
+          batch.del(id);
+          for (const ik of indexes) batch.del(ik);
+          await batch.write();
+        } else {
+          await store.put(id, buildTombstoneRecord(data, new Date().toISOString()));
+        }
 
         if (
           data?.type === DataType.TABLE_ROW &&
@@ -411,15 +428,15 @@ export const handleDelete = async (req: DeleteRequest) => {
           invalidatePublicAgentsCache();
         }
 
-        // 如果被删除的是 Agent，则级联清理所有的收藏关系及统计
-        if (isAgentKey(id)) {
-          const { start, end } = createFavoriteKey.userRangeOfAgentKey(id);
-          const batch = serverDb.batch();
-
-          for await (const [reverseKey] of serverDb.iterator({
-            gte: start,
-            lte: end,
-          })) {
+        // 如果被删除的是 Agent，则级联清理所有的收藏关系及统计
+        if (isAgentKey(id)) {
+          const { start, end } = createFavoriteKey.userRangeOfAgentKey(id);
+          const batch = store.createBatch();
+
+          for await (const [reverseKey] of store.iterator({
+            gte: start,
+            lte: end,
+          })) {
             if (!reverseKey.startsWith(start)) continue;
 
             // reverseKey: fav-agent-key-by-agent-{agentKey}-{userId}
@@ -439,14 +456,14 @@ export const handleDelete = async (req: DeleteRequest) => {
 
         // 如果被删除的是 Dialog，则级联清理该对话下的所有消息
         // Dialog Key 结构: dialog-{userId}-{dialogId} (3 parts)
-        const parts = id.split("-");
-        if (parts[0] === "dialog" && parts.length === 3) {
-          const dialogId = parts[2];
-          if (dialogId) {
-            console.log(`[Delete] Cascading messages for dialog: ${dialogId}`);
-            await deleteMessages(serverDb, dialogId);
-          }
-        }
+        const parts = id.split("-");
+        if (parts[0] === "dialog" && parts.length === 3) {
+          const dialogId = parts[2];
+          if (dialogId) {
+            console.log(`[Delete] Cascading messages for dialog: ${dialogId}`);
+            await deleteMessages(deleteCompatDb, dialogId);
+          }
+        }
       }
 
       return new Response(

package/database/server/emailRepository.ts

@@ -8,15 +8,17 @@ import type {
 } from "../email";
 import { emailKey } from "../keys";
 import type { ApiContext, ApiError } from "../../server/api/types";
-import {
-  type EmailProvider,
-  type EmailProviderSendResult,
-} from "../../server/email/provider";
-import { getEmailProvider } from "../../server/email/providerRegistry";
-import { authorizeActorRecordAccess } from "./actorAccess";
-import { agentDelegationKey } from "./agentDelegation";
-import serverDb from "./db";
-import { resolveKeyOwnerId } from "./writeAuthority";
+import {
+  type EmailProvider,
+  type EmailProviderSendResult,
+} from "../../server/email/provider";
+import { getEmailProvider } from "../../server/email/providerRegistry";
+import { authorizeActorRecordAccess } from "./actorAccess";
+import { agentDelegationKey } from "./agentDelegation";
+import { getServerAuthorityStore } from "./db";
+import { resolveKeyOwnerId } from "./writeAuthority";
+
+const serverDb = getServerAuthorityStore();
 
 type CreateEmailRecordInput = {
   ownerId: string;

package/database/server/fileService.ts

@@ -3,12 +3,13 @@
 import path from "path";
 import { mkdir } from "node:fs/promises";
 import { ulid } from "ulid";
-import serverDb from "./db";
+import { getServerAuthorityStore } from "./db";
 import { blobKey, fileKey, fileIdIndexKey, fileStatKey } from "../keys";
 import { isTombstoneRecord } from "../tombstones";
 import { DataType } from "../../create/types";
 
 const UPLOAD_DIR = path.join(process.cwd(), "data", "uploads");
+const serverDb = getServerAuthorityStore();
 
 type JsonRecord = Record<string, any>;