@yieldstar/core 0.1.3 → 0.2.0-alpha.0

package/dist/index.js

@@ -96,27 +96,22 @@ class WorkflowRunner {
     this.schedulerClient = params.schedulerClient;
     this.router = params.router;
   }
-  run = async (task, logger) => {
-    const { workflowId, executionId } = task;
-    const workflow = this.router[workflowId];
+  run = async (event, logger) => {
+    const workflow = this.router[event.workflowId];
     if (!workflow) {
-      throw new Error(`No workflow registered for "${workflowId}"`);
+      throw new Error(`No workflow registered for "${event.workflowId}"`);
     }
     try {
       const response = await this.runWorkflows({
-        executionId,
         workflow,
-        logger
+        logger,
+        event
       });
       switch (response.type) {
         case "workflow-result":
           return response;
         case "workflow-delay":
-          this.schedulerClient.requestWakeUp({
-            workflowId,
-            executionId,
-            resumeIn: response.resumeIn
-          });
+          this.schedulerClient.requestWakeUp(event, response.resumeIn);
           break;
       }
     } catch (err) {
@@ -124,10 +119,10 @@ class WorkflowRunner {
     }
   };
   async runWorkflows(params) {
-    const { executionId, workflow, logger } = params;
+    const { workflow, event, logger } = params;
     const workflowIterator = workflow({
+      event,
       heapClient: this.heapClient,
-      executionId,
       logger
     });
     const iteratorResult = await workflowIterator.next();

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@yieldstar/core",
-  "version": "0.1.3",
+  "version": "0.2.0-alpha.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "src/index.ts",
   "scripts": {
-    "build": "bun build src/index.ts --outfile dist/index.js --target bun --packages=external"
+    "build": "bun build src/index.ts --outfile dist/index.js --target bun --packages=external",
+    "check": "tsc --noEmit"
   },
   "devDependencies": {
     "@types/bun": "latest"

package/src/base/event.ts

@@ -0,0 +1,20 @@
+export type TriggerEvent<
+  WorkflowId extends string,
+  EventParams = any
+> = EventParams extends void
+  ? {
+      workflowId: WorkflowId;
+      executionId?: string;
+      params?: undefined;
+    }
+  : {
+      workflowId: WorkflowId;
+      executionId?: string;
+      params: EventParams;
+    };
+
+export type ExecutionEvent<EventParams = any> = {
+  workflowId: string;
+  executionId: string;
+  params: EventParams;
+};

package/src/base/invoker.ts

@@ -1,7 +1,7 @@
 import type { EventEmitter } from "node:events";
-import type { Task } from "./runtime";
+import type { ExecutionEvent } from "./event";
 
 export type WorkflowInvoker = {
   workflowEndEmitter: EventEmitter;
-  execute(task: Task): Promise<void>;
+  execute<EventParams>(event: ExecutionEvent<EventParams>): Promise<void>;
 };

package/src/base/runtime.ts

@@ -1,9 +1,8 @@
 import type { Logger } from "pino";
 import type { WorkflowResult } from "./step";
+import type { ExecutionEvent } from "./event";
 
-export type Task = { workflowId: string; executionId: string; params?: any };
-
-export type TaskProcessor = <T = any>(
-  task: Task,
+export type EventProcessor<EventParams = any, Result = any> = (
+  event: ExecutionEvent<EventParams>,
   logger: Logger
-) => Promise<void | WorkflowResult<T>>;
+) => Promise<void | WorkflowResult<Result>>;

package/src/base/scheduler.ts

@@ -1,7 +1,8 @@
+import type { ExecutionEvent } from "./event";
+
 export interface SchedulerClient {
-  requestWakeUp(params: {
-    workflowId: string;
-    executionId: string;
-    resumeIn: number;
-  }): Promise<void>;
+  requestWakeUp<EventParams>(
+    event: ExecutionEvent<EventParams>,
+    resumeIn?: number
+  ): Promise<void>;
 }

package/src/base/workflow.ts

@@ -1,17 +1,29 @@
 import type { Logger } from "pino";
 import { HeapClient } from "./heap";
 import { StepResponse, WorkflowResult } from "./step";
+import type { ExecutionEvent } from "./event";
 
-export type WorkflowGenerator<T = any> = (params: {
-  executionId: string;
+export type WorkflowGeneratorParams<EventParams> = {
+  event: ExecutionEvent<EventParams>;
   heapClient: HeapClient;
   logger: Logger;
-}) => AsyncGenerator<StepResponse, WorkflowResult<T>, StepResponse>;
+};
+
+export type WorkflowGenerator<EventParams, Result> = (
+  genParams: WorkflowGeneratorParams<EventParams>
+) => AsyncGenerator<StepResponse, WorkflowResult<Result>, StepResponse>;
 
 export type WorkflowGeneratorReturnType<CG> = CG extends WorkflowGenerator<
-  infer T
+  infer EventParams,
+  infer Result
 >
-  ? T
+  ? Result
   : never;
 
-export type WorkflowRouter = Record<string, WorkflowGenerator>;
+export type WorkflowRouter = Record<string, WorkflowGenerator<any, any>>;
+
+export type EventOfWorkflow<W extends WorkflowGenerator<any, any>> =
+  Parameters<W>[0]["event"];
+
+export type EventParamsOf<W extends WorkflowGenerator<any, any>> =
+  Parameters<W>[0]["event"]["params"];

package/src/index.ts

@@ -1,12 +1,18 @@
 export type { HeapClient, HeapRecord } from "./base/heap";
 export type { WorkflowInvoker } from "./base/invoker";
-export type { Task, TaskProcessor } from "./base/runtime";
+export type { EventProcessor } from "./base/runtime";
 export type { SchedulerClient } from "./base/scheduler";
 export type {
   WorkflowGenerator,
   WorkflowGeneratorReturnType,
   WorkflowRouter,
+  EventOfWorkflow,
+  EventParamsOf,
 } from "./base/workflow";
+export type {
+  TriggerEvent as TriggerEvent,
+  ExecutionEvent as ExecutionEvent,
+} from "./base/event";
 
 export {
   StepCacheCheck,

package/src/lib/workflow-runner.ts

@@ -3,12 +3,13 @@ import type {
   WorkflowGenerator,
   HeapClient,
   SchedulerClient,
-  TaskProcessor,
+  EventProcessor,
+  ExecutionEvent,
 } from "..";
 import { StepDelay, WorkflowDelay, WorkflowResult } from "..";
 
 export class WorkflowRunner<
-  Router extends Record<string, WorkflowGenerator<any>>
+  Router extends Record<string, WorkflowGenerator<any, any>>
 > {
   private heapClient: HeapClient;
   private schedulerClient: SchedulerClient;
@@ -25,19 +26,18 @@ export class WorkflowRunner<
     this.router = params.router;
   }
 
-  run: TaskProcessor = async (task, logger) => {
-    const { workflowId, executionId } = task;
-    const workflow = this.router[workflowId];
+  run: EventProcessor<any, any> = async (event, logger) => {
+    const workflow = this.router[event.workflowId];
 
     if (!workflow) {
-      throw new Error(`No workflow registered for "${workflowId}"`);
+      throw new Error(`No workflow registered for "${event.workflowId}"`);
     }
 
     try {
       const response = await this.runWorkflows({
-        executionId,
         workflow,
         logger,
+        event,
       });
 
       switch (response.type) {
@@ -45,11 +45,7 @@ export class WorkflowRunner<
           return response;
 
         case "workflow-delay":
-          this.schedulerClient.requestWakeUp({
-            workflowId,
-            executionId,
-            resumeIn: response.resumeIn,
-          });
+          this.schedulerClient.requestWakeUp(event, response.resumeIn);
           break;
       }
     } catch (err) {
@@ -58,16 +54,16 @@ export class WorkflowRunner<
     }
   };
 
-  private async runWorkflows<T>(params: {
-    executionId: string;
-    workflow: WorkflowGenerator<T>;
+  private async runWorkflows<EventParams, Result>(params: {
+    workflow: WorkflowGenerator<EventParams, Result>;
+    event: ExecutionEvent<EventParams>;
     logger: Logger;
-  }): Promise<WorkflowResult<T> | WorkflowDelay> {
-    const { executionId, workflow, logger } = params;
+  }): Promise<WorkflowResult<Result> | WorkflowDelay> {
+    const { workflow, event, logger } = params;
 
     const workflowIterator = workflow({
+      event,
       heapClient: this.heapClient,
-      executionId,
       logger,
     });
 
@@ -75,7 +71,7 @@ export class WorkflowRunner<
     const stageResponse = iteratorResult.value;
 
     if (iteratorResult.done) {
-      return stageResponse as WorkflowResult<T>;
+      return stageResponse as WorkflowResult<Result>;
     }
 
     if (stageResponse instanceof StepDelay) {