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

package/src/deletion.ts

@@ -1,7 +1,9 @@
 import type { Context } from "@deepseek-ai/cordis";
 import type { SessionId } from "@deepseek-ai/dsh-session";
-import { SessionDeletionError, type SessionPersistenceRdb } from "./index.ts";
+import { SessionDeletionError } from "./deletion-error.ts";
+import type { SessionPersistenceRdb } from "./session-store.ts";
 import { SESSION_DELETE_PATH } from "./routes.ts";
+import { HttpError, mountJsonRoute } from "./http/route.ts";
 
 export { SESSION_DELETE_PATH };
 
@@ -12,77 +14,22 @@ const STATUS_OF_DELETION_ERROR: Record<SessionDeletionError["code"], number> = {
 };
 
 export function registerSessionDeletion(ctx: Context, persistence: SessionPersistenceRdb): 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: SESSION_DELETE_PATH,
-        handler: async (req, res) => {
-          const rejection = connection.requestRejection(req);
-          if (rejection !== undefined) {
-            res.writeHead(rejection);
-            res.end(rejection === 401 ? "unauthorized" : "forbidden");
-            return;
+  mountJsonRoute(ctx, {
+    path: SESSION_DELETE_PATH,
+    handle: async (body) => {
+      const { sessionId } = body as { sessionId?: unknown };
+      if (typeof sessionId !== "string" || sessionId === "") {
+        throw new HttpError(400, "missing sessionId field");
+      }
+      await persistence.deleteSession(sessionId as SessionId);
+      return { body: { deleted: sessionId } };
+    },
+    statusOfError: (error) =>
+      error instanceof SessionDeletionError
+        ? {
+            status: STATUS_OF_DELETION_ERROR[error.code],
+            body: { error: error.message, code: error.code },
           }
-          if (req.method !== "POST") {
-            res.writeHead(405, { "content-type": "application/json" });
-            res.end(JSON.stringify({ error: "method not allowed" }));
-            return;
-          }
-          const chunks: Buffer[] = [];
-          for await (const chunk of req) chunks.push(chunk as Buffer);
-          let envelope: { sessionId?: unknown };
-          try {
-            envelope = JSON.parse(Buffer.concat(chunks).toString("utf8")) as {
-              sessionId?: unknown;
-            };
-          } catch {
-            res.writeHead(400, { "content-type": "application/json" });
-            res.end(JSON.stringify({ error: "request body is not JSON" }));
-            return;
-          }
-          if (typeof envelope.sessionId !== "string" || envelope.sessionId === "") {
-            res.writeHead(400, { "content-type": "application/json" });
-            res.end(JSON.stringify({ error: "missing sessionId field" }));
-            return;
-          }
-          try {
-            await persistence.deleteSession(envelope.sessionId as SessionId);
-          } catch (error: unknown) {
-            if (error instanceof SessionDeletionError) {
-              res.writeHead(STATUS_OF_DELETION_ERROR[error.code], {
-                "content-type": "application/json",
-              });
-              res.end(JSON.stringify({ error: error.message, code: error.code }));
-              return;
-            }
-            res.writeHead(500, { "content-type": "application/json" });
-            res.end(
-              JSON.stringify({
-                error: error instanceof Error ? error.message : "session deletion failed",
-              }),
-            );
-            return;
-          }
-          res.writeHead(200, { "content-type": "application/json" });
-          res.end(JSON.stringify({ deleted: envelope.sessionId }));
-        },
-      }),
-    );
+        : undefined,
   });
 }

package/src/entities/index.ts

@@ -1,2 +1,17 @@
+import { defineCatalog } from "@morlay/rdbkit";
+import { sqliteTableDefs } from "./v3/index.ts";
+
 export { sqliteTableDefs, postgresTableDefs } from "./v3/index.ts";
