nolo-cli 0.1.26 → 0.1.29

package/auth/server/ledgerWitness.ts

@@ -0,0 +1,472 @@
+import { createHash } from "node:crypto";
+
+import {
+  ledgerAccountEntryKey,
+  ledgerAccountKeyPrefix,
+  ledgerTransactionKeyPrefix,
+  type BillingLedgerClusterId,
+  type LedgerAccountState,
+  type LedgerEntry,
+} from "./ledger";
+import { creatorEarningEntryKeyPrefix } from "./creatorEarningsLedger";
+import {
+  creatorEarningStatusProjectionKeyPrefix,
+  creatorSettlementEventKeyPrefix,
+} from "./creatorSettlementLedger";
+import { revenueShareEventKeyPrefix } from "./revenueShareLedger";
+
+export type BillingLedgerWitnessStoreOperation = {
+  type: "put";
+  key: string;
+  value: unknown;
+};
+
+export type BillingLedgerWitnessStore = {
+  get: (key: string) => Promise<unknown | null>;
+  batch: (ops: BillingLedgerWitnessStoreOperation[]) => Promise<void>;
+  iterator: (options: {
+    gte?: string;
+    lte?: string;
+  }) => AsyncIterable<[string, unknown]>;
+};
+
+export type BillingLedgerWitnessKind =
+  | "ledgerTransactions"
+  | "ledgerIdempotency"
+  | "ledgerAccounts"
+  | "ledgerAccountEntries"
+  | "revenueShareEvents"
+  | "revenueShareIdempotency"
+  | "creatorEarningEntries"
+  | "creatorEarningIdempotency"
+  | "creatorSettlementEvents"
+  | "creatorSettlementIdempotency"
+  | "creatorEarningStatusProjections";
+
+export type BillingLedgerWitnessRecord = {
+  key: string;
+  value: unknown;
+  valueHash: string;
+};
+
+export type BillingLedgerWitnessCheckpoint = {
+  clusterId: BillingLedgerClusterId;
+  nodeId: string;
+  generatedAt: string;
+  recordCount: number;
+  hash: string;
+  firstKey: string | null;
+  lastKey: string | null;
+  byKind: Record<BillingLedgerWitnessKind, number>;
+};
+
+export type BillingLedgerWitnessImportResult =
+  | {
+      status: "imported";
+      importedCount: number;
+      skippedCount: number;
+      importRecordKey: string | null;
+    }
+  | {
+      status: "conflict";
+      conflicts: Array<{ key: string; existingHash: string; incomingHash: string }>;
+    }
+  | {
+      status: "invalid_records";
+      invalidRecords: Array<{ key: string; reason: string }>;
+    };
+
+const stableJson = (value: unknown): string => {
+  if (typeof value === "undefined") {
+    return "undefined";
+  }
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableJson(item)).join(",")}]`;
+  }
+  return `{${Object.entries(value as Record<string, unknown>)
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([key, item]) => `${JSON.stringify(key)}:${stableJson(item)}`)
+    .join(",")}}`;
+};
+
+const sha256 = (value: string) =>
+  createHash("sha256").update(value).digest("hex");
+
+const valueHash = (value: unknown) => sha256(stableJson(value));
+
+const rangeEnd = (prefix: string) => `${prefix}\uffff`;
+
+const emptyKindCounts = (): Record<BillingLedgerWitnessKind, number> => ({
+  ledgerTransactions: 0,
+  ledgerIdempotency: 0,
+  ledgerAccounts: 0,
+  ledgerAccountEntries: 0,
+  revenueShareEvents: 0,
+  revenueShareIdempotency: 0,
+  creatorEarningEntries: 0,
+  creatorEarningIdempotency: 0,
+  creatorSettlementEvents: 0,
+  creatorSettlementIdempotency: 0,
+  creatorEarningStatusProjections: 0,
+});
+
+const ledgerIdempotencyKeyPrefix = (clusterId: BillingLedgerClusterId) =>
+  `ledger-idem-${clusterId}-`;
+
+const revenueShareIdempotencyKeyPrefix = (clusterId: BillingLedgerClusterId) =>
+  `revenue-share-idem-${clusterId}-`;
+
+const creatorEarningIdempotencyKeyPrefix = (
+  clusterId: BillingLedgerClusterId
+) => `creator-earning-idem-${clusterId}-`;
+
+const creatorSettlementIdempotencyKeyPrefix = (
+  clusterId: BillingLedgerClusterId
+) => `creator-settlement-idem-${clusterId}-`;
+
+const witnessImportRecordKeyPrefix = (clusterId: BillingLedgerClusterId) =>
+  `billing-witness-import-${clusterId}-`;
+
+export const billingWitnessCheckpointRecordKeyPrefix = (
+  clusterId: BillingLedgerClusterId
+) => `billing-witness-checkpoint-${clusterId}-`;
+
+export const billingWitnessCheckpointRecordKey = (
+  clusterId: BillingLedgerClusterId,
+  recordedAtMs: number
+) =>
+  `${billingWitnessCheckpointRecordKeyPrefix(clusterId)}${String(
+    recordedAtMs
+  ).padStart(16, "0")}`;
+
+const witnessPrefixes = (clusterId: BillingLedgerClusterId) =>
+  [
+    {
+      kind: "ledgerTransactions" as const,
+      prefix: ledgerTransactionKeyPrefix(clusterId),
+    },
+    { kind: "ledgerIdempotency" as const, prefix: ledgerIdempotencyKeyPrefix(clusterId) },
+    { kind: "ledgerAccounts" as const, prefix: ledgerAccountKeyPrefix(clusterId) },
+    {
+      kind: "ledgerAccountEntries" as const,
+      prefix: `ledger-entry-${clusterId}-`,
+    },
+    { kind: "revenueShareEvents" as const, prefix: revenueShareEventKeyPrefix(clusterId) },
+    {
+      kind: "revenueShareIdempotency" as const,
+      prefix: revenueShareIdempotencyKeyPrefix(clusterId),
+    },
+    {
+      kind: "creatorEarningEntries" as const,
+      prefix: creatorEarningEntryKeyPrefix(clusterId),
+    },
+    {
+      kind: "creatorEarningIdempotency" as const,
+      prefix: creatorEarningIdempotencyKeyPrefix(clusterId),
+    },
+    {
+      kind: "creatorSettlementEvents" as const,
+      prefix: creatorSettlementEventKeyPrefix(clusterId),
+    },
+    {
+      kind: "creatorSettlementIdempotency" as const,
+      prefix: creatorSettlementIdempotencyKeyPrefix(clusterId),
+    },
+    {
+      kind: "creatorEarningStatusProjections" as const,
+      prefix: creatorEarningStatusProjectionKeyPrefix(clusterId),
+    },
+  ] satisfies Array<{ kind: BillingLedgerWitnessKind; prefix: string }>;
+
+const classifyWitnessKey = (
+  clusterId: BillingLedgerClusterId,
+  key: string
+): BillingLedgerWitnessKind | null =>
+  witnessPrefixes(clusterId).find((item) => key.startsWith(item.prefix))?.kind ??
+  null;
+
+async function scanWitnessRecords(
+  store: Pick<BillingLedgerWitnessStore, "iterator">,
+  clusterId: BillingLedgerClusterId
+) {
+  const records: BillingLedgerWitnessRecord[] = [];
+  for (const { prefix } of witnessPrefixes(clusterId)) {
+    for await (const [key, value] of store.iterator({
+      gte: prefix,
+      lte: rangeEnd(prefix),
+    })) {
+      records.push({ key, value, valueHash: valueHash(value) });
+    }
+  }
+  return records.sort((a, b) => a.key.localeCompare(b.key));
+}
+
+export async function buildBillingLedgerWitnessCheckpoint({
+  store,
+  clusterId,
+  nodeId,
+  generatedAtMs = Date.now(),
+}: {
+  store: Pick<BillingLedgerWitnessStore, "iterator">;
+  clusterId: BillingLedgerClusterId;
+  nodeId: string;
+  generatedAtMs?: number;
+}): Promise<BillingLedgerWitnessCheckpoint> {
+  const records = await scanWitnessRecords(store, clusterId);
+  const byKind = emptyKindCounts();
+  let hash = sha256(stableJson({ version: 1, clusterId, seed: "billing-witness" }));
+
+  for (const record of records) {
+    const kind = classifyWitnessKey(clusterId, record.key);
+    if (kind) byKind[kind] += 1;
+    hash = sha256(
+      stableJson({
+        version: 1,
+        previousHash: hash,
+        key: record.key,
+        valueHash: record.valueHash,
+      })
+    );
+  }
+
+  return {
+    clusterId,
+    nodeId,
+    generatedAt: new Date(generatedAtMs).toISOString(),
+    recordCount: records.length,
+    hash,
+    firstKey: records[0]?.key ?? null,
+    lastKey: records.at(-1)?.key ?? null,
+    byKind,
+  };
+}
+
+export async function listBillingLedgerWitnessRecords({
+  store,
+  clusterId,
+  afterKey,
+  limit = 1_000,
+}: {
+  store: Pick<BillingLedgerWitnessStore, "iterator">;
+  clusterId: BillingLedgerClusterId;
+  afterKey?: string | null;
+  limit?: number;
+}) {
+  const safeLimit = Math.max(1, Math.min(Math.floor(limit), 1_000));
+  const records = (await scanWitnessRecords(store, clusterId)).filter((record) =>
+    afterKey ? record.key > afterKey : true
+  );
+  const page = records.slice(0, safeLimit);
+  const hasMore = records.length > safeLimit;
+  return {
+    records: page,
+    nextAfterKey: hasMore ? page.at(-1)?.key ?? null : null,
+  };
+}
+
+const validateIncomingRecords = (
+  clusterId: BillingLedgerClusterId,
+  records: BillingLedgerWitnessRecord[]
+) => {
+  const invalidRecords: Array<{ key: string; reason: string }> = [];
+  for (const record of records) {
+    if (!record || typeof record.key !== "string") {
+      invalidRecords.push({ key: "", reason: "missing key" });
+      continue;
+    }
+    if (!classifyWitnessKey(clusterId, record.key)) {
+      invalidRecords.push({ key: record.key, reason: "out of billing witness scope" });
+      continue;
+    }
+    if (valueHash(record.value) !== record.valueHash) {
+      invalidRecords.push({ key: record.key, reason: "value hash mismatch" });
+    }
+  }
+  return invalidRecords;
+};
+
+const isObjectRecord = (value: unknown): value is Record<string, unknown> =>
+  !!value && typeof value === "object" && !Array.isArray(value);
+
+const isLedgerAccountState = (value: unknown): value is LedgerAccountState => {
+  if (!isObjectRecord(value)) return false;
+  return (
+    typeof value.accountId === "string" &&
+    typeof value.balanceMicros === "string" &&
+    typeof value.accountVersion === "number" &&
+    Number.isInteger(value.accountVersion) &&
+    typeof value.accountHash === "string"
+  );
+};
+
+const isLedgerEntry = (value: unknown): value is LedgerEntry => {
+  if (!isObjectRecord(value)) return false;
+  return (
+    typeof value.accountId === "string" &&
+    typeof value.balanceBeforeMicros === "string" &&
+    typeof value.balanceAfterMicros === "string" &&
+    typeof value.accountVersion === "number" &&
+    Number.isInteger(value.accountVersion) &&
+    typeof value.prevAccountHash === "string" &&
+    typeof value.hash === "string"
+  );
+};
+
+const canFastForwardLedgerAccountProjection = ({
+  clusterId,
+  existing,
+  incoming,
+  incomingRecordsByKey,
+}: {
+  clusterId: BillingLedgerClusterId;
+  existing: unknown;
+  incoming: unknown;
+  incomingRecordsByKey: Map<string, BillingLedgerWitnessRecord>;
+}) => {
+  if (!isLedgerAccountState(existing) || !isLedgerAccountState(incoming)) {
+    return false;
+  }
+  if (existing.accountId !== incoming.accountId) return false;
+  if (existing.ownerUserId !== incoming.ownerUserId) return false;
+  if (incoming.accountVersion <= existing.accountVersion) return false;
+
+  let expectedPrevHash = existing.accountHash;
+  let expectedBalanceBeforeMicros = existing.balanceMicros;
+  for (
+    let version = existing.accountVersion + 1;
+    version <= incoming.accountVersion;
+    version += 1
+  ) {
+    const entryRecord = incomingRecordsByKey.get(
+      ledgerAccountEntryKey(clusterId, incoming.accountId, version)
+    );
+    if (!entryRecord || !isLedgerEntry(entryRecord.value)) return false;
+    if (entryRecord.value.accountId !== incoming.accountId) return false;
+    if (entryRecord.value.accountVersion !== version) return false;
+    if (entryRecord.value.prevAccountHash !== expectedPrevHash) return false;
+    if (entryRecord.value.balanceBeforeMicros !== expectedBalanceBeforeMicros) {
+      return false;
+    }
+    expectedPrevHash = entryRecord.value.hash;
+    expectedBalanceBeforeMicros = entryRecord.value.balanceAfterMicros;
+  }
+
+  return (
+    expectedPrevHash === incoming.accountHash &&
+    expectedBalanceBeforeMicros === incoming.balanceMicros
+  );
+};
+
+export async function importBillingLedgerWitnessRecords({
+  store,
+  clusterId,
+  records,
+  importedAtMs = Date.now(),
+}: {
+  store: BillingLedgerWitnessStore;
+  clusterId: BillingLedgerClusterId;
+  records: BillingLedgerWitnessRecord[];
+  importedAtMs?: number;
+}): Promise<BillingLedgerWitnessImportResult> {
+  const invalidRecords = validateIncomingRecords(clusterId, records);
+  if (invalidRecords.length > 0) {
+    return { status: "invalid_records", invalidRecords };
+  }
+
+  const operations: BillingLedgerWitnessStoreOperation[] = [];
+  const conflicts: Array<{ key: string; existingHash: string; incomingHash: string }> = [];
+  const incomingRecordsByKey = new Map(records.map((record) => [record.key, record]));
+  let skippedCount = 0;
+
+  for (const record of records) {
+    const existing = await store.get(record.key).catch(() => null);
+    if (existing === null || typeof existing === "undefined") {
+      operations.push({ type: "put", key: record.key, value: record.value });
+      continue;
+    }
+    const existingHash = valueHash(existing);
+    if (existingHash === record.valueHash) {
+      skippedCount += 1;
+      continue;
+    }
+    if (
+      record.key.startsWith(ledgerAccountKeyPrefix(clusterId)) &&
+      canFastForwardLedgerAccountProjection({
+        clusterId,
+        existing,
+        incoming: record.value,
+        incomingRecordsByKey,
+      })
+    ) {
+      operations.push({ type: "put", key: record.key, value: record.value });
+      continue;
+    }
+    conflicts.push({
+      key: record.key,
+      existingHash,
+      incomingHash: record.valueHash,
+    });
+  }
+
+  if (conflicts.length > 0) {
+    return { status: "conflict", conflicts };
+  }
+
+  const importRecordKey =
+    operations.length > 0
+      ? `${witnessImportRecordKeyPrefix(clusterId)}${String(importedAtMs).padStart(16, "0")}`
+      : null;
+  if (importRecordKey) {
+    operations.push({
+      type: "put",
+      key: importRecordKey,
+      value: {
+        clusterId,
+        importedAt: new Date(importedAtMs).toISOString(),
+        importedCount: operations.length,
+        skippedCount,
+        sourceRecordCount: records.length,
+      },
+    });
+  }
+  if (operations.length > 0) await store.batch(operations);
+
+  return {
+    status: "imported",
+    importedCount: importRecordKey ? operations.length - 1 : 0,
+    skippedCount,
+    importRecordKey,
+  };
+}
+
+export async function storeBillingLedgerWitnessCheckpoint({
+  store,
+  checkpoint,
+  recordedAtMs = Date.now(),
+  reason,
+}: {
+  store: Pick<BillingLedgerWitnessStore, "batch">;
+  checkpoint: BillingLedgerWitnessCheckpoint;
+  recordedAtMs?: number;
+  reason: "import" | "manual";
+}) {
+  const key = billingWitnessCheckpointRecordKey(
+    checkpoint.clusterId,
+    recordedAtMs
+  );
+  await store.batch([
+    {
+      type: "put",
+      key,
+      value: {
+        reason,
+        recordedAt: new Date(recordedAtMs).toISOString(),
+        checkpoint,
+      },
+    },
+  ]);
+  return key;
+}

package/auth/server/listusers.ts

@@ -0,0 +1,154 @@
+// auth/server/listusers.ts
+import serverDb from "../../database/server/db";
+import {
+  createErrorResponse,
+  createSuccessResponse,
+  handleOptionsRequest,
+  checkAdminPermission,
+} from "./shared";
+import { DB_PREFIX } from "../../database/keys";
+
+interface ListUsersOptions {
+  page?: number;
+  pageSize?: number;
+  // 模糊搜索关键字：会在 id/username/email 上做包含匹配
+  search?: string;
+}
+
+interface User {
+  id: string;
+  username: string;
+  email: string;
+  balance: number;
+  createdAt: string;
+  [key: string]: any;
+}
+
+async function listUsers({
+  page = 1,
+  pageSize = 10,
+  search,
+}: ListUsersOptions = {}) {
+  const prefix = DB_PREFIX.USER;
+  let users: User[] = [];
+
+  // 1. 全量读取到内存
+  const iter = serverDb.iterator({
+    gt: prefix,
+    lt: prefix + "\xFF",
+  });
+  try {
+    for await (const [key, value] of iter) {
+      const id = key.slice(prefix.length);
+      users.push({
+        id,
+        username: value.username,
+        email: value.email || "",
+        balance: value.balance || 0,
+        createdAt: value.createdAt,
+        ...value,
+      });
+    }
+  } finally {
+    await iter.close();
+  }
+
+  // 2. 按创建时间降序
+  users.sort(
+    (a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
+  );
+
+  // 3. 如果有 search 参数，先做一次过滤
+  if (search) {
+    const kw = search.toLowerCase();
+    users = users.filter(
+      (u) =>
+        u.id.toLowerCase().includes(kw) ||
+        u.username.toLowerCase().includes(kw) ||
+        u.email.toLowerCase().includes(kw)
+    );
+  }
+
+  // 4. 分页
+  const totalCount = users.length;
+  const totalPages = Math.ceil(totalCount / pageSize);
+  const start = (page - 1) * pageSize;
+  const list = users.slice(start, start + pageSize);
+
+  return {
+    total: totalCount,
+    list,
+    currentPage: page,
+    totalPages,
+    hasMore: page < totalPages,
+  };
+}
+
+export async function handleListUsers(req: Request) {
+  if (req.method === "OPTIONS") {
+    return handleOptionsRequest();
+  }
+  const { userId: actionUserId } = req.user;
+  const permissionError = checkAdminPermission(actionUserId);
+  if (permissionError) return permissionError;
+
+  try {
+    const url = new URL(req.url);
+    // 1. 解析并限制分页参数
+    const page = Math.max(1, parseInt(url.searchParams.get("page") || "1", 10));
+    const pageSize = Math.min(
+      50,
+      Math.max(1, parseInt(url.searchParams.get("pageSize") || "10", 10))
+    );
+
+    // 2. 解析搜索参数
+    const userIdParam = url.searchParams.get("userId")?.trim();
+    const searchParam = url.searchParams.get("search")?.trim();
+
+    const prefix = DB_PREFIX.USER;
+
+    // 3. 如果指定了 userId，直接单条查询
+    if (userIdParam) {
+      try {
+        const value = await serverDb.get(prefix + userIdParam);
+        const user: User = {
+          id: userIdParam,
+          username: value.username,
+          email: value.email || "",
+          balance: value.balance || 0,
+          createdAt: value.createdAt,
+          ...value,
+        };
+        return createSuccessResponse({
+          total: 1,
+          list: [user],
+          currentPage: 1,
+          totalPages: 1,
+          hasMore: false,
+        });
+      } catch (err: any) {
+        // key not found 时返回空列表
+        if (err.notFound) {
+          return createSuccessResponse({
+            total: 0,
+            list: [],
+            currentPage: 1,
+            totalPages: 1,
+            hasMore: false,
+          });
+        }
+        throw err;
+      }
+    }
+
+    // 4. 否则走分页 + （可选）关键字搜索
+    const result = await listUsers({
+      page,
+      pageSize,
+      search: searchParam || undefined,
+    });
+    return createSuccessResponse(result);
+  } catch (error) {
+    return createErrorResponse("Internal server error");
+  }
+}

package/auth/server/locks.ts

@@ -0,0 +1,32 @@
+// auth/server/locks.ts
+import { Mutex } from "async-mutex";
+
+export class BalanceLockManager {
+  private static instance: BalanceLockManager;
+  private locks = new Map<string, Mutex>();
+
+  private constructor() {}
+
+  public static getInstance(): BalanceLockManager {
+    if (!BalanceLockManager.instance) {
+      BalanceLockManager.instance = new BalanceLockManager();
+    }
+    return BalanceLockManager.instance;
+  }
+
+  public getLock(userId: string): Mutex {
+    let lock = this.locks.get(userId);
+    if (!lock) {
+      lock = new Mutex();
+      this.locks.set(userId, lock);
+    }
+    return lock;
+  }
+
+  // 可选:清理长时间未使用的锁
+  public cleanupLocks(inactiveMs: number = 30 * 60 * 1000) {
+    // ... 清理逻辑
+  }
+}
+
+export const balanceLockManager = BalanceLockManager.getInstance();