feat!: trigger run will now return workflow handle

package.json

@@ -1,6 +1,6 @@
 {
   "name": "simple-workflows",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Workflows as code in TypeScript",
   "main": "lib/index.js",
   "type": "module",

src/triggers/startup.ts

@@ -1,12 +1,11 @@
-import { nanoid } from "nanoid";
 import type { Trigger } from "../workflows/index.js";
 
 export const startup = () => {
     return {
         name: "startup",
         options: undefined,
         description: "Trigger runs on application startup",
-        start: async (workflow: { name: string }, run: (id: string, _: any) => Promise<void>) => {
+        start: async (workflow: { name: string }, run) => {
             const id = new Date().getTime().toString();
             void run(id, undefined);
             return Promise.resolve();

src/worker/IWorker.ts

@@ -1,5 +1,5 @@
 import { type IWorkflowHistoryStore } from "../stores/IWorkflowHistoryStore.js";
-import { type BaseWorkflowHandle, type WorkflowFunction } from "./WorkflowFunction.js";
+import { type WorkflowHandle, type WorkflowFunction } from "./WorkflowFunction.js";
 
 export declare type WithWorkflowArgs<W extends WorkflowFunction, T> = T & (Parameters<W> extends [any, ...any[]] ? {
     /**
@@ -28,7 +28,7 @@ export declare type WorkflowOptions = {
 export declare type WorkflowStartOptions<T extends WorkflowFunction = WorkflowFunction> = WithWorkflowArgs<T, WorkflowOptions>;
 
 export interface IWorker {
-    start: <T extends WorkflowFunction>(workflow: T, options?: WorkflowStartOptions<T>) => Promise<BaseWorkflowHandle<T>>
+    start: <T extends WorkflowFunction>(workflow: T, options?: WorkflowStartOptions<T>) => Promise<WorkflowHandle<T>>
     store: IWorkflowHistoryStore
     log?: (s: string) => void
 }

src/worker/Worker.ts

@@ -2,7 +2,7 @@ import { AsyncLocalStorage } from "async_hooks";
 import { type IWorkflowContext } from "./IWorkflowContext.js";
 import { type IWorkflowHistoryStore } from "../stores/IWorkflowHistoryStore.js";
 import { MemoryWorkflowHistoryStore } from "../stores/MemoryWorkflowHistoryStore.js";
-import { type BaseWorkflowHandle, type WorkflowFunction, type WorkflowResultType, type WorkflowFunctionReturnType } from "./WorkflowFunction.js";
+import { type WorkflowHandle, type WorkflowFunction, type WorkflowResultType, type WorkflowFunctionReturnType } from "./WorkflowFunction.js";
 import msPkg from "ms";
 import { Mutex } from "async-mutex";
 import { sleep } from "../sleep.js";
@@ -28,7 +28,7 @@ export class Worker implements IWorker {
         return Worker.instance;
     }
 
-    public async start<T extends WorkflowFunction>(workflow: T, options?: WorkflowStartOptions<T>): Promise<BaseWorkflowHandle<T>> {
+    public async start<T extends WorkflowFunction>(workflow: T, options?: WorkflowStartOptions<T>): Promise<WorkflowHandle<T>> {
         let workflowId = "workflow-" + nanoid();
         if (options?.workflowId) {
             workflowId = options.workflowId;

src/worker/WorkflowFunction.ts

@@ -1,12 +1,12 @@
 import { type IWorkflowHistoryStore } from "../stores/IWorkflowHistoryStore.js";
 
-export declare type WorkflowFunctionReturnType = Promise<any>;
+export type WorkflowFunctionReturnType = Promise<any>;
 
-export declare type WorkflowFunction = (...args: any[]) => WorkflowFunctionReturnType;
+export type WorkflowFunction = (...args: any[]) => WorkflowFunctionReturnType;
 
-export declare type WorkflowResultType<W extends WorkflowFunction> = ReturnType<W> extends Promise<infer R> ? R : never;
+export type WorkflowResultType<W extends WorkflowFunction> = ReturnType<W> extends Promise<infer R> ? R : never;
 
-export interface BaseWorkflowHandle<T extends WorkflowFunction> {
+export type WorkflowHandle<T extends WorkflowFunction> = {
     result: () => Promise<WorkflowResultType<T>>
     store?: IWorkflowHistoryStore
     readonly workflowId: string

src/workflows/index.ts

@@ -2,12 +2,13 @@ import { Worker as WorkflowWorker } from "../worker/Worker.js";
 import { proxyActivities } from "../proxy/proxyActivities.js";
 import { OnlyAsync } from "../types/OnlyAsync.js";
 import { nanoid } from "nanoid";
+import { WorkflowHandle } from "../worker/WorkflowFunction.js";
 
 export type Trigger<P> = {
     name: string,
     options: any,
     description?: string,
-    start: (workflow: any, run: (id: string, triggerData: P) => Promise<void>) => void | Promise<void>;
+    start: (workflow: any, run: (id: string, triggerData: P) => Promise<WorkflowHandle<(triggerData: P) => any> | undefined>) => void | Promise<void>;
     stop?: (workflow: any) => void | Promise<void>;
 };
 
@@ -28,7 +29,7 @@ export const workflows = new Map<string, Workflow<any, any>>();
 export const workflow = <S extends Record<string, any>, P = void>(workflow: Workflow<S, P>) => {
     workflows.set(workflow.name, workflow);
 
-    const runInternal = (id: string) => (services: S) => async (triggerData: P) => {
+    const runInternal = async (id: string, services: S, triggerData: P): Promise<WorkflowHandle<(triggerData: P) => any>> => {
         // Proxy services
         const proxies = {} as any;
         Object.keys(services).forEach((key) => {
@@ -40,7 +41,7 @@ export const workflow = <S extends Record<string, any>, P = void>(workflow: Work
             workflowId: `${workflow.name} ${id}`,
             args: [triggerData],
         });
-        return handle.result();
+        return handle;
     }
 
     return {
@@ -52,18 +53,20 @@ export const workflow = <S extends Record<string, any>, P = void>(workflow: Work
                     worker.log?.(`Workflow '${workflow.name}' disabled, skip`);
                     return;
                 }
-                runInternal(id)(workflow.services)(payload);
+                return runInternal(id, workflow.services, payload);
             }
 
             await workflow.trigger.start(workflow, run);
         },
         // Run workflow
         run: (services: S) => async (triggerData: P) => {
-            return await runInternal(nanoid())(services)(triggerData);
+            const handle = await runInternal(nanoid(), services, triggerData);
+            return await handle.result();
         },
         // Invoke workflow with trigger data
         invoke: async (triggerData: P) => {
-            return await runInternal(nanoid())(workflow.services)(triggerData);
+            const handle = await runInternal(nanoid(), workflow.services, triggerData);
+            return await handle.result();
         },
     };
 };