@hatchet-dev/typescript-sdk 0.1.31 → 0.2.1

package/clients/admin/admin-client.d.ts

@@ -39,7 +39,12 @@ export declare class AdminClient {
      * @param input an object containing the input to the workflow
      * @returns the ID of the new workflow run
      */
-    run_workflow(workflowName: string, input: object): Promise<string>;
+    run_workflow<T = object>(workflowName: string, input: T, options?: {
+        parentId?: string | undefined;
+        parentStepRunId?: string | undefined;
+        childIndex?: number | undefined;
+        childKey?: string | undefined;
+    }): Promise<string>;
     /**
      * List workflows in the tenant associated with the API token.
      * @returns a list of all workflows in the tenant

package/clients/admin/admin-client.js

@@ -63,14 +63,11 @@ class AdminClient {
      * @param input an object containing the input to the workflow
      * @returns the ID of the new workflow run
      */
-    run_workflow(workflowName, input) {
+    run_workflow(workflowName, input, options) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 const inputStr = JSON.stringify(input);
-                const resp = yield this.client.triggerWorkflow({
-                    name: workflowName,
-                    input: inputStr,
-                });
+                const resp = yield this.client.triggerWorkflow(Object.assign({ name: workflowName, input: inputStr }, options));
                 return resp.workflowRunId;
             }
             catch (e) {

package/clients/dispatcher/action-listener.d.ts

@@ -2,6 +2,10 @@ import { DispatcherClient as PbDispatcherClient, AssignedAction } from '../../pr
 import { ClientConfig } from '../hatchet-client/client-config';
 import { Logger } from '../../util/logger';
 import { DispatcherClient } from './dispatcher-client';
+declare enum ListenStrategy {
+    LISTEN_STRATEGY_V1 = 1,
+    LISTEN_STRATEGY_V2 = 2
+}
 export interface Action {
     tenantId: string;
     jobId: string;
@@ -26,9 +30,16 @@ export declare class ActionListener {
     retryInterval: number;
     retryCount: number;
     done: boolean;
+    listenStrategy: ListenStrategy;
+    heartbeatInterval: any;
     constructor(client: DispatcherClient, workerId: string, retryInterval?: number, retryCount?: number);
     actions: () => AsyncGenerator<Action, void, unknown>;
+    setListenStrategy(strategy: ListenStrategy): Promise<void>;
+    getListenStrategy(): Promise<ListenStrategy>;
     incrementRetries(): Promise<void>;
+    heartbeat(): Promise<void>;
+    closeHeartbeat(): void;
     getListenClient(): Promise<AsyncIterable<AssignedAction>>;
     unregister(): Promise<import("../../protoc/dispatcher").WorkerUnsubscribeResponse>;
 }
+export {};

package/clients/dispatcher/action-listener.js

@@ -39,6 +39,12 @@ const hatchet_error_1 = __importDefault(require("../../util/errors/hatchet-error
 const logger_1 = require("../../util/logger");
 const DEFAULT_ACTION_LISTENER_RETRY_INTERVAL = 5000; // milliseconds
 const DEFAULT_ACTION_LISTENER_RETRY_COUNT = 5;
+// eslint-disable-next-line no-shadow
+var ListenStrategy;
+(function (ListenStrategy) {
+    ListenStrategy[ListenStrategy["LISTEN_STRATEGY_V1"] = 1] = "LISTEN_STRATEGY_V1";
+    ListenStrategy[ListenStrategy["LISTEN_STRATEGY_V2"] = 2] = "LISTEN_STRATEGY_V2";
+})(ListenStrategy || (ListenStrategy = {}));
 class ActionListener {
     constructor(client, workerId, retryInterval = DEFAULT_ACTION_LISTENER_RETRY_INTERVAL, retryCount = DEFAULT_ACTION_LISTENER_RETRY_COUNT) {
         this.lastConnectionAttempt = 0;
@@ -46,6 +52,7 @@ class ActionListener {
         this.retryInterval = DEFAULT_ACTION_LISTENER_RETRY_INTERVAL;
         this.retryCount = DEFAULT_ACTION_LISTENER_RETRY_COUNT;
         this.done = false;
+        this.listenStrategy = ListenStrategy.LISTEN_STRATEGY_V2;
         this.actions = () => (function gen(client) {
             return __asyncGenerator(this, arguments, function* gen_1() {
                 var _a, e_1, _b, _c;
@@ -79,6 +86,10 @@ class ActionListener {
                         if (e.code === nice_grpc_1.Status.CANCELLED) {
                             break;
                         }
+                        if ((yield __await(client.getListenStrategy())) === ListenStrategy.LISTEN_STRATEGY_V2 &&
+                            e.code === nice_grpc_1.Status.UNIMPLEMENTED) {
+                            client.setListenStrategy(ListenStrategy.LISTEN_STRATEGY_V1);
+                        }
                         client.incrementRetries();
                     }
                 }
@@ -91,11 +102,62 @@ class ActionListener {
         this.retryInterval = retryInterval;
         this.retryCount = retryCount;
     }
+    setListenStrategy(strategy) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.listenStrategy = strategy;
+        });
+    }
+    getListenStrategy() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.listenStrategy;
+        });
+    }
     incrementRetries() {
         return __awaiter(this, void 0, void 0, function* () {
             this.retries += 1;
         });
     }
+    heartbeat() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.heartbeatInterval) {
+                return;
+            }
+            // start with a heartbeat
+            try {
+                yield this.client.heartbeat({
+                    workerId: this.workerId,
+                    heartbeatAt: new Date(),
+                });
+            }
+            catch (e) {
+                this.logger.error(`Failed to send heartbeat: ${e.message}`);
+                if (e.code === nice_grpc_1.Status.UNIMPLEMENTED) {
+                    return;
+                }
+            }
+            this.heartbeatInterval = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    yield this.client.heartbeat({
+                        workerId: this.workerId,
+                        heartbeatAt: new Date(),
+                    });
+                }
+                catch (e) {
+                    if (e.code === nice_grpc_1.Status.UNIMPLEMENTED) {
+                        // break out of interval
+                        this.closeHeartbeat();
+                        return;
+                    }
+                    this.logger.error(`Failed to send heartbeat: ${e.message}`);
+                }
+            }), 4000);
+        });
+    }
+    closeHeartbeat() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+        }
+    }
     getListenClient() {
         return __awaiter(this, void 0, void 0, function* () {
             const currentTime = Math.floor(Date.now());
@@ -112,9 +174,16 @@ class ActionListener {
                 yield (0, sleep_1.default)(DEFAULT_ACTION_LISTENER_RETRY_INTERVAL);
             }
             try {
-                return this.client.listen({
+                if (this.listenStrategy === ListenStrategy.LISTEN_STRATEGY_V1) {
+                    return this.client.listen({
+                        workerId: this.workerId,
+                    });
+                }
+                const res = this.client.listenV2({
                     workerId: this.workerId,
                 });
+                this.heartbeat();
+                return res;
             }
             catch (e) {
                 this.retries += 1;
@@ -126,6 +195,7 @@ class ActionListener {
     unregister() {
         return __awaiter(this, void 0, void 0, function* () {
             this.done = true;
+            this.closeHeartbeat();
             try {
                 return this.client.unsubscribe({
                     workerId: this.workerId,

package/clients/hatchet-client/hatchet-client.js

@@ -110,7 +110,7 @@ class HatchetClient {
         this.event = new event_client_1.EventClient(this.config, this.channel, clientFactory);
         this.dispatcher = new dispatcher_client_1.DispatcherClient(this.config, this.channel, clientFactory);
         this.admin = new admin_client_1.AdminClient(this.config, this.channel, clientFactory, this.api, this.tenantId);
-        this.listener = new listener_client_1.ListenerClient(this.config, this.channel, clientFactory);
+        this.listener = new listener_client_1.ListenerClient(this.config, this.channel, clientFactory, this.api);
         this.logger = new logger_1.default('HatchetClient', this.config.log_level);
         this.logger.info(`Initialized HatchetClient`);
     }

package/clients/listener/listener-client.d.ts

@@ -1,26 +1,49 @@
+/// <reference types="node" />
 import { Channel, ClientFactory } from 'nice-grpc';
+import { EventEmitter } from 'events';
 import { DispatcherClient as PbDispatcherClient } from '../../protoc/dispatcher';
 import { ClientConfig } from '../hatchet-client/client-config';
 import { Logger } from '../../util/logger';
-export declare enum StepRunEventType {
+import { Api } from '../rest';
+export declare enum RunEventType {
     STEP_RUN_EVENT_TYPE_STARTED = "STEP_RUN_EVENT_TYPE_STARTED",
     STEP_RUN_EVENT_TYPE_COMPLETED = "STEP_RUN_EVENT_TYPE_COMPLETED",
     STEP_RUN_EVENT_TYPE_FAILED = "STEP_RUN_EVENT_TYPE_FAILED",
     STEP_RUN_EVENT_TYPE_CANCELLED = "STEP_RUN_EVENT_TYPE_CANCELLED",
-    STEP_RUN_EVENT_TYPE_TIMED_OUT = "STEP_RUN_EVENT_TYPE_TIMED_OUT"
+    STEP_RUN_EVENT_TYPE_TIMED_OUT = "STEP_RUN_EVENT_TYPE_TIMED_OUT",
+    WORKFLOW_RUN_EVENT_TYPE_STARTED = "WORKFLOW_RUN_EVENT_TYPE_STARTED",
+    WORKFLOW_RUN_EVENT_TYPE_COMPLETED = "WORKFLOW_RUN_EVENT_TYPE_COMPLETED",
+    WORKFLOW_RUN_EVENT_TYPE_FAILED = "WORKFLOW_RUN_EVENT_TYPE_FAILED",
+    WORKFLOW_RUN_EVENT_TYPE_CANCELLED = "WORKFLOW_RUN_EVENT_TYPE_CANCELLED",
+    WORKFLOW_RUN_EVENT_TYPE_TIMED_OUT = "WORKFLOW_RUN_EVENT_TYPE_TIMED_OUT"
 }
 export interface StepRunEvent {
-    type: StepRunEventType;
+    type: RunEventType;
     payload: string;
 }
+export declare class PollingAsyncListener {
+    client: ListenerClient;
+    q: Array<StepRunEvent>;
+    eventEmitter: EventEmitter;
+    pollInterval: any;
+    constructor(workflowRunid: string, client: ListenerClient);
+    emit(event: StepRunEvent): void;
+    listen(workflowRunId: string): Promise<void>;
+    retrySubscribe(workflowRunId: string): Promise<AsyncIterable<import("../../protoc/dispatcher").WorkflowEvent>>;
+    getWorkflowRun(workflowRunId: string): Promise<{
+        type: RunEventType;
+        payload: string;
+    } | undefined>;
+    polling(workflowRunId: string): Promise<void>;
+    close(): void;
+    stream(): AsyncGenerator<StepRunEvent, void, unknown>;
+}
 export declare class ListenerClient {
     config: ClientConfig;
     client: PbDispatcherClient;
     logger: Logger;
-    constructor(config: ClientConfig, channel: Channel, factory: ClientFactory);
-    stream(workflowRunId: string): AsyncGenerator<{
-        type: StepRunEventType;
-        payload: string;
-    }, void, unknown>;
-    retrySubscribe(workflowRunId: string): Promise<AsyncIterable<import("../../protoc/dispatcher").WorkflowEvent>>;
+    api: Api;
+    constructor(config: ClientConfig, channel: Channel, factory: ClientFactory, api: Api);
+    get(workflowRunId: string): PollingAsyncListener;
+    stream(workflowRunId: string): Promise<AsyncGenerator<StepRunEvent, void, unknown>>;
 }

package/clients/listener/listener-client.js

@@ -32,94 +32,137 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ListenerClient = exports.StepRunEventType = void 0;
+exports.ListenerClient = exports.PollingAsyncListener = exports.RunEventType = void 0;
+// eslint-disable-next-line max-classes-per-file
 const nice_grpc_1 = require("nice-grpc");
+const events_1 = require("events");
 const dispatcher_1 = require("../../protoc/dispatcher");
 const hatchet_error_1 = __importDefault(require("../../util/errors/hatchet-error"));
 const logger_1 = require("../../util/logger");
 const sleep_1 = __importDefault(require("../../util/sleep"));
-const DEFAULT_ACTION_LISTENER_RETRY_INTERVAL = 5; // seconds
-const DEFAULT_ACTION_LISTENER_RETRY_COUNT = 5;
+const data_contracts_1 = require("../rest/generated/data-contracts");
+const DEFAULT_EVENT_LISTENER_RETRY_INTERVAL = 5; // seconds
+const DEFAULT_EVENT_LISTENER_RETRY_COUNT = 5;
+const DEFAULT_EVENT_LISTENER_POLL_INTERVAL = 5000; // milliseconds
 // eslint-disable-next-line no-shadow
-var StepRunEventType;
-(function (StepRunEventType) {
-    StepRunEventType["STEP_RUN_EVENT_TYPE_STARTED"] = "STEP_RUN_EVENT_TYPE_STARTED";
-    StepRunEventType["STEP_RUN_EVENT_TYPE_COMPLETED"] = "STEP_RUN_EVENT_TYPE_COMPLETED";
-    StepRunEventType["STEP_RUN_EVENT_TYPE_FAILED"] = "STEP_RUN_EVENT_TYPE_FAILED";
-    StepRunEventType["STEP_RUN_EVENT_TYPE_CANCELLED"] = "STEP_RUN_EVENT_TYPE_CANCELLED";
-    StepRunEventType["STEP_RUN_EVENT_TYPE_TIMED_OUT"] = "STEP_RUN_EVENT_TYPE_TIMED_OUT";
-})(StepRunEventType || (exports.StepRunEventType = StepRunEventType = {}));
-class ListenerClient {
-    constructor(config, channel, factory) {
-        this.config = config;
-        this.client = factory.create(dispatcher_1.DispatcherDefinition, channel);
-        this.logger = new logger_1.Logger(`Listener`, config.log_level);
+var RunEventType;
+(function (RunEventType) {
+    RunEventType["STEP_RUN_EVENT_TYPE_STARTED"] = "STEP_RUN_EVENT_TYPE_STARTED";
+    RunEventType["STEP_RUN_EVENT_TYPE_COMPLETED"] = "STEP_RUN_EVENT_TYPE_COMPLETED";
+    RunEventType["STEP_RUN_EVENT_TYPE_FAILED"] = "STEP_RUN_EVENT_TYPE_FAILED";
+    RunEventType["STEP_RUN_EVENT_TYPE_CANCELLED"] = "STEP_RUN_EVENT_TYPE_CANCELLED";
+    RunEventType["STEP_RUN_EVENT_TYPE_TIMED_OUT"] = "STEP_RUN_EVENT_TYPE_TIMED_OUT";
+    RunEventType["WORKFLOW_RUN_EVENT_TYPE_STARTED"] = "WORKFLOW_RUN_EVENT_TYPE_STARTED";
+    RunEventType["WORKFLOW_RUN_EVENT_TYPE_COMPLETED"] = "WORKFLOW_RUN_EVENT_TYPE_COMPLETED";
+    RunEventType["WORKFLOW_RUN_EVENT_TYPE_FAILED"] = "WORKFLOW_RUN_EVENT_TYPE_FAILED";
+    RunEventType["WORKFLOW_RUN_EVENT_TYPE_CANCELLED"] = "WORKFLOW_RUN_EVENT_TYPE_CANCELLED";
+    RunEventType["WORKFLOW_RUN_EVENT_TYPE_TIMED_OUT"] = "WORKFLOW_RUN_EVENT_TYPE_TIMED_OUT";
+})(RunEventType || (exports.RunEventType = RunEventType = {}));
+const stepEventTypeMap = {
+    [dispatcher_1.ResourceEventType.RESOURCE_EVENT_TYPE_STARTED]: RunEventType.STEP_RUN_EVENT_TYPE_STARTED,
+    [dispatcher_1.ResourceEventType.RESOURCE_EVENT_TYPE_COMPLETED]: RunEventType.STEP_RUN_EVENT_TYPE_COMPLETED,
+    [dispatcher_1.ResourceEventType.RESOURCE_EVENT_TYPE_FAILED]: RunEventType.STEP_RUN_EVENT_TYPE_FAILED,
+    [dispatcher_1.ResourceEventType.RESOURCE_EVENT_TYPE_CANCELLED]: RunEventType.STEP_RUN_EVENT_TYPE_CANCELLED,
+    [dispatcher_1.ResourceEventType.RESOURCE_EVENT_TYPE_TIMED_OUT]: RunEventType.STEP_RUN_EVENT_TYPE_TIMED_OUT,
+    [dispatcher_1.ResourceEventType.RESOURCE_EVENT_TYPE_UNKNOWN]: undefined,
+    [dispatcher_1.ResourceEventType.UNRECOGNIZED]: undefined,
+};
+const workflowEventTypeMap = {
+    [dispatcher_1.ResourceEventType.RESOURCE_EVENT_TYPE_STARTED]: RunEventType.WORKFLOW_RUN_EVENT_TYPE_STARTED,
+    [dispatcher_1.ResourceEventType.RESOURCE_EVENT_TYPE_COMPLETED]: RunEventType.WORKFLOW_RUN_EVENT_TYPE_COMPLETED,
+    [dispatcher_1.ResourceEventType.RESOURCE_EVENT_TYPE_FAILED]: RunEventType.WORKFLOW_RUN_EVENT_TYPE_FAILED,
+    [dispatcher_1.ResourceEventType.RESOURCE_EVENT_TYPE_CANCELLED]: RunEventType.WORKFLOW_RUN_EVENT_TYPE_CANCELLED,
+    [dispatcher_1.ResourceEventType.RESOURCE_EVENT_TYPE_TIMED_OUT]: RunEventType.WORKFLOW_RUN_EVENT_TYPE_TIMED_OUT,
+    [dispatcher_1.ResourceEventType.RESOURCE_EVENT_TYPE_UNKNOWN]: undefined,
+    [dispatcher_1.ResourceEventType.UNRECOGNIZED]: undefined,
+};
+const resourceTypeMap = {
+    [dispatcher_1.ResourceType.RESOURCE_TYPE_STEP_RUN]: stepEventTypeMap,
+    [dispatcher_1.ResourceType.RESOURCE_TYPE_WORKFLOW_RUN]: workflowEventTypeMap,
+    [dispatcher_1.ResourceType.RESOURCE_TYPE_UNKNOWN]: undefined,
+    [dispatcher_1.ResourceType.UNRECOGNIZED]: undefined,
+};
+const workflowStatusMap = {
+    [data_contracts_1.WorkflowRunStatus.SUCCEEDED]: RunEventType.WORKFLOW_RUN_EVENT_TYPE_COMPLETED,
+    [data_contracts_1.WorkflowRunStatus.FAILED]: RunEventType.WORKFLOW_RUN_EVENT_TYPE_FAILED,
+    [data_contracts_1.WorkflowRunStatus.CANCELLED]: RunEventType.WORKFLOW_RUN_EVENT_TYPE_CANCELLED,
+    [data_contracts_1.WorkflowRunStatus.PENDING]: undefined,
+    [data_contracts_1.WorkflowRunStatus.RUNNING]: undefined,
+};
+class PollingAsyncListener {
+    constructor(workflowRunid, client) {
+        this.q = [];
+        this.eventEmitter = new events_1.EventEmitter();
+        this.client = client;
+        this.listen(workflowRunid);
+        this.polling(workflowRunid);
     }
-    stream(workflowRunId) {
-        return __asyncGenerator(this, arguments, function* stream_1() {
-            var _a, e_1, _b, _c;
-            let listener = this.client.subscribeToWorkflowEvents({
+    emit(event) {
+        this.q.push(event);
+        this.eventEmitter.emit('event');
+    }
+    listen(workflowRunId) {
+        var _a, e_1, _b, _c;
+        var _d;
+        return __awaiter(this, void 0, void 0, function* () {
+            let listener = this.client.client.subscribeToWorkflowEvents({
                 workflowRunId,
             });
+            const res = yield this.getWorkflowRun(workflowRunId);
+            if (res) {
+                this.emit(res);
+                this.close();
+            }
             try {
                 try {
-                    for (var _d = true, listener_1 = __asyncValues(listener), listener_1_1; listener_1_1 = yield __await(listener_1.next()), _a = listener_1_1.done, !_a; _d = true) {
+                    for (var _e = true, listener_1 = __asyncValues(listener), listener_1_1; listener_1_1 = yield listener_1.next(), _a = listener_1_1.done, !_a; _e = true) {
                         _c = listener_1_1.value;
-                        _d = false;
+                        _e = false;
                         const workflowEvent = _c;
-                        let eventType;
-                        switch (workflowEvent.eventType) {
-                            case dispatcher_1.ResourceEventType.RESOURCE_EVENT_TYPE_STARTED:
-                                eventType = StepRunEventType.STEP_RUN_EVENT_TYPE_STARTED;
-                                break;
-                            case dispatcher_1.ResourceEventType.RESOURCE_EVENT_TYPE_COMPLETED:
-                                eventType = StepRunEventType.STEP_RUN_EVENT_TYPE_COMPLETED;
-                                break;
-                            case dispatcher_1.ResourceEventType.RESOURCE_EVENT_TYPE_FAILED:
-                                eventType = StepRunEventType.STEP_RUN_EVENT_TYPE_FAILED;
-                                break;
-                            case dispatcher_1.ResourceEventType.RESOURCE_EVENT_TYPE_CANCELLED:
-                                eventType = StepRunEventType.STEP_RUN_EVENT_TYPE_CANCELLED;
-                                break;
-                            case dispatcher_1.ResourceEventType.RESOURCE_EVENT_TYPE_TIMED_OUT:
-                                eventType = StepRunEventType.STEP_RUN_EVENT_TYPE_TIMED_OUT;
-                                break;
-                            default:
-                            // no nothing
-                        }
+                        const eventType = (_d = resourceTypeMap[workflowEvent.resourceType]) === null || _d === void 0 ? void 0 : _d[workflowEvent.eventType];
                         if (eventType) {
-                            yield yield __await({
-                                type: eventType,
-                                payload: workflowEvent.eventPayload,
-                            });
+                            if (eventType === RunEventType.WORKFLOW_RUN_EVENT_TYPE_COMPLETED) {
+                                // OPTIMZATION - consider including the workflow run data in the event?
+                                const data = yield this.getWorkflowRun(workflowRunId);
+                                if (data) {
+                                    this.emit(data);
+                                }
+                            }
+                            else {
+                                this.emit({
+                                    type: eventType,
+                                    payload: workflowEvent.eventPayload,
+                                });
+                            }
                         }
                     }
                 }
                 catch (e_1_1) { e_1 = { error: e_1_1 }; }
                 finally {
                     try {
-                        if (!_d && !_a && (_b = listener_1.return)) yield __await(_b.call(listener_1));
+                        if (!_e && !_a && (_b = listener_1.return)) yield _b.call(listener_1);
                     }
                     finally { if (e_1) throw e_1.error; }
                 }
             }
             catch (e) {
                 if (e.code === nice_grpc_1.Status.CANCELLED) {
-                    return yield __await(void 0);
+                    return;
                 }
                 if (e.code === nice_grpc_1.Status.UNAVAILABLE) {
-                    listener = yield __await(this.retrySubscribe(workflowRunId));
+                    listener = yield this.retrySubscribe(workflowRunId);
                 }
             }
+            setTimeout(() => this.close(), DEFAULT_EVENT_LISTENER_POLL_INTERVAL * 5);
         });
     }
     retrySubscribe(workflowRunId) {
         return __awaiter(this, void 0, void 0, function* () {
             let retries = 0;
-            while (retries < DEFAULT_ACTION_LISTENER_RETRY_COUNT) {
+            while (retries < DEFAULT_EVENT_LISTENER_RETRY_COUNT) {
                 try {
-                    yield (0, sleep_1.default)(DEFAULT_ACTION_LISTENER_RETRY_INTERVAL);
-                    const listener = this.client.subscribeToWorkflowEvents({
+                    yield (0, sleep_1.default)(DEFAULT_EVENT_LISTENER_RETRY_INTERVAL);
+                    const listener = this.client.client.subscribeToWorkflowEvents({
                         workflowRunId,
                     });
                     return listener;
@@ -128,7 +171,98 @@ class ListenerClient {
                     retries += 1;
                 }
             }
-            throw new hatchet_error_1.default(`Could not subscribe to the worker after ${DEFAULT_ACTION_LISTENER_RETRY_COUNT} retries`);
+            throw new hatchet_error_1.default(`Could not subscribe to the worker after ${DEFAULT_EVENT_LISTENER_RETRY_COUNT} retries`);
+        });
+    }
+    getWorkflowRun(workflowRunId) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const res = yield this.client.api.workflowRunGet(this.client.config.tenant_id, workflowRunId);
+                const stepRuns = (_c = (_b = (_a = res.data.jobRuns) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.stepRuns) !== null && _c !== void 0 ? _c : [];
+                const stepRunOutput = stepRuns.reduce((acc, stepRun) => {
+                    var _a;
+                    acc[((_a = stepRun.step) === null || _a === void 0 ? void 0 : _a.readableId) || ''] = JSON.parse(stepRun.output || '{}');
+                    return acc;
+                }, {});
+                if (Object.keys(workflowStatusMap).includes(res.data.status)) {
+                    const type = workflowStatusMap[res.data.status];
+                    if (!type)
+                        return undefined;
+                    return {
+                        type,
+                        payload: JSON.stringify(stepRunOutput),
+                    };
+                }
+                return undefined;
+            }
+            catch (e) {
+                throw new hatchet_error_1.default(e.message);
+            }
+        });
+    }
+    polling(workflowRunId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.pollInterval = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const result = yield this.getWorkflowRun(workflowRunId);
+                    if (result) {
+                        this.emit(result);
+                        this.close();
+                    }
+                }
+                catch (e) {
+                    // TODO error handling
+                }
+            }), DEFAULT_EVENT_LISTENER_POLL_INTERVAL);
+        });
+    }
+    close() {
+        if (this.pollInterval) {
+            clearInterval(this.pollInterval);
+        }
+    }
+    stream() {
+        return __asyncGenerator(this, arguments, function* stream_1() {
+            var _a, e_2, _b, _c;
+            try {
+                for (var _d = true, _e = __asyncValues((0, events_1.on)(this.eventEmitter, 'event')), _f; _f = yield __await(_e.next()), _a = _f.done, !_a; _d = true) {
+                    _c = _f.value;
+                    _d = false;
+                    const _ = _c;
+                    while (this.q.length > 0) {
+                        const r = this.q.shift();
+                        if (r) {
+                            yield yield __await(r);
+                        }
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        });
+    }
+}
+exports.PollingAsyncListener = PollingAsyncListener;
+class ListenerClient {
+    constructor(config, channel, factory, api) {
+        this.config = config;
+        this.client = factory.create(dispatcher_1.DispatcherDefinition, channel);
+        this.logger = new logger_1.Logger(`Listener`, config.log_level);
+        this.api = api;
+    }
+    get(workflowRunId) {
+        const listener = new PollingAsyncListener(workflowRunId, this);
+        return listener;
+    }
+    stream(workflowRunId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.get(workflowRunId).stream();
         });
     }
 }

package/clients/worker/worker.js

@@ -104,7 +104,7 @@ class Worker {
     handleStartStepRun(action) {
         const { actionId } = action;
         try {
-            const context = new step_1.Context(action, this.client.dispatcher, this.client.event);
+            const context = new step_1.Context(action, this.client);
             this.contexts[action.stepRunId] = context;
             const step = this.action_registry[actionId];
             if (!step) {
@@ -153,7 +153,7 @@ class Worker {
     handleStartGroupKeyRun(action) {
         const { actionId } = action;
         try {
-            const context = new step_1.Context(action, this.client.dispatcher, this.client.event);
+            const context = new step_1.Context(action, this.client);
             const key = action.getGroupKeyRunId;
             this.contexts[key] = context;
             this.logger.debug(`Starting group key run ${key}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "0.1.31",
+  "version": "0.2.1",
   "description": "Background task orchestration & visibility for developers",
   "types": "dist/index.d.ts",
   "files": [
@@ -26,14 +26,15 @@
     "generate-protoc": "./generate-protoc.sh",
     "lint:check": "npm run eslint:check && npm run prettier:check",
     "lint:fix": "npm run eslint:fix && npm run prettier:fix",
-    "eslint:check": "eslint \"{hatchet,tests}/**/*.{ts,tsx,js}\"",
-    "eslint:fix": "eslint \"{hatchet,tests}/**/*.{ts,tsx,js}\" --fix",
-    "prettier:check": "prettier \"hatchet/**/*.{ts,tsx}\" --list-different",
-    "prettier:fix": "prettier \"hatchet/**/*.{ts,tsx}\" --write",
+    "eslint:check": "eslint \"{src,tests}/**/*.{ts,tsx,js}\"",
+    "eslint:fix": "eslint \"{src,tests}/**/*.{ts,tsx,js}\" --fix",
+    "prettier:check": "prettier \"src/**/*.{ts,tsx}\" --list-different",
+    "prettier:fix": "prettier \"src/**/*.{ts,tsx}\" --write",
     "exec": "npx dotenv -- ts-node -r tsconfig-paths/register --project tsconfig.json",
     "example:event": "npm run exec -- ./examples/example-event.ts",
     "example:event-listen": "npm run exec -- ./examples/example-event-with-results.ts",
     "worker:namespaced": "npm run exec -- ./examples/namespaced-worker.ts",
+    "worker:fanout": "npm run exec -- ./examples/fanout-worker.ts",
     "worker:simple": "npm run exec -- ./examples/simple-worker.ts",
     "manual:trigger": "npm run exec -- ./examples/manual-trigger.ts",
     "worker:dag": "npm run exec -- ./examples/dag-worker.ts",
@@ -54,8 +55,8 @@
   "author": "",
   "license": "MIT",
   "devDependencies": {
-    "@types/node": "^20.11.16",
     "@types/jest": "^29.5.11",
+    "@types/node": "^20.11.16",
     "@typescript-eslint/eslint-plugin": "^6.4.0",
     "autoprefixer": "^10.4.16",
     "dotenv-cli": "^7.3.0",
@@ -69,6 +70,9 @@
     "eslint-plugin-n": "^15.0.0 || ^16.0.0 ",
     "eslint-plugin-prettier": "^5.0.1",
     "eslint-plugin-promise": "^6.0.0",
+    "eslint-plugin-react": "^7.34.1",
+    "eslint-plugin-react-hooks": "^4.6.0",
+    "eslint-plugin-react-refresh": "^0.4.6",
     "eslint-plugin-unused-imports": "^3.0.0",
     "grpc-tools": "^1.12.4",
     "jest": "^29.7.0",