refactor(run-ops): drop known-migrated from read presenters; id-shape only

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: d-cs

apps/webapp/app/presenters/v3/ApiBatchResultsPresenter.server.ts

@@ -2,7 +2,6 @@ import { BatchTaskRunExecutionResult } from "@trigger.dev/core/v3";
 import { $replica, PrismaClientOrTransaction, PrismaReplicaClient, prisma } from "~/db.server";
 import { executionResultForTaskRun, TaskRunWithAttempts } from "~/models/taskRun.server";
 import { AuthenticatedEnvironment } from "~/services/apiAuth.server";
-import { isKnownMigrated as defaultIsKnownMigrated } from "~/v3/runOpsMigration/knownMigratedFilter.server";
 import { readThroughRun } from "~/v3/runOpsMigration/readThrough.server";
 import { runStore as defaultRunStore } from "~/v3/runStore.server";
 import { BasePresenter } from "./basePresenter.server";
@@ -15,7 +14,6 @@ type ApiBatchResultsReadThroughDeps = {
   splitEnabled?: boolean;
   newClient?: PrismaReplicaClient;
   legacyReplica?: PrismaReplicaClient;
-  isKnownMigrated?: (runId: string) => Promise<boolean>;
   isPastRetention?: (runId: string) => boolean;
 };
 
@@ -193,7 +191,6 @@ export class ApiBatchResultsPresenter extends BasePresenter {
             // own module-level defaults would diverge from the batch read's `?? this._replica`.)
             newClient,
             legacyReplica,
-            isKnownMigrated: this.readThrough?.isKnownMigrated ?? defaultIsKnownMigrated,
             isPastRetention: this.readThrough?.isPastRetention,
           },
         });

apps/webapp/app/presenters/v3/ApiRunResultPresenter.server.ts

@@ -10,7 +10,6 @@ type ApiRunResultReadThroughDeps = {
   newClient?: PrismaReplicaClient;
   // LEGACY RUN-OPS READ REPLICA ONLY (never a writer/primary); defaults to this._replica.
   legacyReplica?: PrismaReplicaClient;
-  isKnownMigrated?: (runId: string) => Promise<boolean>;
   isPastRetention?: (runId: string) => boolean;
 };
 
@@ -35,7 +34,7 @@ export class ApiRunResultPresenter extends BasePresenter {
         });
 
       // Single-run result poll routed through run-ops read-through. Split on: primary store first,
-      // then the secondary read replica only for runs not known-migrated; past-retention ids return
+      // then the secondary read replica for runs that miss on new; past-retention ids return
       // undefined -> the route's normal 404. Split off (single-DB / self-host): readThroughRun does
       // one plain findFirst against the single client (passthrough).
       const result = await readThroughRun({
@@ -47,7 +46,6 @@ export class ApiRunResultPresenter extends BasePresenter {
           splitEnabled: this._readThrough?.splitEnabled,
           newClient: this._readThrough?.newClient ?? (this._prisma as PrismaReplicaClient),
           legacyReplica: this._readThrough?.legacyReplica ?? (this._replica as PrismaReplicaClient),
-          isKnownMigrated: this._readThrough?.isKnownMigrated,
           isPastRetention: this._readThrough?.isPastRetention,
         },
       });

apps/webapp/app/presenters/v3/ApiWaitpointPresenter.server.ts

@@ -6,16 +6,14 @@ import { waitpointStatusToApiStatus } from "./WaitpointListPresenter.server";
 import { generateHttpCallbackUrl } from "~/services/httpCallback.server";
 import type { PrismaClientOrTransaction, PrismaReplicaClient } from "~/db.server";
 import { readThroughRun } from "~/v3/runOpsMigration/readThrough.server";
-import { isKnownMigrated } from "~/v3/runOpsMigration/knownMigratedFilter.server";
 
 // When omitted, clients default to the inherited _replica handle => passthrough reads the
