@morlay/session-rdb 0.0.16-alpha.4 → 0.0.17

package/src/postgres.ts

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { readdirSync } from "node:fs";
 import { fileURLToPath } from "node:url";
-import { and, eq, gte, sql } from "drizzle-orm";
+import { and, desc, eq, gte, sql } from "drizzle-orm";
 import type { PgAsyncDatabase, PgAsyncTransaction } from "drizzle-orm/pg-core";
 import type { NodePgDatabase, NodePgQueryResultHKT } from "drizzle-orm/node-postgres";
 import { migrate } from "drizzle-orm/node-postgres/migrator";
@@ -16,7 +16,9 @@ import {
 } from "./backend.ts";
 import { toPostgresSchema } from "./adapters/index.ts";
 import { postgresTableDefs } from "./entities/index.ts";
-import { sessionConflictRow, sessionInsertRow } from "./log.ts";
+import { sessionConflictRow, sessionInsertRow, titleOfEventData } from "./log.ts";
+import { createStorageRepository } from "./storage-takeover/repository.ts";
+import type { StorageRepository } from "./storage-takeover/types.ts";
 
 /** drizzle-kit 生成的迁移目录（随包根 drizzle/ 发布；src/dist 形态经相对 URL 统一解析）。 */
 const postgresMigrationsDir = fileURLToPath(new URL("../drizzle/postgres/", import.meta.url));
