nolo-cli 0.1.30 → 0.1.31

package/database/server/legacyServerDb.ts

@@ -0,0 +1,58 @@
+import type {
+  AuthorityBatchOperation,
+  AuthorityBatchWriter,
+  AuthorityIteratorOptions,
+  AuthorityStore,
+} from "./authorityStoreTypes";
+
+export type LegacyServerDb = {
+  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>;
+  batch(ops: AuthorityBatchOperation[]): Promise<void>;
+  batch(): AuthorityBatchWriter;
+  iterator(
+    options?: AuthorityIteratorOptions
+  ): AsyncIterableIterator<[string, unknown]>;
+};
+
+export function createLegacyServerDb(store: AuthorityStore): LegacyServerDb {
+  const batch = (ops?: AuthorityBatchOperation[]) => {
+    if (Array.isArray(ops)) {
+      return store.batchWrite(ops);
+    }
+    return store.createBatch();
+  };
+
+  return {
+    get location() {
+      return store.location;
+    },
+    get status() {
+      return store.status;
+    },
+    async open() {
+      await store.open();
+    },
+    async close() {
+      await store.close();
+    },
+    async get<T = any>(key: string) {
+      return store.get<T>(key);
+    },
+    async put(key: string, value: unknown) {
+      await store.put(key, value);
+    },
+    async del(key: string) {
+      await store.del(key);
+    },
+    batch: batch as LegacyServerDb["batch"],
+    iterator(options: AuthorityIteratorOptions = {}) {
+      return store.iterator(options);
+    },
+  };
+}

package/database/server/levelAuthorityStore.ts

@@ -0,0 +1,75 @@
+import type {
+  AuthorityBatchOperation,
+  AuthorityBatchWriter,
+  AuthorityIteratorOptions,
+  AuthorityStore,
+} from "./authorityStoreTypes";
+
+type LevelBatchWriterLike = {
+  put(key: string, value: unknown): unknown;
+  del(key: string): unknown;
+  write(): Promise<void>;
+};
+
+type LevelLike = {
+  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>;
+  batch(ops: AuthorityBatchOperation[]): Promise<void>;
+  batch(): LevelBatchWriterLike;
+  iterator(
+    options?: AuthorityIteratorOptions
+  ): AsyncIterableIterator<[string, unknown]>;
+};
+
+export function createLevelAuthorityStore(levelDb: LevelLike): AuthorityStore {
+  const createBatch = (): AuthorityBatchWriter => {
+    const batch = levelDb.batch();
+    return {
+      put(key: string, value: unknown) {
+        batch.put(key, value);
+      },
+      del(key: string) {
+        batch.del(key);
+      },
+      async write() {
+        await batch.write();
+      },
+    };
+  };
+
+  return {
+    get location() {
+      return levelDb.location;
+    },
+    get status() {
+      return levelDb.status;
+    },
+    async open() {
+      await levelDb.open?.();
+    },
+    async close() {
+      await levelDb.close?.();
+    },
+    async get<T = any>(key: string) {
+      return levelDb.get<T>(key);
+    },
+    async put(key: string, value: unknown) {
+      await levelDb.put(key, value);
+    },
+    async del(key: string) {
+      await levelDb.del(key);
+    },
+    async batchWrite(ops: AuthorityBatchOperation[]) {
+      await levelDb.batch(ops);
+    },
+    createBatch,
+    iterator(options: AuthorityIteratorOptions = {}) {
+      return levelDb.iterator(options);
+    },
+  };
+}

package/database/server/memoryAuthorityStore.ts

