nolo-cli 0.1.44 → 0.1.46

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/dbPath.ts

@@ -1,20 +0,0 @@
-import { homedir } from "node:os";
-import path from "node:path";
-
-type EnvLike = Record<string, string | undefined>;
-
-export type ResolveServerDbPathOptions = {
-  env?: EnvLike;
-  homeDir?: string;
-  cwd?: string;
-};
-
-export function resolveServerDbPath(options: ResolveServerDbPathOptions = {}) {
-  const env = options.env ?? process.env;
-  return env.NOLO_SERVER_DB_PATH?.trim() || path.join(options.cwd ?? process.cwd(), "data", "leveldb");
-}
-
-export function resolveNoloHome(options: ResolveServerDbPathOptions = {}) {
-  const env = options.env ?? process.env;
-  return env.NOLO_HOME?.trim() || path.join(options.homeDir ?? homedir(), ".nolo");
-}

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/legacyServerDb.ts

@@ -1,58 +0,0 @@
-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

@@ -1,114 +0,0 @@
-import { Level } from "level";
-
-import type {
-  AuthorityBatchOperation,
-  AuthorityBatchWriter,
-  AuthorityIteratorOptions,
-  AuthorityStore,
-} from "./authorityStoreTypes";
-
-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;
-    }
-  },
-};
-
-type LevelBatchWriterLike = {
-  put(key: string, value: unknown): void;
-  del(key: string): void;
-  write(): Promise<void>;
-};
-
-type LevelLike = {
-  readonly location?: string;
-  readonly status?: string;
-  open(): Promise<void>;
-  close(): Promise<void>;
-  get(key: string): Promise<unknown>;
-  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(
-  source: string | LevelLike
-): AuthorityStore {
-  const levelDb: LevelLike = typeof source === "string"
-    ? new Level<string, any>(source, { valueEncoding: safeJsonEncoding })
-    : source;
-  const writeBatchOps = async (ops: AuthorityBatchOperation[]) => {
-    const result = levelDb.batch(ops);
-    if (result && typeof (result as any).then === "function") {
-      await result;
-      return;
-    }
-    if (result && typeof (result as any).write === "function") {
-      for (const op of ops) {
-        if (op.type === "put") {
-          (result as LevelBatchWriterLike).put(op.key, op.value);
-        } else {
-          (result as LevelBatchWriterLike).del(op.key);
-        }
-      }
-      await (result as LevelBatchWriterLike).write();
-      return;
-    }
-    throw new Error("Level backing does not support batch writes");
-  };
-
-  return {
-    get location() {
-      return levelDb.location;
-    },
-    get status() {
-      return (levelDb as any).status;
-    },
-    async open() {
-      await levelDb.open();
-    },
-    async close() {
-      await levelDb.close();
-    },
-    async get<T = any>(key: string) {
-      return levelDb.get(key) as Promise<T>;
-    },
-    async put(key: string, value: unknown) {
-      await levelDb.put(key, value);
-    },
-    async del(key: string) {
-      await levelDb.del(key);
-    },
-    async batchWrite(ops: AuthorityBatchOperation[]) {
-      await writeBatchOps(ops);
-    },
-    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();
-        },
-      };
-    },
-    iterator(options: AuthorityIteratorOptions = {}) {
-      return levelDb.iterator(options) as AsyncIterableIterator<[string, unknown]>;
-    },
-  };
-}

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,
-  };
-}

package/database/tenantPlacement.ts

@@ -1,57 +0,0 @@
-// 文件路径: 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

@@ -1,52 +0,0 @@
-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,
-});