@morlay/session-rdb 0.0.10 → 0.0.12

package/src/adapters/to-postgres.ts

@@ -0,0 +1,91 @@
+import { sql } from "drizzle-orm";
+import {
+  bigint,
+  check as pgCheck,
+  index,
+  integer,
+  pgSchema,
+  pgTable,
+  serial,
+  text,
+  unique,
+  type AnyPgColumn,
+  type AnyPgColumnBuilder,
+  type AnyPgTable,
+} from "drizzle-orm/pg-core";
+import { toProperty, type ColumnDef, type TableDef } from "../entities/types.ts";
+
+type TableRegistry = Record<string, AnyPgTable>;
+
+function buildColumn(c: ColumnDef, tables: TableRegistry): AnyPgColumnBuilder {
+  // 具体 builder 类型与 AnyPgColumnBuilder 在方法层面不兼容，构建阶段用宽松类型。
+  let col: any;
+  switch (c.type) {
+    case "text":
+      col = text(c.name);
+      break;
+    case "serial":
+      col = serial(c.name).primaryKey();
+      break;
+    case "integer": {
+      const built = integer(c.name);
+      col = c.primaryKey ? built.primaryKey() : built;
+      break;
+    }
+    case "bigint": {
+      const built = bigint(c.name, { mode: "number" });
+      col = c.primaryKey ? built.primaryKey() : built;
+      break;
+    }
+  }
+  if (c.notNull) col = col.notNull();
+  if (c.default !== undefined) col = col.default(c.default);
+  if (c.unique) col = col.unique();
+  if (c.references) {
+    const { table, column, onDelete } = c.references;
+    col = col.references(
+      () => (tables[table] as unknown as Record<string, AnyPgColumn>)[toProperty(column)],
+      { onDelete },
+    );
+  }
+  return col;
+}
+
+export function toPostgresSchema(
+  defs: readonly TableDef[],
+  schemaName = "public",
+): Record<string, AnyPgTable> {
+  const tables: TableRegistry = {};
+  // `pgSchema(name).table` 使表对象携带 schema 限定（查询/DDL 显式引用，
+  // 不依赖 search_path）；public 与无 schema 行为一致。
+  const table = schemaName === "public" ? pgTable : pgSchema(schemaName).table;
+  for (const def of defs) {
+    const columns: Record<string, AnyPgColumnBuilder> = {};
+    for (const c of def.columns) columns[toProperty(c.name)] = buildColumn(c, tables);
+    const extra = (self: Record<string, unknown>) => [
+      ...(def.checks ?? []).map((c) => pgCheck(c.name, sql.raw(c.expression))),
+      ...(def.uniques ?? []).map((u) =>
+        unique(u.name).on(
+          ...(u.columns.map((name) => self[toProperty(name)] as AnyPgColumn) as [
+            AnyPgColumn,
+            ...AnyPgColumn[],
+          ]),
+        ),
+      ),
+      ...(def.indexes ?? []).map((i) =>
+        index(i.name).on(
+          ...(i.columns.map((name) => self[toProperty(name)] as AnyPgColumn) as [
+            AnyPgColumn,
+            ...AnyPgColumn[],
+          ]),
+        ),
+      ),
+    ];
+    tables[def.name] = (table as typeof pgTable)(
+      def.name,
+      columns as Record<string, AnyPgColumnBuilder>,
+      extra as never,
+    );
+  }
+  return tables;
+}

package/src/adapters/to-sqlite.ts

