onStart

Author: ericallam

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

@@ -3,6 +3,7 @@ import {
   AnyOnInitHookFunction,
   AnyOnStartHookFunction,
   AnyOnFailureHookFunction,
+  AnyOnSuccessHookFunction,
 } from "./types.js";
 
 export function createInitHookAdapter<TPayload>(
@@ -47,3 +48,22 @@ export function createFailureHookAdapter<TPayload>(
     return await fn(params.payload as unknown as TPayload, params.error, paramsWithoutPayload);
   };
 }
+
+export function createSuccessHookAdapter<TPayload, TOutput>(
+  fn: NonNullable<TaskOptions<string, TPayload, TOutput, any>["onSuccess"]>
+): AnyOnSuccessHookFunction {
+  return async (params) => {
+    const paramsWithoutPayload = {
+      ...params,
+    };
+
+    delete paramsWithoutPayload["payload"];
+    delete paramsWithoutPayload["output"];
+
+    return await fn(
+      params.payload as unknown as TPayload,
+      params.output as unknown as TOutput,
+      paramsWithoutPayload
+    );
+  };
+}

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

@@ -5,6 +5,7 @@ import {
   RegisteredHookFunction,
   RegisterHookFunctionParams,
   AnyOnFailureHookFunction,
+  AnyOnSuccessHookFunction,
 } from "./types.js";
 
 export class StandardLifecycleHooksManager implements LifecycleHooksManager {
@@ -19,6 +20,11 @@ export class StandardLifecycleHooksManager implements LifecycleHooksManager {
   private taskFailureHooks: Map<string, RegisteredHookFunction<AnyOnFailureHookFunction>> =
     new Map();
 
+  private globalSuccessHooks: Map<string, RegisteredHookFunction<AnyOnSuccessHookFunction>> =
+    new Map();
+  private taskSuccessHooks: Map<string, RegisteredHookFunction<AnyOnSuccessHookFunction>> =
+    new Map();
+
   registerGlobalStartHook(hook: RegisterHookFunctionParams<AnyOnStartHookFunction>): void {
     const id = generateHookId(hook);
 
@@ -114,6 +120,37 @@ export class StandardLifecycleHooksManager implements LifecycleHooksManager {
   getGlobalFailureHooks(): RegisteredHookFunction<AnyOnFailureHookFunction>[] {
     return Array.from(this.globalFailureHooks.values());
   }
+
+  registerGlobalSuccessHook(hook: RegisterHookFunctionParams<AnyOnSuccessHookFunction>): void {
+    const id = generateHookId(hook);
+
+    this.globalSuccessHooks.set(id, {
+      id,
+      name: hook.id ?? hook.fn.name ? (hook.fn.name === "" ? undefined : hook.fn.name) : undefined,
+      fn: hook.fn,
+    });
+  }
+
+  registerTaskSuccessHook(
+    taskId: string,
+    hook: RegisterHookFunctionParams<AnyOnSuccessHookFunction>
+  ): void {
+    const id = generateHookId(hook);
+
+    this.taskSuccessHooks.set(taskId, {
+      id,
+      name: hook.id ?? hook.fn.name ? (hook.fn.name === "" ? undefined : hook.fn.name) : undefined,
+      fn: hook.fn,
+    });
+  }
+
+  getTaskSuccessHook(taskId: string): AnyOnSuccessHookFunction | undefined {
+    return this.taskSuccessHooks.get(taskId)?.fn;
+  }
+
+  getGlobalSuccessHooks(): RegisteredHookFunction<AnyOnSuccessHookFunction>[] {
+    return Array.from(this.globalSuccessHooks.values());
+  }
 }
 
 export class NoopLifecycleHooksManager implements LifecycleHooksManager {
@@ -173,6 +210,25 @@ export class NoopLifecycleHooksManager implements LifecycleHooksManager {
   getGlobalFailureHooks(): RegisteredHookFunction<AnyOnFailureHookFunction>[] {
     return [];
   }
+
+  registerGlobalSuccessHook(hook: RegisterHookFunctionParams<AnyOnSuccessHookFunction>): void {
+    // Noop
+  }
+
+  registerTaskSuccessHook(
+    taskId: string,
+    hook: RegisterHookFunctionParams<AnyOnSuccessHookFunction>
+  ): void {
+    // Noop
+  }
+
+  getTaskSuccessHook(taskId: string): AnyOnSuccessHookFunction | undefined {
+    return undefined;
+  }
+
+  getGlobalSuccessHooks(): RegisteredHookFunction<AnyOnSuccessHookFunction>[] {
+    return [];
+  }
 }
 
 function generateHookId(hook: RegisterHookFunctionParams<any>): string {

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

@@ -40,6 +40,20 @@ export type OnFailureHookFunction<TPayload> = (
 
 export type AnyOnFailureHookFunction = OnFailureHookFunction<unknown>;
 
+export type TaskSuccessHookParams<TPayload = unknown, TOutput = unknown> = {
+  ctx: TaskRunContext;
+  payload: TPayload;
+  task: string;
+  output: TOutput;
+  signal?: AbortSignal;
+};
+
+export type OnSuccessHookFunction<TPayload, TOutput> = (
+  params: TaskSuccessHookParams<TPayload, TOutput>
+) => undefined | void | Promise<undefined | void>;
+
+export type AnyOnSuccessHookFunction = OnSuccessHookFunction<unknown, unknown>;
+
 export type RegisterHookFunctionParams<THookFunction extends (params: any) => any> = {
   id?: string;
   fn: THookFunction;
@@ -73,4 +87,11 @@ export interface LifecycleHooksManager {
   ): void;
   getTaskFailureHook(taskId: string): AnyOnFailureHookFunction | undefined;
   getGlobalFailureHooks(): RegisteredHookFunction<AnyOnFailureHookFunction>[];
+  registerGlobalSuccessHook(hook: RegisterHookFunctionParams<AnyOnSuccessHookFunction>): void;
+  registerTaskSuccessHook(
+    taskId: string,
+    hook: RegisterHookFunctionParams<AnyOnSuccessHookFunction>
+  ): void;
+  getTaskSuccessHook(taskId: string): AnyOnSuccessHookFunction | undefined;
+  getGlobalSuccessHooks(): RegisteredHookFunction<AnyOnSuccessHookFunction>[];
 }

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

@@ -7,6 +7,7 @@ import {
   type TaskStartHookParams,
   type OnStartHookFunction,
   type AnyOnFailureHookFunction,
+  type AnyOnSuccessHookFunction,
 } from "@trigger.dev/core/v3";
 
 export type {
@@ -17,6 +18,7 @@ export type {
   TaskStartHookParams,
   OnStartHookFunction,
   AnyOnFailureHookFunction,
+  AnyOnSuccessHookFunction,
 };
 
 export function onInit(name: string, fn: AnyOnInitHookFunction): void;
@@ -51,3 +53,15 @@ export function onFailure(
     fn: typeof fnOrName === "function" ? fnOrName : fn!,
   });
 }
+
+export function onSuccess(name: string, fn: AnyOnSuccessHookFunction): void;
+export function onSuccess(fn: AnyOnSuccessHookFunction): void;
+export function onSuccess(
+  fnOrName: string | AnyOnSuccessHookFunction,
+  fn?: AnyOnSuccessHookFunction
+): void {
+  lifecycleHooks.registerGlobalSuccessHook({
+    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, onFailure } from "./hooks.js";
+import { onInit, onStart, onFailure, onSuccess } from "./hooks.js";
 import {
   batchTrigger,
   batchTriggerAndWait,
@@ -82,4 +82,5 @@ export const tasks = {
   init: onInit,
   onStart,
   onFailure,
+  onSuccess,
 };