-// replica exactly as today. Pure boundaries (isKnownMigrated/isPastRetention) are injectable
-// for tests. Typed PrismaReplicaClient to match readThroughRun's readNew/readLegacy + deps.
+// replica exactly as today. isPastRetention is injectable for tests. Typed PrismaReplicaClient
+// to match readThroughRun's readNew/readLegacy + deps.
 type ApiWaitpointPresenterReadThroughDeps = {
   newClient?: PrismaReplicaClient;
   legacyReplica?: PrismaReplicaClient;
   splitEnabled?: boolean;
-  isKnownMigrated?: (id: string) => Promise<boolean>;
   isPastRetention?: (id: string) => boolean;
 };
 
@@ -42,7 +40,7 @@ export class ApiWaitpointPresenter extends BasePresenter {
   ) {
     return this.trace("call", async (span) => {
       // Public waitpoint retrieve. Split on: new run-ops client first, then the LEGACY
-      // RUN-OPS READ REPLICA ONLY for ids not known-migrated — never the legacy primary.
+      // RUN-OPS READ REPLICA ONLY on a new-probe miss — never the legacy primary.
       // Split off (single-DB / self-host): one plain waitpoint.findFirst against the replica
       // (passthrough). The waitpointId is the residency-classifiable KSUID id (the route
       // pre-decodes the friendlyId via WaitpointId.toId).
@@ -90,7 +88,6 @@ export class ApiWaitpointPresenter extends BasePresenter {
           newClient: this.readThroughDeps?.newClient ?? (this._replica as PrismaReplicaClient),
           legacyReplica:
             this.readThroughDeps?.legacyReplica ?? (this._replica as PrismaReplicaClient),
-          isKnownMigrated: this.readThroughDeps?.isKnownMigrated ?? isKnownMigrated,
           isPastRetention: this.readThroughDeps?.isPastRetention,
         },
       });

apps/webapp/app/presenters/v3/TestTaskPresenter.server.ts

@@ -14,7 +14,6 @@ import { type PrismaClient } from "~/db.server";
 import { RunsRepository } from "~/services/runsRepository/runsRepository.server";
 import { getTimezones } from "~/utils/timezones.server";
 import { findCurrentWorkerDeployment } from "~/v3/models/workerDeployment.server";
-import { isKnownMigrated as defaultIsKnownMigrated } from "~/v3/runOpsMigration/knownMigratedFilter.server";
 import { runStore as defaultRunStore } from "~/v3/runStore.server";
 import { queueTypeFromType } from "./QueueRetrievePresenter.server";
 
@@ -26,7 +25,6 @@ type TestTaskReadThroughDeps = {
   legacyReplica?: PrismaClientOrTransaction;
   // Resolved boot constant; when false the split branch is never entered.
   splitEnabled?: boolean;
-  isKnownMigrated?: (runId: string) => Promise<boolean>;
 };
 
 // The byte-identical select the recent-payloads hydrate has always used; `id` is
@@ -414,7 +412,7 @@ export class TestTaskPresenter {
   }
 
   // Hydrates the recent-payloads run-id set from the run-ops store. Split on: new
-  // client first, then the LEGACY READ REPLICA ONLY for ids not known-migrated —
+  // client first, then the LEGACY READ REPLICA ONLY for ids that miss on new —
   // never the legacy primary. Split off: one plain findRuns on `this.replica`.
   private async hydrateRecentRuns(runIds: string[]): Promise<RecentRunRow[]> {
     if (runIds.length === 0) {
@@ -427,18 +425,11 @@ export class TestTaskPresenter {
 
     const newClient = this.readThrough.newClient ?? this.replica;
     const legacyReplica = this.readThrough.legacyReplica ?? this.replica;
-    const isKnownMigrated = this.readThrough.isKnownMigrated ?? defaultIsKnownMigrated;
 
     const newRows = await this.hydrateOnClient(newClient, runIds);
     const foundIds = new Set(newRows.map((r) => r.id));
-    const missing = runIds.filter((id) => !foundIds.has(id));
-
-    const toProbeLegacy: string[] = [];
-    for (const id of missing) {
-      if (!(await isKnownMigrated(id))) {
-        toProbeLegacy.push(id);
-      }
-    }
+    // Probe every id that missed on new against the legacy read replica.
+    const toProbeLegacy = runIds.filter((id) => !foundIds.has(id));
 
     const legacyRows = toProbeLegacy.length
       ? await this.hydrateOnClient(legacyReplica, toProbeLegacy)

apps/webapp/app/presenters/v3/WaitpointPresenter.server.ts

@@ -9,7 +9,6 @@ import { clickhouseFactory } from "~/services/clickhouse/clickhouseFactoryInstan
 import { generateHttpCallbackUrl } from "~/services/httpCallback.server";
 import { logger } from "~/services/logger.server";
 import { controlPlaneResolver } from "~/v3/runOpsMigration/controlPlaneResolver.server";
-import { isKnownMigrated } from "~/v3/runOpsMigration/knownMigratedFilter.server";
 import { readThroughRun } from "~/v3/runOpsMigration/readThrough.server";
 import { BasePresenter } from "./basePresenter.server";
 import { NextRunListPresenter, type NextRunListItem } from "./NextRunListPresenter.server";
@@ -29,7 +28,6 @@ export class WaitpointPresenter extends BasePresenter {
       // Resolved boot constant from isSplitEnabled(). When false/absent:
       // the waitpoint lookup is one plain findFirst and the connected-runs hydrate runs passthrough.
       splitEnabled?: boolean;
-      isKnownMigrated?: (id: string) => Promise<boolean>;
     }
   ) {
     super(prisma, replica);
@@ -80,7 +78,6 @@ export class WaitpointPresenter extends BasePresenter {
         legacyReplica:
           (this.readThroughDeps.legacyReplica as PrismaReplicaClient | undefined) ??
           runOpsLegacyReplica,
-        isKnownMigrated: this.readThroughDeps.isKnownMigrated ?? isKnownMigrated,
       },
     });
 

apps/webapp/test/apiBatchResultsPresenter.readthrough.test.ts

@@ -4,7 +4,7 @@
 // REPLICA ONLY; each member run is hydrated independently via the per-run read-through primitive,
 // so a batch whose members span migrated (NEW) + abandoned (LEGACY) runs returns the
 // complete reachable set. Single-DB collapses to one passthrough read. We NEVER mock the DB — the
-// only injected fakes are the pure boundaries (splitEnabled / isKnownMigrated / isPastRetention).
+// only injected fakes are the pure boundaries (splitEnabled / isPastRetention).
 //
 // The BatchTaskRunItem -> TaskRun FK is per-DB; a batch straddling the seam references member ids
 // that live on the other DB, so we drop that one FK on the batch's DB at seed time (the cross-seam
@@ -196,8 +196,6 @@ const env = (ctx: SeedCtx) =>
     project: { name: ctx.project.name },
   }) as unknown as AuthenticatedEnvironment;
 