-export { sqliteTableDefsV2, postgresTableDefsV2 } from "./v2/index.ts";
+
+/** 库结构的唯一事实来源（DDL、迁移与表句柄都从它算出来）。 */
+export const catalog = defineCatalog(sqliteTableDefs);
+export { storageRecords } from "./v3/storage-records.ts";
+export { sessionProjcacheRows } from "./v3/session-projcache-rows.ts";
+export { persistenceState } from "./v3/persistence-state.ts";
+export { sessions } from "./v3/sessions.ts";
+export { events } from "./v3/events.ts";
+export { sessionEvents } from "./v3/session-events.ts";
+export { eventUsage } from "./v3/event-usage.ts";
+export { sessionUsage } from "./v3/session-usage.ts";
+export { sessionCounts } from "./v3/session-counts.ts";
+export { storageUnits } from "./v3/storage-units.ts";

package/src/entities/v3/event-usage.ts

@@ -1,9 +1,9 @@
-import type { TableDef } from "../../adapters/types.ts";
+import { defineTable } from "@morlay/rdbkit";
 
 // 用量日志：一条 `assistant/message` 事件一行（按事件行唯一，fork 共享行不重复）；读侧维度全部物化在行上
 // （本地日、是否被会话引用、是否被子代理会话引用），统计因此不做 `EXISTS` 判定、也不回连事件表。
 // 取舍见 ADR-统计衍生表物化归属与汇总。
