onFailure

Author: ericallam

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

@@ -1,5 +1,9 @@
 import { TaskOptions } from "../types/index.js";
-import { AnyOnInitHookFunction, AnyOnStartHookFunction } from "./types.js";
+import {
+  AnyOnInitHookFunction,
+  AnyOnStartHookFunction,
+  AnyOnFailureHookFunction,
+} from "./types.js";
 
 export function createInitHookAdapter<TPayload>(
   fn: NonNullable<TaskOptions<string, TPayload, unknown, any>["init"]>
@@ -28,3 +32,18 @@ export function createStartHookAdapter<TPayload>(
     return await fn(params.payload as unknown as TPayload, paramsWithoutPayload);
   };
 }
+
+export function createFailureHookAdapter<TPayload>(
+  fn: NonNullable<TaskOptions<string, TPayload, unknown, any>["onFailure"]>
+): AnyOnFailureHookFunction {
+  return async (params) => {
+    const paramsWithoutPayload = {
+      ...params,
+    };
+
+    delete paramsWithoutPayload["payload"];
+    delete paramsWithoutPayload["error"];
+
+    return await fn(params.payload as unknown as TPayload, params.error, paramsWithoutPayload);
+  };
+}

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

@@ -4,6 +4,7 @@ import {
   LifecycleHooksManager,
   RegisteredHookFunction,
   RegisterHookFunctionParams,
+  AnyOnFailureHookFunction,
 } from "./types.js";
 
 export class StandardLifecycleHooksManager implements LifecycleHooksManager {
@@ -13,6 +14,11 @@ export class StandardLifecycleHooksManager implements LifecycleHooksManager {
   private globalStartHooks: Map<string, RegisteredHookFunction<AnyOnStartHookFunction>> = new Map();
   private taskStartHooks: Map<string, RegisteredHookFunction<AnyOnStartHookFunction>> = new Map();
 
+  private globalFailureHooks: Map<string, RegisteredHookFunction<AnyOnFailureHookFunction>> =
+    new Map();
+  private taskFailureHooks: Map<string, RegisteredHookFunction<AnyOnFailureHookFunction>> =
+    new Map();
+
   registerGlobalStartHook(hook: RegisterHookFunctionParams<AnyOnStartHookFunction>): void {
     const id = generateHookId(hook);
 
@@ -77,6 +83,37 @@ export class StandardLifecycleHooksManager implements LifecycleHooksManager {
   getGlobalInitHooks(): RegisteredHookFunction<AnyOnInitHookFunction>[] {
     return Array.from(this.globalInitHooks.values());
   }
+
+  registerGlobalFailureHook(hook: RegisterHookFunctionParams<AnyOnFailureHookFunction>): void {
+    const id = generateHookId(hook);
+
+    this.globalFailureHooks.set(id, {
+      id,
+      name: hook.id ?? hook.fn.name ? (hook.fn.name === "" ? undefined : hook.fn.name) : undefined,
+      fn: hook.fn,
+    });
+  }
+
+  registerTaskFailureHook(
+    taskId: string,
+    hook: RegisterHookFunctionParams<AnyOnFailureHookFunction>
+  ): void {
+    const id = generateHookId(hook);
+
+    this.taskFailureHooks.set(taskId, {
+      id,
+      name: hook.id ?? hook.fn.name ? (hook.fn.name === "" ? undefined : hook.fn.name) : undefined,
+      fn: hook.fn,
+    });
+  }
+
+  getTaskFailureHook(taskId: string): AnyOnFailureHookFunction | undefined {
+    return this.taskFailureHooks.get(taskId)?.fn;
+  }
+
+  getGlobalFailureHooks(): RegisteredHookFunction<AnyOnFailureHookFunction>[] {
+    return Array.from(this.globalFailureHooks.values());
+  }
 }
 
 export class NoopLifecycleHooksManager implements LifecycleHooksManager {
@@ -117,6 +154,25 @@ export class NoopLifecycleHooksManager implements LifecycleHooksManager {
   getGlobalStartHooks(): RegisteredHookFunction<AnyOnStartHookFunction>[] {
     return [];
   }
+
+  registerGlobalFailureHook(hook: RegisterHookFunctionParams<AnyOnFailureHookFunction>): void {
+    // Noop
+  }
+
+  registerTaskFailureHook(
+    taskId: string,
+    hook: RegisterHookFunctionParams<AnyOnFailureHookFunction>
+  ): void {
+    // Noop
+  }
+
+  getTaskFailureHook(taskId: string): AnyOnFailureHookFunction | undefined {
+    return undefined;
+  }
+
+  getGlobalFailureHooks(): RegisteredHookFunction<AnyOnFailureHookFunction>[] {
+    return [];
+  }
 }
 
 function generateHookId(hook: RegisterHookFunctionParams<any>): string {

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

@@ -26,6 +26,20 @@ export type OnStartHookFunction<TPayload> = (
 
 export type AnyOnStartHookFunction = OnStartHookFunction<unknown>;
 
+export type TaskFailureHookParams<TPayload = unknown> = {
+  ctx: TaskRunContext;
+  payload: TPayload;
+  task: string;
+  error: unknown;
+  signal?: AbortSignal;
+};
+
+export type OnFailureHookFunction<TPayload> = (
+  params: TaskFailureHookParams<TPayload>
+) => undefined | void | Promise<undefined | void>;
+
+export type AnyOnFailureHookFunction = OnFailureHookFunction<unknown>;
+
 export type RegisterHookFunctionParams<THookFunction extends (params: any) => any> = {
   id?: string;
   fn: THookFunction;
@@ -52,4 +66,11 @@ export interface LifecycleHooksManager {
   ): void;
   getTaskStartHook(taskId: string): AnyOnStartHookFunction | undefined;
   getGlobalStartHooks(): RegisteredHookFunction<AnyOnStartHookFunction>[];
+  registerGlobalFailureHook(hook: RegisterHookFunctionParams<AnyOnFailureHookFunction>): void;
+  registerTaskFailureHook(
+    taskId: string,
+    hook: RegisterHookFunctionParams<AnyOnFailureHookFunction>
+  ): void;
+  getTaskFailureHook(taskId: string): AnyOnFailureHookFunction | undefined;
+  getGlobalFailureHooks(): RegisteredHookFunction<AnyOnFailureHookFunction>[];
 }

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

@@ -6,6 +6,7 @@ import {
   type AnyOnStartHookFunction,
   type TaskStartHookParams,
   type OnStartHookFunction,
+  type AnyOnFailureHookFunction,
 } from "@trigger.dev/core/v3";
 
 export type {
@@ -15,6 +16,7 @@ export type {
   AnyOnStartHookFunction,
   TaskStartHookParams,
   OnStartHookFunction,
+  AnyOnFailureHookFunction,
 };
 
 export function onInit(name: string, fn: AnyOnInitHookFunction): void;
@@ -37,3 +39,15 @@ export function onStart(
     fn: typeof fnOrName === "function" ? fnOrName : fn!,
   });
 }
+
+export function onFailure(name: string, fn: AnyOnFailureHookFunction): void;
+export function onFailure(fn: AnyOnFailureHookFunction): void;
+export function onFailure(
+  fnOrName: string | AnyOnFailureHookFunction,
+  fn?: AnyOnFailureHookFunction
+): void {
+  lifecycleHooks.registerGlobalFailureHook({
+    id: typeof fnOrName === "string" ? fnOrName : fnOrName.name ? fnOrName.name : undefined,
+    fn: typeof fnOrName === "function" ? fnOrName : fn!,
+  });
+}

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

@@ -1,4 +1,4 @@
-import { onInit, onStart } from "./hooks.js";
+import { onInit, onStart, onFailure } from "./hooks.js";
 import {
   batchTrigger,
   batchTriggerAndWait,
@@ -81,4 +81,5 @@ export const tasks = {
   batchTriggerAndWait,
   init: onInit,
   onStart,
+  onFailure,
 };