@@ -0,0 +1,133 @@
+import type {
+  AuthorityBatchOperation,
+  AuthorityBatchWriter,
+  AuthorityIteratorOptions,
+  AuthorityStore,
+} from "./authorityStoreTypes";
+
+type MemoryEntry = {
+  key: string;
+  value: unknown;
+};
+
+const createNotFoundError = () => {
+  const error = new Error("NotFound") as Error & { notFound: true };
+  error.notFound = true;
+  return error;
+};
+
+class MemoryAuthorityBacking {
+  readonly location: string;
+  status: "closed" | "open" = "closed";
+  private readonly data = new Map<string, unknown>();
+
+  constructor(location: string) {
+    this.location = location;
+  }
+
+  async open() {
+    this.status = "open";
+  }
+
+  async close() {
+    this.status = "closed";
+  }
+
+  async get<T = any>(key: string): Promise<T> {
+    if (!this.data.has(key)) {
+      throw createNotFoundError();
+    }
+    return this.data.get(key) as T;
+  }
+
+  async put(key: string, value: unknown) {
+    this.data.set(key, value);
+  }
+
+  async del(key: string) {
+    this.data.delete(key);
+  }
+
+  async batchWrite(ops: AuthorityBatchOperation[]) {
+    for (const op of ops) {
+      if (op.type === "put") {
+        this.data.set(op.key, op.value);
+      } else {
+        this.data.delete(op.key);
+      }
+    }
+  }
+
+  createBatch(): AuthorityBatchWriter {
+    const buffered: AuthorityBatchOperation[] = [];
+    return {
+      put(key: string, value: unknown) {
+        buffered.push({ type: "put", key, value });
+      },
+      del(key: string) {
+        buffered.push({ type: "del", key });
+      },
+      write: async () => {
+        await this.batchWrite(buffered);
+      },
+    };
+  }
+
+  async *iterator(
+    options: AuthorityIteratorOptions = {}
+  ): AsyncIterableIterator<[string, unknown]> {
+    const entries: MemoryEntry[] = Array.from(this.data.entries())
+      .sort(([left], [right]) => left.localeCompare(right))
+      .map(([key, value]) => ({ key, value }));
+
+    if (options.reverse) {
+      entries.reverse();
+    }
+
+    for (const entry of entries) {
+      if (options.gte && entry.key < options.gte) continue;
+      if (options.lte && entry.key > options.lte) continue;
+      if (options.lt && entry.key >= options.lt) continue;
+      yield [entry.key, entry.value];
+    }
+  }
+}
+
+export function createMemoryAuthorityStore(
+  location = ":memory:"
+): AuthorityStore {
+  const backing = new MemoryAuthorityBacking(location);
+
+  return {
+    get location() {
+      return backing.location;
+    },
+    get status() {
+      return backing.status;
+    },
+    async open() {
+      await backing.open();
+    },
+    async close() {
+      await backing.close();
+    },
+    async get<T = any>(key: string) {
+      return backing.get<T>(key);
+    },
+    async put(key: string, value: unknown) {
+      await backing.put(key, value);
+    },
+    async del(key: string) {
+      await backing.del(key);
+    },
+    async batchWrite(ops: AuthorityBatchOperation[]) {
+      await backing.batchWrite(ops);
+    },
+    createBatch() {
+      return backing.createBatch();
+    },
+    iterator(options: AuthorityIteratorOptions = {}) {
+      return backing.iterator(options);
+    },
+  };
+}

package/database/server/patch.ts

@@ -1,8 +1,8 @@
 // patch.js (或你的 patch 处理文件名)