@@ -35,14 +37,54 @@ export class PostgresBackend implements Backend {
 
   private readonly tables: Record<string, any>;
 
+  /** storages 接管表访问层；句柄在 open()（含迁移）完成后解析。 */
+  readonly storage: StorageRepository;
+
+  private readonly opened: Promise<void>;
+  private resolveOpened!: () => void;
+  private rejectOpened!: (error: unknown) => void;
+  /** 事务期间的连接覆盖：storage 写方法经它加入当前事务。 */
+  private txOverride: unknown;
+
   constructor(
     private readonly db: NodePgDatabase,
     private readonly options: PostgresBackendOptions,
   ) {
     this.tables = toPostgresSchema(postgresTableDefs, this.options.schema ?? "public");
+    this.opened = new Promise<void>((resolve, reject) => {
+      this.resolveOpened = resolve;
+      this.rejectOpened = reject;
+    });
+    // 每个 storage 原语都会重新 await 同一 promise，失败仍逐一可见；这个
+    // 守卫只防止 open 失败早于首次使用时的 unhandled rejection。
+    this.opened.catch(() => {});
+    this.storage = createStorageRepository({
+      db: () => this.opened.then(() => this.txOverride ?? this.db),
+      writeAtomically: (fn) =>
+        this.db.transaction(async (tx) => {
+          const previous = this.txOverride;
+          this.txOverride = tx;
+          try {
+            return await fn();
+          } finally {
+            this.txOverride = previous;
+          }
+        }),
+      tables: this.tables,
+    });
   }
 
   async open(): Promise<void> {
+    try {
+      await this.doOpen();
+      this.resolveOpened();
+    } catch (error: unknown) {
+      this.rejectOpened(error);
+      throw error;
+    }
+  }
+
+  private async doOpen(): Promise<void> {
     const schema = this.options.schema ?? "public";
     // drizzle-kit 迁移：v2 baseline 由旧版本建表（首次打开时标记为已应用），
     // 本版本只执行 v3 diff（删 f_original_seq）。
@@ -149,6 +191,7 @@ export class PostgresBackend implements Backend {
       updateHead: (id, headEventId, headSequence) =>
         this.updateHead(tx, id, headEventId, headSequence),
       bumpRevision: (id) => this.bumpRevision(tx, id),
+      refreshTitle: (id) => this.refreshTitle(tx, id),
       deleteBridgeTail: (id, fromSequence) => this.deleteBridgeTail(tx, id, fromSequence),
       getPrevBridge: (id, sequence) => this.getPrevBridge(tx, id, sequence),
     };
@@ -291,6 +334,31 @@ export class PostgresBackend implements Backend {
       .execute();
   }
 
+  /** 从事件表重算标题（最后一条 `session/title`），写回会话行的 f_title 列。 */
+  private async refreshTitle(
+    exec: PgAsyncDatabase<NodePgQueryResultHKT>,
+    id: SessionId,
+  ): Promise<void> {
+    const bridges = this.tables["t_session_events"];
+    const entities = this.tables["t_events"];
+    const row = (
+      await exec
+        .select({ fSequence: bridges.fSequence, fData: entities.fData })
+        .from(bridges)
+        .innerJoin(entities, eq(entities.fEventId, bridges.fEventId))
+        .where(and(eq(bridges.fSessionId, id), eq(entities.fType, "session/title")))
+        .orderBy(desc(bridges.fSequence))
+        .limit(1)
+        .execute()
+    )[0] as { fSequence: number; fData: string } | undefined;
+    const title = row === undefined ? undefined : titleOfEventData(row.fData);
+    await exec
+      .update(this.tables["t_sessions"])
+      .set({ fTitle: title ?? null, fTitleSeq: title === undefined ? null : row!.fSequence })
+      .where(eq(this.tables["t_sessions"].fSessionId, id))
+      .execute();
+  }
+
   private async deleteBridgeTail(
     exec: PgAsyncDatabase<NodePgQueryResultHKT>,
     id: SessionId,

package/src/schema.ts

@@ -21,6 +21,16 @@ export const tEvents = sqliteTables["t_events"]!;
 
 export const tSessionEvents = sqliteTables["t_session_events"]!;
 
+export const tStorageUnits = sqliteTables["t_storage_units"]!;
+
+export const tWorkspaces = sqliteTables["t_workspaces"]!;
+
+export const tWorkspaceSessions = sqliteTables["t_workspace_sessions"]!;
+
+export const tWorkspaceState = sqliteTables["t_workspace_state"]!;
+
+export const tSessionProjcacheRows = sqliteTables["t_session_projcache_row"]!;
+
 export type { SessionRow } from "./backend.ts";
 
 export type { EventRow } from "./backend.ts";
@@ -70,7 +80,9 @@ export function eventKind(event: { type: string; data?: unknown }): EventKind |
       return "turn";
     case "tool/call":
     case "tool/result":
-    case "tool/code-dispatch-start":
+    case "tool/ptc-dispatch-start":
+    case "tool/ptc-dispatch":
+    case "tool/code-dispatch-start": // v2 旧名（读路径归一为 ptc）
     case "tool/code-dispatch":
       return "tool";
     case "request/header":
@@ -158,7 +170,9 @@ export function eventDimensions(event: SessionEvent): {
         name: typeof data["name"] === "string" ? data["name"] : "",
         actionId: typeof data["callId"] === "string" ? data["callId"] : "",
       };
-    case "tool/code-dispatch-start":
+    case "tool/ptc-dispatch-start":
+    case "tool/ptc-dispatch":
+    case "tool/code-dispatch-start": // v2 旧名（读路径归一为 ptc）
     case "tool/code-dispatch":
       return {
         kind,

package/src/sqlite.ts

@@ -4,7 +4,7 @@ import { mkdir, open } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { DatabaseSync } from "node:sqlite";
-import { and, eq, gte, sql } from "drizzle-orm";
+import { and, desc, eq, gte, sql } from "drizzle-orm";
 import { drizzle, type NodeSQLiteDatabase } from "drizzle-orm/node-sqlite";
 import { migrate } from "drizzle-orm/node-sqlite/migrator";
 import type { SessionId } from "@deepseek-ai/dsh-session";
@@ -16,7 +16,7 @@ import {
   type EventRow,
   type SessionRow,
 } from "./backend.ts";
-import { sessionConflictRow, sessionInsertRow } from "./log.ts";
+import { sessionConflictRow, sessionInsertRow, titleOfEventData } from "./log.ts";
 import {
   DEFAULT_BUSY_TIMEOUT_MS,
   SCHEMA_VERSION,
@@ -24,9 +24,16 @@ import {
   tEvents,
   tPersistenceState,
   tSessionEvents,
+  tSessionProjcacheRows,
   tSessions,
+  tStorageUnits,
+  tWorkspaceSessions,
+  tWorkspaceState,
+  tWorkspaces,
   type JournalMode,
 } from "./schema.ts";
+import { createStorageRepository } from "./storage-takeover/repository.ts";
+import type { StorageRepository } from "./storage-takeover/types.ts";
 
 type SqliteDb = NodeSQLiteDatabase & { $client: DatabaseSync };
 
@@ -178,12 +185,69 @@ export class SqliteBackend implements Backend {
   readonly kind = "sqlite" as const;
   storeIdentity!: string;
 
+  /** storages 接管表访问层；句柄在 open() 完成后解析。 */
+  readonly storage: StorageRepository;
+
   private dbPath = "";
   private db!: SqliteDb;
-
-  constructor(private readonly options: SqliteBackendOptions) {}
+  private readonly dbReady: Promise<SqliteDb>;
+  private resolveDb!: (db: SqliteDb) => void;
+  private rejectDb!: (error: unknown) => void;
+
+  constructor(private readonly options: SqliteBackendOptions) {
+    this.dbReady = new Promise<SqliteDb>((resolve, reject) => {
+      this.resolveDb = resolve;
+      this.rejectDb = reject;
+    });
+    // 每个 storage 原语都会重新 await 同一 promise，失败仍逐一可见；这个
+    // 守卫只防止 open 失败早于首次使用时的 unhandled rejection。
+    this.dbReady.catch(() => {});
+    this.storage = createStorageRepository({
+      db: () => this.dbReady,
+      // 同步驱动：读路径直读介质（open 之前的调用是装配错误，fail loud）。
+      dbSync: () => {
+        if (this.db === undefined) throw new Error("sqlite session database is not open");
+        return this.db;
+      },
+      writeAtomically: (fn) =>
+        enqueueSqliteTx(this.dbPath, async () => {
+          const db = await this.dbReady;
+          db.$client.exec("BEGIN IMMEDIATE");
+          try {
+            const result = await fn();
+            db.$client.exec("COMMIT");
+            return result;
+          } catch (error: unknown) {
+            try {
+              db.$client.exec("ROLLBACK");
+            } catch {
+              // 原始 SQLite 失败仍是可操作的根因。
+            }
+            throw error;
+          }
+        }),
+      tables: {
+        t_sessions: tSessions,
+        t_storage_units: tStorageUnits,
+        t_workspaces: tWorkspaces,
+        t_workspace_sessions: tWorkspaceSessions,
+        t_workspace_state: tWorkspaceState,
+        t_session_projcache_row: tSessionProjcacheRows,
+      },
+    });
+  }
 
   async open(): Promise<void> {
+    try {
+      await this.doOpen();
+      this.resolveDb(this.db);
+    } catch (error: unknown) {
+      this.rejectDb(error);
+      throw error;
+    }
+  }
+
+  private async doOpen(): Promise<void> {
     const actual =
       this.options.path === ":memory:" ? this.options.path : resolve(this.options.path);
     this.dbPath = actual;
@@ -290,6 +354,7 @@ export class SqliteBackend implements Backend {
     insertBridges: (rows) => this.insertBridges(rows),
     updateHead: (id, headEventId, headSequence) => this.updateHead(id, headEventId, headSequence),
     bumpRevision: (id) => this.bumpRevision(id),
+    refreshTitle: (id) => this.refreshTitle(id),
     deleteBridgeTail: (id, fromSequence) => this.deleteBridgeTail(id, fromSequence),
     getPrevBridge: (id, sequence) => this.getPrevBridge(id, sequence),
   };
@@ -388,6 +453,24 @@ export class SqliteBackend implements Backend {
       .run();
   }
 
+  /** 从事件表重算标题（最后一条 `session/title`），写回会话行的 f_title 列。 */
+  private async refreshTitle(id: SessionId): Promise<void> {
+    const row = this.db
+      .select({ fSequence: tSessionEvents.fSequence, fData: tEvents.fData })
+      .from(tSessionEvents)
+      .innerJoin(tEvents, eq(tEvents.fEventId, tSessionEvents.fEventId))
+      .where(and(eq(tSessionEvents.fSessionId, id), eq(tEvents.fType, "session/title")))
+      .orderBy(desc(tSessionEvents.fSequence))
+      .limit(1)
+      .get() as { fSequence: number; fData: string } | undefined;
+    const title = row === undefined ? undefined : titleOfEventData(row.fData);
+    this.db
+      .update(tSessions)
+      .set({ fTitle: title ?? null, fTitleSeq: title === undefined ? null : row!.fSequence })
+      .where(eq(tSessions.fSessionId, id))
+      .run();
+  }
+
   private async deleteBridgeTail(id: SessionId, fromSequence: number): Promise<void> {
     this.db
       .delete(tSessionEvents)

package/src/storage-takeover/index.ts

@@ -0,0 +1,60 @@
+/**
+ * storages 接管的装配入口：在 session-rdb 插件内注册
+ *
+ * 1. storage hub 的 `rdb` KV 后端——上游 `storage-domain` 的 `StorageBackend.kv`
+ *    契约实现（名字来自上游），把 workspace 域映射到 rdb 语义专用表；
+ * 2. `ctx.sessionProjectionCache` 服务——替换上游 `session-projection-cache`
+ *    插件，直接读写 rdb 的投影 checkpoint 表。
+ *
+ * 两者都经 `ctx.inject` 挂在可选依赖上：装配里缺 `storage` 或
+ * `sessionProjections`（纯 cordis 单测）时静默跳过，消费者按上游的缺服务
+ * 路径降级。
+ */
+
+import type { Context } from "@deepseek-ai/cordis";
+import { storageBackendServiceKey } from "@deepseek-ai/dsh-storage";
+import type { ProjectionCacheConfig } from "./projection-cache.ts";
+import { SessionProjectionCacheRdb } from "./projection-cache.ts";
+import { RDB_STORAGE_BACKEND, RdbStorageBackend } from "./storage-backend.ts";
+import type { StorageRepository } from "./types.ts";
+
+/** 装配参数。 */
+export interface StorageTakeoverOptions {
+  /** storages 接管表访问层（与事件日志同介质）。 */
+  repository: StorageRepository;
+  /** 投影缓存的写节流参数（上游 base 装配的部署值）。 */
+  projectionCache: ProjectionCacheConfig;
+  /** 介质就绪信号：投影缓存直读介质前必须等到。 */
+  ready: Promise<unknown>;
+}
+
+/**
+ * Install the storages takeover on the session-rdb plugin context.
+ * @param ctx - session-rdb plugin context.
+ * @param options - repository and projection-cache throttle parameters.
+ */
+export function installStorageTakeover(ctx: Context, options: StorageTakeoverOptions): void {
+  // workspace 域：上游 workspaceRegistry 仍持有服务与内存态，这里只提供它
+  // 依赖的 storage-domain 介质（backend 名 `rdb`，由 profile patch 路由）。
+  ctx.inject(["storage"], (storageCtx) => {
+    const backend = new RdbStorageBackend(options.repository);
+    storageCtx.effect(() => {
+      const unregister = storageCtx.storage.backend.register(RDB_STORAGE_BACKEND, backend);
+      return async () => {
+        unregister();
+        await backend.close();
+      };
+    }, "session-rdb.storageBackend");
+    storageCtx.provide(storageBackendServiceKey(RDB_STORAGE_BACKEND), backend);
+  });
+
+  // 投影 checkpoint：上游插件被禁用后由本服务提供同名 API。
+  ctx.inject(["sessionProjections"], (projectionCtx) => {
+    new SessionProjectionCacheRdb(
+      projectionCtx,
+      options.projectionCache,
+      options.repository,
+      options.ready,
+    );
+  });
+}