-export const eventUsage: TableDef = {
+export const eventUsage = defineTable({
   name: "t_event_usage",
   columns: {
     f_event_id: {
@@ -27,4 +27,4 @@ export const eventUsage: TableDef = {
     f_total_tokens: { type: "integer", notNull: true, default: 0 },
   },
   indexes: { idx_event_usage_created_at: { columns: ["f_created_at"] } },
-};
+});

package/src/entities/v3/events.ts

@@ -1,6 +1,6 @@
-import type { TableDef } from "../../adapters/types.ts";
+import { defineTable } from "@morlay/rdbkit";
 
-export const events: TableDef = {
+export const events = defineTable({
   name: "t_events",
   columns: {
     f_id: { type: "serial", primaryKey: true },
@@ -22,4 +22,4 @@ export const events: TableDef = {
     idx_events_name: { columns: ["f_name"] },
     idx_events_action_id: { columns: ["f_action_id"] },
   },
-};
+});

package/src/entities/v3/index.ts

@@ -4,10 +4,7 @@ import { sessions } from "./sessions.ts";
 import { events } from "./events.ts";
 import { sessionEvents } from "./session-events.ts";
 import { storageUnits } from "./storage-units.ts";
-import { workspaces } from "./workspaces.ts";
-import { workspaceSessions } from "./workspace-sessions.ts";
-import { workspaceState } from "./workspace-state.ts";
-import { scheduleTasks } from "./schedule-tasks.ts";
+import { storageRecords } from "./storage-records.ts";
 import { sessionProjcacheRows } from "./session-projcache-rows.ts";
 import { eventUsage } from "./event-usage.ts";
 import { sessionUsage } from "./session-usage.ts";
@@ -19,10 +16,7 @@ export { sessions };
 export { events };
 export { sessionEvents };
 export { storageUnits };
-export { workspaces };
-export { workspaceSessions };
-export { workspaceState };
-export { scheduleTasks };
+export { storageRecords };
 export { sessionProjcacheRows };
 export { eventUsage };
 export { sessionUsage };
@@ -35,10 +29,7 @@ export const sqliteTableDefs = [
   events,
   sessionEvents,
   storageUnits,
-  workspaces,
-  workspaceSessions,
-  workspaceState,
-  scheduleTasks,
+  storageRecords,
   sessionProjcacheRows,
   eventUsage,
   sessionUsage,
@@ -52,10 +43,7 @@ export const postgresTableDefs = [
   events,
   sessionEvents,
   storageUnits,
-  workspaces,
-  workspaceSessions,
-  workspaceState,
-  scheduleTasks,
+  storageRecords,
   sessionProjcacheRows,
   eventUsage,
   sessionUsage,

package/src/entities/v3/persistence-state.ts

@@ -1,10 +1,10 @@
-import type { TableDef } from "../../adapters/types.ts";
+import { defineTable } from "@morlay/rdbkit";
 
-export const persistenceState: TableDef = {
+export const persistenceState = defineTable({
   name: "t_persistence_state",
   columns: {
     f_singleton: { type: "integer", primaryKey: true },
     f_store_id: { type: "text", notNull: true },
   },
   checks: { ck_persistence_state_singleton: { expression: "f_singleton = 1" } },
-};
+});

package/src/entities/v3/schema-meta.ts

@@ -1,9 +1,9 @@
-import type { TableDef } from "../../adapters/types.ts";
+import { defineTable } from "@morlay/rdbkit";
 
-export const schemaMeta: TableDef = {
+export const schemaMeta = defineTable({
   name: "t_schema_meta",
   columns: {
     f_key: { type: "text", primaryKey: true },
     f_value: { type: "text", notNull: true },
   },
-};
+});

package/src/entities/v3/session-counts.ts

@@ -1,9 +1,9 @@
-import type { TableDef } from "../../adapters/types.ts";
+import { defineTable } from "@morlay/rdbkit";
 
 // 会话 × 本地日的活动计数（派生统计表）：轮次 / 步骤 / 用户输入 / 工具调用四列直接读，
 // 不再存事件类型、也不在读取时折。旁路累加、可按会话重建，读侧只读；
 // 取舍见 ADR-统计衍生表物化归属与汇总。
-export const sessionCounts: TableDef = {
+export const sessionCounts = defineTable({
   name: "t_session_counts",
   columns: {
     f_session_id: {
@@ -18,4 +18,4 @@ export const sessionCounts: TableDef = {
     f_tool_calls: { type: "integer", notNull: true, default: 0 },
   },
   uniques: { uq_session_counts_key: { columns: ["f_session_id", "f_day"] } },
-};
+});

package/src/entities/v3/session-events.ts

@@ -1,6 +1,6 @@
-import type { TableDef } from "../../adapters/types.ts";
+import { defineTable } from "@morlay/rdbkit";
 
-export const sessionEvents: TableDef = {
+export const sessionEvents = defineTable({
   name: "t_session_events",
   columns: {
     f_id: { type: "serial", primaryKey: true },
@@ -22,4 +22,4 @@ export const sessionEvents: TableDef = {
   },
 
   indexes: { idx_session_events_event_id: { columns: ["f_event_id"] } },
-};
+});

package/src/entities/v3/session-projcache-rows.ts

@@ -1,6 +1,6 @@
-import type { TableDef } from "../../adapters/types.ts";
+import { defineTable } from "@morlay/rdbkit";
 
-export const sessionProjcacheRows: TableDef = {
+export const sessionProjcacheRows = defineTable({
   name: "t_session_projcache_row",
   columns: {
     f_id: { type: "serial", primaryKey: true },
@@ -16,4 +16,4 @@ export const sessionProjcacheRows: TableDef = {
   },
   uniques: { uq_session_projcache_row_session_key: { columns: ["f_session_id", "f_key"] } },
   indexes: { idx_session_projcache_row_key: { columns: ["f_key"] } },
-};
+});

package/src/entities/v3/session-usage.ts

@@ -1,9 +1,9 @@
-import type { TableDef } from "../../adapters/types.ts";
+import { defineTable } from "@morlay/rdbkit";
 
 // 会话 × 本地日 × 模型的 token 汇总（派生统计表）：**按会话的行**读它，因此保住
 // 「fork 子会话含继承前缀」的口径（各会话行之和 ≥ 总量）而不回连事件表。
 // 旁路累加、可按会话重建，读侧只读；取舍见 ADR-统计衍生表物化归属与汇总。
-export const sessionUsage: TableDef = {
+export const sessionUsage = defineTable({
   name: "t_session_usage",
   columns: {
     f_session_id: {
@@ -24,4 +24,4 @@ export const sessionUsage: TableDef = {
   uniques: {
     uq_session_usage_key: { columns: ["f_session_id", "f_day", "f_provider", "f_model"] },
   },
-};
+});

package/src/entities/v3/sessions.ts

@@ -1,6 +1,6 @@
-import type { TableDef } from "../../adapters/types.ts";
+import { defineTable } from "@morlay/rdbkit";
 
-export const sessions: TableDef = {
+export const sessions = defineTable({
   name: "t_sessions",
   columns: {
     f_id: { type: "serial", primaryKey: true },
@@ -28,4 +28,4 @@ export const sessions: TableDef = {
 
     f_title_seq: { type: "integer" },
   },
-};
+});

package/src/entities/v3/storage-records.ts

@@ -0,0 +1,17 @@
+import { defineTable } from "@morlay/rdbkit";
+
+// 所有 storage 域共用这一张表：(域, 表, 键) 一行，值是整份记录文档。域是行的一部分，所以新增域
+// （不论它自带几张表、还是只有 global 槽）都不需要再建表——上游 `KvUnit` 的契约本来就只要求
+// 「按表名读写记录 + 一个 global 单例」，行存储直接承载它。global 单例用 `f_table = ''`。
+export const storageRecords = defineTable({
+  name: "t_storage_records",
+  columns: {
+    f_domain: { type: "text", notNull: true },
+    f_table: { type: "text", notNull: true },
+    f_key: { type: "text", notNull: true },
+    f_value: { type: "text", notNull: true },
+  },
+  uniques: {
+    uq_storage_records_domain_table_key: { columns: ["f_domain", "f_table", "f_key"] },
+  },
+});

package/src/entities/v3/storage-units.ts

@@ -1,9 +1,9 @@
-import type { TableDef } from "../../adapters/types.ts";
+import { defineTable } from "@morlay/rdbkit";
 
-export const storageUnits: TableDef = {
+export const storageUnits = defineTable({
   name: "t_storage_units",
   columns: {
     f_name: { type: "text", primaryKey: true },
     f_version: { type: "integer", notNull: true },
   },
-};
+});

package/src/{schema.ts → event-shape.ts}

@@ -1,50 +1,4 @@
 import type { SessionEvent } from "@deepseek-ai/dsh-session";
-import { toSqliteSchema } from "./adapters/index.ts";
-import { sqliteTableDefs } from "./entities/index.ts";
-
-export const SCHEMA_VERSION = 3;
-
-export const SESSION_PERSISTENCE_SQLITE_APPLICATION_ID = 0x44534850;
-
-export const EVENT_ENCODING = "json";
-
-const sqliteTables: Record<string, any> = toSqliteSchema(sqliteTableDefs);
-
-export const tPersistenceState = sqliteTables["t_persistence_state"]!;
-
-export const tSchemaMeta = sqliteTables["t_schema_meta"]!;
-
-export const tSessions = sqliteTables["t_sessions"]!;
-
-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 tScheduleTasks = sqliteTables["t_schedule_tasks"]!;
-
-export const tSessionProjcacheRows = sqliteTables["t_session_projcache_row"]!;
-
-export const tEventUsage = sqliteTables["t_event_usage"]!;
-
-export const tSessionUsage = sqliteTables["t_session_usage"]!;
-
-export const tSessionCounts = sqliteTables["t_session_counts"]!;
-
-export type { SessionRow } from "./backend.ts";
-
-export type { EventRow } from "./backend.ts";
-
-export type JournalMode = "wal" | "delete" | "truncate" | "persist";
-
-export const DEFAULT_BUSY_TIMEOUT_MS = 5000;
 
 export type EventKind =
   | "message"

package/src/export.ts

@@ -1,8 +1,9 @@
 import { strToU8, zip } from "fflate";
 import type { Context } from "@deepseek-ai/cordis";
 import type { SessionId } from "@deepseek-ai/dsh-session";
-import type { SessionPersistenceRdb } from "./index.ts";
+import type { SessionPersistenceRdb } from "./session-store.ts";
 import { SESSION_EXPORT_PATH } from "./routes.ts";
+import { mountRoute } from "./http/route.ts";
 
 export { SESSION_EXPORT_PATH };
 
@@ -23,82 +24,35 @@ function zipBytes(files: Record<string, Uint8Array>): Promise<Uint8Array> {
 
 // 导出通道：直接把会话日志打成 zip 响应体，与导入通道读同一份 artifact。
 export function registerSessionExport(ctx: Context, persistence: SessionPersistenceRdb): 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: SESSION_EXPORT_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") {
-              res.writeHead(405, { "content-type": "application/json" });
-              res.end(JSON.stringify({ error: "method not allowed" }));
-              return;
-            }
-            const chunks: Buffer[] = [];
-            for await (const chunk of req) chunks.push(chunk as Buffer);
-            let envelope: { sessionId?: unknown };
-            try {
-              envelope = JSON.parse(Buffer.concat(chunks).toString("utf8")) as {
-                sessionId?: unknown;
-              };
-            } catch {
-              res.writeHead(400, { "content-type": "application/json" });
-              res.end(JSON.stringify({ error: "request body is not JSON" }));
-              return;
-            }
-            if (typeof envelope.sessionId !== "string" || envelope.sessionId === "") {
-              res.writeHead(400, { "content-type": "application/json" });
-              res.end(JSON.stringify({ error: "missing sessionId field" }));
-              return;
-            }
-            const sessionId = envelope.sessionId;
-            try {
-              const raw = await persistence.readRaw(sessionId as SessionId);
-              if (raw === undefined) {
-                res.writeHead(404, { "content-type": "application/json" });
-                res.end(JSON.stringify({ error: `session "${sessionId}" not found` }));
-                return;
-              }
-              const zipFile = await zipBytes({ [raw.filename]: strToU8(raw.content) });
-              res.writeHead(200, {
-                "content-type": "application/zip",
-                "content-length": String(zipFile.byteLength),
-                "content-disposition": `attachment; filename="${safeFilename(sessionId)}.zip"`,
-              });
-              res.end(Buffer.from(zipFile));
-            } catch (error: unknown) {
-              res.writeHead(500, { "content-type": "application/json" });
-              res.end(
-                JSON.stringify({
-                  error: error instanceof Error ? error.message : "session export failed",
-                }),
-              );
-            }
-          },
-        }),
-      `session-rdb: ${SESSION_EXPORT_PATH} route`,
-    );
+  mountRoute(ctx, SESSION_EXPORT_PATH, async (req, res) => {
+    const chunks: Buffer[] = [];
+    for await (const chunk of req) chunks.push(chunk as Buffer);
+    let envelope: { sessionId?: unknown };
+    try {
+      envelope = JSON.parse(Buffer.concat(chunks).toString("utf8")) as { sessionId?: unknown };
+    } catch {
+      res.writeHead(400, { "content-type": "application/json" });
+      res.end(JSON.stringify({ error: "request body is not JSON" }));
+      return;
+    }
+    if (typeof envelope.sessionId !== "string" || envelope.sessionId === "") {
+      res.writeHead(400, { "content-type": "application/json" });
+      res.end(JSON.stringify({ error: "missing sessionId field" }));
+      return;
+    }
+    const sessionId = envelope.sessionId;
+    const raw = await persistence.readRaw(sessionId as SessionId);
+    if (raw === undefined) {
+      res.writeHead(404, { "content-type": "application/json" });
+      res.end(JSON.stringify({ error: `session "${sessionId}" not found` }));
+      return;
+    }
+    const zipFile = await zipBytes({ [raw.filename]: strToU8(raw.content) });
+    res.writeHead(200, {
+      "content-type": "application/zip",
+      "content-length": String(zipFile.byteLength),
+      "content-disposition": `attachment; filename="${safeFilename(sessionId)}.zip"`,
+    });
+    res.end(Buffer.from(zipFile));
   });
 }