Add Effect persistence runtime modules and wire service bootstrap

Cursor Agent committed 8 months ago

Commit 2cf729e1 parent 40d49f110 files · +80 −21Browse files

Unified · Split

10 files

apps/server/src/persistence/config.ts +16 −0
apps/server/src/persistence/errors.ts +6 −0
apps/server/src/persistence/migrator.ts +6 −0
apps/server/src/persistence/repos/documentsRepo.ts +1 −0
apps/server/src/persistence/repos/metadataRepo.ts +1 −0
apps/server/src/persistence/repos/providerEventsRepo.ts +1 −0
apps/server/src/persistence/repos/stateEventsRepo.ts +1 −0
apps/server/src/persistence/runtime.ts +19 −0
apps/server/src/persistence/sqliteLayer.ts +10 −0
apps/server/src/persistenceService.ts +19 −21

apps/server/src/persistence/config.ts+16−0

@@ -0,0 +1,16 @@
	1	import path from "node:path";
	2
	3	export interface PersistenceConfig {
	4	dbPath: string;
	5	legacyProjectsJsonPath?: string;
	6	}
	7
	8	export function resolvePersistenceConfig(input: PersistenceConfig): PersistenceConfig {
	9	const resolved: PersistenceConfig = {
	10	dbPath: path.resolve(input.dbPath),
	11	};
	12	if (input.legacyProjectsJsonPath) {
	13	resolved.legacyProjectsJsonPath = path.resolve(input.legacyProjectsJsonPath);
	14	}
	15	return resolved;
	16	}

apps/server/src/persistence/errors.ts+6−0

@@ -0,0 +1,6 @@
	1	export class PersistenceInitializationError extends Error {
	2	constructor(message: string, options?: { cause?: unknown }) {
	3	super(message, options);
	4	this.name = "PersistenceInitializationError";
	5	}
	6	}

apps/server/src/persistence/migrator.ts+6−0

@@ -0,0 +1,6 @@
	1	import type { SqliteDatabase } from "../sqliteAdapter";
	2	import { runStateMigrations } from "../stateMigrations";
	3
	4	export function runPersistenceMigrations(db: SqliteDatabase): void {
	5	runStateMigrations(db);
	6	}

apps/server/src/persistence/repos/documentsRepo.ts+1−0

@@ -0,0 +1 @@
		1	export * from "../documentsRepo";

apps/server/src/persistence/repos/metadataRepo.ts+1−0

@@ -0,0 +1 @@
		1	export * from "../metadataRepo";

apps/server/src/persistence/repos/providerEventsRepo.ts+1−0

@@ -0,0 +1 @@
		1	export * from "../providerEventsRepo";

apps/server/src/persistence/repos/stateEventsRepo.ts+1−0

@@ -0,0 +1 @@
		1	export * from "../stateEventsRepo";

apps/server/src/persistence/runtime.ts+19−0

@@ -0,0 +1,19 @@
	1	import type * as Effect from "effect/Effect";
	2	import type * as SqlClient from "effect/unstable/sql/SqlClient";
	3
	4	import type { EffectSqliteDatabaseAdapter, SqliteDatabase } from "../sqliteAdapter";
	5
	6	function isEffectSqliteDatabase(db: SqliteDatabase): db is EffectSqliteDatabaseAdapter {
	7	return "runWithSqlClient" in db && typeof db.runWithSqlClient === "function";
	8	}
	9
	10	export function runWithSqlClient<A>(
	11	db: SqliteDatabase,
	12	effect: Effect.Effect<A, unknown, SqlClient.SqlClient>,
	13	fallback: () => A,
	14	): A {
	15	if (isEffectSqliteDatabase(db)) {
	16	return db.runWithSqlClient(effect);
	17	}
	18	return fallback();
	19	}

apps/server/src/persistence/sqliteLayer.ts+10−0

@@ -0,0 +1,10 @@
	1	import fs from "node:fs";
	2	import path from "node:path";
	3
	4	import { openSqliteDatabase, type SqliteDatabase } from "../sqliteAdapter";
	5
	6	export function openPersistenceSqliteDatabase(dbPath: string): SqliteDatabase {
	7	const resolvedPath = path.resolve(dbPath);
	8	fs.mkdirSync(path.dirname(resolvedPath), { recursive: true });
	9	return openSqliteDatabase(resolvedPath);
	10	}

