@morlay/session-rdb 0.1.10-alpha.0 → 0.1.10-alpha.2

package/src/handles.ts

@@ -0,0 +1,349 @@
+import {
+  SessionAlreadyExistsError,
+  SessionAlreadyOwnedError,
+  SessionHandleClosedError,
+  SessionPersistenceNotFoundError,
+  SessionPersistenceRevision,
+  SessionReadOnlyError,
+  assertContiguous,
+  materializeAppendBatch,
+  type SessionAccess,
+  type SessionHandle,
+  type SessionHandleAppendOptions,
+  type SessionHandleFlushOptions,
+  type SessionHandleReadOptions,
+  type SessionHandleReadResult,
+} from "@deepseek-ai/dsh-session-persistence";
+import { SessionLogOffset } from "@deepseek-ai/dsh-session";
+import type { SessionEvent, SessionHeader, SessionId } from "@deepseek-ai/dsh-session";
+import type { SessionPersistenceRdb } from "./session-store.ts";
+import { repairReadView } from "./log/repair.ts";
+
+interface PendingSession {
+  readonly header: SessionHeader;
+  readonly revision: SessionPersistenceRevision;
+  readonly inheritedEventCount: SessionLogOffset;
+
+  readonly cursor: number;
+
+  readonly everAppended: boolean;
+}
+
+export class RdbBackendTracker {
+  private readonly writers = new Map<SessionId, RdbSessionHandle | null>();
+  private readonly pending = new Map<SessionId, PendingSession>();
+  private readonly openHandles = new Set<RdbSessionHandle>();
+  private counter = 0;
+
+  constructor(private readonly name: string) {}
+
+  registerCreated(header: SessionHeader, inheritedEventCount: SessionLogOffset): void {
+    if (this.writers.has(header.id)) throw new SessionAlreadyExistsError(header.id);
+    this.writers.set(header.id, null);
+    this.pending.set(header.id, {
+      header,
+      revision: SessionPersistenceRevision(`memory:${this.name}:${++this.counter}`),
+      inheritedEventCount,
+      cursor: 0,
+      everAppended: false,
+    });
+  }
+
+  updatePending(id: SessionId, cursor: number, everAppended: boolean): void {
+    const entry = this.pending.get(id);
+    if (entry === undefined) return;
+    this.pending.set(id, { ...entry, cursor, everAppended });
+  }
+
+  claimWrite(id: SessionId): void {
+    if (this.writers.has(id)) throw new SessionAlreadyOwnedError(id);
+    this.writers.set(id, null);
+  }
+
+  releaseClaim(id: SessionId): void {
+    this.writers.delete(id);
+  }
+
+  pendingOf(id: SessionId): PendingSession | undefined {
+    return this.pending.get(id);
+  }
+
+  hasPending(id: SessionId): boolean {
+    return this.pending.has(id);
+  }
+
+  pendingEntries(): IterableIterator<[SessionId, PendingSession]> {
+    return this.pending.entries();
+  }
+
+  materialized(id: SessionId): void {
+    this.pending.delete(id);
+  }
+
+  adopt(handle: RdbSessionHandle): RdbSessionHandle {
+    this.openHandles.add(handle);
+    if (handle.access === "write") this.writers.set(handle.id, handle);
+    return handle;
+  }
+
+  release(handle: RdbSessionHandle, materialized: boolean): void {
+    this.openHandles.delete(handle);
+    if (handle.access !== "write") return;
+    this.writers.delete(handle.id);
+    if (!materialized) this.pending.delete(handle.id);
+  }
+
+  writerOf(id: SessionId): RdbSessionHandle | undefined {
+    const writer = this.writers.get(id);
+    return writer === null ? undefined : writer;
+  }
+
+  hasOpenHandle(id: SessionId): boolean {
+    for (const handle of this.openHandles) {
+      if (handle.id === id) return true;
+    }
+    return false;
+  }
+
+  async flushAll(): Promise<void> {
+    const errors: unknown[] = [];
+    for (const writer of this.writers.values()) {
+      if (writer === null) continue;
+      try {
+        await writer.drainLive();
+        await writer.flush();
+      } catch (error: unknown) {
+        if (error instanceof SessionHandleClosedError) continue;
+        errors.push(error);
+      }
+    }
+    if (errors.length > 0) throw new AggregateError(errors, `${this.name} flush failed`);
+  }
+
+  async closeAll(): Promise<void> {
+    const errors: unknown[] = [];
+    for (const handle of this.openHandles) {
+      try {
+        await handle.close();
+      } catch (error: unknown) {
+        errors.push(error);
+      }
+    }
+    if (errors.length > 0) throw new AggregateError(errors, `${this.name} dispose failed`);
+  }
+}
+
+export class RdbSessionHandle implements SessionHandle {
+  private chain: Promise<unknown> = Promise.resolve();
+  private closing: Promise<void> | undefined;
+
+  private cursor: number;
+  private materialized: boolean;
+
+  private buffered: SessionEvent[] = [];
+  private batchTimer: ReturnType<typeof setTimeout> | undefined;
+  private drainPaused = false;
+  private draining: Promise<void> | undefined;
+
+  private tornTruncateTo: number | undefined;
+
+  private everAppended = false;
+
+  constructor(
+    private readonly persistence: SessionPersistenceRdb,
+    readonly id: SessionId,
+    readonly header: SessionHeader,
+    readonly access: SessionAccess,
+    private readonly state: {
+      cursor: number;
+      materialized: boolean;
+      inheritedEventCount: SessionLogOffset;
+      tornTruncateTo?: number;
+    },
+  ) {
+    this.cursor = state.cursor;
+    this.materialized = state.materialized;
+    this.tornTruncateTo = state.tornTruncateTo;
+  }
+
+  get inheritedEventCount(): SessionLogOffset {
+    return this.state.inheritedEventCount;
+  }
+
+  get cursorValue(): number {
+    return this.cursor;
+  }
+
+  async read(
+    offset = 0,
+    length = Number.MAX_SAFE_INTEGER,
+    options?: SessionHandleReadOptions,
+  ): Promise<SessionHandleReadResult> {
+    this.assertOpen("read");
+    if (!Number.isSafeInteger(offset) || offset < 0) {
+      throw new TypeError(`read offset must be a non-negative safe integer, got ${String(offset)}`);
+    }
+    if (!Number.isSafeInteger(length) || length < 0) {
+      throw new TypeError(`read length must be a non-negative safe integer, got ${String(length)}`);
+    }
+    options?.signal?.throwIfAborted();
+    const log = await this.persistence.readLog(this.id, {}, options?.signal);
+    if (log === undefined) {
+      if (this.persistence.tracker.hasPending(this.id)) {
+        return { eventState: "detached", events: [] };
+      }
+      throw new SessionPersistenceNotFoundError(this.id);
+    }
+
+    repairReadView(log.events);
+    return { eventState: "detached", events: log.events.slice(offset, offset + length) };
+  }
+
+  async append(
+    events: readonly SessionEvent[],
+    options?: SessionHandleAppendOptions,
+  ): Promise<void> {
+    this.assertOpen("append");
+    const batch = materializeAppendBatch(events);
+    return this.run("append", async () => {
+      options?.signal?.throwIfAborted();
+      if (this.access !== "write") throw new SessionReadOnlyError(this.id, "append");
+      if (batch.length === 0) return;
+      this.everAppended = true;
+      assertContiguous(this.id, batch, this.cursor);
+      await this.persistence.appendBatch(
+        this.header,
+        this.state.inheritedEventCount,
+        batch,
+        this.tornTruncateTo,
+      );
+      this.tornTruncateTo = undefined;
+
+      this.cursor += batch.length;
+      this.materialized = true;
+      this.persistence.tracker.updatePending(this.id, this.cursor, true);
+    });
+  }
+
+  async flush(options?: SessionHandleFlushOptions): Promise<void> {
+    return this.run("flush", async () => {
+      options?.signal?.throwIfAborted();
+      if (this.access !== "write") throw new SessionReadOnlyError(this.id, "flush");
+      if (this.materialized) return;
+      await this.persistence.materializeEmpty(this.header, this.state.inheritedEventCount);
+      this.materialized = true;
+    });
+  }
+
+  close(): Promise<void> {
+    return (this.closing ??= (async () => {
+      let drainFailure: unknown;
+      for (;;) {
+        try {
+          await this.drainLive();
+        } catch (error: unknown) {
+          drainFailure = error;
+          break;
+        }
+        await this.chain;
+        if (this.buffered.length === 0) break;
+      }
+      await this.chain;
+      const failures: Error[] = [];
+      if (drainFailure !== undefined) {
+        failures.push(
+          drainFailure instanceof Error ? drainFailure : new Error(JSON.stringify(drainFailure)),
+        );
+      }
+      this.persistence.tracker.release(this, this.materialized || this.everAppended);
+      if (failures.length > 1)
+        throw new AggregateError(failures, `session "${this.id}": close failed to drain`);
+      if (failures[0] !== undefined) throw failures[0];
+    })());
+  }
+
+  [Symbol.asyncDispose](): Promise<void> {
+    return this.close();
+  }
+
+  enqueueLive(event: SessionEvent, reportBackgroundFailure: (error: unknown) => void): void {
+    this.buffered.push(structuredClone(event));
+    if (this.batchTimer !== undefined || this.drainPaused) return;
+    this.batchTimer = setTimeout(() => {
+      this.batchTimer = undefined;
+      this.drainLive().catch(reportBackgroundFailure);
+    }, RdbSessionHandle.LIVE_WRITE_BATCH_MAX_DELAY_MS);
+  }
+
+  resetAfterRewind(cursor: number, inheritedEventCount?: number): void {
+    this.cursor = cursor;
+    if (inheritedEventCount !== undefined) {
+      (this.state as { inheritedEventCount: SessionLogOffset }).inheritedEventCount =
+        SessionLogOffset(inheritedEventCount);
+    }
+  }
+
+  drainLive(): Promise<void> {
+    return (this.draining ??= this.drainBuffered().finally(() => {
+      this.draining = undefined;
+    }));
+  }
+
+  private async drainBuffered(): Promise<void> {
+    if (this.batchTimer !== undefined) {
+      clearTimeout(this.batchTimer);
+      this.batchTimer = undefined;
+    }
+    this.drainPaused = false;
+    while (this.buffered.length > 0) {
+      await this.enqueueChain(async () => {
+        const batch = this.buffered.splice(0);
+        try {
+          const fresh = batch.filter((event) => event.seq >= this.cursor);
+          if (fresh.length === 0) return;
+          for (const [index, event] of fresh.entries()) {
+            if (event.seq !== this.cursor + index) {
+              throw new Error(
+                `append seq mismatch for "${this.id}": expected ${this.cursor + index} at index ${index}, got ${event.seq}`,
+              );
+            }
+          }
+          await this.persistence.appendBatch(
+            this.header,
+            this.state.inheritedEventCount,
+            fresh,
+            this.tornTruncateTo,
+          );
+          this.tornTruncateTo = undefined;
+          this.cursor += fresh.length;
+          this.materialized = true;
+        } catch (error: unknown) {
+          this.buffered = batch.concat(this.buffered);
+          this.drainPaused = true;
+          throw error;
+        }
+      });
+    }
+  }
+
+  private enqueueChain(op: () => Promise<void>): Promise<void> {
+    const next = this.chain.then(op);
+    this.chain = next.catch(() => {});
+    return next;
+  }
+
+  private async run(operation: string, op: () => Promise<void>): Promise<void> {
+    this.assertOpen(operation);
+    return this.enqueueChain(async () => {
+      this.assertOpen(operation);
+      return op();
+    });
+  }
+
+  private assertOpen(operation: string): void {
+    if (this.closing !== undefined) throw new SessionHandleClosedError(this.id, operation);
+  }
+
+  static readonly LIVE_WRITE_BATCH_MAX_DELAY_MS = 200;
+}
+

