refactor(webapp): extract and simplify the delivery-id createdAt bounds calc

getDeliveriesByFriendlyIds computed the createdAt prune window in three passes
(map to timestamps, filter, then map again inside Math.min(...) / Math.max(...)).
Extract it to a single-pass deliveryIdsCreatedAtBounds that decodes each id once
and tracks min/max in one loop, with no Math.min(...spread), which builds the
whole argument list and overflows the stack on large inputs. Same result, plus a
unit test covering the span, single-id, empty, and legacy-fallback cases.

Author: ericallam

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

@@ -1,6 +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 { decodeRunsCursor, encodeRunsCursor } from "../runsRepository/runsCursor.server";
 import {
   type CountDeliveriesByEndpointOptions,
@@ -316,24 +317,13 @@ export class ClickHouseWebhookDeliveriesRepository implements IWebhookDeliveries
     const ids = options.friendlyIds.map((friendlyId) => WebhookDeliveryId.toId(friendlyId));
     if (ids.length === 0) return [];
 
-    const timestamps = options.friendlyIds
-      .map((friendlyId) => WebhookDeliveryId.parseTimestamp(friendlyId))
-      .filter((value): value is Date => value != null);
-    const createdAtBound =
-      timestamps.length === options.friendlyIds.length
-        ? {
-            createdAt: {
-              gte: new Date(Math.min(...timestamps.map((value) => value.getTime()))),
-              lte: new Date(Math.max(...timestamps.map((value) => value.getTime()))),
-            },
-          }
-        : {};
+    const bounds = deliveryIdsCreatedAtBounds(options.friendlyIds);
 
     return this.options.prisma.webhookDelivery.findMany({
       where: {
         id: { in: boundedIn(ids) },
         runtimeEnvironmentId: options.environmentId,
-        ...createdAtBound,
+        ...(bounds ? { createdAt: bounds } : {}),
       },
       select: DELIVERY_LIST_SELECT,
     });

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

@@ -0,0 +1,32 @@
+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.
+ *
+ * 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.
+ *
+ * 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).
+ */
+export function deliveryIdsCreatedAtBounds(
+  friendlyIds: string[]
+): { gte: Date; lte: Date } | undefined {
+  let min = Number.POSITIVE_INFINITY;
+  let max = Number.NEGATIVE_INFINITY;
+
+  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;
+  }
+
+  if (min === Number.POSITIVE_INFINITY) return undefined;
+  return { gte: new Date(min), lte: new Date(max) };
+}

apps/webapp/test/deliveryIdBounds.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, it, vi } from "vitest";
+import { WebhookDeliveryId } from "@trigger.dev/core/v3/isomorphic";
+import { deliveryIdsCreatedAtBounds } from "../app/services/webhookDeliveriesRepository/deliveryIdBounds";
+
+function idAt(iso: string): string {
+  vi.setSystemTime(new Date(iso));
+  return WebhookDeliveryId.generate().friendlyId;
+}
+
+describe("deliveryIdsCreatedAtBounds", () => {
+  it("returns undefined for an empty set", () => {
+    expect(deliveryIdsCreatedAtBounds([])).toBeUndefined();
+  });
+
+  it("returns a zero-width span for a single id (gte == lte == its mint time)", () => {
+    vi.useFakeTimers();
+    try {
+      const at = "2026-08-11T10:00:00.000Z";
+      const friendlyId = idAt(at);
+      const bounds = deliveryIdsCreatedAtBounds([friendlyId]);
+      expect(bounds?.gte.toISOString()).toBe(at);
+      expect(bounds?.lte.toISOString()).toBe(at);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it("spans the earliest and latest mint times across ids, regardless of input order", () => {
+    vi.useFakeTimers();
+    try {
+      const early = idAt("2026-08-09T00:00:00.000Z");
+      const mid = idAt("2026-08-10T12:00:00.000Z");
+      const late = idAt("2026-08-11T23:59:59.000Z");
+      const bounds = deliveryIdsCreatedAtBounds([mid, late, early]);
+      expect(bounds?.gte.toISOString()).toBe("2026-08-09T00:00:00.000Z");
+      expect(bounds?.lte.toISOString()).toBe("2026-08-11T23:59:59.000Z");
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it("returns undefined when any id is legacy (non-time-encoded), so the caller skips pruning", () => {
+    vi.useFakeTimers();
+    try {
+      const v1 = idAt("2026-08-11T10:00:00.000Z");
+      expect(deliveryIdsCreatedAtBounds([v1, "whd_legacycuidstyleid"])).toBeUndefined();
+      expect(deliveryIdsCreatedAtBounds(["whd_legacycuidstyleid"])).toBeUndefined();
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+});