@@ -0,0 +1,79 @@
+import { sql } from "drizzle-orm";
+import {
+  check as sqliteCheck,
+  index,
+  integer,
+  sqliteTable,
+  text,
+  unique,
+  type AnySQLiteColumn,
+  type AnySQLiteTable,
+  type SQLiteColumnBuilder,
+} from "drizzle-orm/sqlite-core";
+import { toProperty, type ColumnDef, type TableDef } from "../entities/types.ts";
+
+type TableRegistry = Record<string, AnySQLiteTable>;
+
+function buildColumn(c: ColumnDef, tables: TableRegistry): SQLiteColumnBuilder {
+  // 具体 builder 类型与基类在方法层面不兼容（泛型逆变），构建阶段用宽松
+  // 类型合并，返回时收窄为基类；查询类型安全由手写行接口兜底。
+  let col: any;
+  switch (c.type) {
+    case "text":
+      col = text(c.name);
+      break;
+    case "serial":
+      col = integer(c.name).primaryKey({ autoIncrement: true });
+      break;
+    case "integer":
+    case "bigint": {
+      const built = integer(c.name);
+      col = c.primaryKey ? built.primaryKey() : built;
+      break;
+    }
+  }
+  if (c.notNull) col = col.notNull();
+  if (c.default !== undefined) col = col.default(c.default);
+  if (c.unique) col = col.unique();
+  if (c.references) {
+    const { table, column, onDelete } = c.references;
+    col = col.references(
+      () => (tables[table] as unknown as Record<string, AnySQLiteColumn>)[toProperty(column)],
+      { onDelete },
+    );
+  }
+  return col as SQLiteColumnBuilder;
+}
+
+export function toSqliteSchema(defs: readonly TableDef[]): Record<string, AnySQLiteTable> {
+  const tables: TableRegistry = {};
+  for (const def of defs) {
+    const columns: Record<string, SQLiteColumnBuilder> = {};
+    for (const c of def.columns) columns[toProperty(c.name)] = buildColumn(c, tables);
+    const extra = (self: Record<string, unknown>) => [
+      ...(def.checks ?? []).map((c) => sqliteCheck(c.name, sql.raw(c.expression))),
+      ...(def.uniques ?? []).map((u) =>
+        unique(u.name).on(
+          ...(u.columns.map((name) => self[toProperty(name)] as AnySQLiteColumn) as [
+            AnySQLiteColumn,
+            ...AnySQLiteColumn[],
+          ]),
+        ),
+      ),
+      ...(def.indexes ?? []).map((i) =>
+        index(i.name).on(
+          ...(i.columns.map((name) => self[toProperty(name)] as AnySQLiteColumn) as [
+            AnySQLiteColumn,
+            ...AnySQLiteColumn[],
+          ]),
+        ),
+      ),
+    ];
+    tables[def.name] = sqliteTable(
+      def.name,
+      columns as Record<string, SQLiteColumnBuilder>,
+      extra as never,
+    );
+  }
+  return tables;
+}

package/src/backend.ts

@@ -0,0 +1,112 @@
+import type { SessionId } from "@deepseek-ai/dsh-session";
+import type { SessionStorageMetadata } from "@deepseek-ai/dsh-session-persistence";
+
+export interface SessionRow {
+  fSessionId: string;
+
+  fHeadEventId: string;
+  fHeadSequence: number;
+  fVersion: number;
+  fCreatedAt: number;
+  fCwd: string | null;
+  fParentSession: string | null;
+  fSeedLength: number | null;
+  fOrigin: string | null;
+  fDelegationDepth: number | null;
+
+  fIncarnation: string;
+
+  fRevision: number;
+}
+
+export interface EventInsert {
+  fEventId: string;
+  fParentId: string;
+  fType: string;
+  fKind: string;
+  fRole: string;
+  fName: string;
+  fActionId: string;
+  fEncoding: string;
+  fData: string;
+  fCreatedAt: number;
+}
+
+export interface EventRow {
+  fEventId: string;
+
+  fSequence: number;
+
+  fOriginalSeq: number;
+
+  fType: string;
+
+  fKind: string;
+
+  fRole: string;
+
+  fName: string;
+
+  fActionId: string;
+
+  fCreatedAt: number;
+
+  fData: string;
+
+  fSurfaceOp: string | null;
+}
+
+export interface BackendTx {
+  upsertSession(storage: SessionStorageMetadata, incarnation: string): Promise<void>;
+
+  getHead(id: SessionId): Promise<Pick<SessionRow, "fHeadEventId" | "fHeadSequence">>;
+
+  getSeedLength(id: SessionId): Promise<number | null>;
+
+  updateSeedLength(id: SessionId, seedLength: number): Promise<void>;
+
+  insertEvents(events: EventInsert[]): Promise<void>;
+
+  insertBridges(
+    rows: Array<{
+      fSessionId: SessionId;
+      fEventId: string;
+      fSequence: number;
+      fOriginalSeq: number;
+      fSurfaceOp: string | null;
+    }>,
+  ): Promise<void>;
+
+  updateHead(id: SessionId, headEventId: string, headSequence: number): Promise<void>;
+
+  bumpRevision(id: SessionId): Promise<void>;
+
+  deleteBridgeTail(id: SessionId, fromSequence: number): Promise<void>;
+
+  getPrevBridge(
+    id: SessionId,
+    sequence: number,
+  ): Promise<{ fEventId: string; fSequence: number } | undefined>;
+
+  getLastBridge(id: SessionId): Promise<{ fEventId: string; fSequence: number } | undefined>;
+}
+
+export interface Backend {
+  readonly kind: "sqlite" | "postgres";
+
+  readonly storeIdentity: string;
+
+  open(): Promise<void>;
+
+  getSession(id: SessionId): Promise<SessionRow | undefined>;
+
+  getSeqMapRows(id: SessionId): Promise<Array<{ fSequence: number; fOriginalSeq: number }>>;
+
+  getEventRows(id: SessionId, fromSequence?: number): Promise<EventRow[]>;
+
+  listSessions(): Promise<SessionRow[]>;
+
+  transaction<T>(fn: (tx: BackendTx) => Promise<T>): Promise<T>;
+
+  close(): Promise<void>;
+}