import { ThreadId } from "@t3tools/contracts";
import * as Context from "effect/Context";
import * as DateTime from "effect/DateTime";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Schema from "effect/Schema";
import * as Stream from "effect/Stream";
import * as SqlClient from "effect/sql/SqlClient";
import * as EventStore from "../EventStore.ts";
import * as ProjectionStore from "../ProjectionStore.ts";
export interface ProjectionReplayVerification {
readonly valid: boolean;
readonly schemaVersion: number;
readonly expectedSequence: number;
readonly projectionSequence: number;
readonly unreadableThreadIds: ReadonlyArray<ThreadId>;
readonly missingThreadIds: ReadonlyArray<ThreadId>;
readonly unexpectedThreadIds: ReadonlyArray<ThreadId>;
}
export class ProjectionReplayError extends Schema.TaggedError<ProjectionReplayError>()(
"ProjectionReplayError",
{ cause: Schema.Defect() },
) {}
/**
* Test oracle: projections must equal a replay of an unpruned event log. Production prunes
* events the projections cover, so it never replays (see ProjectionMaintenance).
*/
export class ProjectionReplay extends Context.Service<
ProjectionReplay,
{
readonly verify: Effect.Effect<ProjectionReplayVerification, ProjectionReplayError>;
readonly rebuild: Effect.Effect<ProjectionReplayVerification, ProjectionReplayError>;
}
>()("t3/orchestration-v2/testkit/ProjectionReplay") {}
type ProjectionMetadataRow = {
readonly schema_version: number;
readonly last_sequence: number;
};
export const layer: Layer.Layer<
ProjectionReplay,
never,
EventStore.EventStoreV2 | ProjectionStore.ProjectionStoreV2 | SqlClient.SqlClient
> = Layer.effect(
ProjectionReplay,
Effect.gen(function* () {
const sql = yield* SqlClient.SqlClient;
const eventStore = yield* EventStore.EventStoreV2;
const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
const verify = Effect.gen(function* () {
const expectedThreadRows = yield* sql<{ readonly thread_id: string }>`
SELECT DISTINCT stream_id AS thread_id
FROM orchestration_events INDEXED BY orchestration_events_v2_created_threads_idx
WHERE application_event_version = 2
AND aggregate_kind = 'thread'
AND event_type = 'thread.created'
ORDER BY stream_id ASC
`;
const projectionRows = yield* sql<{ readonly thread_id: string }>`
SELECT thread_id
FROM orchestration_v2_projection_threads
ORDER BY thread_id ASC
`;
const actualIds = projectionRows.map((row) => ThreadId.make(row.thread_id));
const expectedIds = expectedThreadRows.map((row) => ThreadId.make(row.thread_id));
const actualSet = new Set(actualIds);
const expectedSet = new Set(expectedIds);
const missingThreadIds = expectedIds.filter((threadId) => !actualSet.has(threadId));
const unexpectedThreadIds = actualIds.filter((threadId) => !expectedSet.has(threadId));
const unreadableThreadIds = yield* projectionStore.getUnreadableThreadIds();
const metadata = yield* sql<ProjectionMetadataRow>`
SELECT schema_version, last_sequence
FROM orchestration_v2_projection_metadata
WHERE projection_name = 'thread-projections'
LIMIT 1
`;
const expectedSequence = yield* eventStore.latestSequence();
const schemaVersion = metadata[0]?.schema_version ?? 0;
const projectionSequence = metadata[0]?.last_sequence ?? 0;
return {
valid:
schemaVersion === ProjectionStore.ORCHESTRATION_V2_PROJECTION_SCHEMA_VERSION &&
projectionSequence === expectedSequence &&
missingThreadIds.length === 0 &&
unexpectedThreadIds.length === 0 &&
unreadableThreadIds.length === 0,
schemaVersion,
expectedSequence,
projectionSequence,
unreadableThreadIds,
missingThreadIds,
unexpectedThreadIds,
} satisfies ProjectionReplayVerification;
}).pipe(sql.withTransaction);
const rebuild = Effect.gen(function* () {
yield* sql.withTransaction(
Effect.gen(function* () {
const throughSequence = yield* eventStore.latestSequence();
yield* sql`DELETE FROM orchestration_v2_projection_context_transfers`;
yield* sql`DELETE FROM orchestration_v2_projection_context_handoffs`;
yield* sql`DELETE FROM orchestration_v2_projection_checkpoints`;
yield* sql`DELETE FROM orchestration_v2_projection_checkpoint_scopes`;
yield* sql`DELETE FROM orchestration_v2_projection_turn_items`;
yield* sql`DELETE FROM orchestration_v2_projection_plans`;
yield* sql`DELETE FROM orchestration_v2_projection_messages`;
yield* sql`DELETE FROM orchestration_v2_projection_runtime_requests`;
yield* sql`DELETE FROM orchestration_v2_projection_provider_turns`;
yield* sql`DELETE FROM orchestration_v2_projection_provider_threads`;
yield* sql`DELETE FROM orchestration_v2_projection_provider_session_bindings`;
yield* sql`DELETE FROM orchestration_v2_projection_provider_sessions`;
yield* sql`DELETE FROM orchestration_v2_projection_subagents`;
yield* sql`DELETE FROM orchestration_v2_projection_nodes`;
yield* sql`DELETE FROM orchestration_v2_projection_run_attempts`;
yield* sql`DELETE FROM orchestration_v2_projection_runs`;
yield* sql`DELETE FROM orchestration_v2_projection_threads`;
yield* sql`DELETE FROM orchestration_v2_turn_item_positions`;
const pageSize = 500;
let lastSequence = 0;
while (true) {
const page = yield* eventStore
.read({ afterSequence: lastSequence, throughSequence, limit: pageSize })
.pipe(Stream.runCollect);
for (const stored of page) {
yield* projectionStore.apply(stored.event);
if (stored.event.type === "turn-item.updated") {
yield* sql`
INSERT INTO orchestration_v2_turn_item_positions (
thread_id,
turn_item_id,
ordinal
)
VALUES (
${stored.event.threadId},
${stored.event.payload.id},
${stored.event.payload.ordinal}
)
ON CONFLICT(thread_id, turn_item_id) DO UPDATE SET
ordinal = excluded.ordinal
`;
}
lastSequence = stored.sequence;
}
if (page.length < pageSize) break;
yield* Effect.yieldNow;
}
const now = DateTime.formatIso(yield* DateTime.now);
yield* sql`
INSERT INTO orchestration_v2_projection_metadata (
projection_name,
schema_version,
last_sequence,
updated_at
)
VALUES (
'thread-projections',
${ProjectionStore.ORCHESTRATION_V2_PROJECTION_SCHEMA_VERSION},
${lastSequence},
${now}
)
ON CONFLICT(projection_name) DO UPDATE SET
schema_version = excluded.schema_version,
last_sequence = excluded.last_sequence,
updated_at = excluded.updated_at
`;
}),
);
return yield* verify;
});
const mapError = <A, E>(effect: Effect.Effect<A, E>) =>
effect.pipe(Effect.mapError((cause) => new ProjectionReplayError({ cause })));
return ProjectionReplay.of({ verify: mapError(verify), rebuild: mapError(rebuild) });
}),
);