@raspect/workflow-sdk 0.1.0

package/dist/workflow.d.ts

@@ -0,0 +1,74 @@
+import type { ActivityHandler, WorkflowClass } from './types';
+/**
+ * Context for workflow execution, holds activities and allows execute_activity calls.
+ */
+export declare class WorkflowContext {
+    readonly activities: Map<string, ActivityHandler>;
+    readonly workflowId: string;
+    readonly worker: WorkerInterface | null;
+    readonly activityResults: unknown[];
+    readonly metadata: Record<string, unknown>;
+    private _completedActivities;
+    private _currentActivityIndex;
+    private _isReplaying;
+    constructor(activities: Map<string, ActivityHandler>, workflowId: string, worker?: WorkerInterface | null, completedActivities?: Map<number, unknown> | null, metadata?: Record<string, unknown> | null);
+    /**
+     * Execute an activity and return its result.
+     */
+    executeActivity<TInput = unknown, TOutput = unknown>(activity: ActivityHandler<TInput, TOutput> | string, inputData?: TInput, startToCloseTimeoutMs?: number): Promise<TOutput>;
+}
+export interface WorkerInterface {
+    reportLocalActivityCompletion(workflowId: string, activityName: string, activityIndex: number, output: unknown, durationMs: number): Promise<void>;
+    reportLocalActivityFailure(workflowId: string, activityName: string, activityIndex: number, error: string, errorType: string, durationMs: number): Promise<void>;
+    executeRemoteActivity(workflowId: string, activityName: string, activityIndex: number, inputData: unknown, timeoutMs: number): Promise<unknown>;
+}
+/**
+ * Get the current workflow context.
+ */
+export declare function getCurrentContext(): WorkflowContext;
+/**
+ * Run a function within a workflow context.
+ */
+export declare function runWithContext<T>(ctx: WorkflowContext, fn: () => Promise<T>): Promise<T>;
+/**
+ * Decorator to mark a class as a workflow definition.
+ *
+ * Usage:
+ *   import { workflow } from '@inspectica/workflow-sdk';
+ *
+ *   @workflow.defn
+ *   class MyWorkflow {
+ *     @workflow.run
+ *     async run(input: { name: string }) {
+ *       return await workflow.executeActivity(myActivity, input);
+ *     }
+ *   }
+ */
+export declare function defn<T extends WorkflowClass>(cls: T): T;
+/**
+ * Decorator to mark a method as the workflow entry point.
+ */
+export declare function run(target: any, propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;
+/**
+ * Execute an activity within a workflow.
+ *
+ * Usage:
+ *   // Option 1: Local activity (function reference)
+ *   const result = await workflow.executeActivity(myActivity, { key: "value" });
+ *
+ *   // Option 2: Remote activity (string name) - for cross-worker calls
+ *   const result = await workflow.executeActivity("say_count", { message: "hi", count: 1 });
+ */
+export declare function executeActivity<TInput = unknown, TOutput = unknown>(activity: ActivityHandler<TInput, TOutput> | string, inputData?: TInput, startToCloseTimeoutMs?: number): Promise<TOutput>;
+/**
+ * Get the workflow name from a class
+ */
+export declare function getWorkflowName(cls: WorkflowClass): string;
+/**
+ * Check if a class is a decorated workflow
+ */
+export declare function isWorkflow(cls: unknown): boolean;
+/**
+ * Find the run method in a workflow class
+ */
+export declare function findRunMethod(cls: WorkflowClass): ((input: unknown) => Promise<unknown>) | null;

package/dist/workflow.js

@@ -0,0 +1,186 @@
+"use strict";
+// Workflow decorators and context utilities
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowContext = void 0;
+exports.getCurrentContext = getCurrentContext;
+exports.runWithContext = runWithContext;
+exports.defn = defn;
+exports.run = run;
+exports.executeActivity = executeActivity;
+exports.getWorkflowName = getWorkflowName;
+exports.isWorkflow = isWorkflow;
+exports.findRunMethod = findRunMethod;
+const activity_1 = require("./activity");
+// Symbol for workflow metadata
+const WORKFLOW_NAME = Symbol('workflowName');
+const IS_WORKFLOW = Symbol('isWorkflow');
+const IS_WORKFLOW_RUN = Symbol('isWorkflowRun');
+// AsyncLocalStorage for workflow context (Node.js equivalent of Python's contextvars)
+const async_hooks_1 = require("async_hooks");
+const workflowContextStorage = new async_hooks_1.AsyncLocalStorage();
+/**
+ * Context for workflow execution, holds activities and allows execute_activity calls.
+ */
+class WorkflowContext {
+    activities;
+    workflowId;
+    worker;
+    activityResults = [];
+    metadata;
+    _completedActivities;
+    _currentActivityIndex = 0;
+    _isReplaying;
+    constructor(activities, workflowId, worker = null, completedActivities = null, metadata = null) {
+        this.activities = activities;
+        this.workflowId = workflowId;
+        this.worker = worker;
+        this._completedActivities = completedActivities || new Map();
+        this._currentActivityIndex = 0;
+        this._isReplaying = completedActivities !== null && completedActivities.size > 0;
+        this.metadata = metadata || {};
+    }
+    /**
+     * Execute an activity and return its result.
+     */
+    async executeActivity(activity, inputData, startToCloseTimeoutMs = 60000) {
+        // Increment activity index for this call
+        this._currentActivityIndex += 1;
+        const currentIndex = this._currentActivityIndex;
+        // Check if this activity was already completed (replay mode)
+        if (this._completedActivities.has(currentIndex)) {
+            const cachedResult = this._completedActivities.get(currentIndex);
+            console.log(`Replay: Returning cached result for activity index ${currentIndex}`);
+            this.activityResults.push(cachedResult);
+            return cachedResult;
+        }
+        // Support both function reference and string name
+        const activityName = (0, activity_1.getActivityName)(activity);
+        // Check if activity is registered locally
+        const activityFn = this.activities.get(activityName);
+        if (activityFn) {
+            // Execute locally (in-process)
+            const startTime = Date.now();
+            try {
+                const result = await Promise.race([
+                    Promise.resolve(activityFn(inputData)),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error(`Activity timed out after ${startToCloseTimeoutMs}ms`)), startToCloseTimeoutMs)),
+                ]);
+                const durationMs = Date.now() - startTime;
+                // Report local activity completion to server for activity history tracking
+                if (this.worker) {
+                    await this.worker.reportLocalActivityCompletion(this.workflowId, activityName, currentIndex, result, durationMs);
+                }
+                this.activityResults.push(result);
+                return result;
+            }
+            catch (error) {
+                const durationMs = Date.now() - startTime;
+                const err = error;
+                // Report local activity failure to server
+                if (this.worker) {
+                    await this.worker.reportLocalActivityFailure(this.workflowId, activityName, currentIndex, err.message, err.name, durationMs);
+                }
+                throw error;
+            }
+        }
+        // Activity not registered locally - route via server
+        if (!this.worker) {
+            throw new Error(`Activity '${activityName}' not registered locally and no worker available for remote execution`);
+        }
+        // Execute remotely via server routing
+        const result = await this.worker.executeRemoteActivity(this.workflowId, activityName, currentIndex, inputData, startToCloseTimeoutMs);
+        this.activityResults.push(result);
+        return result;
+    }
+}
+exports.WorkflowContext = WorkflowContext;
+/**
+ * Get the current workflow context.
+ */
+function getCurrentContext() {
+    const ctx = workflowContextStorage.getStore();
+    if (!ctx) {
+        throw new Error('Not running inside a workflow context');
+    }
+    return ctx;
+}
+/**
+ * Run a function within a workflow context.
+ */
+function runWithContext(ctx, fn) {
+    return workflowContextStorage.run(ctx, fn);
+}
+/**
+ * Decorator to mark a class as a workflow definition.
+ *
+ * Usage:
+ *   import { workflow } from '@inspectica/workflow-sdk';
+ *
+ *   @workflow.defn
+ *   class MyWorkflow {
+ *     @workflow.run
+ *     async run(input: { name: string }) {
+ *       return await workflow.executeActivity(myActivity, input);
+ *     }
+ *   }
+ */
+function defn(cls) {
+    cls.__workflowName__ = cls.name;
+    cls.__isWorkflow__ = true;
+    cls[WORKFLOW_NAME] = cls.name;
+    cls[IS_WORKFLOW] = true;
+    return cls;
+}
+/**
+ * Decorator to mark a method as the workflow entry point.
+ */
+function run(target, propertyKey, descriptor) {
+    descriptor.value.__isWorkflowRun__ = true;
+    descriptor.value[IS_WORKFLOW_RUN] = true;
+    return descriptor;
+}
+/**
+ * Execute an activity within a workflow.
+ *
+ * Usage:
+ *   // Option 1: Local activity (function reference)
+ *   const result = await workflow.executeActivity(myActivity, { key: "value" });
+ *
+ *   // Option 2: Remote activity (string name) - for cross-worker calls
+ *   const result = await workflow.executeActivity("say_count", { message: "hi", count: 1 });
+ */
+async function executeActivity(activity, inputData, startToCloseTimeoutMs = 60000) {
+    const ctx = getCurrentContext();
+    return ctx.executeActivity(activity, inputData, startToCloseTimeoutMs);
+}
+/**
+ * Get the workflow name from a class
+ */
+function getWorkflowName(cls) {
+    return cls.__workflowName__ || cls.name;
+}
+/**
+ * Check if a class is a decorated workflow
+ */
+function isWorkflow(cls) {
+    return typeof cls === 'function' && cls.__isWorkflow__ === true;
+}
+/**
+ * Find the run method in a workflow class
+ */
+function findRunMethod(cls) {
+    const instance = new cls();
+    const proto = Object.getPrototypeOf(instance);
+    for (const key of Object.getOwnPropertyNames(proto)) {
+        const method = instance[key];
+        if (typeof method === 'function' && method.__isWorkflowRun__) {
+            return method.bind(instance);
+        }
+    }
+    // Fallback: check for a method named 'run'
+    if (typeof instance.run === 'function') {
+        return instance.run.bind(instance);
+    }
+    return null;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workflow.js","sourceRoot":"","sources":["../src/workflow.ts"],"names":[],"mappings":";AAAA,4CAA4C;;;AAuK5C,8CAMC;AAKD,wCAEC;AAgBD,oBAMC;AAKD,kBAQC;AAYD,0CAOC;AAKD,0CAEC;AAKD,gCAEC;AAKD,sCAiBC;AA3QD,yCAA6C;AAE7C,+BAA+B;AAC/B,MAAM,aAAa,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC;AAC7C,MAAM,WAAW,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC;AACzC,MAAM,eAAe,GAAG,MAAM,CAAC,eAAe,CAAC,CAAC;AAEhD,sFAAsF;AACtF,6CAAgD;AAEhD,MAAM,sBAAsB,GAAG,IAAI,+BAAiB,EAAmB,CAAC;AAExE;;GAEG;AACH,MAAa,eAAe;IACV,UAAU,CAA+B;IACzC,UAAU,CAAS;IACnB,MAAM,CAAyB;IAC/B,eAAe,GAAc,EAAE,CAAC;IAChC,QAAQ,CAA0B;IAE1C,oBAAoB,CAAuB;IAC3C,qBAAqB,GAAG,CAAC,CAAC;IAC1B,YAAY,CAAU;IAE9B,YACE,UAAwC,EACxC,UAAkB,EAClB,SAAiC,IAAI,EACrC,sBAAmD,IAAI,EACvD,WAA2C,IAAI;QAE/C,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,oBAAoB,GAAG,mBAAmB,IAAI,IAAI,GAAG,EAAE,CAAC;QAC7D,IAAI,CAAC,qBAAqB,GAAG,CAAC,CAAC;QAC/B,IAAI,CAAC,YAAY,GAAG,mBAAmB,KAAK,IAAI,IAAI,mBAAmB,CAAC,IAAI,GAAG,CAAC,CAAC;QACjF,IAAI,CAAC,QAAQ,GAAG,QAAQ,IAAI,EAAE,CAAC;IACjC,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,eAAe,CACnB,QAAmD,EACnD,SAAkB,EAClB,qBAAqB,GAAG,KAAK;QAE7B,yCAAyC;QACzC,IAAI,CAAC,qBAAqB,IAAI,CAAC,CAAC;QAChC,MAAM,YAAY,GAAG,IAAI,CAAC,qBAAqB,CAAC;QAEhD,6DAA6D;QAC7D,IAAI,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,YAAY,CAAC,EAAE,CAAC;YAChD,MAAM,YAAY,GAAG,IAAI,CAAC,oBAAoB,CAAC,GAAG,CAAC,YAAY,CAAY,CAAC;YAC5E,OAAO,CAAC,GAAG,CAAC,sDAAsD,YAAY,EAAE,CAAC,CAAC;YAClF,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YACxC,OAAO,YAAY,CAAC;QACtB,CAAC;QAED,kDAAkD;QAClD,MAAM,YAAY,GAAG,IAAA,0BAAe,EAAC,QAAoC,CAAC,CAAC;QAE3E,0CAA0C;QAC1C,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;QACrD,IAAI,UAAU,EAAE,CAAC;YACf,+BAA+B;YAC/B,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YAE7B,IAAI,CAAC;gBACH,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC;oBAChC,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;oBACtC,IAAI,OAAO,CAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAC/B,UAAU,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,4BAA4B,qBAAqB,IAAI,CAAC,CAAC,EAAE,qBAAqB,CAAC,CAClH;iBACF,CAAY,CAAC;gBAEd,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,CAAC;gBAE1C,2EAA2E;gBAC3E,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;oBAChB,MAAM,IAAI,CAAC,MAAM,CAAC,6BAA6B,CAC7C,IAAI,CAAC,UAAU,EACf,YAAY,EACZ,YAAY,EACZ,MAAM,EACN,UAAU,CACX,CAAC;gBACJ,CAAC;gBAED,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;gBAClC,OAAO,MAAM,CAAC;YAChB,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,CAAC;gBAC1C,MAAM,GAAG,GAAG,KAAc,CAAC;gBAE3B,0CAA0C;gBAC1C,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;oBAChB,MAAM,IAAI,CAAC,MAAM,CAAC,0BAA0B,CAC1C,IAAI,CAAC,UAAU,EACf,YAAY,EACZ,YAAY,EACZ,GAAG,CAAC,OAAO,EACX,GAAG,CAAC,IAAI,EACR,UAAU,CACX,CAAC;gBACJ,CAAC;gBAED,MAAM,KAAK,CAAC;YACd,CAAC;QACH,CAAC;QAED,qDAAqD;QACrD,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;YACjB,MAAM,IAAI,KAAK,CACb,aAAa,YAAY,uEAAuE,CACjG,CAAC;QACJ,CAAC;QAED,sCAAsC;QACtC,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,qBAAqB,CACpD,IAAI,CAAC,UAAU,EACf,YAAY,EACZ,YAAY,EACZ,SAAS,EACT,qBAAqB,CACX,CAAC;QAEb,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAClC,OAAO,MAAM,CAAC;IAChB,CAAC;CACF;AAtHD,0CAsHC;AA4BD;;GAEG;AACH,SAAgB,iBAAiB;IAC/B,MAAM,GAAG,GAAG,sBAAsB,CAAC,QAAQ,EAAE,CAAC;IAC9C,IAAI,CAAC,GAAG,EAAE,CAAC;QACT,MAAM,IAAI,KAAK,CAAC,uCAAuC,CAAC,CAAC;IAC3D,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;GAEG;AACH,SAAgB,cAAc,CAAI,GAAoB,EAAE,EAAoB;IAC1E,OAAO,sBAAsB,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;AAC7C,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,SAAgB,IAAI,CAA0B,GAAM;IACjD,GAAW,CAAC,gBAAgB,GAAG,GAAG,CAAC,IAAI,CAAC;IACxC,GAAW,CAAC,cAAc,GAAG,IAAI,CAAC;IAClC,GAAW,CAAC,aAAa,CAAC,GAAG,GAAG,CAAC,IAAI,CAAC;IACtC,GAAW,CAAC,WAAW,CAAC,GAAG,IAAI,CAAC;IACjC,OAAO,GAAG,CAAC;AACb,CAAC;AAED;;GAEG;AACH,SAAgB,GAAG,CACjB,MAAW,EACX,WAAmB,EACnB,UAA8B;IAE9B,UAAU,CAAC,KAAK,CAAC,iBAAiB,GAAG,IAAI,CAAC;IAC1C,UAAU,CAAC,KAAK,CAAC,eAAe,CAAC,GAAG,IAAI,CAAC;IACzC,OAAO,UAAU,CAAC;AACpB,CAAC;AAED;;;;;;;;;GASG;AACI,KAAK,UAAU,eAAe,CACnC,QAAmD,EACnD,SAAkB,EAClB,qBAAqB,GAAG,KAAK;IAE7B,MAAM,GAAG,GAAG,iBAAiB,EAAE,CAAC;IAChC,OAAO,GAAG,CAAC,eAAe,CAAC,QAAQ,EAAE,SAAS,EAAE,qBAAqB,CAAC,CAAC;AACzE,CAAC;AAED;;GAEG;AACH,SAAgB,eAAe,CAAC,GAAkB;IAChD,OAAQ,GAAW,CAAC,gBAAgB,IAAI,GAAG,CAAC,IAAI,CAAC;AACnD,CAAC;AAED;;GAEG;AACH,SAAgB,UAAU,CAAC,GAAY;IACrC,OAAO,OAAO,GAAG,KAAK,UAAU,IAAK,GAAW,CAAC,cAAc,KAAK,IAAI,CAAC;AAC3E,CAAC;AAED;;GAEG;AACH,SAAgB,aAAa,CAAC,GAAkB;IAC9C,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAE,CAAC;IAC3B,MAAM,KAAK,GAAG,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC;IAE9C,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,mBAAmB,CAAC,KAAK,CAAC,EAAE,CAAC;QACpD,MAAM,MAAM,GAAI,QAAgB,CAAC,GAAG,CAAC,CAAC;QACtC,IAAI,OAAO,MAAM,KAAK,UAAU,IAAI,MAAM,CAAC,iBAAiB,EAAE,CAAC;YAC7D,OAAO,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC/B,CAAC;IACH,CAAC;IAED,2CAA2C;IAC3C,IAAI,OAAO,QAAQ,CAAC,GAAG,KAAK,UAAU,EAAE,CAAC;QACvC,OAAO,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IACrC,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC","sourcesContent":["// Workflow decorators and context utilities\n\nimport type { ActivityHandler, WorkflowClass, WorkflowInstance } from './types';\nimport { getActivityName } from './activity';\n\n// Symbol for workflow metadata\nconst WORKFLOW_NAME = Symbol('workflowName');\nconst IS_WORKFLOW = Symbol('isWorkflow');\nconst IS_WORKFLOW_RUN = Symbol('isWorkflowRun');\n\n// AsyncLocalStorage for workflow context (Node.js equivalent of Python's contextvars)\nimport { AsyncLocalStorage } from 'async_hooks';\n\nconst workflowContextStorage = new AsyncLocalStorage<WorkflowContext>();\n\n/**\n * Context for workflow execution, holds activities and allows execute_activity calls.\n */\nexport class WorkflowContext {\n  public readonly activities: Map<string, ActivityHandler>;\n  public readonly workflowId: string;\n  public readonly worker: WorkerInterface | null;\n  public readonly activityResults: unknown[] = [];\n  public readonly metadata: Record<string, unknown>;\n\n  private _completedActivities: Map<number, unknown>;\n  private _currentActivityIndex = 0;\n  private _isReplaying: boolean;\n\n  constructor(\n    activities: Map<string, ActivityHandler>,\n    workflowId: string,\n    worker: WorkerInterface | null = null,\n    completedActivities: Map<number, unknown> | null = null,\n    metadata: Record<string, unknown> | null = null\n  ) {\n    this.activities = activities;\n    this.workflowId = workflowId;\n    this.worker = worker;\n    this._completedActivities = completedActivities || new Map();\n    this._currentActivityIndex = 0;\n    this._isReplaying = completedActivities !== null && completedActivities.size > 0;\n    this.metadata = metadata || {};\n  }\n\n  /**\n   * Execute an activity and return its result.\n   */\n  async executeActivity<TInput = unknown, TOutput = unknown>(\n    activity: ActivityHandler<TInput, TOutput> | string,\n    inputData?: TInput,\n    startToCloseTimeoutMs = 60000\n  ): Promise<TOutput> {\n    // Increment activity index for this call\n    this._currentActivityIndex += 1;\n    const currentIndex = this._currentActivityIndex;\n\n    // Check if this activity was already completed (replay mode)\n    if (this._completedActivities.has(currentIndex)) {\n      const cachedResult = this._completedActivities.get(currentIndex) as TOutput;\n      console.log(`Replay: Returning cached result for activity index ${currentIndex}`);\n      this.activityResults.push(cachedResult);\n      return cachedResult;\n    }\n\n    // Support both function reference and string name\n    const activityName = getActivityName(activity as ActivityHandler | string);\n\n    // Check if activity is registered locally\n    const activityFn = this.activities.get(activityName);\n    if (activityFn) {\n      // Execute locally (in-process)\n      const startTime = Date.now();\n\n      try {\n        const result = await Promise.race([\n          Promise.resolve(activityFn(inputData)),\n          new Promise<never>((_, reject) =>\n            setTimeout(() => reject(new Error(`Activity timed out after ${startToCloseTimeoutMs}ms`)), startToCloseTimeoutMs)\n          ),\n        ]) as TOutput;\n\n        const durationMs = Date.now() - startTime;\n\n        // Report local activity completion to server for activity history tracking\n        if (this.worker) {\n          await this.worker.reportLocalActivityCompletion(\n            this.workflowId,\n            activityName,\n            currentIndex,\n            result,\n            durationMs\n          );\n        }\n\n        this.activityResults.push(result);\n        return result;\n      } catch (error) {\n        const durationMs = Date.now() - startTime;\n        const err = error as Error;\n\n        // Report local activity failure to server\n        if (this.worker) {\n          await this.worker.reportLocalActivityFailure(\n            this.workflowId,\n            activityName,\n            currentIndex,\n            err.message,\n            err.name,\n            durationMs\n          );\n        }\n\n        throw error;\n      }\n    }\n\n    // Activity not registered locally - route via server\n    if (!this.worker) {\n      throw new Error(\n        `Activity '${activityName}' not registered locally and no worker available for remote execution`\n      );\n    }\n\n    // Execute remotely via server routing\n    const result = await this.worker.executeRemoteActivity(\n      this.workflowId,\n      activityName,\n      currentIndex,\n      inputData,\n      startToCloseTimeoutMs\n    ) as TOutput;\n\n    this.activityResults.push(result);\n    return result;\n  }\n}\n\n// Interface for worker methods needed by WorkflowContext\nexport interface WorkerInterface {\n  reportLocalActivityCompletion(\n    workflowId: string,\n    activityName: string,\n    activityIndex: number,\n    output: unknown,\n    durationMs: number\n  ): Promise<void>;\n  reportLocalActivityFailure(\n    workflowId: string,\n    activityName: string,\n    activityIndex: number,\n    error: string,\n    errorType: string,\n    durationMs: number\n  ): Promise<void>;\n  executeRemoteActivity(\n    workflowId: string,\n    activityName: string,\n    activityIndex: number,\n    inputData: unknown,\n    timeoutMs: number\n  ): Promise<unknown>;\n}\n\n/**\n * Get the current workflow context.\n */\nexport function getCurrentContext(): WorkflowContext {\n  const ctx = workflowContextStorage.getStore();\n  if (!ctx) {\n    throw new Error('Not running inside a workflow context');\n  }\n  return ctx;\n}\n\n/**\n * Run a function within a workflow context.\n */\nexport function runWithContext<T>(ctx: WorkflowContext, fn: () => Promise<T>): Promise<T> {\n  return workflowContextStorage.run(ctx, fn);\n}\n\n/**\n * Decorator to mark a class as a workflow definition.\n * \n * Usage:\n *   import { workflow } from '@inspectica/workflow-sdk';\n *   \n *   @workflow.defn\n *   class MyWorkflow {\n *     @workflow.run\n *     async run(input: { name: string }) {\n *       return await workflow.executeActivity(myActivity, input);\n *     }\n *   }\n */\nexport function defn<T extends WorkflowClass>(cls: T): T {\n  (cls as any).__workflowName__ = cls.name;\n  (cls as any).__isWorkflow__ = true;\n  (cls as any)[WORKFLOW_NAME] = cls.name;\n  (cls as any)[IS_WORKFLOW] = true;\n  return cls;\n}\n\n/**\n * Decorator to mark a method as the workflow entry point.\n */\nexport function run(\n  target: any,\n  propertyKey: string,\n  descriptor: PropertyDescriptor\n): PropertyDescriptor {\n  descriptor.value.__isWorkflowRun__ = true;\n  descriptor.value[IS_WORKFLOW_RUN] = true;\n  return descriptor;\n}\n\n/**\n * Execute an activity within a workflow.\n * \n * Usage:\n *   // Option 1: Local activity (function reference)\n *   const result = await workflow.executeActivity(myActivity, { key: \"value\" });\n *   \n *   // Option 2: Remote activity (string name) - for cross-worker calls\n *   const result = await workflow.executeActivity(\"say_count\", { message: \"hi\", count: 1 });\n */\nexport async function executeActivity<TInput = unknown, TOutput = unknown>(\n  activity: ActivityHandler<TInput, TOutput> | string,\n  inputData?: TInput,\n  startToCloseTimeoutMs = 60000\n): Promise<TOutput> {\n  const ctx = getCurrentContext();\n  return ctx.executeActivity(activity, inputData, startToCloseTimeoutMs);\n}\n\n/**\n * Get the workflow name from a class\n */\nexport function getWorkflowName(cls: WorkflowClass): string {\n  return (cls as any).__workflowName__ || cls.name;\n}\n\n/**\n * Check if a class is a decorated workflow\n */\nexport function isWorkflow(cls: unknown): boolean {\n  return typeof cls === 'function' && (cls as any).__isWorkflow__ === true;\n}\n\n/**\n * Find the run method in a workflow class\n */\nexport function findRunMethod(cls: WorkflowClass): ((input: unknown) => Promise<unknown>) | null {\n  const instance = new cls();\n  const proto = Object.getPrototypeOf(instance);\n  \n  for (const key of Object.getOwnPropertyNames(proto)) {\n    const method = (instance as any)[key];\n    if (typeof method === 'function' && method.__isWorkflowRun__) {\n      return method.bind(instance);\n    }\n  }\n  \n  // Fallback: check for a method named 'run'\n  if (typeof instance.run === 'function') {\n    return instance.run.bind(instance);\n  }\n  \n  return null;\n}\n"]}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@raspect/workflow-sdk",
+  "version": "0.1.0",
+  "description": "Node.js SDK for Inspectica Workflow Server - Activity worker implementation",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "lint": "eslint src --ext .ts",
+    "format": "prettier --write src/**/*.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "workflow",
+    "orchestration",
+    "kafka",
+    "distributed",
+    "activity",
+    "worker"
+  ],
+  "author": "Inspectica Team",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/your-org/inspectica-workflow-server.git",
+    "directory": "packages/node-sdk"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "aws-msk-iam-sasl-signer-js": "^1.0.0",
+    "kafkajs": "^2.2.4"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.10.0",
+    "eslint": "^9.17.0",
+    "jest": "^29.7.0",
+    "prettier": "^3.4.2",
+    "ts-jest": "^29.2.5",
+    "typescript": "^5.7.2",
+    "typescript-eslint": "^8.18.0"
+  }
+}