@yigitahmetsahin/workflow-ts 1.2.1 → 2.1.0

package/README.md

@@ -11,6 +11,7 @@ A simple, extensible TypeScript workflow engine supporting serial and parallel w
 
 - 🔄 **Serial & Parallel Execution** - Chain work items sequentially or run them concurrently
 - 🎯 **Full Type Inference** - Work names and result types are automatically inferred
+- 🧩 **Standalone Work Definitions** - Define works as reusable `Work` instances
 - ⏭️ **Conditional Execution** - Skip work items based on runtime conditions
 - 🛡️ **Error Handling** - Built-in error callbacks and workflow failure states
 - 📊 **Execution Tracking** - Duration tracking for individual works and total workflow
@@ -33,8 +34,9 @@ pnpm add @yigitahmetsahin/workflow-ts
 ## Quick Start
 
 ```typescript
-import { Workflow, WorkflowStatus } from '@yigitahmetsahin/workflow-ts';
+import { Workflow, Work, WorkflowStatus } from '@yigitahmetsahin/workflow-ts';
 
+// Option 1: Define works inline
 const workflow = new Workflow<{ userId: string }>()
   .serial({
     name: 'validate',
@@ -54,17 +56,31 @@ const workflow = new Workflow<{ userId: string }>()
     name: 'process',
     execute: async (ctx) => {
       // ✅ Types are automatically inferred!
-      const orders = ctx.workResults.get('fetchOrders'); // { id: number }[] | undefined
-      const profile = ctx.workResults.get('fetchProfile'); // { name: string; email: string } | undefined
+      // workResults.get() returns IWorkResult with status, result, duration
+      const orders = ctx.workResults.get('fetchOrders').result; // { id: number }[]
+      const profile = ctx.workResults.get('fetchProfile').result; // { name: string; email: string }
       return { orderCount: orders?.length ?? 0, userName: profile?.name };
     },
   });
 
+// Option 2: Define works as reusable Work instances
+const validateUser = new Work({
+  name: 'validate',
+  execute: async (ctx) => ctx.data.userId.length > 0,
+});
+
+const fetchOrders = new Work({
+  name: 'fetchOrders',
+  execute: async (ctx) => [{ id: 1 }, { id: 2 }],
+});
+
+const workflow2 = new Workflow<{ userId: string }>().serial(validateUser).parallel([fetchOrders]);
+
 const result = await workflow.run({ userId: 'user-123' });
 
 if (result.status === WorkflowStatus.COMPLETED) {
   console.log('Workflow completed in', result.totalDuration, 'ms');
-  console.log('Final result:', result.context.workResults.get('process'));
+  console.log('Final result:', result.context.workResults.get('process').result);
 }
 ```
 
@@ -109,6 +125,62 @@ workflow.parallel([
 ]);
 ```
 
+### `Work` Class
+
+Define standalone, reusable work units using the `Work` class:
+
+```typescript
+import { Work, Workflow } from '@yigitahmetsahin/workflow-ts';
+
+// Define works as standalone units
+const fetchUser = new Work({
+  name: 'fetchUser',
+  execute: async (ctx) => {
+    const response = await fetch(`/api/users/${ctx.data.userId}`);
+    return response.json();
+  },
+});
+
+const fetchOrders = new Work({
+  name: 'fetchOrders',
+  execute: async (ctx) => {
+    const response = await fetch(`/api/orders?userId=${ctx.data.userId}`);
+    return response.json();
+  },
+});
+
+// Use them in workflows
+const workflow = new Workflow<{ userId: string }>()
+  .serial(fetchUser)
+  .parallel([fetchOrders, anotherWork]);
+```
+
+Works can be mixed with inline definitions:
+
+```typescript
+workflow
+  .serial(fetchUser) // Work instance
+  .parallel([
+    fetchOrders, // Work instance
+    {
+      // Inline definition
+      name: 'fetchProfile',
+      execute: async (ctx) => ({ name: 'John' }),
+    },
+  ]);
+```
+
+The `Work` class supports all the same options as inline definitions:
+
+```typescript
+const conditionalWork = new Work({
+  name: 'conditionalTask',
+  execute: async (ctx) => 'result',
+  shouldRun: (ctx) => ctx.data.enabled, // Optional condition
+  onError: (error, ctx) => console.error(error), // Optional error handler
+});
+```
+
 ### `.run(initialData)`
 
 Execute the workflow with initial data.
@@ -130,8 +202,37 @@ interface IWorkflowResult {
   totalDuration: number; // Total execution time in ms
   error?: Error; // Error if workflow failed
 }
+
+// Each work result contains execution details
+interface IWorkResult<T> {
+  status: WorkStatus; // 'completed' | 'failed' | 'skipped'
+  result?: T; // The return value from execute()
+  error?: Error; // Error if work failed
+  duration: number; // Execution time in ms
+}
+```
+
+### Accessing Work Results
+
+`ctx.workResults.get()` returns an `IWorkResult` object, not the raw value:
+
+```typescript
+// Get the full work result with metadata
+const workResult = ctx.workResults.get('fetchUser');
+console.log(workResult.status); // 'completed' | 'failed' | 'skipped'
+console.log(workResult.duration); // execution time in ms
+
+// Get just the return value
+const user = ctx.workResults.get('fetchUser').result;
+
+// Check status before accessing result
+if (workResult.status === WorkStatus.COMPLETED) {
+  console.log('User:', workResult.result);
+}
 ```
 
+> **Note:** `workResults.get()` throws an error if called for a work that hasn't executed yet. Use `workResults.has()` to check if a result exists.
+
 ## Conditional Execution
 
 Skip works based on runtime conditions:
@@ -147,6 +248,17 @@ workflow.serial({
 });
 ```
 
+Skipped works are still accessible via `workResults.get()` with `status: 'skipped'`:
+
+```typescript
+const emailResult = ctx.workResults.get('sendEmail');
+if (emailResult.status === WorkStatus.SKIPPED) {
+  console.log('Email was skipped');
+} else if (emailResult.status === WorkStatus.COMPLETED) {
+  console.log('Email sent:', emailResult.result);
+}
+```
+
 ## Error Handling
 
 Handle errors at the work level:

package/dist/index.cjs

@@ -20,9 +20,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  Work: () => Work,
   WorkStatus: () => WorkStatus,
   Workflow: () => Workflow,
-  WorkflowStatus: () => WorkflowStatus
+  WorkflowStatus: () => WorkflowStatus,
+  getWorkDefinition: () => getWorkDefinition
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -43,13 +45,32 @@ var WorkflowStatus = /* @__PURE__ */ ((WorkflowStatus2) => {
   return WorkflowStatus2;
 })(WorkflowStatus || {});
 
+// src/work.ts
+var Work = class {
+  constructor(definition) {
+    this.name = definition.name;
+    this.execute = definition.execute;
+    this.shouldRun = definition.shouldRun;
+    this.onError = definition.onError;
+  }
+};
+function getWorkDefinition(input) {
+  return input;
+}
+
 // src/workflow.ts
 var WorkResultsMap = class {
   constructor() {
     this.map = /* @__PURE__ */ new Map();
   }
   get(name) {
-    return this.map.get(name);
+    const result = this.map.get(name);
+    if (!result) {
+      throw new Error(
+        `Work result "${String(name)}" not found. This work may not have executed yet.`
+      );
+    }
+    return result;
   }
   set(name, value) {
     this.map.set(name, value);
@@ -64,23 +85,25 @@ var Workflow = class {
   }
   /**
    * Add a serial work to the workflow.
+   * Accepts either an inline work definition or a Work instance.
    * The work name and result type are automatically inferred.
    */
   serial(work) {
     this.works.push({
       type: "serial",
-      works: [work]
+      works: [getWorkDefinition(work)]
     });
     return this;
   }
   /**
    * Add parallel works to the workflow.
+   * Accepts either inline work definitions or Work instances.
    * All work names and result types are automatically inferred.
    */
   parallel(works) {
     this.works.push({
       type: "parallel",
-      works
+      works: works.map((w) => getWorkDefinition(w))
     });
     return this;
   }
@@ -126,21 +149,24 @@ var Workflow = class {
     if (work.shouldRun) {
       const shouldRun = await work.shouldRun(context);
       if (!shouldRun) {
-        workResults.set(work.name, {
+        const skippedResult = {
           status: "skipped" /* SKIPPED */,
           duration: Date.now() - workStartTime
-        });
+        };
+        context.workResults.set(work.name, skippedResult);
+        workResults.set(work.name, skippedResult);
         return;
       }
     }
     try {
       const result = await work.execute(context);
-      context.workResults.set(work.name, result);
-      workResults.set(work.name, {
+      const workResult = {
         status: "completed" /* COMPLETED */,
         result,
         duration: Date.now() - workStartTime
-      });
+      };
+      context.workResults.set(work.name, workResult);
+      workResults.set(work.name, workResult);
     } catch (error) {
       const err = error instanceof Error ? error : new Error(String(error));
       workResults.set(work.name, {
@@ -163,10 +189,12 @@ var Workflow = class {
       if (work.shouldRun) {
         const shouldRun = await work.shouldRun(context);
         if (!shouldRun) {
-          workResults.set(work.name, {
+          const skippedResult = {
             status: "skipped" /* SKIPPED */,
             duration: Date.now() - workStartTime
-          });
+          };
+          context.workResults.set(work.name, skippedResult);
+          workResults.set(work.name, skippedResult);
           return { work, skipped: true };
         }
       }
@@ -186,19 +214,21 @@ var Workflow = class {
       }
       const duration = Date.now() - result.startTime;
       if ("error" in result && result.error) {
-        workResults.set(result.work.name, {
+        const workResult = {
           status: "failed" /* FAILED */,
           error: result.error,
           duration
-        });
+        };
+        workResults.set(result.work.name, workResult);
         errors.push({ work: result.work, error: result.error });
       } else {
-        context.workResults.set(result.work.name, result.result);
-        workResults.set(result.work.name, {
+        const workResult = {
           status: "completed" /* COMPLETED */,
           result: result.result,
           duration
-        });
+        };
+        context.workResults.set(result.work.name, workResult);
+        workResults.set(result.work.name, workResult);
       }
     }
     if (errors.length > 0) {
@@ -213,8 +243,10 @@ var Workflow = class {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  Work,
   WorkStatus,
   Workflow,
-  WorkflowStatus
+  WorkflowStatus,
+  getWorkDefinition
 });
 //# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts","../src/workflow.types.ts","../src/workflow.ts"],"sourcesContent":["export * from './workflow';\nexport * from './workflow.types';\n","/**\n * Work Status\n */\nexport enum WorkStatus {\n  PENDING = 'pending',\n  RUNNING = 'running',\n  COMPLETED = 'completed',\n  FAILED = 'failed',\n  SKIPPED = 'skipped',\n}\n\n/**\n * Workflow Status\n */\nexport enum WorkflowStatus {\n  PENDING = 'pending',\n  RUNNING = 'running',\n  COMPLETED = 'completed',\n  FAILED = 'failed',\n}\n\n/**\n * Context passed between workflow works\n * TData is the type of shared data between works\n * TWorkResults is a record mapping work names to their result types\n */\nexport interface IWorkflowContext<\n  TData = Record<string, unknown>,\n  TWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> {\n  /** Shared data between works */\n  data: TData;\n  /** Work-specific results keyed by work name with inferred types */\n  workResults: IWorkResultsMap<TWorkResults>;\n}\n\n/**\n * Type-safe map for work results with automatic type inference\n */\nexport interface IWorkResultsMap<\n  TWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> {\n  get<K extends keyof TWorkResults>(name: K): TWorkResults[K] | undefined;\n  set<K extends keyof TWorkResults>(name: K, value: TWorkResults[K]): void;\n  has(name: keyof TWorkResults): boolean;\n}\n\n/**\n * Result of a single work execution\n */\nexport interface IWorkResult<TResult = unknown> {\n  status: WorkStatus;\n  result?: TResult;\n  error?: Error;\n  duration: number;\n}\n\n/**\n * Definition of a work with inferred name and result type\n */\nexport interface IWorkDefinition<\n  TName extends string,\n  TData = Record<string, unknown>,\n  TResult = unknown,\n  TAvailableWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> {\n  /** Unique name for the work */\n  name: TName;\n  /** Execute function - receives context and returns result */\n  execute: (context: IWorkflowContext<TData, TAvailableWorkResults>) => Promise<TResult>;\n  /** Optional: condition to determine if work should run */\n  shouldRun?: (\n    context: IWorkflowContext<TData, TAvailableWorkResults>\n  ) => boolean | Promise<boolean>;\n  /** Optional: called when work fails */\n  onError?: (\n    error: Error,\n    context: IWorkflowContext<TData, TAvailableWorkResults>\n  ) => void | Promise<void>;\n}\n\n/**\n * Internal work representation\n */\nexport interface IWorkflowWork {\n  type: 'serial' | 'parallel';\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  works: IWorkDefinition<string, any, any, any>[];\n}\n\n/**\n * Result of workflow execution\n */\nexport interface IWorkflowResult<\n  TData = Record<string, unknown>,\n  TWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> {\n  status: WorkflowStatus;\n  context: IWorkflowContext<TData, TWorkResults>;\n  workResults: Map<keyof TWorkResults, IWorkResult>;\n  totalDuration: number;\n  error?: Error;\n}\n","import {\n  IWorkflowContext,\n  IWorkflowResult,\n  IWorkResultsMap,\n  WorkflowStatus,\n  IWorkflowWork,\n  IWorkDefinition,\n  IWorkResult,\n  WorkStatus,\n} from './workflow.types';\n\n/**\n * Internal implementation of IWorkResultsMap using a Map\n */\nclass WorkResultsMap<\n  TWorkResults extends Record<string, unknown>,\n> implements IWorkResultsMap<TWorkResults> {\n  private map = new Map<keyof TWorkResults, unknown>();\n\n  get<K extends keyof TWorkResults>(name: K): TWorkResults[K] | undefined {\n    return this.map.get(name) as TWorkResults[K] | undefined;\n  }\n\n  set<K extends keyof TWorkResults>(name: K, value: TWorkResults[K]): void {\n    this.map.set(name, value);\n  }\n\n  has(name: keyof TWorkResults): boolean {\n    return this.map.has(name);\n  }\n}\n\n/**\n * A simple, extensible workflow engine that supports serial and parallel work execution.\n * Work names and result types are automatically inferred from the workflow definition.\n *\n * @example\n * ```typescript\n * const workflow = new Workflow<{ userId: string }>()\n *   .serial({\n *     name: 'validate',\n *     execute: async (ctx) => true, // returns boolean\n *   })\n *   .parallel([\n *     {\n *       name: 'fetchOrders',\n *       execute: async (ctx) => [{ id: 1 }], // returns Order[]\n *     },\n *     {\n *       name: 'fetchProfile',\n *       execute: async (ctx) => ({ name: 'John' }), // returns Profile\n *     },\n *   ])\n *   .serial({\n *     name: 'process',\n *     execute: async (ctx) => {\n *       // ✅ Autocomplete for names AND types are inferred!\n *       const isValid = ctx.workResults.get('validate');     // boolean | undefined\n *       const orders = ctx.workResults.get('fetchOrders');   // Order[] | undefined\n *       const profile = ctx.workResults.get('fetchProfile'); // Profile | undefined\n *       return { orders, profile };\n *     },\n *   });\n *\n * const result = await workflow.run({ userId: '123' });\n * ```\n */\nexport class Workflow<\n  TData = Record<string, unknown>,\n  TWorkResults extends Record<string, unknown> = NonNullable<unknown>,\n> {\n  private works: IWorkflowWork[] = [];\n\n  /**\n   * Add a serial work to the workflow.\n   * The work name and result type are automatically inferred.\n   */\n  serial<TName extends string, TResult>(\n    work: IWorkDefinition<TName, TData, TResult, TWorkResults>\n  ): Workflow<TData, TWorkResults & { [K in TName]: TResult }> {\n    this.works.push({\n      type: 'serial',\n      works: [work],\n    });\n    return this as unknown as Workflow<TData, TWorkResults & { [K in TName]: TResult }>;\n  }\n\n  /**\n   * Add parallel works to the workflow.\n   * All work names and result types are automatically inferred.\n   */\n  parallel<\n    const TParallelWorks extends readonly IWorkDefinition<string, TData, unknown, TWorkResults>[],\n  >(works: TParallelWorks): Workflow<TData, TWorkResults & ParallelWorksToRecord<TParallelWorks>> {\n    this.works.push({\n      type: 'parallel',\n      works: works as unknown as IWorkDefinition<string, TData, unknown, TWorkResults>[],\n    });\n    return this as unknown as Workflow<TData, TWorkResults & ParallelWorksToRecord<TParallelWorks>>;\n  }\n\n  /**\n   * Execute the workflow with initial data\n   */\n  async run(initialData: TData): Promise<IWorkflowResult<TData, TWorkResults>> {\n    const startTime = Date.now();\n    const context: IWorkflowContext<TData, TWorkResults> = {\n      data: initialData,\n      workResults: new WorkResultsMap<TWorkResults>(),\n    };\n    const workResults = new Map<keyof TWorkResults, IWorkResult>();\n\n    try {\n      for (const workGroup of this.works) {\n        if (workGroup.type === 'serial') {\n          await this.executeWork(workGroup.works[0], context, workResults);\n        } else {\n          await this.executeParallelWorks(workGroup.works, context, workResults);\n        }\n      }\n\n      return {\n        status: WorkflowStatus.COMPLETED,\n        context,\n        workResults,\n        totalDuration: Date.now() - startTime,\n      };\n    } catch (error) {\n      return {\n        status: WorkflowStatus.FAILED,\n        context,\n        workResults,\n        totalDuration: Date.now() - startTime,\n        error: error instanceof Error ? error : new Error(String(error)),\n      };\n    }\n  }\n\n  /**\n   * Execute a single work\n   */\n  private async executeWork(\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    work: IWorkDefinition<string, TData, any, any>,\n    context: IWorkflowContext<TData, TWorkResults>,\n    workResults: Map<keyof TWorkResults, IWorkResult>\n  ): Promise<void> {\n    const workStartTime = Date.now();\n\n    // Check if work should run\n    if (work.shouldRun) {\n      const shouldRun = await work.shouldRun(context);\n      if (!shouldRun) {\n        workResults.set(work.name as keyof TWorkResults, {\n          status: WorkStatus.SKIPPED,\n          duration: Date.now() - workStartTime,\n        });\n        return;\n      }\n    }\n\n    try {\n      const result = await work.execute(context);\n\n      // Store result in context for subsequent works\n      context.workResults.set(work.name as keyof TWorkResults, result);\n\n      workResults.set(work.name as keyof TWorkResults, {\n        status: WorkStatus.COMPLETED,\n        result,\n        duration: Date.now() - workStartTime,\n      });\n    } catch (error) {\n      const err = error instanceof Error ? error : new Error(String(error));\n\n      workResults.set(work.name as keyof TWorkResults, {\n        status: WorkStatus.FAILED,\n        error: err,\n        duration: Date.now() - workStartTime,\n      });\n\n      // Call error handler if provided\n      if (work.onError) {\n        await work.onError(err, context);\n      }\n\n      // Re-throw to stop workflow execution\n      throw err;\n    }\n  }\n\n  /**\n   * Execute multiple works in parallel\n   */\n  private async executeParallelWorks(\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    works: IWorkDefinition<string, TData, any, any>[],\n    context: IWorkflowContext<TData, TWorkResults>,\n    workResults: Map<keyof TWorkResults, IWorkResult>\n  ): Promise<void> {\n    const promises = works.map(async (work) => {\n      const workStartTime = Date.now();\n\n      // Check if work should run\n      if (work.shouldRun) {\n        const shouldRun = await work.shouldRun(context);\n        if (!shouldRun) {\n          workResults.set(work.name as keyof TWorkResults, {\n            status: WorkStatus.SKIPPED,\n            duration: Date.now() - workStartTime,\n          });\n          return { work, skipped: true };\n        }\n      }\n\n      try {\n        const result = await work.execute(context);\n        return { work, result, startTime: workStartTime };\n      } catch (error) {\n        const err = error instanceof Error ? error : new Error(String(error));\n        return { work, error: err, startTime: workStartTime };\n      }\n    });\n\n    const results = await Promise.all(promises);\n\n    // Process results and check for errors\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const errors: { work: IWorkDefinition<string, TData, any, any>; error: Error }[] = [];\n\n    for (const result of results) {\n      if ('skipped' in result && result.skipped) {\n        continue;\n      }\n\n      const duration = Date.now() - result.startTime!;\n\n      if ('error' in result && result.error) {\n        workResults.set(result.work.name as keyof TWorkResults, {\n          status: WorkStatus.FAILED,\n          error: result.error,\n          duration,\n        });\n        errors.push({ work: result.work, error: result.error });\n      } else {\n        context.workResults.set(result.work.name as keyof TWorkResults, result.result);\n        workResults.set(result.work.name as keyof TWorkResults, {\n          status: WorkStatus.COMPLETED,\n          result: result.result,\n          duration,\n        });\n      }\n    }\n\n    // Handle errors after all parallel works complete\n    if (errors.length > 0) {\n      // Call error handlers\n      for (const { work, error } of errors) {\n        if (work.onError) {\n          await work.onError(error, context);\n        }\n      }\n\n      // Throw the first error to stop workflow\n      throw errors[0].error;\n    }\n  }\n}\n\n/**\n * Helper type to extract work results from parallel works array\n * Uses Extract to preserve the specific type for each work name\n */\ntype ParallelWorksToRecord<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  T extends readonly IWorkDefinition<string, any, any, any>[],\n> = {\n  [K in T[number]['name']]: Extract<\n    T[number],\n    { name: K }\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  > extends IWorkDefinition<string, any, infer R, any>\n    ? R\n    : never;\n};\n"],"mappings":"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","names":["WorkStatus","WorkflowStatus"]}
+{"version":3,"sources":["../src/index.ts","../src/workflow.types.ts","../src/work.ts","../src/workflow.ts"],"sourcesContent":["export * from './workflow';\nexport * from './workflow.types';\nexport * from './work';\n","/**\n * Work Status\n */\nexport enum WorkStatus {\n  PENDING = 'pending',\n  RUNNING = 'running',\n  COMPLETED = 'completed',\n  FAILED = 'failed',\n  SKIPPED = 'skipped',\n}\n\n/**\n * Workflow Status\n */\nexport enum WorkflowStatus {\n  PENDING = 'pending',\n  RUNNING = 'running',\n  COMPLETED = 'completed',\n  FAILED = 'failed',\n}\n\n/**\n * Context passed between workflow works\n * TData is the type of shared data between works\n * TWorkResults is a record mapping work names to their result types\n */\nexport interface IWorkflowContext<\n  TData = Record<string, unknown>,\n  TWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> {\n  /** Shared data between works */\n  data: TData;\n  /** Work-specific results keyed by work name with inferred types */\n  workResults: IWorkResultsMap<TWorkResults>;\n}\n\n/**\n * Type-safe map for work results with automatic type inference\n */\nexport interface IWorkResultsMap<\n  TWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> {\n  get<K extends keyof TWorkResults>(name: K): IWorkResult<TWorkResults[K]>;\n  set<K extends keyof TWorkResults>(name: K, value: IWorkResult<TWorkResults[K]>): void;\n  has(name: keyof TWorkResults): boolean;\n}\n\n/**\n * Result of a single work execution\n */\nexport interface IWorkResult<TResult = unknown> {\n  status: WorkStatus;\n  result?: TResult;\n  error?: Error;\n  duration: number;\n}\n\n/**\n * Definition of a work with inferred name and result type\n */\nexport interface IWorkDefinition<\n  TName extends string,\n  TData = Record<string, unknown>,\n  TResult = unknown,\n  TAvailableWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> {\n  /** Unique name for the work */\n  name: TName;\n  /** Execute function - receives context and returns result */\n  execute: (context: IWorkflowContext<TData, TAvailableWorkResults>) => Promise<TResult>;\n  /** Optional: condition to determine if work should run */\n  shouldRun?: (\n    context: IWorkflowContext<TData, TAvailableWorkResults>\n  ) => boolean | Promise<boolean>;\n  /** Optional: called when work fails */\n  onError?: (\n    error: Error,\n    context: IWorkflowContext<TData, TAvailableWorkResults>\n  ) => void | Promise<void>;\n}\n\n/**\n * Internal work representation\n */\nexport interface IWorkflowWork {\n  type: 'serial' | 'parallel';\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  works: IWorkDefinition<string, any, any, any>[];\n}\n\n/**\n * Result of workflow execution\n */\nexport interface IWorkflowResult<\n  TData = Record<string, unknown>,\n  TWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> {\n  status: WorkflowStatus;\n  context: IWorkflowContext<TData, TWorkResults>;\n  workResults: Map<keyof TWorkResults, IWorkResult>;\n  totalDuration: number;\n  error?: Error;\n}\n","import { IWorkDefinition, IWorkflowContext } from './workflow.types';\n\n/**\n * A standalone Work unit that can be added to workflows.\n * Implements IWorkDefinition so it can be used anywhere a work definition is expected.\n *\n * @example\n * ```typescript\n * const fetchUser = new Work({\n *   name: 'fetchUser',\n *   execute: async (ctx) => {\n *     return { id: ctx.data.userId, name: 'John' };\n *   },\n * });\n *\n * const workflow = new Workflow<{ userId: string }>()\n *   .serial(fetchUser)\n *   .parallel([work1, work2]);\n * ```\n */\nexport class Work<\n  TName extends string,\n  TData = Record<string, unknown>,\n  TResult = unknown,\n  TAvailableWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> implements IWorkDefinition<TName, TData, TResult, TAvailableWorkResults> {\n  /** Unique name for the work */\n  readonly name: TName;\n\n  /** Execute function - receives context and returns result */\n  readonly execute: (context: IWorkflowContext<TData, TAvailableWorkResults>) => Promise<TResult>;\n\n  /** Optional: condition to determine if work should run */\n  readonly shouldRun?: (\n    context: IWorkflowContext<TData, TAvailableWorkResults>\n  ) => boolean | Promise<boolean>;\n\n  /** Optional: called when work fails */\n  readonly onError?: (\n    error: Error,\n    context: IWorkflowContext<TData, TAvailableWorkResults>\n  ) => void | Promise<void>;\n\n  constructor(definition: IWorkDefinition<TName, TData, TResult, TAvailableWorkResults>) {\n    this.name = definition.name;\n    this.execute = definition.execute;\n    this.shouldRun = definition.shouldRun;\n    this.onError = definition.onError;\n  }\n}\n\n/**\n * Type that accepts a work definition (either inline object or Work instance).\n * Since Work implements IWorkDefinition, this is simply IWorkDefinition.\n */\nexport type WorkInput<\n  TName extends string,\n  TData = Record<string, unknown>,\n  TResult = unknown,\n  TAvailableWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> = IWorkDefinition<TName, TData, TResult, TAvailableWorkResults>;\n\n/**\n * Helper to get the work definition from a WorkInput.\n * Since Work implements IWorkDefinition, this simply returns the input.\n */\nexport function getWorkDefinition<\n  TName extends string,\n  TData,\n  TResult,\n  TAvailableWorkResults extends Record<string, unknown>,\n>(\n  input: WorkInput<TName, TData, TResult, TAvailableWorkResults>\n): IWorkDefinition<TName, TData, TResult, TAvailableWorkResults> {\n  return input;\n}\n","import {\n  IWorkflowContext,\n  IWorkflowResult,\n  IWorkResultsMap,\n  WorkflowStatus,\n  IWorkflowWork,\n  IWorkDefinition,\n  IWorkResult,\n  WorkStatus,\n} from './workflow.types';\nimport { WorkInput, getWorkDefinition } from './work';\n\n/**\n * Internal implementation of IWorkResultsMap using a Map\n */\nclass WorkResultsMap<\n  TWorkResults extends Record<string, unknown>,\n> implements IWorkResultsMap<TWorkResults> {\n  private map = new Map<keyof TWorkResults, IWorkResult<unknown>>();\n\n  get<K extends keyof TWorkResults>(name: K): IWorkResult<TWorkResults[K]> {\n    const result = this.map.get(name);\n    if (!result) {\n      throw new Error(\n        `Work result \"${String(name)}\" not found. This work may not have executed yet.`\n      );\n    }\n    return result as IWorkResult<TWorkResults[K]>;\n  }\n\n  set<K extends keyof TWorkResults>(name: K, value: IWorkResult<TWorkResults[K]>): void {\n    this.map.set(name, value);\n  }\n\n  has(name: keyof TWorkResults): boolean {\n    return this.map.has(name);\n  }\n}\n\n/**\n * A simple, extensible workflow engine that supports serial and parallel work execution.\n * Work names and result types are automatically inferred from the workflow definition.\n *\n * @example\n * ```typescript\n * const workflow = new Workflow<{ userId: string }>()\n *   .serial({\n *     name: 'validate',\n *     execute: async (ctx) => true, // returns boolean\n *   })\n *   .parallel([\n *     {\n *       name: 'fetchOrders',\n *       execute: async (ctx) => [{ id: 1 }], // returns Order[]\n *     },\n *     {\n *       name: 'fetchProfile',\n *       execute: async (ctx) => ({ name: 'John' }), // returns Profile\n *     },\n *   ])\n *   .serial({\n *     name: 'process',\n *     execute: async (ctx) => {\n *       // ✅ Autocomplete for names AND types are inferred!\n *       const isValid = ctx.workResults.get('validate').result;     // boolean | undefined\n *       const orders = ctx.workResults.get('fetchOrders').result;   // Order[] | undefined\n *       const profile = ctx.workResults.get('fetchProfile').result; // Profile | undefined\n *       return { orders, profile };\n *     },\n *   });\n *\n * const result = await workflow.run({ userId: '123' });\n * ```\n */\nexport class Workflow<\n  TData = Record<string, unknown>,\n  TWorkResults extends Record<string, unknown> = NonNullable<unknown>,\n> {\n  private works: IWorkflowWork[] = [];\n\n  /**\n   * Add a serial work to the workflow.\n   * Accepts either an inline work definition or a Work instance.\n   * The work name and result type are automatically inferred.\n   */\n  serial<TName extends string, TResult>(\n    work: WorkInput<TName, TData, TResult, TWorkResults>\n  ): Workflow<TData, TWorkResults & { [K in TName]: TResult }> {\n    this.works.push({\n      type: 'serial',\n      works: [getWorkDefinition(work)],\n    });\n    return this as unknown as Workflow<TData, TWorkResults & { [K in TName]: TResult }>;\n  }\n\n  /**\n   * Add parallel works to the workflow.\n   * Accepts either inline work definitions or Work instances.\n   * All work names and result types are automatically inferred.\n   */\n  parallel<const TParallelWorks extends readonly WorkInput<string, TData, unknown, TWorkResults>[]>(\n    works: TParallelWorks\n  ): Workflow<TData, TWorkResults & ParallelWorksToRecord<TParallelWorks>> {\n    this.works.push({\n      type: 'parallel',\n      works: works.map((w) => getWorkDefinition(w)) as unknown as IWorkDefinition<\n        string,\n        TData,\n        unknown,\n        TWorkResults\n      >[],\n    });\n    return this as unknown as Workflow<TData, TWorkResults & ParallelWorksToRecord<TParallelWorks>>;\n  }\n\n  /**\n   * Execute the workflow with initial data\n   */\n  async run(initialData: TData): Promise<IWorkflowResult<TData, TWorkResults>> {\n    const startTime = Date.now();\n    const context: IWorkflowContext<TData, TWorkResults> = {\n      data: initialData,\n      workResults: new WorkResultsMap<TWorkResults>(),\n    };\n    const workResults = new Map<keyof TWorkResults, IWorkResult>();\n\n    try {\n      for (const workGroup of this.works) {\n        if (workGroup.type === 'serial') {\n          await this.executeWork(workGroup.works[0], context, workResults);\n        } else {\n          await this.executeParallelWorks(workGroup.works, context, workResults);\n        }\n      }\n\n      return {\n        status: WorkflowStatus.COMPLETED,\n        context,\n        workResults,\n        totalDuration: Date.now() - startTime,\n      };\n    } catch (error) {\n      return {\n        status: WorkflowStatus.FAILED,\n        context,\n        workResults,\n        totalDuration: Date.now() - startTime,\n        error: error instanceof Error ? error : new Error(String(error)),\n      };\n    }\n  }\n\n  /**\n   * Execute a single work\n   */\n  private async executeWork(\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    work: IWorkDefinition<string, TData, any, any>,\n    context: IWorkflowContext<TData, TWorkResults>,\n    workResults: Map<keyof TWorkResults, IWorkResult>\n  ): Promise<void> {\n    const workStartTime = Date.now();\n\n    // Check if work should run\n    if (work.shouldRun) {\n      const shouldRun = await work.shouldRun(context);\n      if (!shouldRun) {\n        const skippedResult: IWorkResult = {\n          status: WorkStatus.SKIPPED,\n          duration: Date.now() - workStartTime,\n        };\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        context.workResults.set(work.name as keyof TWorkResults, skippedResult as any);\n        workResults.set(work.name as keyof TWorkResults, skippedResult);\n        return;\n      }\n    }\n\n    try {\n      const result = await work.execute(context);\n\n      const workResult: IWorkResult = {\n        status: WorkStatus.COMPLETED,\n        result,\n        duration: Date.now() - workStartTime,\n      };\n\n      // Store result in context for subsequent works\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      context.workResults.set(work.name as keyof TWorkResults, workResult as any);\n      workResults.set(work.name as keyof TWorkResults, workResult);\n    } catch (error) {\n      const err = error instanceof Error ? error : new Error(String(error));\n\n      workResults.set(work.name as keyof TWorkResults, {\n        status: WorkStatus.FAILED,\n        error: err,\n        duration: Date.now() - workStartTime,\n      });\n\n      // Call error handler if provided\n      if (work.onError) {\n        await work.onError(err, context);\n      }\n\n      // Re-throw to stop workflow execution\n      throw err;\n    }\n  }\n\n  /**\n   * Execute multiple works in parallel\n   */\n  private async executeParallelWorks(\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    works: IWorkDefinition<string, TData, any, any>[],\n    context: IWorkflowContext<TData, TWorkResults>,\n    workResults: Map<keyof TWorkResults, IWorkResult>\n  ): Promise<void> {\n    const promises = works.map(async (work) => {\n      const workStartTime = Date.now();\n\n      // Check if work should run\n      if (work.shouldRun) {\n        const shouldRun = await work.shouldRun(context);\n        if (!shouldRun) {\n          const skippedResult: IWorkResult = {\n            status: WorkStatus.SKIPPED,\n            duration: Date.now() - workStartTime,\n          };\n          // eslint-disable-next-line @typescript-eslint/no-explicit-any\n          context.workResults.set(work.name as keyof TWorkResults, skippedResult as any);\n          workResults.set(work.name as keyof TWorkResults, skippedResult);\n          return { work, skipped: true };\n        }\n      }\n\n      try {\n        const result = await work.execute(context);\n        return { work, result, startTime: workStartTime };\n      } catch (error) {\n        const err = error instanceof Error ? error : new Error(String(error));\n        return { work, error: err, startTime: workStartTime };\n      }\n    });\n\n    const results = await Promise.all(promises);\n\n    // Process results and check for errors\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const errors: { work: IWorkDefinition<string, TData, any, any>; error: Error }[] = [];\n\n    for (const result of results) {\n      if ('skipped' in result && result.skipped) {\n        continue;\n      }\n\n      const duration = Date.now() - result.startTime!;\n\n      if ('error' in result && result.error) {\n        const workResult: IWorkResult = {\n          status: WorkStatus.FAILED,\n          error: result.error,\n          duration,\n        };\n        workResults.set(result.work.name as keyof TWorkResults, workResult);\n        errors.push({ work: result.work, error: result.error });\n      } else {\n        const workResult: IWorkResult = {\n          status: WorkStatus.COMPLETED,\n          result: result.result,\n          duration,\n        };\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        context.workResults.set(result.work.name as keyof TWorkResults, workResult as any);\n        workResults.set(result.work.name as keyof TWorkResults, workResult);\n      }\n    }\n\n    // Handle errors after all parallel works complete\n    if (errors.length > 0) {\n      // Call error handlers\n      for (const { work, error } of errors) {\n        if (work.onError) {\n          await work.onError(error, context);\n        }\n      }\n\n      // Throw the first error to stop workflow\n      throw errors[0].error;\n    }\n  }\n}\n\n/**\n * Helper type to extract work results from parallel works array.\n * Since Work implements IWorkDefinition, we can use Extract directly.\n */\ntype ParallelWorksToRecord<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  T extends readonly IWorkDefinition<string, any, any, any>[],\n> = {\n  [K in T[number]['name']]: Extract<\n    T[number],\n    { name: K }\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  > extends IWorkDefinition<string, any, infer R, any>\n    ? R\n    : never;\n};\n"],"mappings":"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","names":["WorkStatus","WorkflowStatus"]}

package/dist/index.d.cts

@@ -32,8 +32,8 @@ interface IWorkflowContext<TData = Record<string, unknown>, TWorkResults extends
  * Type-safe map for work results with automatic type inference
  */
 interface IWorkResultsMap<TWorkResults extends Record<string, unknown> = Record<string, unknown>> {
-    get<K extends keyof TWorkResults>(name: K): TWorkResults[K] | undefined;
-    set<K extends keyof TWorkResults>(name: K, value: TWorkResults[K]): void;
+    get<K extends keyof TWorkResults>(name: K): IWorkResult<TWorkResults[K]>;
+    set<K extends keyof TWorkResults>(name: K, value: IWorkResult<TWorkResults[K]>): void;
     has(name: keyof TWorkResults): boolean;
 }
 /**
@@ -76,6 +76,46 @@ interface IWorkflowResult<TData = Record<string, unknown>, TWorkResults extends
     error?: Error;
 }
 
+/**
+ * A standalone Work unit that can be added to workflows.
+ * Implements IWorkDefinition so it can be used anywhere a work definition is expected.
+ *
+ * @example
+ * ```typescript
+ * const fetchUser = new Work({
+ *   name: 'fetchUser',
+ *   execute: async (ctx) => {
+ *     return { id: ctx.data.userId, name: 'John' };
+ *   },
+ * });
+ *
+ * const workflow = new Workflow<{ userId: string }>()
+ *   .serial(fetchUser)
+ *   .parallel([work1, work2]);
+ * ```
+ */
+declare class Work<TName extends string, TData = Record<string, unknown>, TResult = unknown, TAvailableWorkResults extends Record<string, unknown> = Record<string, unknown>> implements IWorkDefinition<TName, TData, TResult, TAvailableWorkResults> {
+    /** Unique name for the work */
+    readonly name: TName;
+    /** Execute function - receives context and returns result */
+    readonly execute: (context: IWorkflowContext<TData, TAvailableWorkResults>) => Promise<TResult>;
+    /** Optional: condition to determine if work should run */
+    readonly shouldRun?: (context: IWorkflowContext<TData, TAvailableWorkResults>) => boolean | Promise<boolean>;
+    /** Optional: called when work fails */
+    readonly onError?: (error: Error, context: IWorkflowContext<TData, TAvailableWorkResults>) => void | Promise<void>;
+    constructor(definition: IWorkDefinition<TName, TData, TResult, TAvailableWorkResults>);
+}
+/**
+ * Type that accepts a work definition (either inline object or Work instance).
+ * Since Work implements IWorkDefinition, this is simply IWorkDefinition.
+ */
+type WorkInput<TName extends string, TData = Record<string, unknown>, TResult = unknown, TAvailableWorkResults extends Record<string, unknown> = Record<string, unknown>> = IWorkDefinition<TName, TData, TResult, TAvailableWorkResults>;
+/**
+ * Helper to get the work definition from a WorkInput.
+ * Since Work implements IWorkDefinition, this simply returns the input.
+ */
+declare function getWorkDefinition<TName extends string, TData, TResult, TAvailableWorkResults extends Record<string, unknown>>(input: WorkInput<TName, TData, TResult, TAvailableWorkResults>): IWorkDefinition<TName, TData, TResult, TAvailableWorkResults>;
+
 /**
  * A simple, extensible workflow engine that supports serial and parallel work execution.
  * Work names and result types are automatically inferred from the workflow definition.
@@ -101,9 +141,9 @@ interface IWorkflowResult<TData = Record<string, unknown>, TWorkResults extends
  *     name: 'process',
  *     execute: async (ctx) => {
  *       // ✅ Autocomplete for names AND types are inferred!
- *       const isValid = ctx.workResults.get('validate');     // boolean | undefined
- *       const orders = ctx.workResults.get('fetchOrders');   // Order[] | undefined
- *       const profile = ctx.workResults.get('fetchProfile'); // Profile | undefined
+ *       const isValid = ctx.workResults.get('validate').result;     // boolean | undefined
+ *       const orders = ctx.workResults.get('fetchOrders').result;   // Order[] | undefined
+ *       const profile = ctx.workResults.get('fetchProfile').result; // Profile | undefined
  *       return { orders, profile };
  *     },
  *   });
@@ -115,16 +155,18 @@ declare class Workflow<TData = Record<string, unknown>, TWorkResults extends Rec
     private works;
     /**
      * Add a serial work to the workflow.
+     * Accepts either an inline work definition or a Work instance.
      * The work name and result type are automatically inferred.
      */
-    serial<TName extends string, TResult>(work: IWorkDefinition<TName, TData, TResult, TWorkResults>): Workflow<TData, TWorkResults & {
+    serial<TName extends string, TResult>(work: WorkInput<TName, TData, TResult, TWorkResults>): Workflow<TData, TWorkResults & {
         [K in TName]: TResult;
     }>;
     /**
      * Add parallel works to the workflow.
+     * Accepts either inline work definitions or Work instances.
      * All work names and result types are automatically inferred.
      */
-    parallel<const TParallelWorks extends readonly IWorkDefinition<string, TData, unknown, TWorkResults>[]>(works: TParallelWorks): Workflow<TData, TWorkResults & ParallelWorksToRecord<TParallelWorks>>;
+    parallel<const TParallelWorks extends readonly WorkInput<string, TData, unknown, TWorkResults>[]>(works: TParallelWorks): Workflow<TData, TWorkResults & ParallelWorksToRecord<TParallelWorks>>;
     /**
      * Execute the workflow with initial data
      */
@@ -139,8 +181,8 @@ declare class Workflow<TData = Record<string, unknown>, TWorkResults extends Rec
     private executeParallelWorks;
 }
 /**
- * Helper type to extract work results from parallel works array
- * Uses Extract to preserve the specific type for each work name
+ * Helper type to extract work results from parallel works array.
+ * Since Work implements IWorkDefinition, we can use Extract directly.
  */
 type ParallelWorksToRecord<T extends readonly IWorkDefinition<string, any, any, any>[]> = {
     [K in T[number]['name']]: Extract<T[number], {
@@ -148,4 +190,4 @@ type ParallelWorksToRecord<T extends readonly IWorkDefinition<string, any, any,
     }> extends IWorkDefinition<string, any, infer R, any> ? R : never;
 };
 
-export { type IWorkDefinition, type IWorkResult, type IWorkResultsMap, type IWorkflowContext, type IWorkflowResult, type IWorkflowWork, WorkStatus, Workflow, WorkflowStatus };
+export { type IWorkDefinition, type IWorkResult, type IWorkResultsMap, type IWorkflowContext, type IWorkflowResult, type IWorkflowWork, Work, type WorkInput, WorkStatus, Workflow, WorkflowStatus, getWorkDefinition };

package/dist/index.d.ts

@@ -32,8 +32,8 @@ interface IWorkflowContext<TData = Record<string, unknown>, TWorkResults extends
  * Type-safe map for work results with automatic type inference
  */
 interface IWorkResultsMap<TWorkResults extends Record<string, unknown> = Record<string, unknown>> {
-    get<K extends keyof TWorkResults>(name: K): TWorkResults[K] | undefined;
-    set<K extends keyof TWorkResults>(name: K, value: TWorkResults[K]): void;
+    get<K extends keyof TWorkResults>(name: K): IWorkResult<TWorkResults[K]>;
+    set<K extends keyof TWorkResults>(name: K, value: IWorkResult<TWorkResults[K]>): void;
     has(name: keyof TWorkResults): boolean;
 }
 /**
@@ -76,6 +76,46 @@ interface IWorkflowResult<TData = Record<string, unknown>, TWorkResults extends
     error?: Error;
 }
 
+/**
+ * A standalone Work unit that can be added to workflows.
+ * Implements IWorkDefinition so it can be used anywhere a work definition is expected.
+ *
+ * @example
+ * ```typescript
+ * const fetchUser = new Work({
+ *   name: 'fetchUser',
+ *   execute: async (ctx) => {
+ *     return { id: ctx.data.userId, name: 'John' };
+ *   },
+ * });
+ *
+ * const workflow = new Workflow<{ userId: string }>()
+ *   .serial(fetchUser)
+ *   .parallel([work1, work2]);
+ * ```
+ */
+declare class Work<TName extends string, TData = Record<string, unknown>, TResult = unknown, TAvailableWorkResults extends Record<string, unknown> = Record<string, unknown>> implements IWorkDefinition<TName, TData, TResult, TAvailableWorkResults> {
+    /** Unique name for the work */
+    readonly name: TName;
+    /** Execute function - receives context and returns result */
+    readonly execute: (context: IWorkflowContext<TData, TAvailableWorkResults>) => Promise<TResult>;
+    /** Optional: condition to determine if work should run */
+    readonly shouldRun?: (context: IWorkflowContext<TData, TAvailableWorkResults>) => boolean | Promise<boolean>;
+    /** Optional: called when work fails */
+    readonly onError?: (error: Error, context: IWorkflowContext<TData, TAvailableWorkResults>) => void | Promise<void>;
+    constructor(definition: IWorkDefinition<TName, TData, TResult, TAvailableWorkResults>);
+}
+/**
+ * Type that accepts a work definition (either inline object or Work instance).
+ * Since Work implements IWorkDefinition, this is simply IWorkDefinition.
+ */
+type WorkInput<TName extends string, TData = Record<string, unknown>, TResult = unknown, TAvailableWorkResults extends Record<string, unknown> = Record<string, unknown>> = IWorkDefinition<TName, TData, TResult, TAvailableWorkResults>;
+/**
+ * Helper to get the work definition from a WorkInput.
+ * Since Work implements IWorkDefinition, this simply returns the input.
+ */
+declare function getWorkDefinition<TName extends string, TData, TResult, TAvailableWorkResults extends Record<string, unknown>>(input: WorkInput<TName, TData, TResult, TAvailableWorkResults>): IWorkDefinition<TName, TData, TResult, TAvailableWorkResults>;
+
 /**
  * A simple, extensible workflow engine that supports serial and parallel work execution.
  * Work names and result types are automatically inferred from the workflow definition.
@@ -101,9 +141,9 @@ interface IWorkflowResult<TData = Record<string, unknown>, TWorkResults extends
  *     name: 'process',
  *     execute: async (ctx) => {
  *       // ✅ Autocomplete for names AND types are inferred!
- *       const isValid = ctx.workResults.get('validate');     // boolean | undefined
- *       const orders = ctx.workResults.get('fetchOrders');   // Order[] | undefined
- *       const profile = ctx.workResults.get('fetchProfile'); // Profile | undefined
+ *       const isValid = ctx.workResults.get('validate').result;     // boolean | undefined
+ *       const orders = ctx.workResults.get('fetchOrders').result;   // Order[] | undefined
+ *       const profile = ctx.workResults.get('fetchProfile').result; // Profile | undefined
  *       return { orders, profile };
  *     },
  *   });
@@ -115,16 +155,18 @@ declare class Workflow<TData = Record<string, unknown>, TWorkResults extends Rec
     private works;
     /**
      * Add a serial work to the workflow.
+     * Accepts either an inline work definition or a Work instance.
      * The work name and result type are automatically inferred.
      */
-    serial<TName extends string, TResult>(work: IWorkDefinition<TName, TData, TResult, TWorkResults>): Workflow<TData, TWorkResults & {
+    serial<TName extends string, TResult>(work: WorkInput<TName, TData, TResult, TWorkResults>): Workflow<TData, TWorkResults & {
         [K in TName]: TResult;
     }>;
     /**
      * Add parallel works to the workflow.
+     * Accepts either inline work definitions or Work instances.
      * All work names and result types are automatically inferred.
      */
-    parallel<const TParallelWorks extends readonly IWorkDefinition<string, TData, unknown, TWorkResults>[]>(works: TParallelWorks): Workflow<TData, TWorkResults & ParallelWorksToRecord<TParallelWorks>>;
+    parallel<const TParallelWorks extends readonly WorkInput<string, TData, unknown, TWorkResults>[]>(works: TParallelWorks): Workflow<TData, TWorkResults & ParallelWorksToRecord<TParallelWorks>>;
     /**
      * Execute the workflow with initial data
      */
@@ -139,8 +181,8 @@ declare class Workflow<TData = Record<string, unknown>, TWorkResults extends Rec
     private executeParallelWorks;
 }
 /**
- * Helper type to extract work results from parallel works array
- * Uses Extract to preserve the specific type for each work name
+ * Helper type to extract work results from parallel works array.
+ * Since Work implements IWorkDefinition, we can use Extract directly.
  */
 type ParallelWorksToRecord<T extends readonly IWorkDefinition<string, any, any, any>[]> = {
     [K in T[number]['name']]: Extract<T[number], {
@@ -148,4 +190,4 @@ type ParallelWorksToRecord<T extends readonly IWorkDefinition<string, any, any,
     }> extends IWorkDefinition<string, any, infer R, any> ? R : never;
 };
 
-export { type IWorkDefinition, type IWorkResult, type IWorkResultsMap, type IWorkflowContext, type IWorkflowResult, type IWorkflowWork, WorkStatus, Workflow, WorkflowStatus };
+export { type IWorkDefinition, type IWorkResult, type IWorkResultsMap, type IWorkflowContext, type IWorkflowResult, type IWorkflowWork, Work, type WorkInput, WorkStatus, Workflow, WorkflowStatus, getWorkDefinition };

package/dist/index.js

@@ -15,13 +15,32 @@ var WorkflowStatus = /* @__PURE__ */ ((WorkflowStatus2) => {
   return WorkflowStatus2;
 })(WorkflowStatus || {});
 
+// src/work.ts
+var Work = class {
+  constructor(definition) {
+    this.name = definition.name;
+    this.execute = definition.execute;
+    this.shouldRun = definition.shouldRun;
+    this.onError = definition.onError;
+  }
+};
+function getWorkDefinition(input) {
+  return input;
+}
+
 // src/workflow.ts
 var WorkResultsMap = class {
   constructor() {
     this.map = /* @__PURE__ */ new Map();
   }
   get(name) {
-    return this.map.get(name);
+    const result = this.map.get(name);
+    if (!result) {
+      throw new Error(
+        `Work result "${String(name)}" not found. This work may not have executed yet.`
+      );
+    }
+    return result;
   }
   set(name, value) {
     this.map.set(name, value);
@@ -36,23 +55,25 @@ var Workflow = class {
   }
   /**
    * Add a serial work to the workflow.
+   * Accepts either an inline work definition or a Work instance.
    * The work name and result type are automatically inferred.
    */
   serial(work) {
     this.works.push({
       type: "serial",
-      works: [work]
+      works: [getWorkDefinition(work)]
     });
     return this;
   }
   /**
    * Add parallel works to the workflow.
+   * Accepts either inline work definitions or Work instances.
    * All work names and result types are automatically inferred.
    */
   parallel(works) {
     this.works.push({
       type: "parallel",
-      works
+      works: works.map((w) => getWorkDefinition(w))
     });
     return this;
   }
@@ -98,21 +119,24 @@ var Workflow = class {
     if (work.shouldRun) {
       const shouldRun = await work.shouldRun(context);
       if (!shouldRun) {
-        workResults.set(work.name, {
+        const skippedResult = {
           status: "skipped" /* SKIPPED */,
           duration: Date.now() - workStartTime
-        });
+        };
+        context.workResults.set(work.name, skippedResult);
+        workResults.set(work.name, skippedResult);
         return;
       }
     }
     try {
       const result = await work.execute(context);
-      context.workResults.set(work.name, result);
-      workResults.set(work.name, {
+      const workResult = {
         status: "completed" /* COMPLETED */,
         result,
         duration: Date.now() - workStartTime
-      });
+      };
+      context.workResults.set(work.name, workResult);
+      workResults.set(work.name, workResult);
     } catch (error) {
       const err = error instanceof Error ? error : new Error(String(error));
       workResults.set(work.name, {
@@ -135,10 +159,12 @@ var Workflow = class {
       if (work.shouldRun) {
         const shouldRun = await work.shouldRun(context);
         if (!shouldRun) {
-          workResults.set(work.name, {
+          const skippedResult = {
             status: "skipped" /* SKIPPED */,
             duration: Date.now() - workStartTime
-          });
+          };
+          context.workResults.set(work.name, skippedResult);
+          workResults.set(work.name, skippedResult);
           return { work, skipped: true };
         }
       }
@@ -158,19 +184,21 @@ var Workflow = class {
       }
       const duration = Date.now() - result.startTime;
       if ("error" in result && result.error) {
-        workResults.set(result.work.name, {
+        const workResult = {
           status: "failed" /* FAILED */,
           error: result.error,
           duration
-        });
+        };
+        workResults.set(result.work.name, workResult);
         errors.push({ work: result.work, error: result.error });
       } else {
-        context.workResults.set(result.work.name, result.result);
-        workResults.set(result.work.name, {
+        const workResult = {
           status: "completed" /* COMPLETED */,
           result: result.result,
           duration
-        });
+        };
+        context.workResults.set(result.work.name, workResult);
+        workResults.set(result.work.name, workResult);
       }
     }
     if (errors.length > 0) {
@@ -184,8 +212,10 @@ var Workflow = class {
   }
 };
 export {
+  Work,
   WorkStatus,
   Workflow,
-  WorkflowStatus
+  WorkflowStatus,
+  getWorkDefinition
 };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/workflow.types.ts","../src/workflow.ts"],"sourcesContent":["/**\n * Work Status\n */\nexport enum WorkStatus {\n  PENDING = 'pending',\n  RUNNING = 'running',\n  COMPLETED = 'completed',\n  FAILED = 'failed',\n  SKIPPED = 'skipped',\n}\n\n/**\n * Workflow Status\n */\nexport enum WorkflowStatus {\n  PENDING = 'pending',\n  RUNNING = 'running',\n  COMPLETED = 'completed',\n  FAILED = 'failed',\n}\n\n/**\n * Context passed between workflow works\n * TData is the type of shared data between works\n * TWorkResults is a record mapping work names to their result types\n */\nexport interface IWorkflowContext<\n  TData = Record<string, unknown>,\n  TWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> {\n  /** Shared data between works */\n  data: TData;\n  /** Work-specific results keyed by work name with inferred types */\n  workResults: IWorkResultsMap<TWorkResults>;\n}\n\n/**\n * Type-safe map for work results with automatic type inference\n */\nexport interface IWorkResultsMap<\n  TWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> {\n  get<K extends keyof TWorkResults>(name: K): TWorkResults[K] | undefined;\n  set<K extends keyof TWorkResults>(name: K, value: TWorkResults[K]): void;\n  has(name: keyof TWorkResults): boolean;\n}\n\n/**\n * Result of a single work execution\n */\nexport interface IWorkResult<TResult = unknown> {\n  status: WorkStatus;\n  result?: TResult;\n  error?: Error;\n  duration: number;\n}\n\n/**\n * Definition of a work with inferred name and result type\n */\nexport interface IWorkDefinition<\n  TName extends string,\n  TData = Record<string, unknown>,\n  TResult = unknown,\n  TAvailableWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> {\n  /** Unique name for the work */\n  name: TName;\n  /** Execute function - receives context and returns result */\n  execute: (context: IWorkflowContext<TData, TAvailableWorkResults>) => Promise<TResult>;\n  /** Optional: condition to determine if work should run */\n  shouldRun?: (\n    context: IWorkflowContext<TData, TAvailableWorkResults>\n  ) => boolean | Promise<boolean>;\n  /** Optional: called when work fails */\n  onError?: (\n    error: Error,\n    context: IWorkflowContext<TData, TAvailableWorkResults>\n  ) => void | Promise<void>;\n}\n\n/**\n * Internal work representation\n */\nexport interface IWorkflowWork {\n  type: 'serial' | 'parallel';\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  works: IWorkDefinition<string, any, any, any>[];\n}\n\n/**\n * Result of workflow execution\n */\nexport interface IWorkflowResult<\n  TData = Record<string, unknown>,\n  TWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> {\n  status: WorkflowStatus;\n  context: IWorkflowContext<TData, TWorkResults>;\n  workResults: Map<keyof TWorkResults, IWorkResult>;\n  totalDuration: number;\n  error?: Error;\n}\n","import {\n  IWorkflowContext,\n  IWorkflowResult,\n  IWorkResultsMap,\n  WorkflowStatus,\n  IWorkflowWork,\n  IWorkDefinition,\n  IWorkResult,\n  WorkStatus,\n} from './workflow.types';\n\n/**\n * Internal implementation of IWorkResultsMap using a Map\n */\nclass WorkResultsMap<\n  TWorkResults extends Record<string, unknown>,\n> implements IWorkResultsMap<TWorkResults> {\n  private map = new Map<keyof TWorkResults, unknown>();\n\n  get<K extends keyof TWorkResults>(name: K): TWorkResults[K] | undefined {\n    return this.map.get(name) as TWorkResults[K] | undefined;\n  }\n\n  set<K extends keyof TWorkResults>(name: K, value: TWorkResults[K]): void {\n    this.map.set(name, value);\n  }\n\n  has(name: keyof TWorkResults): boolean {\n    return this.map.has(name);\n  }\n}\n\n/**\n * A simple, extensible workflow engine that supports serial and parallel work execution.\n * Work names and result types are automatically inferred from the workflow definition.\n *\n * @example\n * ```typescript\n * const workflow = new Workflow<{ userId: string }>()\n *   .serial({\n *     name: 'validate',\n *     execute: async (ctx) => true, // returns boolean\n *   })\n *   .parallel([\n *     {\n *       name: 'fetchOrders',\n *       execute: async (ctx) => [{ id: 1 }], // returns Order[]\n *     },\n *     {\n *       name: 'fetchProfile',\n *       execute: async (ctx) => ({ name: 'John' }), // returns Profile\n *     },\n *   ])\n *   .serial({\n *     name: 'process',\n *     execute: async (ctx) => {\n *       // ✅ Autocomplete for names AND types are inferred!\n *       const isValid = ctx.workResults.get('validate');     // boolean | undefined\n *       const orders = ctx.workResults.get('fetchOrders');   // Order[] | undefined\n *       const profile = ctx.workResults.get('fetchProfile'); // Profile | undefined\n *       return { orders, profile };\n *     },\n *   });\n *\n * const result = await workflow.run({ userId: '123' });\n * ```\n */\nexport class Workflow<\n  TData = Record<string, unknown>,\n  TWorkResults extends Record<string, unknown> = NonNullable<unknown>,\n> {\n  private works: IWorkflowWork[] = [];\n\n  /**\n   * Add a serial work to the workflow.\n   * The work name and result type are automatically inferred.\n   */\n  serial<TName extends string, TResult>(\n    work: IWorkDefinition<TName, TData, TResult, TWorkResults>\n  ): Workflow<TData, TWorkResults & { [K in TName]: TResult }> {\n    this.works.push({\n      type: 'serial',\n      works: [work],\n    });\n    return this as unknown as Workflow<TData, TWorkResults & { [K in TName]: TResult }>;\n  }\n\n  /**\n   * Add parallel works to the workflow.\n   * All work names and result types are automatically inferred.\n   */\n  parallel<\n    const TParallelWorks extends readonly IWorkDefinition<string, TData, unknown, TWorkResults>[],\n  >(works: TParallelWorks): Workflow<TData, TWorkResults & ParallelWorksToRecord<TParallelWorks>> {\n    this.works.push({\n      type: 'parallel',\n      works: works as unknown as IWorkDefinition<string, TData, unknown, TWorkResults>[],\n    });\n    return this as unknown as Workflow<TData, TWorkResults & ParallelWorksToRecord<TParallelWorks>>;\n  }\n\n  /**\n   * Execute the workflow with initial data\n   */\n  async run(initialData: TData): Promise<IWorkflowResult<TData, TWorkResults>> {\n    const startTime = Date.now();\n    const context: IWorkflowContext<TData, TWorkResults> = {\n      data: initialData,\n      workResults: new WorkResultsMap<TWorkResults>(),\n    };\n    const workResults = new Map<keyof TWorkResults, IWorkResult>();\n\n    try {\n      for (const workGroup of this.works) {\n        if (workGroup.type === 'serial') {\n          await this.executeWork(workGroup.works[0], context, workResults);\n        } else {\n          await this.executeParallelWorks(workGroup.works, context, workResults);\n        }\n      }\n\n      return {\n        status: WorkflowStatus.COMPLETED,\n        context,\n        workResults,\n        totalDuration: Date.now() - startTime,\n      };\n    } catch (error) {\n      return {\n        status: WorkflowStatus.FAILED,\n        context,\n        workResults,\n        totalDuration: Date.now() - startTime,\n        error: error instanceof Error ? error : new Error(String(error)),\n      };\n    }\n  }\n\n  /**\n   * Execute a single work\n   */\n  private async executeWork(\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    work: IWorkDefinition<string, TData, any, any>,\n    context: IWorkflowContext<TData, TWorkResults>,\n    workResults: Map<keyof TWorkResults, IWorkResult>\n  ): Promise<void> {\n    const workStartTime = Date.now();\n\n    // Check if work should run\n    if (work.shouldRun) {\n      const shouldRun = await work.shouldRun(context);\n      if (!shouldRun) {\n        workResults.set(work.name as keyof TWorkResults, {\n          status: WorkStatus.SKIPPED,\n          duration: Date.now() - workStartTime,\n        });\n        return;\n      }\n    }\n\n    try {\n      const result = await work.execute(context);\n\n      // Store result in context for subsequent works\n      context.workResults.set(work.name as keyof TWorkResults, result);\n\n      workResults.set(work.name as keyof TWorkResults, {\n        status: WorkStatus.COMPLETED,\n        result,\n        duration: Date.now() - workStartTime,\n      });\n    } catch (error) {\n      const err = error instanceof Error ? error : new Error(String(error));\n\n      workResults.set(work.name as keyof TWorkResults, {\n        status: WorkStatus.FAILED,\n        error: err,\n        duration: Date.now() - workStartTime,\n      });\n\n      // Call error handler if provided\n      if (work.onError) {\n        await work.onError(err, context);\n      }\n\n      // Re-throw to stop workflow execution\n      throw err;\n    }\n  }\n\n  /**\n   * Execute multiple works in parallel\n   */\n  private async executeParallelWorks(\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    works: IWorkDefinition<string, TData, any, any>[],\n    context: IWorkflowContext<TData, TWorkResults>,\n    workResults: Map<keyof TWorkResults, IWorkResult>\n  ): Promise<void> {\n    const promises = works.map(async (work) => {\n      const workStartTime = Date.now();\n\n      // Check if work should run\n      if (work.shouldRun) {\n        const shouldRun = await work.shouldRun(context);\n        if (!shouldRun) {\n          workResults.set(work.name as keyof TWorkResults, {\n            status: WorkStatus.SKIPPED,\n            duration: Date.now() - workStartTime,\n          });\n          return { work, skipped: true };\n        }\n      }\n\n      try {\n        const result = await work.execute(context);\n        return { work, result, startTime: workStartTime };\n      } catch (error) {\n        const err = error instanceof Error ? error : new Error(String(error));\n        return { work, error: err, startTime: workStartTime };\n      }\n    });\n\n    const results = await Promise.all(promises);\n\n    // Process results and check for errors\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const errors: { work: IWorkDefinition<string, TData, any, any>; error: Error }[] = [];\n\n    for (const result of results) {\n      if ('skipped' in result && result.skipped) {\n        continue;\n      }\n\n      const duration = Date.now() - result.startTime!;\n\n      if ('error' in result && result.error) {\n        workResults.set(result.work.name as keyof TWorkResults, {\n          status: WorkStatus.FAILED,\n          error: result.error,\n          duration,\n        });\n        errors.push({ work: result.work, error: result.error });\n      } else {\n        context.workResults.set(result.work.name as keyof TWorkResults, result.result);\n        workResults.set(result.work.name as keyof TWorkResults, {\n          status: WorkStatus.COMPLETED,\n          result: result.result,\n          duration,\n        });\n      }\n    }\n\n    // Handle errors after all parallel works complete\n    if (errors.length > 0) {\n      // Call error handlers\n      for (const { work, error } of errors) {\n        if (work.onError) {\n          await work.onError(error, context);\n        }\n      }\n\n      // Throw the first error to stop workflow\n      throw errors[0].error;\n    }\n  }\n}\n\n/**\n * Helper type to extract work results from parallel works array\n * Uses Extract to preserve the specific type for each work name\n */\ntype ParallelWorksToRecord<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  T extends readonly IWorkDefinition<string, any, any, any>[],\n> = {\n  [K in T[number]['name']]: Extract<\n    T[number],\n    { name: K }\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  > extends IWorkDefinition<string, any, infer R, any>\n    ? R\n    : never;\n};\n"],"mappings":"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","names":["WorkStatus","WorkflowStatus"]}
+{"version":3,"sources":["../src/workflow.types.ts","../src/work.ts","../src/workflow.ts"],"sourcesContent":["/**\n * Work Status\n */\nexport enum WorkStatus {\n  PENDING = 'pending',\n  RUNNING = 'running',\n  COMPLETED = 'completed',\n  FAILED = 'failed',\n  SKIPPED = 'skipped',\n}\n\n/**\n * Workflow Status\n */\nexport enum WorkflowStatus {\n  PENDING = 'pending',\n  RUNNING = 'running',\n  COMPLETED = 'completed',\n  FAILED = 'failed',\n}\n\n/**\n * Context passed between workflow works\n * TData is the type of shared data between works\n * TWorkResults is a record mapping work names to their result types\n */\nexport interface IWorkflowContext<\n  TData = Record<string, unknown>,\n  TWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> {\n  /** Shared data between works */\n  data: TData;\n  /** Work-specific results keyed by work name with inferred types */\n  workResults: IWorkResultsMap<TWorkResults>;\n}\n\n/**\n * Type-safe map for work results with automatic type inference\n */\nexport interface IWorkResultsMap<\n  TWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> {\n  get<K extends keyof TWorkResults>(name: K): IWorkResult<TWorkResults[K]>;\n  set<K extends keyof TWorkResults>(name: K, value: IWorkResult<TWorkResults[K]>): void;\n  has(name: keyof TWorkResults): boolean;\n}\n\n/**\n * Result of a single work execution\n */\nexport interface IWorkResult<TResult = unknown> {\n  status: WorkStatus;\n  result?: TResult;\n  error?: Error;\n  duration: number;\n}\n\n/**\n * Definition of a work with inferred name and result type\n */\nexport interface IWorkDefinition<\n  TName extends string,\n  TData = Record<string, unknown>,\n  TResult = unknown,\n  TAvailableWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> {\n  /** Unique name for the work */\n  name: TName;\n  /** Execute function - receives context and returns result */\n  execute: (context: IWorkflowContext<TData, TAvailableWorkResults>) => Promise<TResult>;\n  /** Optional: condition to determine if work should run */\n  shouldRun?: (\n    context: IWorkflowContext<TData, TAvailableWorkResults>\n  ) => boolean | Promise<boolean>;\n  /** Optional: called when work fails */\n  onError?: (\n    error: Error,\n    context: IWorkflowContext<TData, TAvailableWorkResults>\n  ) => void | Promise<void>;\n}\n\n/**\n * Internal work representation\n */\nexport interface IWorkflowWork {\n  type: 'serial' | 'parallel';\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  works: IWorkDefinition<string, any, any, any>[];\n}\n\n/**\n * Result of workflow execution\n */\nexport interface IWorkflowResult<\n  TData = Record<string, unknown>,\n  TWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> {\n  status: WorkflowStatus;\n  context: IWorkflowContext<TData, TWorkResults>;\n  workResults: Map<keyof TWorkResults, IWorkResult>;\n  totalDuration: number;\n  error?: Error;\n}\n","import { IWorkDefinition, IWorkflowContext } from './workflow.types';\n\n/**\n * A standalone Work unit that can be added to workflows.\n * Implements IWorkDefinition so it can be used anywhere a work definition is expected.\n *\n * @example\n * ```typescript\n * const fetchUser = new Work({\n *   name: 'fetchUser',\n *   execute: async (ctx) => {\n *     return { id: ctx.data.userId, name: 'John' };\n *   },\n * });\n *\n * const workflow = new Workflow<{ userId: string }>()\n *   .serial(fetchUser)\n *   .parallel([work1, work2]);\n * ```\n */\nexport class Work<\n  TName extends string,\n  TData = Record<string, unknown>,\n  TResult = unknown,\n  TAvailableWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> implements IWorkDefinition<TName, TData, TResult, TAvailableWorkResults> {\n  /** Unique name for the work */\n  readonly name: TName;\n\n  /** Execute function - receives context and returns result */\n  readonly execute: (context: IWorkflowContext<TData, TAvailableWorkResults>) => Promise<TResult>;\n\n  /** Optional: condition to determine if work should run */\n  readonly shouldRun?: (\n    context: IWorkflowContext<TData, TAvailableWorkResults>\n  ) => boolean | Promise<boolean>;\n\n  /** Optional: called when work fails */\n  readonly onError?: (\n    error: Error,\n    context: IWorkflowContext<TData, TAvailableWorkResults>\n  ) => void | Promise<void>;\n\n  constructor(definition: IWorkDefinition<TName, TData, TResult, TAvailableWorkResults>) {\n    this.name = definition.name;\n    this.execute = definition.execute;\n    this.shouldRun = definition.shouldRun;\n    this.onError = definition.onError;\n  }\n}\n\n/**\n * Type that accepts a work definition (either inline object or Work instance).\n * Since Work implements IWorkDefinition, this is simply IWorkDefinition.\n */\nexport type WorkInput<\n  TName extends string,\n  TData = Record<string, unknown>,\n  TResult = unknown,\n  TAvailableWorkResults extends Record<string, unknown> = Record<string, unknown>,\n> = IWorkDefinition<TName, TData, TResult, TAvailableWorkResults>;\n\n/**\n * Helper to get the work definition from a WorkInput.\n * Since Work implements IWorkDefinition, this simply returns the input.\n */\nexport function getWorkDefinition<\n  TName extends string,\n  TData,\n  TResult,\n  TAvailableWorkResults extends Record<string, unknown>,\n>(\n  input: WorkInput<TName, TData, TResult, TAvailableWorkResults>\n): IWorkDefinition<TName, TData, TResult, TAvailableWorkResults> {\n  return input;\n}\n","import {\n  IWorkflowContext,\n  IWorkflowResult,\n  IWorkResultsMap,\n  WorkflowStatus,\n  IWorkflowWork,\n  IWorkDefinition,\n  IWorkResult,\n  WorkStatus,\n} from './workflow.types';\nimport { WorkInput, getWorkDefinition } from './work';\n\n/**\n * Internal implementation of IWorkResultsMap using a Map\n */\nclass WorkResultsMap<\n  TWorkResults extends Record<string, unknown>,\n> implements IWorkResultsMap<TWorkResults> {\n  private map = new Map<keyof TWorkResults, IWorkResult<unknown>>();\n\n  get<K extends keyof TWorkResults>(name: K): IWorkResult<TWorkResults[K]> {\n    const result = this.map.get(name);\n    if (!result) {\n      throw new Error(\n        `Work result \"${String(name)}\" not found. This work may not have executed yet.`\n      );\n    }\n    return result as IWorkResult<TWorkResults[K]>;\n  }\n\n  set<K extends keyof TWorkResults>(name: K, value: IWorkResult<TWorkResults[K]>): void {\n    this.map.set(name, value);\n  }\n\n  has(name: keyof TWorkResults): boolean {\n    return this.map.has(name);\n  }\n}\n\n/**\n * A simple, extensible workflow engine that supports serial and parallel work execution.\n * Work names and result types are automatically inferred from the workflow definition.\n *\n * @example\n * ```typescript\n * const workflow = new Workflow<{ userId: string }>()\n *   .serial({\n *     name: 'validate',\n *     execute: async (ctx) => true, // returns boolean\n *   })\n *   .parallel([\n *     {\n *       name: 'fetchOrders',\n *       execute: async (ctx) => [{ id: 1 }], // returns Order[]\n *     },\n *     {\n *       name: 'fetchProfile',\n *       execute: async (ctx) => ({ name: 'John' }), // returns Profile\n *     },\n *   ])\n *   .serial({\n *     name: 'process',\n *     execute: async (ctx) => {\n *       // ✅ Autocomplete for names AND types are inferred!\n *       const isValid = ctx.workResults.get('validate').result;     // boolean | undefined\n *       const orders = ctx.workResults.get('fetchOrders').result;   // Order[] | undefined\n *       const profile = ctx.workResults.get('fetchProfile').result; // Profile | undefined\n *       return { orders, profile };\n *     },\n *   });\n *\n * const result = await workflow.run({ userId: '123' });\n * ```\n */\nexport class Workflow<\n  TData = Record<string, unknown>,\n  TWorkResults extends Record<string, unknown> = NonNullable<unknown>,\n> {\n  private works: IWorkflowWork[] = [];\n\n  /**\n   * Add a serial work to the workflow.\n   * Accepts either an inline work definition or a Work instance.\n   * The work name and result type are automatically inferred.\n   */\n  serial<TName extends string, TResult>(\n    work: WorkInput<TName, TData, TResult, TWorkResults>\n  ): Workflow<TData, TWorkResults & { [K in TName]: TResult }> {\n    this.works.push({\n      type: 'serial',\n      works: [getWorkDefinition(work)],\n    });\n    return this as unknown as Workflow<TData, TWorkResults & { [K in TName]: TResult }>;\n  }\n\n  /**\n   * Add parallel works to the workflow.\n   * Accepts either inline work definitions or Work instances.\n   * All work names and result types are automatically inferred.\n   */\n  parallel<const TParallelWorks extends readonly WorkInput<string, TData, unknown, TWorkResults>[]>(\n    works: TParallelWorks\n  ): Workflow<TData, TWorkResults & ParallelWorksToRecord<TParallelWorks>> {\n    this.works.push({\n      type: 'parallel',\n      works: works.map((w) => getWorkDefinition(w)) as unknown as IWorkDefinition<\n        string,\n        TData,\n        unknown,\n        TWorkResults\n      >[],\n    });\n    return this as unknown as Workflow<TData, TWorkResults & ParallelWorksToRecord<TParallelWorks>>;\n  }\n\n  /**\n   * Execute the workflow with initial data\n   */\n  async run(initialData: TData): Promise<IWorkflowResult<TData, TWorkResults>> {\n    const startTime = Date.now();\n    const context: IWorkflowContext<TData, TWorkResults> = {\n      data: initialData,\n      workResults: new WorkResultsMap<TWorkResults>(),\n    };\n    const workResults = new Map<keyof TWorkResults, IWorkResult>();\n\n    try {\n      for (const workGroup of this.works) {\n        if (workGroup.type === 'serial') {\n          await this.executeWork(workGroup.works[0], context, workResults);\n        } else {\n          await this.executeParallelWorks(workGroup.works, context, workResults);\n        }\n      }\n\n      return {\n        status: WorkflowStatus.COMPLETED,\n        context,\n        workResults,\n        totalDuration: Date.now() - startTime,\n      };\n    } catch (error) {\n      return {\n        status: WorkflowStatus.FAILED,\n        context,\n        workResults,\n        totalDuration: Date.now() - startTime,\n        error: error instanceof Error ? error : new Error(String(error)),\n      };\n    }\n  }\n\n  /**\n   * Execute a single work\n   */\n  private async executeWork(\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    work: IWorkDefinition<string, TData, any, any>,\n    context: IWorkflowContext<TData, TWorkResults>,\n    workResults: Map<keyof TWorkResults, IWorkResult>\n  ): Promise<void> {\n    const workStartTime = Date.now();\n\n    // Check if work should run\n    if (work.shouldRun) {\n      const shouldRun = await work.shouldRun(context);\n      if (!shouldRun) {\n        const skippedResult: IWorkResult = {\n          status: WorkStatus.SKIPPED,\n          duration: Date.now() - workStartTime,\n        };\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        context.workResults.set(work.name as keyof TWorkResults, skippedResult as any);\n        workResults.set(work.name as keyof TWorkResults, skippedResult);\n        return;\n      }\n    }\n\n    try {\n      const result = await work.execute(context);\n\n      const workResult: IWorkResult = {\n        status: WorkStatus.COMPLETED,\n        result,\n        duration: Date.now() - workStartTime,\n      };\n\n      // Store result in context for subsequent works\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      context.workResults.set(work.name as keyof TWorkResults, workResult as any);\n      workResults.set(work.name as keyof TWorkResults, workResult);\n    } catch (error) {\n      const err = error instanceof Error ? error : new Error(String(error));\n\n      workResults.set(work.name as keyof TWorkResults, {\n        status: WorkStatus.FAILED,\n        error: err,\n        duration: Date.now() - workStartTime,\n      });\n\n      // Call error handler if provided\n      if (work.onError) {\n        await work.onError(err, context);\n      }\n\n      // Re-throw to stop workflow execution\n      throw err;\n    }\n  }\n\n  /**\n   * Execute multiple works in parallel\n   */\n  private async executeParallelWorks(\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    works: IWorkDefinition<string, TData, any, any>[],\n    context: IWorkflowContext<TData, TWorkResults>,\n    workResults: Map<keyof TWorkResults, IWorkResult>\n  ): Promise<void> {\n    const promises = works.map(async (work) => {\n      const workStartTime = Date.now();\n\n      // Check if work should run\n      if (work.shouldRun) {\n        const shouldRun = await work.shouldRun(context);\n        if (!shouldRun) {\n          const skippedResult: IWorkResult = {\n            status: WorkStatus.SKIPPED,\n            duration: Date.now() - workStartTime,\n          };\n          // eslint-disable-next-line @typescript-eslint/no-explicit-any\n          context.workResults.set(work.name as keyof TWorkResults, skippedResult as any);\n          workResults.set(work.name as keyof TWorkResults, skippedResult);\n          return { work, skipped: true };\n        }\n      }\n\n      try {\n        const result = await work.execute(context);\n        return { work, result, startTime: workStartTime };\n      } catch (error) {\n        const err = error instanceof Error ? error : new Error(String(error));\n        return { work, error: err, startTime: workStartTime };\n      }\n    });\n\n    const results = await Promise.all(promises);\n\n    // Process results and check for errors\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const errors: { work: IWorkDefinition<string, TData, any, any>; error: Error }[] = [];\n\n    for (const result of results) {\n      if ('skipped' in result && result.skipped) {\n        continue;\n      }\n\n      const duration = Date.now() - result.startTime!;\n\n      if ('error' in result && result.error) {\n        const workResult: IWorkResult = {\n          status: WorkStatus.FAILED,\n          error: result.error,\n          duration,\n        };\n        workResults.set(result.work.name as keyof TWorkResults, workResult);\n        errors.push({ work: result.work, error: result.error });\n      } else {\n        const workResult: IWorkResult = {\n          status: WorkStatus.COMPLETED,\n          result: result.result,\n          duration,\n        };\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        context.workResults.set(result.work.name as keyof TWorkResults, workResult as any);\n        workResults.set(result.work.name as keyof TWorkResults, workResult);\n      }\n    }\n\n    // Handle errors after all parallel works complete\n    if (errors.length > 0) {\n      // Call error handlers\n      for (const { work, error } of errors) {\n        if (work.onError) {\n          await work.onError(error, context);\n        }\n      }\n\n      // Throw the first error to stop workflow\n      throw errors[0].error;\n    }\n  }\n}\n\n/**\n * Helper type to extract work results from parallel works array.\n * Since Work implements IWorkDefinition, we can use Extract directly.\n */\ntype ParallelWorksToRecord<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  T extends readonly IWorkDefinition<string, any, any, any>[],\n> = {\n  [K in T[number]['name']]: Extract<\n    T[number],\n    { name: K }\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  > extends IWorkDefinition<string, any, infer R, any>\n    ? R\n    : never;\n};\n"],"mappings":"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","names":["WorkStatus","WorkflowStatus"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yigitahmetsahin/workflow-ts",
-  "version": "1.2.1",
+  "version": "2.1.0",
   "description": "A simple, extensible TypeScript workflow engine supporting serial and parallel work execution with full type inference",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -21,8 +21,8 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
-    "lint": "eslint src && tsc --noEmit",
-    "lint:fix": "eslint src --fix",
+    "lint": "eslint src examples && tsc --noEmit",
+    "lint:fix": "eslint src examples --fix",
     "format": "prettier --write .",
     "format:check": "prettier --check .",
     "prepublishOnly": "npm run build"