nolo-cli 0.1.34 → 0.1.35

package/database/server/db.ts

@@ -1,99 +0,0 @@
-// 文件路径: packages/database/server/db.ts
-
-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();
-
-console.log("数据库配置:");
-console.log("- 当前工作目录:", process.cwd());
-console.log("- 数据库路径:", DB_PATH);
-
-export function isServerDbLockError(error: unknown): boolean {
-  const queue: unknown[] = [error];
-  const seen = new Set<unknown>();
-
-  while (queue.length > 0) {
-    const current = queue.shift();
-    if (!current || seen.has(current)) continue;
-    seen.add(current);
-
-    const text = `${(current as any)?.code ?? ""} ${(current as any)?.message ?? current}`;
-    if (/LEVEL_LOCKED|Resource temporarily unavailable|\/LOCK|LOCK:/.test(text)) {
-      return true;
-    }
-
-    if ((current as any)?.cause) queue.push((current as any).cause);
-    if (Array.isArray((current as any)?.errors)) {
-      queue.push(...(current as any).errors);
-    }
-  }
-
-  return false;
-}
-
-const {
-  authorityStore,
-  serverDb,
-}: { authorityStore: AuthorityStore; serverDb: LegacyServerDb } =
-  getOrCreateServerStoreRuntime(DB_PATH);
-
-console.log("- LevelDB实际路径:", serverDb.location);
-
-// ✅ 保留默认导出：兼容现有的 import serverDb from "./db"
-export default serverDb;
-
-// 具名导出：需要的时候可以引用
-export { serverDb };
-export function getServerAuthorityStore() {
-  return authorityStore;
-}
-
-/**
- * 确保数据库处于 open 状态。
- * - 已 open / opening：直接返回
- * - 其他状态：尝试 open，一旦失败抛错
- */
-export async function ensureServerDbOpen() {
-  const status = authorityStore.status;
-  if (status === "open") return;
-
-  try {
-    await ensureDbOpen(authorityStore);
-    if (status !== "opening") {
-      console.log("✅ LevelDB 已打开");
-    }
-  } catch (err) {
-    if (isServerDbLockError(err)) {
-      console.error("❌ 打开 LevelDB 失败: 数据库已被其他进程占用");
-    } else {
-      console.error("❌ 打开 LevelDB 失败:", err);
-    }
-    throw err;
-  }
-}
-
-/**
- * 兼容入口调用：启动时显式 open 一次
- */
-export async function openServerDb() {
-  return ensureServerDbOpen();
-}
-
-/**
- * 优雅关机时关闭 DB
- */
-export async function closeServerDb() {
-  const status = authorityStore.status;
-  if (status !== "open") return;
-
-  try {
-    await authorityStore.close();
-    console.log("✅ LevelDB 已关闭");
-  } catch (err) {
-    console.error("❌ 关闭 LevelDB 失败:", err);
-  }
-}

package/database/server/ensureDbOpen.ts

@@ -1,12 +0,0 @@
-export type DbWithOpenStatus = {
-  status?: string | null;
-  open(): Promise<unknown>;
-};
-
-export async function ensureDbOpen(db: DbWithOpenStatus) {
-  if (db.status === "open") {
-    return;
-  }
-
-  await db.open();
-}

package/database/server/memoryAuthorityStore.ts

@@ -1,133 +0,0 @@
-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/serverStoreFactory.ts

@@ -1,118 +0,0 @@
-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";
-
-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
-): AuthorityStore {
-  switch (driver) {
-    case "level":
-      return createLevelBackedAuthorityStore(dbPath);
-    case "memory":
-      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
-    );
-    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,
-  };
-}