Add batch.retrieve and allow filtering by batch in runs.list

Author: ericallam

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

@@ -0,0 +1,32 @@
+import { RetrieveBatchResponse } from "@trigger.dev/core/v3";
+import { AuthenticatedEnvironment } from "~/services/apiAuth.server";
+import { BasePresenter } from "./basePresenter.server";
+
+export class ApiRetrieveBatchPresenter extends BasePresenter {
+  public async call(
+    friendlyId: string,
+    env: AuthenticatedEnvironment
+  ): Promise<RetrieveBatchResponse | undefined> {
+    return this.traceWithEnv<RetrieveBatchResponse | undefined>("call", env, async (span) => {
+      const batch = await this._replica.batchTaskRun.findFirst({
+        where: {
+          friendlyId,
+          runtimeEnvironmentId: env.id,
+        },
+      });
+
+      if (!batch) {
+        return;
+      }
+
+      return {
+        id: batch.friendlyId,
+        status: batch.status,
+        idempotencyKey: batch.idempotencyKey ?? undefined,
+        createdAt: batch.createdAt,
+        updatedAt: batch.updatedAt,
+        runCount: batch.runCount,
+      };
+    });
+  }
+}

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

@@ -119,6 +119,7 @@ export const ApiRunListSearchParams = z.object({
   "filter[createdAt][from]": CoercedDate,
   "filter[createdAt][to]": CoercedDate,
   "filter[createdAt][period]": z.string().optional(),
+  "filter[batch]": z.string().optional(),
 });
 
 type ApiRunListSearchParams = z.infer<typeof ApiRunListSearchParams>;
@@ -209,6 +210,10 @@ export class ApiRunListPresenter extends BasePresenter {
         options.isTest = searchParams["filter[isTest]"];
       }
 
+      if (searchParams["filter[batch]"]) {
+        options.batchId = searchParams["filter[batch]"];
+      }
+
       const presenter = new RunListPresenter();
 
       logger.debug("Calling RunListPresenter", { options });

apps/webapp/app/routes/api.v1.batches.$batchId.ts

@@ -0,0 +1,31 @@
+import { json } from "@remix-run/server-runtime";
+import { z } from "zod";
+import { ApiRetrieveBatchPresenter } from "~/presenters/v3/ApiRetrieveBatchPresenter.server";
+import { createLoaderApiRoute } from "~/services/routeBuilders/apiBuilder.server";
+
+const ParamsSchema = z.object({
+  batchId: z.string(),
+});
+
+export const loader = createLoaderApiRoute(
+  {
+    params: ParamsSchema,
+    allowJWT: true,
+    corsStrategy: "all",
+    authorization: {
+      action: "read",
+      resource: (params) => ({ batch: params.batchId }),
+      superScopes: ["read:runs", "read:all", "admin"],
+    },
+  },
+  async ({ params, authentication }) => {
+    const presenter = new ApiRetrieveBatchPresenter();
+    const result = await presenter.call(params.batchId, authentication.environment);
+
+    if (!result) {
+      return json({ error: "Batch not found" }, { status: 404 });
+    }
+
+    return json(result);
+  }
+);

packages/core/src/v3/apiClient/index.ts

@@ -18,6 +18,7 @@ import {
   ListScheduleOptions,
   ReplayRunResponse,
   RescheduleRunRequestBody,
+  RetrieveBatchResponse,
   RetrieveRunResponse,
   ScheduleObject,
   TaskRunExecutionResult,
@@ -670,6 +671,18 @@ export class ApiClient {
     );
   }
 
+  retrieveBatch(batchId: string, requestOptions?: ZodFetchOptions) {
+    return zodfetch(
+      RetrieveBatchResponse,
+      `${this.baseUrl}/api/v1/batches/${batchId}`,
+      {
+        method: "GET",
+        headers: this.#getHeaders(false),
+      },
+      mergeRequestOptions(this.defaultRequestOptions, requestOptions)
+    );
+  }
+
   #getHeaders(spanParentAsLink: boolean, additionalHeaders?: Record<string, string | undefined>) {
     const headers: Record<string, string> = {
       "Content-Type": "application/json",
@@ -793,6 +806,10 @@ function createSearchQueryForListRuns(query?: ListRunsQueryParams): URLSearchPar
     if (query.period) {
       searchParams.append("filter[createdAt][period]", query.period);
     }
+
+    if (query.batch) {
+      searchParams.append("filter[batch]", query.batch);
+    }
   }
 
   return searchParams;

packages/core/src/v3/apiClient/types.ts

@@ -31,6 +31,7 @@ export interface ListRunsQueryParams extends CursorPageParams {
   tag?: Array<string> | string;
   schedule?: string;
   isTest?: boolean;
+  batch?: string;
 }
 
 export interface ListProjectRunsQueryParams extends CursorPageParams, ListRunsQueryParams {

packages/core/src/v3/schemas/api.ts

@@ -712,3 +712,18 @@ export const SubscribeRunRawShape = z.object({
 });
 
 export type SubscribeRunRawShape = z.infer<typeof SubscribeRunRawShape>;
+
+export const BatchStatus = z.enum(["PENDING", "COMPLETED"]);
+
+export type BatchStatus = z.infer<typeof BatchStatus>;
+
+export const RetrieveBatchResponse = z.object({
+  id: z.string(),
+  status: BatchStatus,
+  idempotencyKey: z.string().optional(),
+  createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date(),
+  runCount: z.number(),
+});
+
+export type RetrieveBatchResponse = z.infer<typeof RetrieveBatchResponse>;

packages/trigger-sdk/src/v3/batch.ts

@@ -1,13 +1,53 @@
+import {
+  accessoryAttributes,
+  apiClientManager,
+  ApiPromise,
+  ApiRequestOptions,
+  mergeRequestOptions,
+  RetrieveBatchResponse,
+} from "@trigger.dev/core/v3";
 import {
   batchTriggerById,
   batchTriggerByIdAndWait,
   batchTriggerTasks,
   batchTriggerAndWaitTasks,
 } from "./shared.js";
+import { tracer } from "./tracer.js";
 
 export const batch = {
   trigger: batchTriggerById,
   triggerAndWait: batchTriggerByIdAndWait,
   triggerByTask: batchTriggerTasks,
   triggerByTaskAndWait: batchTriggerAndWaitTasks,
+  retrieve: retrieveBatch,
 };
+
+function retrieveBatch(
+  batchId: string,
+  requestOptions?: ApiRequestOptions
+): ApiPromise<RetrieveBatchResponse> {
+  const apiClient = apiClientManager.clientOrThrow();
+
+  const $requestOptions = mergeRequestOptions(
+    {
+      tracer,
+      name: "batch.retrieve()",
+      icon: "batch",
+      attributes: {
+        batchId: batchId,
+        ...accessoryAttributes({
+          items: [
+            {
+              text: batchId,
+              variant: "normal",
+            },
+          ],
+          style: "codepath",
+        }),
+      },
+    },
+    requestOptions
+  );
+
+  return apiClient.retrieveBatch(batchId, $requestOptions);
+}

references/v3-catalog/src/management.ts

@@ -261,6 +261,14 @@ async function doBatchTrigger() {
   ]);
 
   console.log("batch trigger response", response);
+
+  const $batch = await batch.retrieve(response.batchId);
+
+  console.log("batch", $batch);
+
+  const $runs = await runs.list({ batch: response.batchId });
+
+  console.log("batch runs", $runs.data);
 }
 
 // doRuns().catch(console.error);