@yigitahmetsahin/workflow-ts 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 yigitahmetsahin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,255 @@
+# @yigitahmetsahin/workflow-ts
+
+A simple, extensible TypeScript workflow engine supporting serial and parallel work execution with full type inference.
+
+[![npm version](https://badge.fury.io/js/%40yigitahmetsahin%2Fworkflow-ts.svg)](https://www.npmjs.com/package/@yigitahmetsahin/workflow-ts)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## Features
+
+- 🔄 **Serial & Parallel Execution** - Chain work items sequentially or run them concurrently
+- 🎯 **Full Type Inference** - Work names and result types are automatically inferred
+- ⏭️ **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
+- 🪶 **Zero Dependencies** - Lightweight with no external runtime dependencies
+
+## Installation
+
+```bash
+npm install @yigitahmetsahin/workflow-ts
+```
+
+```bash
+yarn add @yigitahmetsahin/workflow-ts
+```
+
+```bash
+pnpm add @yigitahmetsahin/workflow-ts
+```
+
+## Quick Start
+
+```typescript
+import { Workflow, WorkflowStatus } from '@yigitahmetsahin/workflow-ts';
+
+const workflow = new Workflow<{ userId: string }>()
+  .serial({
+    name: 'validate',
+    execute: async (ctx) => ctx.data.userId.length > 0,
+  })
+  .parallel([
+    {
+      name: 'fetchOrders',
+      execute: async (ctx) => [{ id: 1 }, { id: 2 }],
+    },
+    {
+      name: 'fetchProfile',
+      execute: async (ctx) => ({ name: 'John', email: 'john@example.com' }),
+    },
+  ])
+  .serial({
+    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
+      return { orderCount: orders?.length ?? 0, userName: profile?.name };
+    },
+  });
+
+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'));
+}
+```
+
+## API Reference
+
+### `Workflow<TData>`
+
+Create a new workflow with optional initial data type.
+
+```typescript
+const workflow = new Workflow<{ userId: string }>();
+```
+
+### `.serial(work)`
+
+Add a serial (sequential) work to the workflow.
+
+```typescript
+workflow.serial({
+  name: 'workName',           // Unique name for this work
+  execute: async (ctx) => {   // Async function that performs the work
+    return result;            // Return value becomes available to subsequent works
+  },
+  shouldRun: (ctx) => true,   // Optional: condition to skip this work
+  onError: (error, ctx) => {  // Optional: error handler
+    console.error(error);
+  },
+});
+```
+
+### `.parallel(works)`
+
+Add parallel works that execute concurrently.
+
+```typescript
+workflow.parallel([
+  { name: 'task1', execute: async (ctx) => result1 },
+  { name: 'task2', execute: async (ctx) => result2 },
+  { name: 'task3', execute: async (ctx) => result3 },
+]);
+```
+
+### `.run(initialData)`
+
+Execute the workflow with initial data.
+
+```typescript
+const result = await workflow.run({ userId: '123' });
+```
+
+### Result Object
+
+```typescript
+interface IWorkflowResult {
+  status: WorkflowStatus;        // 'completed' | 'failed'
+  context: {
+    data: TData;                 // Initial data passed to run()
+    workResults: IWorkResultsMap; // Type-safe map of work results
+  };
+  workResults: Map<string, IWorkResult>; // Detailed results per work
+  totalDuration: number;         // Total execution time in ms
+  error?: Error;                 // Error if workflow failed
+}
+```
+
+## Conditional Execution
+
+Skip works based on runtime conditions:
+
+```typescript
+workflow.serial({
+  name: 'sendEmail',
+  shouldRun: (ctx) => ctx.data.sendNotifications,
+  execute: async (ctx) => {
+    await sendEmail(ctx.data.email);
+    return { sent: true };
+  },
+});
+```
+
+## Error Handling
+
+Handle errors at the work level:
+
+```typescript
+workflow.serial({
+  name: 'riskyOperation',
+  execute: async (ctx) => {
+    if (Math.random() < 0.5) throw new Error('Random failure');
+    return 'success';
+  },
+  onError: async (error, ctx) => {
+    await logError(error, ctx.data);
+    // Error will still propagate and fail the workflow
+  },
+});
+```
+
+## Behavior Diagram
+
+```
+┌─────────────────────────────────────────────────────────────────────────────┐
+│                              Workflow.run()                                 │
+└─────────────────────────────────────────────────────────────────────────────┘
+                                      │
+                                      ▼
+                        ┌─────────────────────────┐
+                        │   Initialize Context    │
+                        │   { data, workResults } │
+                        └─────────────────────────┘
+                                      │
+                                      ▼
+                        ┌─────────────────────────┐
+                        │   For each work item    │◄─────────────────┐
+                        └─────────────────────────┘                  │
+                                      │                              │
+                          ┌───────────┴───────────┐                  │
+                          ▼                       ▼                  │
+                    ┌──────────┐           ┌────────────┐            │
+                    │  Serial  │           │  Parallel  │            │
+                    └──────────┘           └────────────┘            │
+                          │                       │                  │
+                          ▼                       ▼                  │
+                ┌──────────────────┐   ┌────────────────────┐        │
+                │   shouldRun()?   │   │  For each work in  │        │
+                └──────────────────┘   │      parallel      │        │
+                    │           │      └────────────────────┘        │
+                   Yes          No              │                    │
+                    │           │      ┌────────┼────────┐           │
+                    ▼           ▼      ▼        ▼        ▼           │
+            ┌───────────┐  ┌────────┐ ┌──┐    ┌──┐    ┌──┐           │
+            │ execute() │  │ SKIP   │ │W1│    │W2│    │W3│           │
+            └───────────┘  └────────┘ └──┘    └──┘    └──┘           │
+                    │                   │       │       │            │
+                    ▼                   └───────┴───────┘            │
+            ┌───────────────┐                   │                    │
+            │ Store result  │                   ▼                    │
+            │ in context    │       ┌─────────────────────┐          │
+            └───────────────┘       │  Promise.all()      │          │
+                    │               │  (concurrent exec)  │          │
+                    │               └─────────────────────┘          │
+                    ▼                          │                     │
+            ┌───────────────┐       ┌─────────────────────┐          │
+            │    Success    │       │  Collect results    │          │
+            └───────────────┘       │  Check for errors   │          │
+                    │               └─────────────────────┘          │
+                    │                          │                     │
+                    └──────────────┬───────────┘                     │
+                                   │                                 │
+                                   ▼                                 │
+                         ┌─────────────────┐                         │
+                         │  More works?    │─────────Yes─────────────┘
+                         └─────────────────┘
+                                   │
+                                  No
+                                   │
+                                   ▼
+                    ┌─────────────────────────────┐
+                    │      Return Result          │
+                    │  { status, workResults,     │
+                    │    context, totalDuration } │
+                    └─────────────────────────────┘
+```
+
+## Execution Timeline
+
+```
+Time ──────────────────────────────────────────────────────────────────►
+
+     ┌──────────────┐
+     │   validate   │
+     │   (serial)   │
+     └──────────────┘
+                     ┌──────────────┐
+                     │ fetchOrders  │
+                     │  (parallel)  ├──────────┐
+                     └──────────────┘          │
+                     ┌──────────────┐          │ concurrent
+                     │ fetchProfile │          │
+                     │  (parallel)  ├──────────┘
+                     └──────────────┘
+                                    ┌──────────────┐
+                                    │   process    │
+                                    │   (serial)   │
+                                    └──────────────┘
+```
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,151 @@
+/**
+ * Work Status
+ */
+declare enum WorkStatus {
+    PENDING = "pending",
+    RUNNING = "running",
+    COMPLETED = "completed",
+    FAILED = "failed",
+    SKIPPED = "skipped"
+}
+/**
+ * Workflow Status
+ */
+declare enum WorkflowStatus {
+    PENDING = "pending",
+    RUNNING = "running",
+    COMPLETED = "completed",
+    FAILED = "failed"
+}
+/**
+ * Context passed between workflow works
+ * TData is the type of shared data between works
+ * TWorkResults is a record mapping work names to their result types
+ */
+interface IWorkflowContext<TData = Record<string, unknown>, TWorkResults extends Record<string, unknown> = Record<string, unknown>> {
+    /** Shared data between works */
+    data: TData;
+    /** Work-specific results keyed by work name with inferred types */
+    workResults: IWorkResultsMap<TWorkResults>;
+}
+/**
+ * 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;
+    has(name: keyof TWorkResults): boolean;
+}
+/**
+ * Result of a single work execution
+ */
+interface IWorkResult<TResult = unknown> {
+    status: WorkStatus;
+    result?: TResult;
+    error?: Error;
+    duration: number;
+}
+/**
+ * Definition of a work with inferred name and result type
+ */
+interface IWorkDefinition<TName extends string, TData = Record<string, unknown>, TResult = unknown, TAvailableWorkResults extends Record<string, unknown> = Record<string, unknown>> {
+    /** Unique name for the work */
+    name: TName;
+    /** Execute function - receives context and returns result */
+    execute: (context: IWorkflowContext<TData, TAvailableWorkResults>) => Promise<TResult>;
+    /** Optional: condition to determine if work should run */
+    shouldRun?: (context: IWorkflowContext<TData, TAvailableWorkResults>) => boolean | Promise<boolean>;
+    /** Optional: called when work fails */
+    onError?: (error: Error, context: IWorkflowContext<TData, TAvailableWorkResults>) => void | Promise<void>;
+}
+/**
+ * Internal work representation
+ */
+interface IWorkflowWork {
+    type: 'serial' | 'parallel';
+    works: IWorkDefinition<string, any, any, any>[];
+}
+/**
+ * Result of workflow execution
+ */
+interface IWorkflowResult<TData = Record<string, unknown>, TWorkResults extends Record<string, unknown> = Record<string, unknown>> {
+    status: WorkflowStatus;
+    context: IWorkflowContext<TData, TWorkResults>;
+    workResults: Map<keyof TWorkResults, IWorkResult>;
+    totalDuration: number;
+    error?: Error;
+}
+
+/**
+ * A simple, extensible workflow engine that supports serial and parallel work execution.
+ * Work names and result types are automatically inferred from the workflow definition.
+ *
+ * @example
+ * ```typescript
+ * const workflow = new Workflow<{ userId: string }>()
+ *   .serial({
+ *     name: 'validate',
+ *     execute: async (ctx) => true, // returns boolean
+ *   })
+ *   .parallel([
+ *     {
+ *       name: 'fetchOrders',
+ *       execute: async (ctx) => [{ id: 1 }], // returns Order[]
+ *     },
+ *     {
+ *       name: 'fetchProfile',
+ *       execute: async (ctx) => ({ name: 'John' }), // returns Profile
+ *     },
+ *   ])
+ *   .serial({
+ *     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
+ *       return { orders, profile };
+ *     },
+ *   });
+ *
+ * const result = await workflow.run({ userId: '123' });
+ * ```
+ */
+declare class Workflow<TData = Record<string, unknown>, TWorkResults extends Record<string, unknown> = NonNullable<unknown>> {
+    private works;
+    /**
+     * Add a serial work to the workflow.
+     * The work name and result type are automatically inferred.
+     */
+    serial<TName extends string, TResult>(work: IWorkDefinition<TName, TData, TResult, TWorkResults>): Workflow<TData, TWorkResults & {
+        [K in TName]: TResult;
+    }>;
+    /**
+     * Add parallel works to the workflow.
+     * 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>>;
+    /**
+     * Execute the workflow with initial data
+     */
+    run(initialData: TData): Promise<IWorkflowResult<TData, TWorkResults>>;
+    /**
+     * Execute a single work
+     */
+    private executeWork;
+    /**
+     * Execute multiple works in parallel
+     */
+    private executeParallelWorks;
+}
+/**
+ * Helper type to extract work results from parallel works array
+ * Uses Extract to preserve the specific type for each work name
+ */
+type ParallelWorksToRecord<T extends readonly IWorkDefinition<string, any, any, any>[]> = {
+    [K in T[number]['name']]: Extract<T[number], {
+        name: K;
+    }> 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 };

package/dist/index.d.ts

@@ -0,0 +1,151 @@
+/**
+ * Work Status
+ */
+declare enum WorkStatus {
+    PENDING = "pending",
+    RUNNING = "running",
+    COMPLETED = "completed",
+    FAILED = "failed",
+    SKIPPED = "skipped"
+}
+/**
+ * Workflow Status
+ */
+declare enum WorkflowStatus {
+    PENDING = "pending",
+    RUNNING = "running",
+    COMPLETED = "completed",
+    FAILED = "failed"
+}
+/**
+ * Context passed between workflow works
+ * TData is the type of shared data between works
+ * TWorkResults is a record mapping work names to their result types
+ */
+interface IWorkflowContext<TData = Record<string, unknown>, TWorkResults extends Record<string, unknown> = Record<string, unknown>> {
+    /** Shared data between works */
+    data: TData;
+    /** Work-specific results keyed by work name with inferred types */
+    workResults: IWorkResultsMap<TWorkResults>;
+}
+/**
+ * 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;
+    has(name: keyof TWorkResults): boolean;
+}
+/**
+ * Result of a single work execution
+ */
+interface IWorkResult<TResult = unknown> {
+    status: WorkStatus;
+    result?: TResult;
+    error?: Error;
+    duration: number;
+}
+/**
+ * Definition of a work with inferred name and result type
+ */
+interface IWorkDefinition<TName extends string, TData = Record<string, unknown>, TResult = unknown, TAvailableWorkResults extends Record<string, unknown> = Record<string, unknown>> {
+    /** Unique name for the work */
+    name: TName;
+    /** Execute function - receives context and returns result */
+    execute: (context: IWorkflowContext<TData, TAvailableWorkResults>) => Promise<TResult>;
+    /** Optional: condition to determine if work should run */
+    shouldRun?: (context: IWorkflowContext<TData, TAvailableWorkResults>) => boolean | Promise<boolean>;
+    /** Optional: called when work fails */
+    onError?: (error: Error, context: IWorkflowContext<TData, TAvailableWorkResults>) => void | Promise<void>;
+}
+/**
+ * Internal work representation
+ */
+interface IWorkflowWork {
+    type: 'serial' | 'parallel';
+    works: IWorkDefinition<string, any, any, any>[];
+}
+/**
+ * Result of workflow execution
+ */
+interface IWorkflowResult<TData = Record<string, unknown>, TWorkResults extends Record<string, unknown> = Record<string, unknown>> {
+    status: WorkflowStatus;
+    context: IWorkflowContext<TData, TWorkResults>;
+    workResults: Map<keyof TWorkResults, IWorkResult>;
+    totalDuration: number;
+    error?: Error;
+}
+
+/**
+ * A simple, extensible workflow engine that supports serial and parallel work execution.
+ * Work names and result types are automatically inferred from the workflow definition.
+ *
+ * @example
+ * ```typescript
+ * const workflow = new Workflow<{ userId: string }>()
+ *   .serial({
+ *     name: 'validate',
+ *     execute: async (ctx) => true, // returns boolean
+ *   })
+ *   .parallel([
+ *     {
+ *       name: 'fetchOrders',
+ *       execute: async (ctx) => [{ id: 1 }], // returns Order[]
+ *     },
+ *     {
+ *       name: 'fetchProfile',
+ *       execute: async (ctx) => ({ name: 'John' }), // returns Profile
+ *     },
+ *   ])
+ *   .serial({
+ *     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
+ *       return { orders, profile };
+ *     },
+ *   });
+ *
+ * const result = await workflow.run({ userId: '123' });
+ * ```
+ */
+declare class Workflow<TData = Record<string, unknown>, TWorkResults extends Record<string, unknown> = NonNullable<unknown>> {
+    private works;
+    /**
+     * Add a serial work to the workflow.
+     * The work name and result type are automatically inferred.
+     */
+    serial<TName extends string, TResult>(work: IWorkDefinition<TName, TData, TResult, TWorkResults>): Workflow<TData, TWorkResults & {
+        [K in TName]: TResult;
+    }>;
+    /**
+     * Add parallel works to the workflow.
+     * 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>>;
+    /**
+     * Execute the workflow with initial data
+     */
+    run(initialData: TData): Promise<IWorkflowResult<TData, TWorkResults>>;
+    /**
+     * Execute a single work
+     */
+    private executeWork;
+    /**
+     * Execute multiple works in parallel
+     */
+    private executeParallelWorks;
+}
+/**
+ * Helper type to extract work results from parallel works array
+ * Uses Extract to preserve the specific type for each work name
+ */
+type ParallelWorksToRecord<T extends readonly IWorkDefinition<string, any, any, any>[]> = {
+    [K in T[number]['name']]: Extract<T[number], {
+        name: K;
+    }> 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 };

package/dist/index.js

@@ -0,0 +1,223 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  WorkStatus: () => WorkStatus,
+  Workflow: () => Workflow,
+  WorkflowStatus: () => WorkflowStatus
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/workflow.types.ts
+var WorkStatus = /* @__PURE__ */ ((WorkStatus2) => {
+  WorkStatus2["PENDING"] = "pending";
+  WorkStatus2["RUNNING"] = "running";
+  WorkStatus2["COMPLETED"] = "completed";
+  WorkStatus2["FAILED"] = "failed";
+  WorkStatus2["SKIPPED"] = "skipped";
+  return WorkStatus2;
+})(WorkStatus || {});
+var WorkflowStatus = /* @__PURE__ */ ((WorkflowStatus2) => {
+  WorkflowStatus2["PENDING"] = "pending";
+  WorkflowStatus2["RUNNING"] = "running";
+  WorkflowStatus2["COMPLETED"] = "completed";
+  WorkflowStatus2["FAILED"] = "failed";
+  return WorkflowStatus2;
+})(WorkflowStatus || {});
+
+// src/workflow.ts
+var WorkResultsMap = class {
+  constructor() {
+    this.map = /* @__PURE__ */ new Map();
+  }
+  get(name) {
+    return this.map.get(name);
+  }
+  set(name, value) {
+    this.map.set(name, value);
+  }
+  has(name) {
+    return this.map.has(name);
+  }
+};
+var Workflow = class {
+  constructor() {
+    this.works = [];
+  }
+  /**
+   * Add a serial work to the workflow.
+   * The work name and result type are automatically inferred.
+   */
+  serial(work) {
+    this.works.push({
+      type: "serial",
+      works: [work]
+    });
+    return this;
+  }
+  /**
+   * Add parallel works to the workflow.
+   * All work names and result types are automatically inferred.
+   */
+  parallel(works) {
+    this.works.push({
+      type: "parallel",
+      works
+    });
+    return this;
+  }
+  /**
+   * Execute the workflow with initial data
+   */
+  async run(initialData) {
+    const startTime = Date.now();
+    const context = {
+      data: initialData,
+      workResults: new WorkResultsMap()
+    };
+    const workResults = /* @__PURE__ */ new Map();
+    try {
+      for (const workGroup of this.works) {
+        if (workGroup.type === "serial") {
+          await this.executeWork(workGroup.works[0], context, workResults);
+        } else {
+          await this.executeParallelWorks(workGroup.works, context, workResults);
+        }
+      }
+      return {
+        status: "completed" /* COMPLETED */,
+        context,
+        workResults,
+        totalDuration: Date.now() - startTime
+      };
+    } catch (error) {
+      return {
+        status: "failed" /* FAILED */,
+        context,
+        workResults,
+        totalDuration: Date.now() - startTime,
+        error: error instanceof Error ? error : new Error(String(error))
+      };
+    }
+  }
+  /**
+   * Execute a single work
+   */
+  async executeWork(work, context, workResults) {
+    const workStartTime = Date.now();
+    if (work.shouldRun) {
+      const shouldRun = await work.shouldRun(context);
+      if (!shouldRun) {
+        workResults.set(work.name, {
+          status: "skipped" /* SKIPPED */,
+          duration: Date.now() - workStartTime
+        });
+        return;
+      }
+    }
+    try {
+      const result = await work.execute(context);
+      context.workResults.set(work.name, result);
+      workResults.set(work.name, {
+        status: "completed" /* COMPLETED */,
+        result,
+        duration: Date.now() - workStartTime
+      });
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      workResults.set(work.name, {
+        status: "failed" /* FAILED */,
+        error: err,
+        duration: Date.now() - workStartTime
+      });
+      if (work.onError) {
+        await work.onError(err, context);
+      }
+      throw err;
+    }
+  }
+  /**
+   * Execute multiple works in parallel
+   */
+  async executeParallelWorks(works, context, workResults) {
+    const promises = works.map(async (work) => {
+      const workStartTime = Date.now();
+      if (work.shouldRun) {
+        const shouldRun = await work.shouldRun(context);
+        if (!shouldRun) {
+          workResults.set(work.name, {
+            status: "skipped" /* SKIPPED */,
+            duration: Date.now() - workStartTime
+          });
+          return { work, skipped: true };
+        }
+      }
+      try {
+        const result = await work.execute(context);
+        return { work, result, startTime: workStartTime };
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        return { work, error: err, startTime: workStartTime };
+      }
+    });
+    const results = await Promise.all(promises);
+    const errors = [];
+    for (const result of results) {
+      if ("skipped" in result && result.skipped) {
+        continue;
+      }
+      const duration = Date.now() - result.startTime;
+      if ("error" in result && result.error) {
+        workResults.set(result.work.name, {
+          status: "failed" /* FAILED */,
+          error: result.error,
+          duration
+        });
+        errors.push({ work: result.work, error: result.error });
+      } else {
+        context.workResults.set(
+          result.work.name,
+          result.result
+        );
+        workResults.set(result.work.name, {
+          status: "completed" /* COMPLETED */,
+          result: result.result,
+          duration
+        });
+      }
+    }
+    if (errors.length > 0) {
+      for (const { work, error } of errors) {
+        if (work.onError) {
+          await work.onError(error, context);
+        }
+      }
+      throw errors[0].error;
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WorkStatus,
+  Workflow,
+  WorkflowStatus
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +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: (\n    context: IWorkflowContext<TData, TAvailableWorkResults>,\n  ) => 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   \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<TWorkResults extends Record<string, unknown>>\n  implements IWorkResultsMap<TWorkResults>\n{\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<\n      TData,\n      TWorkResults & { [K in TName]: TResult }\n    >;\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<\n      string,\n      TData,\n      unknown,\n      TWorkResults\n    >[],\n  >(\n    works: TParallelWorks,\n  ): 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<\n      TData,\n      TWorkResults & ParallelWorksToRecord<TParallelWorks>\n    >;\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     \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     \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     \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(\n          result.work.name as keyof TWorkResults,\n          result.result,\n        );\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"]}

package/dist/index.mjs

@@ -0,0 +1,194 @@
+// src/workflow.types.ts
+var WorkStatus = /* @__PURE__ */ ((WorkStatus2) => {
+  WorkStatus2["PENDING"] = "pending";
+  WorkStatus2["RUNNING"] = "running";
+  WorkStatus2["COMPLETED"] = "completed";
+  WorkStatus2["FAILED"] = "failed";
+  WorkStatus2["SKIPPED"] = "skipped";
+  return WorkStatus2;
+})(WorkStatus || {});
+var WorkflowStatus = /* @__PURE__ */ ((WorkflowStatus2) => {
+  WorkflowStatus2["PENDING"] = "pending";
+  WorkflowStatus2["RUNNING"] = "running";
+  WorkflowStatus2["COMPLETED"] = "completed";
+  WorkflowStatus2["FAILED"] = "failed";
+  return WorkflowStatus2;
+})(WorkflowStatus || {});
+
+// src/workflow.ts
+var WorkResultsMap = class {
+  constructor() {
+    this.map = /* @__PURE__ */ new Map();
+  }
+  get(name) {
+    return this.map.get(name);
+  }
+  set(name, value) {
+    this.map.set(name, value);
+  }
+  has(name) {
+    return this.map.has(name);
+  }
+};
+var Workflow = class {
+  constructor() {
+    this.works = [];
+  }
+  /**
+   * Add a serial work to the workflow.
+   * The work name and result type are automatically inferred.
+   */
+  serial(work) {
+    this.works.push({
+      type: "serial",
+      works: [work]
+    });
+    return this;
+  }
+  /**
+   * Add parallel works to the workflow.
+   * All work names and result types are automatically inferred.
+   */
+  parallel(works) {
+    this.works.push({
+      type: "parallel",
+      works
+    });
+    return this;
+  }
+  /**
+   * Execute the workflow with initial data
+   */
+  async run(initialData) {
+    const startTime = Date.now();
+    const context = {
+      data: initialData,
+      workResults: new WorkResultsMap()
+    };
+    const workResults = /* @__PURE__ */ new Map();
+    try {
+      for (const workGroup of this.works) {
+        if (workGroup.type === "serial") {
+          await this.executeWork(workGroup.works[0], context, workResults);
+        } else {
+          await this.executeParallelWorks(workGroup.works, context, workResults);
+        }
+      }
+      return {
+        status: "completed" /* COMPLETED */,
+        context,
+        workResults,
+        totalDuration: Date.now() - startTime
+      };
+    } catch (error) {
+      return {
+        status: "failed" /* FAILED */,
+        context,
+        workResults,
+        totalDuration: Date.now() - startTime,
+        error: error instanceof Error ? error : new Error(String(error))
+      };
+    }
+  }
+  /**
+   * Execute a single work
+   */
+  async executeWork(work, context, workResults) {
+    const workStartTime = Date.now();
+    if (work.shouldRun) {
+      const shouldRun = await work.shouldRun(context);
+      if (!shouldRun) {
+        workResults.set(work.name, {
+          status: "skipped" /* SKIPPED */,
+          duration: Date.now() - workStartTime
+        });
+        return;
+      }
+    }
+    try {
+      const result = await work.execute(context);
+      context.workResults.set(work.name, result);
+      workResults.set(work.name, {
+        status: "completed" /* COMPLETED */,
+        result,
+        duration: Date.now() - workStartTime
+      });
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      workResults.set(work.name, {
+        status: "failed" /* FAILED */,
+        error: err,
+        duration: Date.now() - workStartTime
+      });
+      if (work.onError) {
+        await work.onError(err, context);
+      }
+      throw err;
+    }
+  }
+  /**
+   * Execute multiple works in parallel
+   */
+  async executeParallelWorks(works, context, workResults) {
+    const promises = works.map(async (work) => {
+      const workStartTime = Date.now();
+      if (work.shouldRun) {
+        const shouldRun = await work.shouldRun(context);
+        if (!shouldRun) {
+          workResults.set(work.name, {
+            status: "skipped" /* SKIPPED */,
+            duration: Date.now() - workStartTime
+          });
+          return { work, skipped: true };
+        }
+      }
+      try {
+        const result = await work.execute(context);
+        return { work, result, startTime: workStartTime };
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        return { work, error: err, startTime: workStartTime };
+      }
+    });
+    const results = await Promise.all(promises);
+    const errors = [];
+    for (const result of results) {
+      if ("skipped" in result && result.skipped) {
+        continue;
+      }
+      const duration = Date.now() - result.startTime;
+      if ("error" in result && result.error) {
+        workResults.set(result.work.name, {
+          status: "failed" /* FAILED */,
+          error: result.error,
+          duration
+        });
+        errors.push({ work: result.work, error: result.error });
+      } else {
+        context.workResults.set(
+          result.work.name,
+          result.result
+        );
+        workResults.set(result.work.name, {
+          status: "completed" /* COMPLETED */,
+          result: result.result,
+          duration
+        });
+      }
+    }
+    if (errors.length > 0) {
+      for (const { work, error } of errors) {
+        if (work.onError) {
+          await work.onError(error, context);
+        }
+      }
+      throw errors[0].error;
+    }
+  }
+};
+export {
+  WorkStatus,
+  Workflow,
+  WorkflowStatus
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +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: (\n    context: IWorkflowContext<TData, TAvailableWorkResults>,\n  ) => 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   \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<TWorkResults extends Record<string, unknown>>\n  implements IWorkResultsMap<TWorkResults>\n{\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<\n      TData,\n      TWorkResults & { [K in TName]: TResult }\n    >;\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<\n      string,\n      TData,\n      unknown,\n      TWorkResults\n    >[],\n  >(\n    works: TParallelWorks,\n  ): 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<\n      TData,\n      TWorkResults & ParallelWorksToRecord<TParallelWorks>\n    >;\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     \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     \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     \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(\n          result.work.name as keyof TWorkResults,\n          result.result,\n        );\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"]}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@yigitahmetsahin/workflow-ts",
+  "version": "1.0.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",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "lint": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "workflow",
+    "typescript",
+    "serial",
+    "parallel",
+    "pipeline",
+    "task",
+    "orchestration",
+    "async"
+  ],
+  "author": "yigitahmetsahin",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yigitahmetsahin/workflow-ts.git"
+  },
+  "bugs": {
+    "url": "https://github.com/yigitahmetsahin/workflow-ts/issues"
+  },
+  "homepage": "https://github.com/yigitahmetsahin/workflow-ts#readme",
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0",
+    "vitest": "^2.0.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}