-import { pino } from "pino";
-import { DataType } from "../../create/types";
-import serverDb from "./db"; // 确认路径正确
-import { handleToken } from "../../auth/server/token";
+import { pino } from "pino";
+import { DataType } from "../../create/types";
+import { getServerAuthorityStore } from "./db"; // 确认路径正确
+import { handleToken } from "../../auth/server/token";
 import {
   CYBOT_READONLY_MESSAGE,
   isCybotReadOnlyMutation,
@@ -63,8 +63,9 @@ const deepMerge = (target, source) => {
   return output;
 };
 
-export const handlePatch = async (req, res) => {
-  req.user = await handleToken(req, res);
+export const handlePatch = async (req, res) => {
+  const store = getServerAuthorityStore();
+  req.user = await handleToken(req, res);
 
   // --- 修改：变量名改为 dbKey，但仍然从 req.params.id 获取值 ---
   // (路由中仍然是 :id, 所以这里还是 req.params.id)
@@ -112,8 +113,8 @@ export const handlePatch = async (req, res) => {
   }
 
   try {
-    // --- 修改：使用 dbKey 变量与数据库交互 ---
-    const exist = await serverDb.get(dbKey);
+    // --- 修改：使用 dbKey 变量与数据库交互 ---
+    const exist = await store.get(dbKey);
     if (!exist) {
       // 使用 404 Not Found 更合适
       return res
@@ -152,10 +153,10 @@ export const handlePatch = async (req, res) => {
       });
     }
 
-    // 深度合并现有数据和变更 (保持不变)
-    const final = deepMerge(exist, changes);
-
-    await serverDb.put(dbKey, final);
+    // 深度合并现有数据和变更 (保持不变)
+    const final = deepMerge(exist, changes);
+
+    await store.put(dbKey, final);
 
     if (
       (final?.type === "table" || final?.type === "table_row") &&

package/database/server/query.ts

@@ -1,5 +1,5 @@
 // database/server/handler.ts
-import serverDb from "./db";
+import { getServerAuthorityStore } from "./db";
 import { getUserDataPrefixes } from "../queryPrefixes";
 
 interface BaseItem {
@@ -102,6 +102,7 @@ async function fetchUserData(
   userId: string,
   options: { includeDeleted?: boolean } = {}
 ): Promise<Record<string, BaseItem[]>> {
+  const store = getServerAuthorityStore();
   const results: Record<string, BaseItem[]> = {};
   if (!userId || userId === "local" || userId === "undefined") return results;
   const typeArray = Array.isArray(types) ? types : [types];
@@ -109,7 +110,7 @@ async function fetchUserData(
   for (const type of typeArray) {
     const prefixes = getUserDataPrefixes(type, userId);
     for (const prefix of prefixes) {
-      for await (const [key, value] of serverDb.iterator({
+      for await (const [key, value] of store.iterator({
         gte: prefix,
         lte: `${prefix}\uffff`,
       })) {

package/database/server/read.ts

@@ -1,7 +1,7 @@
 // 文件路径: packages/database/server/read.ts
 
-import serverDb, { ensureServerDbOpen } from "./db";
-import { DB_PREFIX, shareKey } from "../keys";
+import { getServerAuthorityStore } from "./db";
+import { DB_PREFIX, shareKey } from "../keys";
 import { parseToken, verifyToken } from "../../auth/token";
 import { assertSessionTokenVersion } from "../../auth/sessionTokenVersion";
 import { hasActiveEntitlement } from "../../auth/server/productEntitlements";
@@ -11,6 +11,7 @@ import { authorizeActorRecordAccess } from "./actorAccess";
 import {
   resolveSharePaidAccess,
 } from "../../share/paidAccess";
+import { ensureDbOpen } from "./ensureDbOpen";
 
 const isLevelNotFoundError = (error: any): boolean => {
   const code = error?.code;
@@ -33,17 +34,18 @@ const isPublicAgentKey = (dbKey: string): boolean =>
 const getUserIdFromProfileKey = (dbKey: string): string =>
   dbKey.slice(0, -PROFILE_KEY_SUFFIX.length);
 
-const getAuthorizedUserId = async (req: any): Promise<string | null> => {
-  const authHeader = req.headers?.get?.("authorization");
-  const token = typeof authHeader === "string" ? authHeader.split(" ")[1] : "";
-  if (!token) return null;
+const getAuthorizedUserId = async (req: any): Promise<string | null> => {
+  const store = getServerAuthorityStore();
+  const authHeader = req.headers?.get?.("authorization");
+  const token = typeof authHeader === "string" ? authHeader.split(" ")[1] : "";
+  if (!token) return null;
 
   const parsed = parseToken(token);
   const userId = parsed?.userId;
   if (!userId || typeof userId !== "string") return null;
-
-  try {
-    const user = await serverDb.get(`${DB_PREFIX.USER}${userId}`);
+
+  try {
+    const user = await store.get(`${DB_PREFIX.USER}${userId}`);
     if (!user?.publicKey || user?.isDisabled) return null;
 
     const payload = verifyToken(token, user.publicKey);
@@ -116,8 +118,9 @@ const isAgentOwner = (agent: any, userId: string | null): boolean =>
         agent?.userId === userId ||
         agent?.tenantId === userId)
   );
-export const handleReadSingle = async (req: any) => {
-  const corsHeaders = {
+export const handleReadSingle = async (req: any) => {
+  const store = getServerAuthorityStore();
+  const corsHeaders = {
     "Access-Control-Allow-Origin": "*",
     "Content-Type": "application/json",
   };
@@ -132,9 +135,9 @@ export const handleReadSingle = async (req: any) => {
   const dbKey = req.params.id;
   const isShareDataKey = dbKey.startsWith("share-") || shareKey.isShareKey(dbKey);
 
-  try {
-    // ⭐ 确保 LevelDB 已打开，避免 LEVEL_DATABASE_NOT_OPEN
-    await ensureServerDbOpen();
+  try {
+    // ⭐ 确保 LevelDB 已打开，避免 LEVEL_DATABASE_NOT_OPEN
+    await ensureDbOpen(store);
 
     const authedUserId = await getAuthorizedUserId(req);
     const isPublicAgentDataKey = isPublicAgentKey(dbKey);
@@ -156,19 +159,19 @@ export const handleReadSingle = async (req: any) => {
     if (!authedUserId && isPublicProfileKey(dbKey)) {
       const inviterId = getUserIdFromProfileKey(dbKey);
 
-      let profile: any = null;
-      try {
-        profile = await serverDb.get(dbKey);
-      } catch (error: any) {
-        if (!isLevelNotFoundError(error)) throw error;
-      }
-
-      let user: any = null;
-      try {
-        user = await serverDb.get(`${DB_PREFIX.USER}${inviterId}`);
-      } catch (error: any) {
-        if (!isLevelNotFoundError(error)) throw error;
-      }
+      let profile: any = null;
+      try {
+        profile = await store.get(dbKey);
+      } catch (error: any) {
+        if (!isLevelNotFoundError(error)) throw error;
+      }
+
+      let user: any = null;
+      try {
+        user = await store.get(`${DB_PREFIX.USER}${inviterId}`);
+      } catch (error: any) {
+        if (!isLevelNotFoundError(error)) throw error;
+      }
 
       if (user?.isDisabled) {
         return new Response(
@@ -195,8 +198,8 @@ export const handleReadSingle = async (req: any) => {
         headers: corsHeaders,
       });
     }
-
-    const result = await serverDb.get(dbKey);
+
+    const result = await store.get(dbKey);
     if (
       result === null ||
       typeof result === "undefined" ||
@@ -236,7 +239,7 @@ export const handleReadSingle = async (req: any) => {
       const paidAccess = resolveSharePaidAccess(result);
       if (paidAccess.mode === "product" && !owner) {
         const purchased = await hasActiveEntitlement({
-          store: serverDb,
+          store,
           userId: authedUserId,
           productId: paidAccess.productId,
         });

package/database/server/resourceAccess.ts

@@ -1,6 +1,6 @@
 import { isSystemAdmin } from "../../core/init";
 import { shareKey } from "../keys";
-import serverDb from "./db";
+import { getServerAuthorityStore } from "./db";
 import { resolveKeyOwnerId } from "./writeAuthority";
 
 export type AccessAction = "read" | "write" | "delete" | "manage";
@@ -73,11 +73,12 @@ const hasSpaceMembership = async (
   userId: string,
   spaceId: string | null
 ): Promise<boolean> => {
+  const store = getServerAuthorityStore();
   const normalized = normalizeSpaceId(spaceId);
   if (!userId || !normalized) return false;
 
   try {
-    const membership = await serverDb.get(
+    const membership = await store.get(
       `${SPACE_MEMBER_PREFIX}${userId}-${normalized}`
     );
     if (membership) return true;
@@ -86,7 +87,7 @@ const hasSpaceMembership = async (
   }
 
   try {
-    const space = await serverDb.get(`${SPACE_PREFIX}${normalized}`);
+    const space = await store.get(`${SPACE_PREFIX}${normalized}`);
     return (
       space?.ownerId === userId ||
       (Array.isArray(space?.members) && space.members.includes(userId))
@@ -112,13 +113,14 @@ const isRecordLinkedFromMemberSpace = async (
   dbKey: string,
   record: any
 ): Promise<string | null> => {
+  const store = getServerAuthorityStore();
   if (!userId || !dbKey) return null;
 
   const contentKeys = getContentKeyCandidates(dbKey, record);
   const prefix = `${SPACE_MEMBER_PREFIX}${userId}-`;
 
   try {
-    for await (const [, membership] of serverDb.iterator({
+    for await (const [, membership] of store.iterator({
       gte: prefix,
       lte: prefix + "\uffff",
     })) {
@@ -126,7 +128,7 @@ const isRecordLinkedFromMemberSpace = async (
       if (!spaceId) continue;
 
       try {
-        const space = await serverDb.get(`${SPACE_PREFIX}${spaceId}`);
+        const space = await store.get(`${SPACE_PREFIX}${spaceId}`);
         const contents = space?.contents;
         if (!contents || typeof contents !== "object") continue;
 

package/database/server/serverStoreFactory.ts

@@ -0,0 +1,124 @@
+import fs from "fs";
+import path from "path";
+import { Level } from "level";
+
+import type { AuthorityStore } from "./authorityStoreTypes";
+import { createLegacyServerDb, type LegacyServerDb } from "./legacyServerDb";
+import { createLevelAuthorityStore } from "./levelAuthorityStore";
+import { createMemoryAuthorityStore } from "./memoryAuthorityStore";
+
+// Keep the storage seam local-first. Cross-process sharing stays in the
+// existing core/proxy runtime layer; this factory is only for embedded drivers.
+export type ServerStoreDriver = "level" | "memory";
+
+export type ServerStoreFactoryEnv = {
+  NOLO_SERVER_AUTHORITY_DRIVER?: string | undefined;
+};
+
+export 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 type ServerStoreRuntime = {
+  authorityStore: AuthorityStore;
+  serverDb: LegacyServerDb;
+};
+
+export type ServerStoreFactoryOptions = {
+  driver?: ServerStoreDriver;
+  env?: ServerStoreFactoryEnv;
+  globalScope?: Record<string, unknown>;
+};
+
+export function ensureServerDbDirectory(dbPath: string) {
+  const dir = path.dirname(dbPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+export function createLevelBackedAuthorityStore(dbPath: string): AuthorityStore {
+  const levelDb = new Level<string, any>(dbPath, {
+    valueEncoding: safeJsonEncoding,
+  });
+  return createLevelAuthorityStore(levelDb);
+}
+
+export function resolveServerStoreDriver(
+  env: ServerStoreFactoryEnv = process.env
+): ServerStoreDriver {
+  const rawDriver = env.NOLO_SERVER_AUTHORITY_DRIVER?.trim().toLowerCase();
+  if (!rawDriver) return "level";
+  if (rawDriver === "level") return "level";
+  if (rawDriver === "memory") return "memory";
+  throw new Error(`Unsupported server authority store driver: ${rawDriver}`);
+}
+
+export function createAuthorityStoreForDriver(
+  driver: ServerStoreDriver,
+  dbPath: string,
+  env: ServerStoreFactoryEnv = process.env
+): AuthorityStore {
+  switch (driver) {
+    case "level":
+      return createLevelBackedAuthorityStore(dbPath);
+    case "memory":
+      // Test/dev-only driver that exercises the seam without changing the
+      // production single-writer runtime model.
+      return createMemoryAuthorityStore(dbPath);
+  }
+}
+
+export function getOrCreateServerStoreRuntime(
+  dbPath: string,
+  options: ServerStoreFactoryOptions = {}
+): ServerStoreRuntime {
+  const globalScope =
+    options.globalScope ?? (globalThis as Record<string, unknown>);
+  const driver = options.driver ?? resolveServerStoreDriver(options.env);
+  const cachedDriver = globalScope.__serverAuthorityStoreDriver;
+
+  ensureServerDbDirectory(dbPath);
+
+  if (
+    globalScope.__serverAuthorityStore &&
+    typeof cachedDriver === "string" &&
+    cachedDriver !== driver
+  ) {
+    throw new Error(
+      `Server authority store already initialized with driver ${cachedDriver}, cannot reuse it for ${driver}`
+    );
+  }
+
+  if (!globalScope.__serverAuthorityStore) {
+    globalScope.__serverAuthorityStore = createAuthorityStoreForDriver(
+      driver,
+      dbPath,
+      options.env
+    );
+    globalScope.__serverAuthorityStoreDriver = driver;
+  } else if (!cachedDriver) {
+    globalScope.__serverAuthorityStoreDriver = driver;
+  }
+
+  const authorityStore = globalScope.__serverAuthorityStore as AuthorityStore;
+
+  if (!globalScope.__serverDb) {
+    globalScope.__serverDb = createLegacyServerDb(authorityStore);
+  }
+
+  return {
+    authorityStore,
+    serverDb: globalScope.__serverDb as LegacyServerDb,
+  };
+}

package/database/server/spaceMemberAuthority.ts

@@ -1,4 +1,4 @@
-import serverDb from "./db";
+import { getServerAuthorityStore } from "./db";
 
 const SPACE_MEMBER_PREFIX = "space-member-";
 const SPACE_PREFIX = "space-";
@@ -23,8 +23,9 @@ export const parseSpaceMemberKey = (
 };
 
 const loadSpaceRecord = async (spaceId: string): Promise<any | null> => {
+  const store = getServerAuthorityStore();
   try {
-    return await serverDb.get(`${SPACE_PREFIX}${spaceId}`);
+    return await store.get(`${SPACE_PREFIX}${spaceId}`);
   } catch {
     return null;
   }

package/database/server/storeBatchCompat.ts

@@ -0,0 +1,37 @@
+import type {
+  AuthorityBatchOperation,
+  AuthorityBatchWriter,
+} from "./authorityStoreTypes";
+
+type BatchArrayStoreLike = {
+  batchWrite?(ops: AuthorityBatchOperation[]): Promise<void>;
+  batch?(ops: AuthorityBatchOperation[]): Promise<void>;
+};
+
+type BatchBuilderStoreLike = {
+  createBatch?(): AuthorityBatchWriter;
+  batch?(): AuthorityBatchWriter;
+};
+
+export function writeStoreOps(
+  store: BatchArrayStoreLike,
+  ops: AuthorityBatchOperation[]
+): Promise<void> {
+  if (typeof store.batchWrite === "function") {
+    return store.batchWrite(ops);
+  }
+  if (typeof store.batch === "function") {
+    return store.batch(ops);
+  }
+  throw new Error("Store does not support batch array writes");
+}
+
+export function createStoreBatch(store: BatchBuilderStoreLike): AuthorityBatchWriter {
+  if (typeof store.createBatch === "function") {
+    return store.createBatch();
+  }
+  if (typeof store.batch === "function") {
+    return store.batch();
+  }
+  throw new Error("Store does not support batch builder writes");
+}