Add triggerAndWait().unwrap() to more easily get at the output or throw the subtask error

Author: ericallam

.changeset/stale-actors-camp.md

@@ -0,0 +1,5 @@
+---
+"@trigger.dev/sdk": patch
+---
+
+Add triggerAndWait().unwrap() to more easily get at the output or throw the subtask error

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

@@ -263,6 +263,40 @@ export type TaskRunResult<TOutput = any> =
       error: unknown;
     };
 
+export class SubtaskUnwrapError extends Error {
+  constructor(taskId: string, subtaskError: unknown) {
+    if (subtaskError instanceof Error) {
+      super(`Error in ${taskId}: ${subtaskError.message}`, { cause: subtaskError });
+      this.name = "SubtaskUnwrapError";
+    } else {
+      super(`Error in ${taskId}`, { cause: subtaskError });
+      this.name = "SubtaskUnwrapError";
+    }
+  }
+}
+
+export class TaskRunPromise<T> extends Promise<TaskRunResult<T>> {
+  constructor(
+    executor: (
+      resolve: (value: TaskRunResult<T> | PromiseLike<TaskRunResult<T>>) => void,
+      reject: (reason?: any) => void
+    ) => void,
+    private readonly taskId: string
+  ) {
+    super(executor);
+  }
+
+  unwrap(): Promise<T> {
+    return this.then((result) => {
+      if (result.ok) {
+        return result.output;
+      } else {
+        throw new SubtaskUnwrapError(this.taskId, result.error);
+      }
+    });
+  }
+}
+
 export type BatchResult<TOutput = any> = {
   id: string;
   runs: TaskRunResult<TOutput>[];
@@ -311,7 +345,7 @@ export interface Task<TIdentifier extends string, TInput = void, TOutput = any>
    * }
    * ```
    */
-  triggerAndWait: (payload: TInput, options?: TaskRunOptions) => Promise<TaskRunResult<TOutput>>;
+  triggerAndWait: (payload: TInput, options?: TaskRunOptions) => TaskRunPromise<TOutput>;
 
   /**
    * Batch trigger multiple task runs with the given payloads, and wait for the results. Returns the results of the task runs.
@@ -512,20 +546,28 @@ export function createTask<
         customQueue
       );
     },
-    triggerAndWait: async (payload, options) => {
+    triggerAndWait: (payload, options) => {
       const taskMetadata = taskCatalog.getTaskManifest(params.id);
 
-      return await triggerAndWait_internal<TInput, TOutput>(
-        taskMetadata && taskMetadata.exportName
-          ? `${taskMetadata.exportName}.triggerAndWait()`
-          : `triggerAndWait()`,
-        params.id,
-        payload,
-        {
-          queue: customQueue,
-          ...options,
-        }
-      );
+      return new TaskRunPromise<TOutput>((resolve, reject) => {
+        triggerAndWait_internal<TInput, TOutput>(
+          taskMetadata && taskMetadata.exportName
+            ? `${taskMetadata.exportName}.triggerAndWait()`
+            : `triggerAndWait()`,
+          params.id,
+          payload,
+          {
+            queue: customQueue,
+            ...options,
+          }
+        )
+          .then((result) => {
+            resolve(result);
+          })
+          .catch((error) => {
+            reject(error);
+          });
+      }, params.id);
     },
     batchTriggerAndWait: async (items) => {
       const taskMetadata = taskCatalog.getTaskManifest(params.id);
@@ -614,19 +656,27 @@ export async function trigger<TTask extends AnyTask>(
  * }
  * ```
  */
-export async function triggerAndWait<TTask extends AnyTask>(
+export function triggerAndWait<TTask extends AnyTask>(
   id: TaskIdentifier<TTask>,
   payload: TaskPayload<TTask>,
   options?: TaskRunOptions,
   requestOptions?: ApiRequestOptions
-): Promise<TaskRunResult<TaskOutput<TTask>>> {
-  return await triggerAndWait_internal<TaskPayload<TTask>, TaskOutput<TTask>>(
-    "tasks.triggerAndWait()",
-    id,
-    payload,
-    options,
-    requestOptions
-  );
+): TaskRunPromise<TaskOutput<TTask>> {
+  return new TaskRunPromise<TaskOutput<TTask>>((resolve, reject) => {
+    triggerAndWait_internal<TaskPayload<TTask>, TaskOutput<TTask>>(
+      "tasks.triggerAndWait()",
+      id,
+      payload,
+      options,
+      requestOptions
+    )
+      .then((result) => {
+        resolve(result);
+      })
+      .catch((error) => {
+        reject(error);
+      });
+  }, id);
 }
 
 /**

references/v3-catalog/src/trigger/simple.ts

@@ -31,15 +31,13 @@ export const fetchPostTask = task({
 export const anyPayloadTask = task({
   id: "any-payload-task",
   run: async (payload: any) => {
-    const result = await tasks.triggerAndWait<typeof fetchPostTask>("fetch-post-task", {
-      url: "https://jsonplaceholder.typicode.com/posts/1",
-    });
+    const { url, method } = await tasks
+      .triggerAndWait<typeof fetchPostTask>("fetch-post-task", {
+        url: "https://jsonplaceholder.typicode.comasdqdasd/posts/1",
+      })
+      .unwrap();
 
-    if (result.ok) {
-      logger.info("Result from fetch-post-task 211111sss", { output: result.output });
-    } else {
-      logger.error("Error from fetch-post-task", { error: result.error });
-    }
+    console.log("Result from fetch-post-task 211111sss", { output: { url, method } });
 
     return {
       payload,
@@ -126,10 +124,12 @@ export const parentTask = task({
 
     await wait.for({ seconds: 5 });
 
-    const childTaskResponse = await childTask.triggerAndWait({
-      message: payload.message,
-      forceError: false,
-    });
+    const childTaskResponse = await childTask
+      .triggerAndWait({
+        message: payload.message,
+        forceError: false,
+      })
+      .unwrap();
 
     logger.info("Child task response", { childTaskResponse });