TypeScript
fix(server): route missing read-only queries to readers
Yash Singhaee76a8b4736
diff --git a/apps/server/src/orchestration-v2/ProjectionStore.test.ts b/apps/server/src/orchestration-v2/ProjectionStore.test.tsindex f453dec9567..14bb72e3c78 100644--- a/apps/server/src/orchestration-v2/ProjectionStore.test.ts+++ b/apps/server/src/orchestration-v2/ProjectionStore.test.ts@@ -31,11 +31,14 @@ import {} from "@t3tools/contracts";import * as DateTime from "effect/DateTime";import * as Effect from "effect/Effect";+import * as Deferred from "effect/Deferred";+import * as Fiber from "effect/Fiber";import * as Layer from "effect/Layer";import * as Option from "effect/Option";import * as Schema from "effect/Schema";import * as Tracer from "effect/Tracer";import * as SqlClient from "effect/sql/SqlClient";+import * as Statement from "effect/sql/Statement";import { projectThreadAwarenessV2 } from "@t3tools/shared/agentAwareness";import * as SqlitePersistence from "../persistence/Sqlite.ts";@@ -51,6 +54,8 @@ import {} from "./threadHistoryPaging.ts";import { limitRecoveryCommand } from "./UsageLimitRecoveryWorker.ts";+import { layerReaderDatabase, traceSqlRouting } from "../persistence/testkit/SqliteRouting.ts";+const layerTest = Layer.mergeAll(ProjectionStore.layer.pipe(Layer.provideMerge(SqlitePersistence.layerMemory)),SqlitePersistence.layerMemory,@@ -226,6 +231,93 @@ const addRolledBackRecoveryCandidate = Effect.fn("addRolledBackRecoveryCandidatereturn threadId;});+it.effect("routes full projection reads to readers and retains uncommitted writer state", () =>+ Effect.gen(function* () {+ const store = yield* ProjectionStore.ProjectionStoreV2;+ const sql = yield* SqlClient.SqlClient;+ const parentId = yield* addRolledBackRecoveryCandidate("reader-routing");+ const parent = yield* store.getThreadProjection(parentId);+ const threadId = ThreadId.make("thread:reader-routing:fork");+ yield* store.apply({+ id: EventId.make("event:reader-routing:fork"),+ type: "thread.created",+ threadId,+ occurredAt: parent.thread.createdAt,+ payload: {+ ...parent.thread,+ id: threadId,+ forkedFrom: { type: "run", threadId: parentId, runId: parent.runs[0]!.id },+ },+ });+ const { queries, trace } = traceSqlRouting();+ const projection = yield* store.getThreadProjection(threadId).pipe(trace);+ assert.equal(projection.thread.id, threadId);+ assert.deepEqual(+ projection.visibleTurnItems+ .filter((row) => row.visibility === "inherited")+ .map((row) => row.sourceItemId),+ parent.turnItems.map((item) => item.id),+ );+ assert.isAbove(queries.length, 1);+ assert.deepEqual([...new Set(queries.map((row) => row.connection))], ["reader"]);+ const commitRequested = yield* Deferred.make<void>();+ const writer = yield* Deferred.await(commitRequested).pipe(+ Effect.andThen(+ sql.withTransaction(+ Effect.gen(function* () {+ yield* sql`+ UPDATE orchestration_v2_projection_threads+ SET payload_json = json_set(payload_json, '$.title', 'Committed title')+ WHERE thread_id = ${threadId}+ `;+ yield* sql`+ UPDATE orchestration_v2_projection_turn_items+ SET payload_json = json_set(payload_json, '$.title', 'Committed command')+ WHERE thread_id = ${parentId}+ `;+ }),+ ),+ ),+ Effect.forkChild,+ );+ let commitInjected = false;+ const duringCommit = yield* store.getThreadProjection(threadId).pipe(+ Effect.provideService(Statement.CurrentTransformer, (statement) => {+ const [query] = statement.compile();+ if (!commitInjected && query.includes("FROM orchestration_v2_projection_turn_items")) {+ commitInjected = true;+ return Deferred.succeed(commitRequested, undefined).pipe(+ Effect.andThen(Fiber.join(writer).pipe(Effect.orDie)),+ Effect.as(statement),+ );+ }+ return Effect.succeed(statement);+ }),+ );+ assert.isTrue(commitInjected);+ assert.deepEqual(duringCommit, projection);+ const afterCommit = yield* store.getThreadProjection(threadId);+ assert.equal(afterCommit.thread.title, "Committed title");+ assert.equal(+ afterCommit.visibleTurnItems.find((row) => row.visibility === "inherited")?.item.title,+ "Committed command",+ );+ yield* sql.withTransaction(+ Effect.gen(function* () {+ yield* sql`+ UPDATE orchestration_v2_projection_threads+ SET payload_json = json_set(payload_json, '$.title', 'Uncommitted title')+ WHERE thread_id = ${threadId}+ `;+ assert.equal(+ (yield* store.getThreadProjection(threadId)).thread.title,+ "Uncommitted title",+ );+ }),+ );+ }).pipe(Effect.provide(ProjectionStore.layer.pipe(Layer.provideMerge(layerReaderDatabase)))),+);+it.effect("record reads restrict provider histories to delivery identities", () =>Effect.gen(function* () {const store = yield* ProjectionStore.ProjectionStoreV2;diff --git a/apps/server/src/orchestration-v2/ProjectionStore.ts b/apps/server/src/orchestration-v2/ProjectionStore.tsindex 8726799153c..3e6ca0d75a1 100644--- a/apps/server/src/orchestration-v2/ProjectionStore.ts+++ b/apps/server/src/orchestration-v2/ProjectionStore.ts@@ -4522,7 +4522,15 @@ export const layer: Layer.Layer<ProjectionStoreV2, never, SqlClient.SqlClient> =);const getThreadProjection: ProjectionStoreV2Shape["getThreadProjection"] = (threadId) =>- readProjection(threadId, new Set());+ sql+ .withTransaction(readProjection(threadId, new Set()))+ .pipe(+ Effect.mapError((cause) =>+ isProjectionStoreThreadNotFoundError(cause) || isProjectionStoreReadError(cause)+ ? cause+ : new ProjectionStoreReadError({ threadId, cause }),+ ),+ );const getRuntimeRecoveryProjection: ProjectionStoreV2Shape["getRuntimeRecoveryProjection"] =Effect.fn("ProjectionStore.getRuntimeRecoveryProjection")(@@ -7252,7 +7260,7 @@ export const layer: Layer.Layer<ProjectionStoreV2, never, SqlClient.SqlClient> =getThreadsWithPullRequests: readOnReader(getThreadsWithPullRequests),getThreadWorktreePaths: readOnReader(getThreadWorktreePaths),getOpenRemoteDelegatedTasks: getOpenRemoteDelegatedTasks.pipe(NodeSqliteClient.readOnly),- getThreadProjection,+ getThreadProjection: readOnReader(getThreadProjection),getTurnStartContext: readOnReader(getTurnStartContext),getTurnStartHistory: readOnReader(getTurnStartHistory),getRuntimeRecoveryProjection: readOnReader(getRuntimeRecoveryProjection),diff --git a/apps/server/src/orchestration-v2/legacy/LegacyV1ThreadImporter.test.ts b/apps/server/src/orchestration-v2/legacy/LegacyV1ThreadImporter.test.tsindex 50671194d46..a50b3ed3c19 100644--- a/apps/server/src/orchestration-v2/legacy/LegacyV1ThreadImporter.test.ts+++ b/apps/server/src/orchestration-v2/legacy/LegacyV1ThreadImporter.test.ts@@ -14,7 +14,6 @@ import * as Layer from "effect/Layer";import * as SqlClient from "effect/sql/SqlClient";import * as Statement from "effect/sql/Statement";-import * as SqlitePersistence from "../../persistence/Sqlite.ts";import { listLinkedPullRequestThreads } from "../../pullRequest/linkedThreads.ts";import * as EventSink from "../EventSink.ts";import * as EventStore from "../EventStore.ts";@@ -22,7 +21,9 @@ import * as LegacyV1ThreadImporter from "./LegacyV1ThreadImporter.ts";import * as ProjectionReplay from "../testkit/ProjectionReplay.ts";import * as ProjectionStore from "../ProjectionStore.ts";-const layerDatabase = SqlitePersistence.layerMemory;+import { layerReaderDatabase, traceSqlRouting } from "../../persistence/testkit/SqliteRouting.ts";++const layerDatabase = layerReaderDatabase;const layerEventStoreProvided = EventStore.layer.pipe(Layer.provideMerge(layerDatabase));const layerProjectionStoreProvided = ProjectionStore.layer.pipe(Layer.provideMerge(layerDatabase));const layerStoresProvided = Layer.mergeAll(@@ -80,6 +81,72 @@ const seedPendingTranscripts = Effect.gen(function* () {yield* importer.reconcileShells;});+it.effect("routes shell selectors to readers while imports stay writable", () =>+ Effect.gen(function* () {+ const importer = yield* LegacyV1ThreadImporter.LegacyV1ThreadImporter;+ const sql = yield* SqlClient.SqlClient;+ const { queries, trace } = traceSqlRouting();+ yield* seedPendingTranscripts.pipe(trace);+ const selectors = queries.filter(+ ({ query }) =>+ query.includes("FROM projection_threads AS thread") ||+ query.includes("FROM orchestration_v2_legacy_imports AS legacy_import") ||+ query.includes("FROM projection_thread_messages AS message"),+ );+ assert.lengthOf(selectors, 6);+ assert.deepEqual([...new Set(selectors.map((row) => row.connection))], ["reader"]);+ assert.deepEqual(yield* importer.reconcileShells, {+ importedThreadCount: 0,+ importedMessageCount: 0,+ });+ yield* sql.withTransaction(+ Effect.gen(function* () {+ yield* sql`+ INSERT INTO projection_threads (+ thread_id, project_id, title, model_selection_json, runtime_mode,+ interaction_mode, created_at, updated_at+ ) VALUES (+ 'thread:uncommitted', 'project:background', 'Uncommitted legacy title',+ '{"instanceId":"codex","model":"gpt-5.4"}', 'full-access', 'default',+ '2026-01-01T00:00:00.000Z', '2026-01-01T00:00:00.000Z'+ )+ `;+ yield* sql`+ INSERT INTO projection_thread_messages (+ message_id, thread_id, role, text, is_streaming, created_at, updated_at+ ) VALUES (+ 'message:uncommitted', 'thread:uncommitted', 'user', 'Uncommitted preview', 0,+ '2026-01-01T00:00:00.000Z', '2026-01-01T00:00:00.000Z'+ )+ `;+ yield* sql`+ UPDATE orchestration_v2_projection_threads+ SET payload_json = json_remove(payload_json, '$.pinnedAt')+ WHERE thread_id = 'thread:first'+ `;+ yield* sql`+ UPDATE projection_threads SET pinned_at = '2026-01-01T00:00:00.000Z'+ WHERE thread_id = 'thread:first'+ `;+ const result = yield* importer.reconcileShells;+ assert.deepEqual(result, { importedThreadCount: 2, importedMessageCount: 1 });+ const projections = yield* ProjectionStore.ProjectionStoreV2;+ const repaired = yield* projections.getThreadProjection(ThreadId.make("thread:first"));+ assert.equal(DateTime.formatIso(repaired.thread.pinnedAt!), "2026-01-01T00:00:00.000Z");+ const imported = yield* projections.getThreadProjection(+ ThreadId.make("thread:uncommitted"),+ );+ assert.equal(imported.messages[0]?.text, "Uncommitted preview");+ assert.equal(+ (yield* projections.getThreadProjection(ThreadId.make("thread:uncommitted"))).thread+ .title,+ "Uncommitted legacy title",+ );+ }),+ );+ }).pipe(Effect.provide(layerTest)),+);+it.effect("keeps hydrating later transcripts after a defect and leaves the failed thread pending",() =>diff --git a/apps/server/src/orchestration-v2/legacy/LegacyV1ThreadImporter.ts b/apps/server/src/orchestration-v2/legacy/LegacyV1ThreadImporter.tsindex d82a9e80a23..8c134d3b57d 100644--- a/apps/server/src/orchestration-v2/legacy/LegacyV1ThreadImporter.ts+++ b/apps/server/src/orchestration-v2/legacy/LegacyV1ThreadImporter.ts@@ -394,7 +394,7 @@ const make = Effect.gen(function* () {AND message.role IN ('user', 'assistant')ORDER BY message.created_at DESC, message.message_id DESCLIMIT 1- `;+ `.pipe(NodeSqliteClient.readOnly);const latestUser = yield* sql<LegacyMessageRow>`SELECTmessage.message_id,@@ -424,7 +424,7 @@ const make = Effect.gen(function* () {AND message.role = 'user'ORDER BY message.created_at DESC, message.message_id DESCLIMIT 1- `;+ `.pipe(NodeSqliteClient.readOnly);return [latestUser[0], latest[0]].filter((message, index, selected): message is LegacyMessageRow =>message !== undefined &&@@ -476,7 +476,7 @@ const make = Effect.gen(function* () {OR json_type(projection.payload_json, '$.branchPullRequest') IS NULLOR json_type(projection.payload_json, '$.activeOrderKey') IS NULLORDER BY thread.created_at ASC, thread.thread_id ASC- `;+ `.pipe(NodeSqliteClient.readOnly);let repairedThreadCount = 0;for (const row of repairRows) {const decoded = decodeStoredThread(row.payload_json);@@ -574,7 +574,7 @@ const make = Effect.gen(function* () {AND event.event_type = 'thread.created')ORDER BY thread.created_at ASC, thread.thread_id ASC- `;+ `.pipe(NodeSqliteClient.readOnly);let importedThreadCount = repairedThreadCount;let importedMessageCount = 0;for (const row of rows) {diff --git a/apps/server/src/peer/PeerLinks.test.ts b/apps/server/src/peer/PeerLinks.test.tsindex 3c510c35e69..a99cb7f9051 100644--- a/apps/server/src/peer/PeerLinks.test.ts+++ b/apps/server/src/peer/PeerLinks.test.ts@@ -36,6 +36,8 @@ import {} from "./PeerLinks.testkit.ts";import * as PeerMcpClient from "./PeerMcpClient.ts";+import { layerReaderDatabase, traceSqlRouting } from "../persistence/testkit/SqliteRouting.ts";+/** What B's probe saw: the calling client and the modes it may start work with. */const Probe = Schema.Struct({ caller: Schema.String, modes: Schema.String });@@ -115,6 +117,47 @@ const serveApart = (descriptor: ExecutionEnvironmentDescriptor) =>Effect.flatMap((server) => serveB(descriptor).pipe(Effect.provideContext(server))),);+it.effect("routes peer reads to readers and sees uncommitted link updates", () =>+ Effect.scoped(+ Effect.gen(function* () {+ const context = yield* layerLinkingEnvironment(+ laptop,+ ServerSecretStore.layer,+ layerReaderDatabase,+ ).pipe(Layer.build);+ const links = Context.get(context, PeerLinks.PeerLinks);+ const sql = Context.get(context, SqlClient.SqlClient);+ yield* sql`+ INSERT INTO peer_environment_links (+ environment_id, secret_name, label, urls_json, access, linked_at, expires_at, fenced+ ) VALUES (+ ${box.environmentId}, 'test-secret', 'Box', '[]', 'auto',+ '2026-01-01T00:00:00.000Z', '2026-01-02T00:00:00.000Z', 1+ )+ `;+ const { queries, trace } = traceSqlRouting();+ yield* links.list.pipe(trace);+ expect(Option.getOrThrow(yield* links.get(box.environmentId).pipe(trace)).label).toBe("Box");+ const reads = queries.filter(({ query }) =>+ query.includes("SELECT * FROM peer_environment_links"),+ );+ expect(reads).toHaveLength(2);+ expect(reads.map((row) => row.connection)).toEqual(["reader", "reader"]);+ yield* sql.withTransaction(+ Effect.gen(function* () {+ yield* sql`UPDATE peer_environment_links SET label = 'Uncommitted box'`;+ expect(Option.getOrThrow(yield* links.get(box.environmentId)).label).toBe(+ "Uncommitted box",+ );+ expect((yield* links.list)[0]?.label).toBe("Uncommitted box");+ }),+ );+ expect(yield* links.unlink(box.environmentId)).toBe(true);+ expect(yield* links.list).toEqual([]);+ }),+ ),+);+it.effect("links with a pairing code, and the peer holds its agents to the limits they carry", () =>Effect.scoped(Effect.gen(function* () {diff --git a/apps/server/src/peer/PeerLinks.testkit.ts b/apps/server/src/peer/PeerLinks.testkit.tsindex c72c5ba8c81..1ff940af9b3 100644--- a/apps/server/src/peer/PeerLinks.testkit.ts+++ b/apps/server/src/peer/PeerLinks.testkit.ts@@ -21,6 +21,7 @@ import * as EnvironmentAuth from "../auth/EnvironmentAuth.ts";import * as AuthHttp from "../auth/http.ts";import * as McpOAuth from "../auth/McpOAuth.ts";import * as McpOAuthHttp from "../auth/mcpOAuthHttp.ts";+import type * as SqlClient from "effect/sql/SqlClient";import * as ServerSecretStore from "../auth/ServerSecretStore.ts";import * as ServerConfig from "../config.ts";import * as ServerEnvironment from "../environment/ServerEnvironment.ts";@@ -154,14 +155,18 @@ export type ServedPeer = Effect.Success<ReturnType<typeof servePeer>>;* The environment that links: its own database and secret store, reaching* peers over plain HTTP. Provide it to anything built on its links.*/-export const layerLinkingEnvironment = (+export const layerLinkingEnvironment = <E = never>(descriptor: ExecutionEnvironmentDescriptor,secrets: typeof ServerSecretStore.layer = ServerSecretStore.layer,+ database: Layer.Layer<+ SqlClient.SqlClient,+ E | Layer.Error<typeof Sqlite.layerMemory>+ > = Sqlite.layerMemory,) =>PeerMcpClient.layer.pipe(Layer.provideMerge(PeerLinks.layer),Layer.provideMerge(ServerSettings.layerTest({ linkedEnvironmentsEnabled: true })),- Layer.provideMerge(Sqlite.layerMemory),+ Layer.provideMerge(database),Layer.provide(Layer.mergeAll(secrets, FetchHttpClient.layer)),// Services that act for this environment, such as delegation, name it too.Layer.provideMerge(diff --git a/apps/server/src/peer/PeerLinks.ts b/apps/server/src/peer/PeerLinks.tsindex adbc8cbd1ed..70aa68d25cc 100644--- a/apps/server/src/peer/PeerLinks.ts+++ b/apps/server/src/peer/PeerLinks.ts@@ -12,6 +12,7 @@ import {type PeerLinkStatus,type PeerLinkSummary,} from "@t3tools/contracts";+import * as NodeSqliteClient from "@t3tools/shared/nodeSqliteClient";import * as Context from "effect/Context";import * as Digest from "effect/crypto/Digest";import * as SecureRandom from "effect/crypto/SecureRandom";@@ -222,12 +223,13 @@ const make = Effect.gen(function* () {const readRows = sql<PeerLinkRow>`SELECT * FROM peer_environment_links ORDER BY label, environment_id- `.pipe(Effect.catch(failStorage));+ `.pipe(NodeSqliteClient.readOnly, Effect.catch(failStorage));const readRow = (environmentId: EnvironmentId) =>sql<PeerLinkRow>`SELECT * FROM peer_environment_links WHERE environment_id = ${environmentId}`.pipe(+ NodeSqliteClient.readOnly,Effect.catch(failStorage),Effect.map((rows) => Option.fromNullishOr(rows[0])),);diff --git a/apps/server/src/persistence/testkit/SqliteRouting.ts b/apps/server/src/persistence/testkit/SqliteRouting.tsnew file mode 100644index 00000000000..2dcd65ec2b2--- /dev/null+++ b/apps/server/src/persistence/testkit/SqliteRouting.ts@@ -0,0 +1,52 @@+import * as NodeServices from "@effect/platform-node/NodeServices";+import * as Effect from "effect/Effect";+import * as FileSystem from "effect/FileSystem";+import * as Layer from "effect/Layer";+import * as Option from "effect/Option";+import * as Path from "effect/Path";+import * as Statement from "effect/sql/Statement";+import * as Tracer from "effect/Tracer";++import * as Sqlite from "../Sqlite.ts";++export const layerReaderDatabase = Layer.unwrap(+ Effect.gen(function* () {+ const fs = yield* FileSystem.FileSystem;+ const path = yield* Path.Path;+ const directory = yield* fs.makeTempDirectoryScoped({ prefix: "t3-routing-" });+ return Sqlite.layerFromPath(path.join(directory, "state.sqlite"));+ }),+).pipe(Layer.provide(NodeServices.layer));++export const traceSqlRouting = () => {+ const queries: Array<{ query: string; connection: unknown }> = [];+ const tracer = Tracer.make({+ span(options) {+ const span = new Tracer.NativeSpan(options);+ const end = span.end.bind(span);+ span.end = (endTime, exit) => {+ end(endTime, exit);+ const query = span.attributes.get("db.query.text");+ if (typeof query === "string") {+ let owner: Tracer.AnySpan | undefined = span;+ let connection: unknown;+ while (owner?._tag === "Span") {+ connection = owner.attributes.get("db.connection");+ if (connection !== undefined) break;+ owner = Option.getOrUndefined(owner.parent);+ }+ queries.push({ query, connection });+ }+ };+ return span;+ },+ });+ return {+ queries,+ trace: <A, E, R>(effect: Effect.Effect<A, E, R>) =>+ effect.pipe(+ Effect.withTracer(tracer),+ Effect.provideService(Statement.SpanPropagationEnabled, true),+ ),+ };+};