refactor(webapp): share the single-pass createdAt bounds calc across delivery queries

Route the list-hydration query through the same createdAtMsBounds helper the
id-bounds path uses, dropping the last Math.min(...spread)/Math.max(...spread)
in the delivery repository. The spread builds an O(n) argument list and
overflows the call stack on large inputs; the helper is a single pass.

Author: ericallam

apps/webapp/app/services/webhookDeliveriesRepository/clickhouseWebhookDeliveriesRepository.server.ts

@@ -1,7 +1,7 @@
 import { type ClickhouseQueryBuilder } from "@internal/clickhouse";
 import { WebhookDeliveryId } from "@trigger.dev/core/v3/isomorphic";
 import { boundedIn } from "@trigger.dev/database";
-import { deliveryIdsCreatedAtBounds } from "./deliveryIdBounds";
+import { createdAtMsBounds, deliveryIdsCreatedAtBounds } from "./deliveryIdBounds";
 import { decodeRunsCursor, encodeRunsCursor } from "../runsRepository/runsCursor.server";
 import {
   type CountDeliveriesByEndpointOptions,
@@ -195,18 +195,13 @@ export class ClickHouseWebhookDeliveriesRepository implements IWebhookDeliveries
     // `id IN (...)` query without a createdAt predicate scans every child
     // partition, so derive a [min, max] range from the CH page and pass it
     // through. This is the one place webhook hydration diverges from runs.
-    const createdAtMsValues = pageRows.map((row) => row.createdAt);
-    const minCreatedAtMs = Math.min(...createdAtMsValues);
-    const maxCreatedAtMs = Math.max(...createdAtMsValues);
+    const bounds = createdAtMsBounds(pageRows.map((row) => row.createdAt));
 
     // CH gives the ordered id list; Postgres hydrates the full lean rows by PK id.
     const deliveries = await this.options.prisma.webhookDelivery.findMany({
       where: {
         id: { in: boundedIn(deliveryIds) },
-        createdAt: {
-          gte: new Date(minCreatedAtMs),
-          lte: new Date(maxCreatedAtMs),
-        },
+        ...(bounds ? { createdAt: bounds } : {}),
       },
       select: DELIVERY_LIST_SELECT,
     });

apps/webapp/app/services/webhookDeliveriesRepository/deliveryIdBounds.ts

@@ -1,32 +1,46 @@
 import { WebhookDeliveryId } from "@trigger.dev/core/v3/isomorphic";
 
 /**
- * Compute the `createdAt` span covering a set of webhook delivery friendlyIds, for partition-pruning a
- * lookup by id on the RANGE-partitioned `WebhookDelivery` table.
+ * Single-pass min/max over a set of `createdAt` timestamps (unix ms), returned as a Prisma
+ * `{ gte, lte }` range for partition-pruning the RANGE-partitioned `WebhookDelivery` table.
  *
- * Each v1 id is time-encoded (see `WebhookDeliveryId`) with the same timestamp the engine stores as the
- * row's `createdAt`, so the returned `[gte, lte]` covers every row in the set exactly. Returns
- * `undefined` when the set is empty or contains any legacy (non-time-encoded) id: in that case the
- * caller must not add a `createdAt` predicate, since a bound derived from only the decodable ids would
- * wrongly exclude the legacy rows.
+ * Avoids `Math.min(...spread)` / `Math.max(...spread)`: the spread builds an O(n) argument list and
+ * throws "Maximum call stack size exceeded" once the array is large (~1e5+ elements). Returns
+ * `undefined` for an empty set, so the caller adds no `createdAt` predicate.
+ */
+export function createdAtMsBounds(msValues: number[]): { gte: Date; lte: Date } | undefined {
+  let min = Number.POSITIVE_INFINITY;
+  let max = Number.NEGATIVE_INFINITY;
+
+  for (const ms of msValues) {
+    if (ms < min) min = ms;
+    if (ms > max) max = ms;
+  }
+
+  if (min === Number.POSITIVE_INFINITY) return undefined;
+  return { gte: new Date(min), lte: new Date(max) };
+}
+
+/**
+ * Compute the `createdAt` span covering a set of webhook delivery friendlyIds, for partition-pruning
+ * a lookup by id on the RANGE-partitioned `WebhookDelivery` table.
  *
- * Single pass, no intermediate arrays and no `Math.min(...spread)` (which is O(n) to build the argument
- * list and can overflow the call stack for large inputs).
+ * Each v1 id is time-encoded (see `WebhookDeliveryId`) with the same timestamp the engine stores as
+ * the row's `createdAt`, so the returned `[gte, lte]` covers every row in the set exactly. Returns
+ * `undefined` when the set is empty or contains any legacy (non-time-encoded) id: in that case the
+ * caller must not add a `createdAt` predicate, since a bound derived from only the decodable ids
+ * would wrongly exclude the legacy rows.
  */
 export function deliveryIdsCreatedAtBounds(
   friendlyIds: string[]
 ): { gte: Date; lte: Date } | undefined {
-  let min = Number.POSITIVE_INFINITY;
-  let max = Number.NEGATIVE_INFINITY;
+  const msValues: number[] = [];
 
   for (const friendlyId of friendlyIds) {
     const timestamp = WebhookDeliveryId.parseTimestamp(friendlyId);
     if (!timestamp) return undefined;
-    const ms = timestamp.getTime();
-    if (ms < min) min = ms;
-    if (ms > max) max = ms;
+    msValues.push(timestamp.getTime());
   }
 
-  if (min === Number.POSITIVE_INFINITY) return undefined;
-  return { gte: new Date(min), lte: new Date(max) };
+  return createdAtMsBounds(msValues);
 }

apps/webapp/test/deliveryIdBounds.test.ts

@@ -1,6 +1,9 @@
 import { describe, expect, it, vi } from "vitest";
 import { WebhookDeliveryId } from "@trigger.dev/core/v3/isomorphic";
-import { deliveryIdsCreatedAtBounds } from "../app/services/webhookDeliveriesRepository/deliveryIdBounds";
+import {
+  createdAtMsBounds,
+  deliveryIdsCreatedAtBounds,
+} from "../app/services/webhookDeliveriesRepository/deliveryIdBounds";
 
 function idAt(iso: string): string {
   vi.setSystemTime(new Date(iso));
@@ -50,3 +53,28 @@ describe("deliveryIdsCreatedAtBounds", () => {
     }
   });
 });
+
+describe("createdAtMsBounds", () => {
+  it("returns undefined for an empty set", () => {
+    expect(createdAtMsBounds([])).toBeUndefined();
+  });
+
+  it("returns a zero-width span for a single value", () => {
+    const bounds = createdAtMsBounds([1_000]);
+    expect(bounds?.gte.getTime()).toBe(1_000);
+    expect(bounds?.lte.getTime()).toBe(1_000);
+  });
+
+  it("spans the smallest and largest value regardless of input order", () => {
+    const bounds = createdAtMsBounds([50, 10, 30, 90, 40]);
+    expect(bounds?.gte.getTime()).toBe(10);
+    expect(bounds?.lte.getTime()).toBe(90);
+  });
+
+  it("handles a large input without a stack overflow (unlike Math.min(...spread))", () => {
+    const values = Array.from({ length: 300_000 }, (_, i) => i);
+    const bounds = createdAtMsBounds(values);
+    expect(bounds?.gte.getTime()).toBe(0);
+    expect(bounds?.lte.getTime()).toBe(299_999);
+  });
+});