perf(webapp): compute delivery createdAt bounds from the two extreme ids

The delivery-id bounds calc decoded every id in the set to find the createdAt
span. Delivery id bodies are base32hex(big-endian timestamp then random bytes),
and base32hex is order-preserving, so lexical order equals chronological order:
the earliest and latest timestamps sit at the lexical extremes. Track the min
and max id in a single pass and decode only those two.

The list-hydration query shares the same single-pass min/max helper for its
already-decoded page timestamps, dropping the last Math.min(...spread) in the
delivery repository (the spread overflows the call stack on large inputs).

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,
     });
@@ -285,8 +280,7 @@ export class ClickHouseWebhookDeliveriesRepository implements IWebhookDeliveries
    * `WebhookDelivery` is RANGE-partitioned on `createdAt`, so a bare `id` predicate can't prune and
    * probes every partition. The delivery id is time-encoded (see `WebhookDeliveryId`) with the same
    * timestamp the engine stores as `createdAt`, so we recover it from the id and add it as an exact
-   * predicate to prune to the row's partition. A legacy id that doesn't decode falls back to the
-   * unpruned lookup.
+   * predicate to prune to the row's partition.
    */
   async getDelivery(options: GetWebhookDeliveryOptions): Promise<DetailedWebhookDelivery | null> {
     const id = WebhookDeliveryId.toId(options.friendlyId);
@@ -306,10 +300,9 @@ export class ClickHouseWebhookDeliveriesRepository implements IWebhookDeliveries
    * Hydrate a known set of deliveries by friendlyId. Pure Postgres: the caller (the live poll)
    * already has the ids, so there is nothing for ClickHouse to filter or order.
    *
-   * The ids are time-encoded (see `WebhookDeliveryId`), so when every id decodes we bound the query
-   * to the span of their mint timestamps, which equal the rows' `createdAt`. That prunes the
-   * RANGE-partitioned table to the visible page's few days instead of probing all of retention on
-   * every poll. A mix that includes a legacy id falls back to the unbounded lookup.
+   * The ids are time-encoded (see `WebhookDeliveryId`), so we bound the query to the span of their
+   * mint timestamps, which equal the rows' `createdAt`. That prunes the RANGE-partitioned table to
+   * the visible page's few days instead of probing all of retention on every poll.
    */
   async getDeliveriesByFriendlyIds(
     options: GetDeliveriesByFriendlyIdsOptions

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

@@ -1,32 +1,55 @@
 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.
- *
- * 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).
+ * 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 deliveryIdsCreatedAtBounds(
-  friendlyIds: string[]
-): { gte: Date; lte: Date } | undefined {
+export function createdAtMsBounds(msValues: number[]): { 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();
+  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.
+ *
+ * A delivery id body is `base32hex(big-endian ms timestamp then random bytes)`, and base32hex is
+ * order-preserving, so lexical id order equals chronological order. The earliest and latest
+ * timestamps therefore sit at the lexical extremes, and we recover the span by decoding only those
+ * two ids instead of all N. The embedded timestamp equals the row's `createdAt`, so `[gte, lte]`
+ * covers every row in the set exactly.
+ *
+ * Returns `undefined` for an empty set, or if an extreme id fails to decode, so the caller adds no
+ * `createdAt` predicate and the lookup stays correct (just unpruned).
+ */
+export function deliveryIdsCreatedAtBounds(
+  friendlyIds: string[]
+): { gte: Date; lte: Date } | undefined {
+  if (friendlyIds.length === 0) return undefined;
+
+  let minBody = WebhookDeliveryId.toId(friendlyIds[0]!);
+  let maxBody = minBody;
+  for (let i = 1; i < friendlyIds.length; i++) {
+    const body = WebhookDeliveryId.toId(friendlyIds[i]!);
+    if (body < minBody) minBody = body;
+    if (body > maxBody) maxBody = body;
+  }
+
+  const gte = WebhookDeliveryId.parseTimestamp(minBody);
+  const lte = WebhookDeliveryId.parseTimestamp(maxBody);
+  if (!gte || !lte) return undefined;
+
+  return { gte, lte };
+}

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));
@@ -39,14 +42,32 @@ describe("deliveryIdsCreatedAtBounds", () => {
     }
   });
 
-  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();
-    }
+  it("returns undefined when an id fails to decode, so the caller skips pruning", () => {
+    expect(deliveryIdsCreatedAtBounds(["whd_notavaliddeliveryid"])).toBeUndefined();
+  });
+});
+
+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);
   });
 });