@morlay/session-rdb 0.0.11 → 0.0.13

package/dist/index.mjs

@@ -0,0 +1,466 @@
+import { i as WriteGuard, r as createTablesSql, t as SqliteBackend } from "./sqlite-DIXY-dFZ.mjs";
+import { A as toJsonlArtifact, C as repairOrphanInboxSplices, D as scanRows, E as rowToMeta, O as sessionConflictRow, _ as buildSeqMap, a as SESSION_PERSISTENCE_SQLITE_APPLICATION_ID, b as recomputeReplaceProvenance, g as toPostgresSchema, i as SCHEMA_VERSION, k as sessionInsertRow, l as isPersistedEvent, m as postgresTableDefs, n as EPHEMERAL_EVENT_TYPES, o as eventDimensions, r as EVENT_ENCODING, t as DEFAULT_BUSY_TIMEOUT_MS, w as repairSurfaceOps } from "./schema-B-8G4lWc.mjs";
+import { c as SessionBranchRdb, l as SessionBranchRdbProvider, s as registerSessionImport, u as locateTurnEnd } from "./import-D2vUnUZe.mjs";
+import z from "@deepseek-ai/schemastery";
+import { randomUUID } from "node:crypto";
+import { Pool } from "pg";
+import { drizzle } from "drizzle-orm/node-postgres";
+import { PersistenceCoordinator, SessionPersistence, SessionPersistenceRevision } from "@deepseek-ai/dsh-session-persistence";
+import { SessionLogOffset } from "@deepseek-ai/dsh-session";
+import { and, desc, eq, gte, sql } from "drizzle-orm";
+//#region src/postgres.ts
+var PostgresBackend = class PostgresBackend {
+	db;
+	options;
+	kind = "postgres";
+	storeIdentity;
+	tables;
+	constructor(db, options) {
+		this.db = db;
+		this.options = options;
+		this.tables = toPostgresSchema(postgresTableDefs, this.options.schema ?? "public");
+	}
+	async open() {
+		const storeId = await this.db.transaction(async (tx) => {
+			const schema = this.options.schema ?? "public";
+			const qualifiedMeta = schema === "public" ? "t_schema_meta" : `"${schema}".t_schema_meta`;
+			const metaExists = (await tx.execute(sql`SELECT to_regclass(${qualifiedMeta}) IS NOT NULL AS exists`)).rows[0]?.exists === true;
+			for (const statement of createTablesSql("postgres", postgresTableDefs, schema)) await tx.execute(sql.raw(statement));
+			if (!metaExists) await tx.insert(this.tables["t_schema_meta"]).values([{
+				fKey: "schema_version",
+				fValue: String(2)
+			}, {
+				fKey: "application_id",
+				fValue: String(SESSION_PERSISTENCE_SQLITE_APPLICATION_ID)
+			}]).execute();
+			const version = await this.readMeta(tx, "schema_version");
+			const applicationId = await this.readMeta(tx, "application_id");
+			if (version === void 0 || applicationId === void 0) throw new Error("session database has an unversioned schema or application identity");
+			if (Number(version) !== 2) throw new Error(`session database has schema version ${version}, incompatible with this build (2)`);
+			if (Number(applicationId) !== 1146308688) throw new Error(`session database has application id ${applicationId}, expected ${SESSION_PERSISTENCE_SQLITE_APPLICATION_ID}`);
+			await tx.insert(this.tables["t_persistence_state"]).values({
+				fSingleton: 1,
+				fStoreId: randomUUID()
+			}).onConflictDoNothing().execute();
+			const storeId = (await tx.select({ fStoreId: this.tables["t_persistence_state"].fStoreId }).from(this.tables["t_persistence_state"]).where(eq(this.tables["t_persistence_state"].fSingleton, 1)).execute())[0]?.fStoreId;
+			if (storeId === void 0 || storeId.length === 0) throw new Error("session database has no valid store identity");
+			return storeId;
+		});
+		this.storeIdentity = `${this.options.identityBase}:store:${storeId}`;
+	}
+	async close() {
+		await this.options.close();
+	}
+	async getSession(id) {
+		return (await this.db.select().from(this.tables["t_sessions"]).where(eq(this.tables["t_sessions"].fSessionId, id)).execute())[0];
+	}
+	async getSeqMapRows(id) {
+		return this.db.select({
+			fSequence: this.tables["t_session_events"].fSequence,
+			fOriginalSeq: this.tables["t_session_events"].fOriginalSeq
+		}).from(this.tables["t_session_events"]).where(eq(this.tables["t_session_events"].fSessionId, id)).execute();
+	}
+	async getEventRows(id, fromSequence) {
+		return (fromSequence === void 0 ? this.eventRows(this.db).where(eq(this.tables["t_session_events"].fSessionId, id)) : this.eventRows(this.db).where(and(eq(this.tables["t_session_events"].fSessionId, id), gte(this.tables["t_session_events"].fSequence, fromSequence)))).orderBy(this.tables["t_session_events"].fSequence).execute();
+	}
+	async listSessions() {
+		return this.db.select().from(this.tables["t_sessions"]).execute();
+	}
+	async transaction(fn) {
+		return this.db.transaction(async (tx) => fn(this.txFor(tx)));
+	}
+	txFor(tx) {
+		return {
+			upsertSession: (storage, incarnation) => this.upsertSession(tx, storage, incarnation),
+			getHead: (id) => this.getHead(tx, id),
+			getSeedLength: (id) => this.getSeedLength(tx, id),
+			updateSeedLength: (id, seedLength) => this.updateSeedLength(tx, id, seedLength),
+			insertEvents: (events) => this.insertEvents(tx, events),
+			insertBridges: (rows) => this.insertBridges(tx, rows),
+			updateHead: (id, headEventId, headSequence) => this.updateHead(tx, id, headEventId, headSequence),
+			bumpRevision: (id) => this.bumpRevision(tx, id),
+			deleteBridgeTail: (id, fromSequence) => this.deleteBridgeTail(tx, id, fromSequence),
+			getPrevBridge: (id, sequence) => this.getPrevBridge(tx, id, sequence),
+			getLastBridge: (id) => this.getLastBridge(tx, id)
+		};
+	}
+	async readMeta(exec, key) {
+		return (await exec.select({ fValue: this.tables["t_schema_meta"].fValue }).from(this.tables["t_schema_meta"]).where(eq(this.tables["t_schema_meta"].fKey, key)).execute())[0]?.fValue;
+	}
+	async upsertSession(exec, storage, incarnation) {
+		await exec.insert(this.tables["t_sessions"]).values(sessionInsertRow(storage, incarnation)).onConflictDoUpdate({
+			target: this.tables["t_sessions"].fSessionId,
+			set: sessionConflictRow(storage)
+		}).execute();
+	}
+	async getHead(exec, id) {
+		const head = (await exec.select({
+			fHeadEventId: this.tables["t_sessions"].fHeadEventId,
+			fHeadSequence: this.tables["t_sessions"].fHeadSequence
+		}).from(this.tables["t_sessions"]).where(eq(this.tables["t_sessions"].fSessionId, id)).execute())[0];
+		/* v8 ignore next -- appendBatch/commitRepair always materialize the row before reading the head */
+		if (head === void 0) throw new Error(`session "${id}" has no materialized row`);
+		return head;
+	}
+	async getSeedLength(exec, id) {
+		const row = (await exec.select({ fSeedLength: this.tables["t_sessions"].fSeedLength }).from(this.tables["t_sessions"]).where(eq(this.tables["t_sessions"].fSessionId, id)).execute())[0];
+		/* v8 ignore next -- rewind always materializes the row before reading the seed length */
+		if (row === void 0) throw new Error(`session "${id}" has no materialized row`);
+		return row.fSeedLength;
+	}
+	async updateSeedLength(exec, id, seedLength) {
+		await exec.update(this.tables["t_sessions"]).set({ fSeedLength: seedLength }).where(eq(this.tables["t_sessions"].fSessionId, id)).execute();
+	}
+	static INSERT_BATCH_ROWS = 1e3;
+	async insertEvents(exec, events) {
+		if (events.length === 0) return;
+		for (let i = 0; i < events.length; i += PostgresBackend.INSERT_BATCH_ROWS) await exec.insert(this.tables["t_events"]).values(events.slice(i, i + PostgresBackend.INSERT_BATCH_ROWS).map((event) => ({ ...event }))).execute();
+	}
+	async insertBridges(exec, rows) {
+		if (rows.length === 0) return;
+		for (let i = 0; i < rows.length; i += PostgresBackend.INSERT_BATCH_ROWS) await exec.insert(this.tables["t_session_events"]).values(rows.slice(i, i + PostgresBackend.INSERT_BATCH_ROWS).map((row) => ({ ...row }))).execute();
+	}
+	async updateHead(exec, id, headEventId, headSequence) {
+		await exec.update(this.tables["t_sessions"]).set({
+			fHeadEventId: headEventId,
+			fHeadSequence: headSequence
+		}).where(eq(this.tables["t_sessions"].fSessionId, id)).execute();
+	}
+	async bumpRevision(exec, id) {
+		await exec.update(this.tables["t_sessions"]).set({ fRevision: sql`${this.tables["t_sessions"].fRevision} + 1` }).where(eq(this.tables["t_sessions"].fSessionId, id)).execute();
+	}
+	async deleteBridgeTail(exec, id, fromSequence) {
+		await exec.delete(this.tables["t_session_events"]).where(and(eq(this.tables["t_session_events"].fSessionId, id), gte(this.tables["t_session_events"].fSequence, fromSequence))).execute();
+	}
+	async getPrevBridge(exec, id, sequence) {
+		return (await exec.select({
+			fEventId: this.tables["t_session_events"].fEventId,
+			fSequence: this.tables["t_session_events"].fSequence
+		}).from(this.tables["t_session_events"]).where(and(eq(this.tables["t_session_events"].fSessionId, id), eq(this.tables["t_session_events"].fSequence, sequence))).execute())[0];
+	}
+	async getLastBridge(exec, id) {
+		return (await exec.select({
+			fEventId: this.tables["t_session_events"].fEventId,
+			fSequence: this.tables["t_session_events"].fSequence
+		}).from(this.tables["t_session_events"]).where(eq(this.tables["t_session_events"].fSessionId, id)).orderBy(desc(this.tables["t_session_events"].fSequence)).limit(1).execute())[0];
+	}
+	eventRows(exec) {
+		return exec.select({
+			fEventId: this.tables["t_session_events"].fEventId,
+			fSequence: this.tables["t_session_events"].fSequence,
+			fOriginalSeq: this.tables["t_session_events"].fOriginalSeq,
+			fType: this.tables["t_events"].fType,
+			fKind: this.tables["t_events"].fKind,
+			fRole: this.tables["t_events"].fRole,
+			fName: this.tables["t_events"].fName,
+			fActionId: this.tables["t_events"].fActionId,
+			fCreatedAt: this.tables["t_events"].fCreatedAt,
+			fData: this.tables["t_events"].fData,
+			fSurfaceOp: this.tables["t_session_events"].fSurfaceOp
+		}).from(this.tables["t_session_events"]).innerJoin(this.tables["t_events"], eq(this.tables["t_session_events"].fEventId, this.tables["t_events"].fEventId));
+	}
+};
+//#endregion
+//#region src/index.ts
+var SessionPersistenceRdb = class SessionPersistenceRdb extends SessionPersistence {
+	config;
+	static inject = ["sessions", "settings"];
+	static Config = z.union([z.object({
+		type: z.const("sqlite"),
+		path: z.string().required(),
+		journalMode: z.union([
+			"wal",
+			"delete",
+			"truncate",
+			"persist"
+		]).default("wal"),
+		busyTimeout: z.number().step(1).min(0).default(DEFAULT_BUSY_TIMEOUT_MS)
+	}), z.object({
+		type: z.const("postgres"),
+		connectionString: z.string().required(),
+		schema: z.string().default("public")
+	})]);
+	static settingsNs = "session-rdb";
+	name = "session-rdb";
+	supportsRawArtifacts = true;
+	async readRaw(id, signal) {
+		signal?.throwIfAborted();
+		await this.ready;
+		signal?.throwIfAborted();
+		const log = await this.readLog(id, {}, signal);
+		if (log === void 0) return void 0;
+		repairSurfaceOps(log.events);
+		recomputeReplaceProvenance(log.events);
+		const inheritedEventCount = Math.min(log.inheritedEventCount, log.events.length);
+		return {
+			meta: log.meta,
+			inheritedEventCount: SessionLogOffset(inheritedEventCount),
+			filename: "session.jsonl",
+			content: toJsonlArtifact(log.meta, inheritedEventCount, log.events)
+		};
+	}
+	backend;
+	storeIdentity;
+	ready;
+	coordinator;
+	writeGuard = new WriteGuard();
+	reuseEventIds = /* @__PURE__ */ new Map();
+	constructor(ctx, config, injectedBackend) {
+		let resolved = config;
+		const settings = ctx.reflect.get("settings");
+		if (settings !== void 0) {
+			const scope = settings.register(SessionPersistenceRdb.settingsNs, SessionPersistenceRdb.Config, { base: config });
+			resolved = scope.get();
+			scope.watch(() => {
+				ctx.logger.warn("session-rdb: settings changed; restart to apply the new configuration");
+			});
+		}
+		super(ctx);
+		this.config = config;
+		this.config = resolved;
+		this.backend = injectedBackend ?? createBackend(resolved);
+		this.ready = this.init();
+		this.coordinator = new PersistenceCoordinator(this.ctx, this);
+		new SessionBranchRdb(this.ctx);
+		registerSessionImport(this.ctx, this);
+	}
+	async init() {
+		await this.backend.open();
+		this.storeIdentity = this.backend.storeIdentity;
+	}
+	locate(_meta) {}
+	create(meta, inheritedEventCount) {
+		return this.coordinator.create(meta, inheritedEventCount === void 0 ? void 0 : SessionLogOffset(inheritedEventCount));
+	}
+	append(id, events) {
+		return this.coordinator.append(id, events);
+	}
+	load(id) {
+		return this.coordinator.load(id);
+	}
+	inspect(id, signal) {
+		return this.coordinator.inspect(id, signal);
+	}
+	readFrom(id, fromSeq, signal) {
+		return this.coordinator.readFrom(id, fromSeq, signal);
+	}
+	borrowSession(id, signal) {
+		return this.coordinator.borrowSession(id, signal);
+	}
+	loadStored(id, signal) {
+		return this.readPrefix(id, signal);
+	}
+	async loadStoredFrom(id, fromSeq, signal) {
+		const log = await this.readLog(id, { fromSeq }, signal);
+		if (log === void 0) return void 0;
+		return {
+			meta: log.meta,
+			inheritedEventCount: SessionLogOffset(log.inheritedEventCount),
+			events: log.events
+		};
+	}
+	async readPrefix(id, signal) {
+		const log = await this.readLog(id, {}, signal);
+		if (log === void 0) {
+			this.writeGuard.confirmHead(id, -1);
+			return;
+		}
+		this.writeGuard.confirmHead(id, log.events.at(-1)?.seq ?? -1);
+		recomputeReplaceProvenance(log.events);
+		repairOrphanInboxSplices(log.events);
+		return {
+			meta: log.meta,
+			inheritedEventCount: SessionLogOffset(log.inheritedEventCount),
+			events: log.events,
+			revision: SessionPersistenceRevision(`${this.storeIdentity}:incarnation:${log.incarnation}:revision:${log.revision}`),
+			...log.tornFrom !== void 0 ? { tornMarker: log.tornFrom } : {}
+		};
+	}
+	async readStoredRevision(id, signal) {
+		signal?.throwIfAborted();
+		await this.ready;
+		signal?.throwIfAborted();
+		const row = await this.backend.getSession(id);
+		if (row === void 0) return void 0;
+		return SessionPersistenceRevision(`${this.storeIdentity}:incarnation:${row.fIncarnation}:revision:${row.fRevision}`);
+	}
+	async readLog(id, options = {}, signal) {
+		signal?.throwIfAborted();
+		await this.ready;
+		signal?.throwIfAborted();
+		const row = await this.backend.getSession(id);
+		if (row === void 0) return void 0;
+		const meta = rowToMeta(row);
+		let eventRows;
+		let seqMap;
+		if (options.fromSeq === void 0) {
+			eventRows = await this.backend.getEventRows(id);
+			seqMap = buildSeqMap(eventRows);
+		} else {
+			eventRows = await this.backend.getEventRows(id, options.fromSeq);
+			const seqRows = await this.backend.getSeqMapRows(id);
+			seqMap = buildSeqMap(seqRows);
+		}
+		signal?.throwIfAborted();
+		const { preserved, tornFrom } = scanRows(eventRows, options.fromSeq ?? 0, seqMap);
+		return {
+			meta,
+			inheritedEventCount: row.fSeedLength ?? 0,
+			events: preserved,
+			incarnation: row.fIncarnation,
+			revision: row.fRevision,
+			...tornFrom !== void 0 ? { tornFrom } : {}
+		};
+	}
+	async appendBatch(storage, events, _isMaterialized) {
+		await this.ready;
+		const persisted = events.filter(isPersistedEvent);
+		if (persisted.length === 0) return;
+		const meta = storage.meta;
+		const reuse = this.reuseEventIds.get(meta.id);
+		if (reuse !== void 0) this.reuseEventIds.delete(meta.id);
+		let confirmedHead = -1;
+		await this.backend.transaction(async (tx) => {
+			await tx.upsertSession(storage, randomUUID());
+			const head = await tx.getHead(meta.id);
+			this.writeGuard.assertNoConcurrentWriter(meta.id, head.fHeadSequence);
+			const { headEventId, headSequence } = await appendEventTail(tx, meta, persisted, {
+				parentId: head.fHeadEventId,
+				nextSeq: head.fHeadSequence + 1
+			}, reuse);
+			await tx.updateHead(meta.id, headEventId, headSequence);
+			await tx.bumpRevision(meta.id);
+			confirmedHead = headSequence;
+		});
+		this.writeGuard.confirmHead(meta.id, confirmedHead);
+	}
+	async commitRepair(storage, tornMarker, closers) {
+		await this.ready;
+		const meta = storage.meta;
+		const persistedClosers = closers.filter(isPersistedEvent);
+		if (tornMarker === void 0 && persistedClosers.length === 0) return;
+		await this.backend.transaction(async (tx) => {
+			if (tornMarker !== void 0) {
+				await tx.deleteBridgeTail(meta.id, tornMarker);
+				const prev = await tx.getPrevBridge(meta.id, tornMarker - 1);
+				if (prev === void 0) await tx.updateHead(meta.id, "", -1);
+				else await tx.updateHead(meta.id, prev.fEventId, prev.fSequence);
+			}
+			if (persistedClosers.length > 0) {
+				const last = await tx.getLastBridge(meta.id);
+				const { headEventId, headSequence } = await appendEventTail(tx, meta, persistedClosers, {
+					parentId: last?.fEventId ?? "",
+					nextSeq: (last?.fSequence ?? -1) + 1
+				});
+				await tx.updateHead(meta.id, headEventId, headSequence);
+			}
+			await tx.bumpRevision(meta.id);
+		});
+		const row = await this.backend.getSession(meta.id);
+		this.writeGuard.confirmHead(meta.id, row?.fHeadSequence ?? -1);
+	}
+	async list(signal) {
+		signal?.throwIfAborted();
+		await this.ready;
+		signal?.throwIfAborted();
+		const rows = await this.backend.listSessions();
+		signal?.throwIfAborted();
+		return rows.map(rowToMeta);
+	}
+	async listSnapshots(signal) {
+		signal?.throwIfAborted();
+		await this.ready;
+		signal?.throwIfAborted();
+		const rows = await this.backend.listSessions();
+		signal?.throwIfAborted();
+		return rows.map((row) => ({
+			header: rowToMeta(row),
+			revision: SessionPersistenceRevision(`${this.storeIdentity}:incarnation:${row.fIncarnation}:revision:${row.fRevision}`),
+			inheritedEventCount: row.fSeedLength ?? 0
+		}));
+	}
+	async close() {
+		await this.ready;
+		await this.backend.close();
+	}
+	registerReuseEventIds(childId, map) {
+		this.reuseEventIds.set(childId, new Map(map));
+	}
+	internals() {
+		return {
+			backend: this.backend,
+			writeGuard: this.writeGuard,
+			create: (meta, inheritedEventCount) => this.create(meta, inheritedEventCount),
+			append: (id, events) => this.append(id, events),
+			load: (id) => this.load(id),
+			inspect: (id, signal) => this.inspect(id, signal),
+			readFrom: (id, fromSeq, signal) => this.readFrom(id, fromSeq, signal),
+			listSnapshots: (signal) => this.listSnapshots(signal),
+			readStoredRevision: (id, signal) => this.readStoredRevision(id, signal),
+			registerReuseEventIds: (childId, map) => this.registerReuseEventIds(childId, map)
+		};
+	}
+};
+function createBackend(config) {
+	if (config.type === "sqlite") return new SqliteBackend({
+		path: config.path,
+		journalMode: config.journalMode ?? "wal",
+		busyTimeout: config.busyTimeout ?? 5e3
+	});
+	const pool = new Pool({ connectionString: config.connectionString });
+	pool.on("error", () => {});
+	return new PostgresBackend(drizzle({ client: pool }), {
+		identityBase: [
+			"postgres",
+			pool.options.host ?? "localhost",
+			String(pool.options.port ?? 5432),
+			pool.options.database ?? "",
+			config.schema ?? "public"
+		].join(":"),
+		schema: config.schema ?? "public",
+		close: () => pool.end()
+	});
+}
+async function appendEventTail(tx, meta, events, anchor, reuse) {
+	let parentId = anchor.parentId;
+	let nextSeq = anchor.nextSeq;
+	const eventRows = [];
+	const bridgeRows = [];
+	for (const event of events) {
+		const reusedId = reuse?.get(event.seq);
+		const eventId = reusedId ?? randomUUID();
+		if (reusedId === void 0) {
+			const { kind, role, name, actionId } = eventDimensions(event);
+			eventRows.push({
+				fEventId: eventId,
+				fParentId: parentId,
+				fType: event.type,
+				fKind: kind,
+				fRole: role,
+				fName: name,
+				fActionId: actionId,
+				fEncoding: EVENT_ENCODING,
+				fData: JSON.stringify(event.data),
+				fCreatedAt: event.time
+			});
+		}
+		const surfaceOp = event.surfaceOp === void 0 ? null : JSON.stringify(event.surfaceOp);
+		bridgeRows.push({
+			fSessionId: meta.id,
+			fEventId: eventId,
+			fSequence: nextSeq,
+			fOriginalSeq: event.seq,
+			fSurfaceOp: surfaceOp
+		});
+		parentId = eventId;
+		nextSeq++;
+	}
+	if (eventRows.length > 0) await tx.insertEvents(eventRows);
+	await tx.insertBridges(bridgeRows);
+	return {
+		headEventId: parentId,
+		headSequence: nextSeq - 1
+	};
+}
+//#endregion
+export { EPHEMERAL_EVENT_TYPES, SCHEMA_VERSION, SessionBranchRdb, SessionBranchRdbProvider, SessionPersistenceRdb, SessionPersistenceRdb as default, locateTurnEnd };

package/dist/invariant.d.mts

@@ -0,0 +1,7 @@
+import { Context } from "@deepseek-ai/cordis";
+//#region src/invariant.d.ts
+declare const name = "session-rdb-invariant";
+declare const inject: string[];
+declare const apply: (ctx: Context) => Promise<() => void>;
+//#endregion
+export { apply, inject, name };

package/dist/invariant.mjs

@@ -0,0 +1,8 @@
+//#region src/invariant.ts
+const PACKAGE_NAME = "@morlay/session-rdb";
+const name = "session-rdb-invariant";
+const inject = ["invariants"];
+const install = () => {};
+const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//#endregion
+export { apply, inject, name };