handleError

Author: ericallam

packages/core/src/v3/lifecycleHooks/manager.ts

@@ -9,6 +9,7 @@ import {
   AnyOnCompleteHookFunction,
   AnyOnWaitHookFunction,
   AnyOnResumeHookFunction,
+  AnyOnHandleErrorHookFunction,
 } from "./types.js";
 
 export class StandardLifecycleHooksManager implements LifecycleHooksManager {
@@ -40,6 +41,13 @@ export class StandardLifecycleHooksManager implements LifecycleHooksManager {
     new Map();
   private taskResumeHooks: Map<string, RegisteredHookFunction<AnyOnResumeHookFunction>> = new Map();
 
+  private globalHandleErrorHooks: Map<
+    string,
+    RegisteredHookFunction<AnyOnHandleErrorHookFunction>
+  > = new Map();
+  private taskHandleErrorHooks: Map<string, RegisteredHookFunction<AnyOnHandleErrorHookFunction>> =
+    new Map();
+
   registerGlobalStartHook(hook: RegisterHookFunctionParams<AnyOnStartHookFunction>): void {
     const id = generateHookId(hook);
 
@@ -259,6 +267,39 @@ export class StandardLifecycleHooksManager implements LifecycleHooksManager {
   getGlobalResumeHooks(): RegisteredHookFunction<AnyOnResumeHookFunction>[] {
     return Array.from(this.globalResumeHooks.values());
   }
+
+  registerGlobalHandleErrorHook(
+    hook: RegisterHookFunctionParams<AnyOnHandleErrorHookFunction>
+  ): void {
+    const id = generateHookId(hook);
+
+    this.globalHandleErrorHooks.set(id, {
+      id,
+      name: hook.id ?? hook.fn.name ? (hook.fn.name === "" ? undefined : hook.fn.name) : undefined,
+      fn: hook.fn,
+    });
+  }
+
+  registerTaskHandleErrorHook(
+    taskId: string,
+    hook: RegisterHookFunctionParams<AnyOnHandleErrorHookFunction>
+  ): void {
+    const id = generateHookId(hook);
+
+    this.taskHandleErrorHooks.set(taskId, {
+      id,
+      name: hook.id ?? hook.fn.name ? (hook.fn.name === "" ? undefined : hook.fn.name) : undefined,
+      fn: hook.fn,
+    });
+  }
+
+  getTaskHandleErrorHook(taskId: string): AnyOnHandleErrorHookFunction | undefined {
+    return this.taskHandleErrorHooks.get(taskId)?.fn;
+  }
+
+  getGlobalHandleErrorHooks(): RegisteredHookFunction<AnyOnHandleErrorHookFunction>[] {
+    return Array.from(this.globalHandleErrorHooks.values());
+  }
 }
 
 export class NoopLifecycleHooksManager implements LifecycleHooksManager {
@@ -394,6 +435,27 @@ export class NoopLifecycleHooksManager implements LifecycleHooksManager {
   getGlobalResumeHooks(): RegisteredHookFunction<AnyOnResumeHookFunction>[] {
     return [];
   }
+
+  registerGlobalHandleErrorHook(
+    hook: RegisterHookFunctionParams<AnyOnHandleErrorHookFunction>
+  ): void {
+    // Noop
+  }
+
+  registerTaskHandleErrorHook(
+    taskId: string,
+    hook: RegisterHookFunctionParams<AnyOnHandleErrorHookFunction>
+  ): void {
+    // Noop
+  }
+
+  getTaskHandleErrorHook(taskId: string): AnyOnHandleErrorHookFunction | undefined {
+    return undefined;
+  }
+
+  getGlobalHandleErrorHooks(): RegisteredHookFunction<AnyOnHandleErrorHookFunction>[] {
+    return [];
+  }
 }
 
 function generateHookId(hook: RegisterHookFunctionParams<any>): string {

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

@@ -119,6 +119,23 @@ export type RegisteredHookFunction<THookFunction extends (params: any) => any> =
   fn: THookFunction;
 };
 
+export type TaskHandleErrorHookParams<TPayload = unknown> = {
+  ctx: TaskRunContext;
+  payload: TPayload;
+  task: string;
+  error: unknown;
+  retry?: RetryOptions;
+  retryAt?: Date;
+  retryDelayInMs?: number;
+  signal?: AbortSignal;
+};
+
+export type OnHandleErrorHookFunction<TPayload> = (
+  params: TaskHandleErrorHookParams<TPayload>
+) => HandleErrorResult;
+
+export type AnyOnHandleErrorHookFunction = OnHandleErrorHookFunction<unknown>;
+
 export interface LifecycleHooksManager {
   registerGlobalInitHook(hook: RegisterHookFunctionParams<AnyOnInitHookFunction>): void;
   registerTaskInitHook(
@@ -169,4 +186,13 @@ export interface LifecycleHooksManager {
   ): void;
   getTaskResumeHook(taskId: string): AnyOnResumeHookFunction | undefined;
   getGlobalResumeHooks(): RegisteredHookFunction<AnyOnResumeHookFunction>[];
+  registerGlobalHandleErrorHook(
+    hook: RegisterHookFunctionParams<AnyOnHandleErrorHookFunction>
+  ): void;
+  registerTaskHandleErrorHook(
+    taskId: string,
+    hook: RegisterHookFunctionParams<AnyOnHandleErrorHookFunction>
+  ): void;
+  getTaskHandleErrorHook(taskId: string): AnyOnHandleErrorHookFunction | undefined;
+  getGlobalHandleErrorHooks(): RegisteredHookFunction<AnyOnHandleErrorHookFunction>[];
 }

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

@@ -12,6 +12,7 @@ import {
   type TaskCompleteResult,
   type AnyOnWaitHookFunction,
   type AnyOnResumeHookFunction,
+  type AnyOnHandleErrorHookFunction,
 } from "@trigger.dev/core/v3";
 
 export type {
@@ -27,6 +28,7 @@ export type {
   TaskCompleteResult,
   AnyOnWaitHookFunction,
   AnyOnResumeHookFunction,
+  AnyOnHandleErrorHookFunction,
 };
 
 export function onInit(name: string, fn: AnyOnInitHookFunction): void;
@@ -106,3 +108,15 @@ export function onResume(
     fn: typeof fnOrName === "function" ? fnOrName : fn!,
   });
 }
+
+export function onHandleError(name: string, fn: AnyOnHandleErrorHookFunction): void;
+export function onHandleError(fn: AnyOnHandleErrorHookFunction): void;
+export function onHandleError(
+  fnOrName: string | AnyOnHandleErrorHookFunction,
+  fn?: AnyOnHandleErrorHookFunction
+): void {
+  lifecycleHooks.registerGlobalHandleErrorHook({
+    id: typeof fnOrName === "string" ? fnOrName : fnOrName.name ? fnOrName.name : undefined,
+    fn: typeof fnOrName === "function" ? fnOrName : fn!,
+  });
+}

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

@@ -86,4 +86,5 @@ export const tasks = {
   onComplete,
   onWait,
   onResume,
+  onHandleError,
 };