package/src/http/route.ts

@@ -0,0 +1,178 @@
+import type { Context } from "@deepseek-ai/cordis";
+
+/** 一条路由自己决定的状态码（鉴权 / 方法 / 解析之外的那些校验）。 */
+export class HttpError extends Error {
+  constructor(
+    readonly status: number,
+    message: string,
+    readonly payload: Record<string, unknown> = {},
+  ) {
+    super(message);
+    this.name = "HttpError";
+  }
+}
+
+export interface JsonRouteReply {
+  status?: number;
+  body: unknown;
+}
+
+export type JsonRouteHandler = (
+  body: unknown,
+  webCtx: Context,
+) => Promise<JsonRouteReply> | JsonRouteReply;
+
+export interface JsonRouteSpec {
+  /** 精确路径（`/api/...`）。 */
+  path: string;
+  /** 业务处理：拿到解析后的 JSON（空 body 视为 `{}`）；校验失败抛 `HttpError`。 */
+  handle: JsonRouteHandler;
+  /** 业务错误的状态码映射（没映射的按 500）。 */
+  statusOfError?: (error: unknown) => { status: number; body: unknown } | undefined;
+}
+
+function writeJson(
+  res: import("node:http").ServerResponse,
+  status: number,
+  body: unknown,
+): void {
+  res.writeHead(status, { "content-type": "application/json" });
+  res.end(JSON.stringify(body));
+}
+
+/**
+ * 挂一条路由：鉴权与方法检查这些每处都一样的部分收在这里。
+ *
+ * 二进制响应（导出 zip）自己写响应体，所以只共用鉴权 / 405 / 错误兜底。
+ */
+export function mountRoute(
+  ctx: Context,
+  path: string,
+  handler: (
+    req: import("node:http").IncomingMessage,
+    res: import("node:http").ServerResponse,
+  ) => Promise<void>,
+): void {
+  ctx.inject(["webServer", "connection"] as const, (webCtx) => {
+    const webServer = webCtx.webServer as unknown as {
+      register(route: {
+        kind: "exact";
+        path: string;
+        handler: (
+          req: import("node:http").IncomingMessage,
+          res: import("node:http").ServerResponse,
+        ) => void | Promise<void>;
+      }): () => void;
+    };
+    const connection = webCtx.get("connection") as unknown as {
+      requestRejection(request: {
+        headers: import("node:http").IncomingHttpHeaders;
+      }): number | undefined;
+    };
+
+    return webCtx.effect(
+      () =>
+        webServer.register({
+          kind: "exact",
+          path,
+          handler: async (req, res) => {
+            const rejection = connection.requestRejection(req);
+            if (rejection !== undefined) {
+              res.writeHead(rejection);
+              res.end(rejection === 401 ? "unauthorized" : "forbidden");
+              return;
+            }
+            if (req.method !== "POST") {
+              writeJson(res, 405, { error: "method not allowed" });
+              return;
+            }
+            try {
+              await handler(req, res);
+            } catch (error) {
+              if (res.headersSent) return;
+              writeJson(res, 500, {
+                error: error instanceof Error ? error.message : "request failed",
+              });
+            }
+          },
+        }),
+      `session-rdb: ${path}`,
+    );
+  });
+}
+
+/**
+ * 挂一条 JSON 路由：鉴权、方法、body 解析、错误码这些每处都一样的部分收在这里。
+ *
+ * 5 个 JSON 路由（rows / usage / gc / deletion / import）共用 `mountJsonRoute`；`export` 的响应体是 zip，走
+ * `mountRoute`，只复用鉴权 / 405 / 500。之前每个文件各抄一遍（约 270 行样板，而且 `import` 那条漏了 405）。
+ */
+export function mountJsonRoute(ctx: Context, spec: JsonRouteSpec): void {
+  ctx.inject(["webServer", "connection"] as const, (webCtx) => {
+    const webServer = webCtx.webServer as unknown as {
+      register(route: {
+        kind: "exact";
+        path: string;
+        handler: (
+          req: import("node:http").IncomingMessage,
+          res: import("node:http").ServerResponse,
+        ) => void | Promise<void>;
+      }): () => void;
+    };
+    const connection = webCtx.get("connection") as unknown as {
+      requestRejection(request: {
+        headers: import("node:http").IncomingHttpHeaders;
+      }): number | undefined;
+    };
+
+    return webCtx.effect(
+      () =>
+        webServer.register({
+          kind: "exact",
+          path: spec.path,
+          handler: async (req, res) => {
+            const rejection = connection.requestRejection(req);
+            if (rejection !== undefined) {
+              res.writeHead(rejection);
+              res.end(rejection === 401 ? "unauthorized" : "forbidden");
+              return;
+            }
+            if (req.method !== "POST") {
+              writeJson(res, 405, { error: "method not allowed" });
+              return;
+            }
+            const chunks: Buffer[] = [];
+            for await (const chunk of req) chunks.push(chunk as Buffer);
+            const raw = Buffer.concat(chunks).toString("utf8");
+            let body: unknown = {};
+            if (raw !== "") {
+              try {
+                body = JSON.parse(raw);
+              } catch {
+                writeJson(res, 400, { error: "request body is not JSON" });
+                return;
+              }
+            }
+            try {
+              const reply = await spec.handle(body, webCtx);
+              writeJson(res, reply.status ?? 200, reply.body);
+            } catch (error) {
+              if (error instanceof HttpError) {
+                writeJson(res, error.status, { error: error.message, ...error.payload });
+                return;
+              }
+              const mapped = spec.statusOfError?.(error);
+              if (mapped !== undefined) {
+                writeJson(res, mapped.status, mapped.body);
+                return;
+              }
+              writeJson(res, 500, {
+                error: error instanceof Error ? error.message : "request failed",
+              });
+            }
+          },
+        }),
+      `session-rdb: ${spec.path}`,
+    );
+  });
+}

package/src/import-storages.ts

@@ -47,11 +47,14 @@ export async function importStorages(
       WORKSPACE_UNIT_VERSIONS.values().next().value as number,
     );
     for (const [id, record] of Object.entries(tables["workspaces"] ?? {})) {
-      await repository.putWorkspace(id, record as WorkspaceRecord);
+      await repository.putDomainRecord("workspace", "workspaces", id, record as WorkspaceRecord);
       result.workspaces += 1;
     }
     if (workspaceDocument.global !== undefined && workspaceDocument.global !== null) {
-      await repository.writeWorkspaceState(workspaceDocument.global as WorkspaceDomainState);
+      await repository.writeDomainGlobal(
+        "workspace",
+        workspaceDocument.global as WorkspaceDomainState,
+      );
       result.workspaceState = true;
     }
   }