-const neverMigrated = async () => false;
-
 describe("ApiBatchResultsPresenter read-through (legacy + new DB)", () => {
   // A batch with members on BOTH DBs returns the complete set, byte-identical.
   heteroPostgresTest(
@@ -235,7 +233,6 @@ describe("ApiBatchResultsPresenter read-through (legacy + new DB)", () => {
         splitEnabled: true,
         newClient: prisma17 as unknown as PrismaReplicaClient,
         legacyReplica: prisma14 as unknown as PrismaReplicaClient,
-        isKnownMigrated: neverMigrated,
       });
 
       const result = await presenter.call("batch_span", env(ctx));
@@ -286,7 +283,6 @@ describe("ApiBatchResultsPresenter read-through (legacy + new DB)", () => {
         splitEnabled: true,
         newClient: prisma17 as unknown as PrismaReplicaClient,
         legacyReplica: prisma14 as unknown as PrismaReplicaClient,
-        isKnownMigrated: neverMigrated,
       });
 
       const result = await presenter.call("batch_legacy", env(ctx));
@@ -298,69 +294,6 @@ describe("ApiBatchResultsPresenter read-through (legacy + new DB)", () => {
     }
   );
 
-  // A known-migrated member is not re-probed against the legacy replica.
-  heteroPostgresTest(
-    "a known-migrated member missing from the new probe is NOT re-probed on legacy",
-    async ({ prisma14, prisma17 }) => {
-      const newDb = prisma17 as unknown as PrismaClient;
-      const legacyDb = prisma14 as unknown as PrismaClient;
-
-      const ctx = await seedEnv(newDb, "mig-new");
-      await mirrorEnv(legacyDb, ctx, "mig-legacy");
-      await relaxFks(newDb);
-      await relaxFks(legacyDb);
-
-      // A legacy-classified id (so the LEGACY fan-out branch is reachable) that is "known migrated".
-      const migratedId = legacyRunId("d");
-      // Seed the member ONLY on legacy, but mark it known-migrated → legacy must NOT be probed,
-      // so it resolves to not-found and is omitted.
-      await seedMember(legacyDb, ctx, {
-        id: migratedId,
-        friendlyId: "run_migrated_d",
-        status: "COMPLETED_SUCCESSFULLY",
-        output: JSON.stringify({}),
-      });
-      await seedBatch(newDb, ctx, "batch_mig", [migratedId]);
-
-      // Spy legacy replica: throw if the member-hydrate findFirst runs for the migrated id.
-      const legacySpy = new Proxy(prisma14, {
-        get(target, prop) {
-          if (prop === "taskRun") {
-            return new Proxy((target as any).taskRun, {
-              get(trTarget, trProp) {
-                if (trProp === "findFirst") {
-                  return async (args: any) => {
-                    if (args?.where?.id === migratedId) {
-                      throw new Error(
-                        "legacy replica must not be probed for a known-migrated member"
-                      );
-                    }
-                    return (trTarget as any).findFirst(args);
-                  };
-                }
-                return (trTarget as any)[trProp];
-              },
-            });
-          }
-          return (target as any)[prop];
-        },
-      }) as unknown as PrismaReplicaClient;
-
-      const presenter = new ApiBatchResultsPresenter(throwingPrisma, throwingPrisma, {
-        splitEnabled: true,
-        newClient: prisma17 as unknown as PrismaReplicaClient,
-        legacyReplica: legacySpy,
-        isKnownMigrated: async (id) => id === migratedId,
-      });
-
-      const result = await presenter.call("batch_mig", env(ctx));
-
-      expect(result).toBeDefined();
-      // Known-migrated + missing from NEW → not-found → omitted, without probing legacy.
-      expect(result!.items).toHaveLength(0);
-    }
-  );
-
   // Past-retention / missing member is omitted (dangling-ref gate adjacent), not errored.
   heteroPostgresTest(
     "a member present on neither DB is omitted; the reachable members still return",
@@ -388,7 +321,6 @@ describe("ApiBatchResultsPresenter read-through (legacy + new DB)", () => {
         splitEnabled: true,
         newClient: prisma17 as unknown as PrismaReplicaClient,
         legacyReplica: prisma14 as unknown as PrismaReplicaClient,
-        isKnownMigrated: neverMigrated,
       });
 
       const result = await presenter.call("batch_dangle", env(ctx));
@@ -411,7 +343,6 @@ describe("ApiBatchResultsPresenter read-through (legacy + new DB)", () => {
         splitEnabled: true,
         newClient: prisma17 as unknown as PrismaReplicaClient,
         legacyReplica: prisma14 as unknown as PrismaReplicaClient,
-        isKnownMigrated: neverMigrated,
       });
 
       const result = await presenter.call("batch_does_not_exist", env(ctx));
@@ -439,16 +370,13 @@ describe("ApiBatchResultsPresenter passthrough (single-DB collapse)", () => {
 
       const runStore = new PostgresRunStore({ prisma, readOnlyPrisma: prisma });
 
-      // Throwing boundaries: if the split path is entered, these blow up.
+      // Throwing legacy replica: if the split path is entered, it blows up.
       const presenter = new ApiBatchResultsPresenter(
         prisma,
         prisma,
         {
           splitEnabled: false,
           legacyReplica: throwingPrisma,
-          isKnownMigrated: async () => {
-            throw new Error("isKnownMigrated must not be invoked on the passthrough path");
-          },
         },
         runStore
       );