apps/server/src/persistenceService.ts+19−21

   readNextSortKey as readNextSortKeyEffect,
   upsertDocument as upsertDocumentEffect,
   type DocumentRow,
-} from "./persistence/documentsRepo";
+} from "./persistence/repos/documentsRepo";
 import {
   insertProviderEvent as insertProviderEventEffect,
   listCompletedItemEventsBySessionTurn as listCompletedItemEventsBySessionTurnEffect,
   listCompletedItemEventsByThreadTurn as listCompletedItemEventsByThreadTurnEffect,
   listCompletedItemEventsByTurn as listCompletedItemEventsByTurnEffect,
   type CompletedProviderItemRow,
-} from "./persistence/providerEventsRepo";
+} from "./persistence/repos/providerEventsRepo";
 import {
   appendStateEvent as appendStateEventEffect,
   listStateEventsAfterSeq as listStateEventsAfterSeqEffect,
   readLastStateSeq as readLastStateSeqEffect,
-} from "./persistence/stateEventsRepo";
+} from "./persistence/repos/stateEventsRepo";
 import {
   readMetadataValue as readMetadataValueEffect,
   writeMetadataValue as writeMetadataValueEffect,
-} from "./persistence/metadataRepo";
+} from "./persistence/repos/metadataRepo";
 import {
   buildUpdatedAppSettings,
   resolveAppSettings,
 } from "./persistence/domain/stateSync";
 import { fallbackGroupId, normalizeTerminalIds, normalizeThread } from "./persistence/domain/threads";
 import { mergeTurnSummaryFiles, summarizeUnifiedDiff } from "./persistence/domain/turnSummaries";
-import { openSqliteDatabase, type EffectSqliteDatabaseAdapter, type SqliteDatabase } from "./sqliteAdapter";
+import { resolvePersistenceConfig } from "./persistence/config";
-import { runStateMigrations } from "./stateMigrations";
+import { PersistenceInitializationError } from "./persistence/errors";
+import { runPersistenceMigrations } from "./persistence/migrator";
+import { runWithSqlClient } from "./persistence/runtime";
+import { openPersistenceSqliteDatabase } from "./persistence/sqliteLayer";
+import type { SqliteDatabase } from "./sqliteAdapter";
 const METADATA_KEY_PROJECTS_JSON_IMPORTED = "migration.projects_json_imported";
 const METADATA_KEY_APP_SETTINGS = "app.settings.v1";
   constructor(options: PersistenceServiceOptions) {
     super();
-    const dbPath = path.resolve(options.dbPath);
+    const config = resolvePersistenceConfig(options);
-    fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+    this.db = openPersistenceSqliteDatabase(config.dbPath);
-    this.db = openSqliteDatabase(dbPath);
     try {
-      runStateMigrations(this.db);
+      runPersistenceMigrations(this.db);
     } catch (error) {
       try {
         this.db.close();
       } catch {
         // Best effort close on failed initialization.
       }
-      throw error;
+      throw new PersistenceInitializationError("Failed to initialize persistence database", {
+        cause: error,
+      });
     }
-    if (options.legacyProjectsJsonPath) {
+    if (config.legacyProjectsJsonPath) {
-      this.importProjectsJsonIfNeeded(options.legacyProjectsJsonPath);
+      this.importProjectsJsonIfNeeded(config.legacyProjectsJsonPath);
     }
   }
     effect: Effect.Effect<A, unknown, SqlClient.SqlClient>,
     fallback: () => A,
   ): A {
-    if (isEffectSqliteDatabase(this.db)) {
+    return runWithSqlClient(this.db, effect, fallback);
-      return this.db.runWithSqlClient(effect);
-    }
-    return fallback();
   }
 }
-function isEffectSqliteDatabase(db: SqliteDatabase): db is EffectSqliteDatabaseAdapter {
-  return "runWithSqlClient" in db && typeof db.runWithSqlClient === "function";
-}