@hatchet-dev/typescript-sdk 1.0.0-alpha1 → 1.0.0-alpha2

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

@@ -3,9 +3,10 @@ import { CreateWorkflowVersionOpts, RateLimitDuration, WorkflowServiceClient } f
 import { ClientConfig } from '../hatchet-client/client-config';
 import { Logger } from '../../util/logger';
 import WorkflowRunRef from '../../util/workflow-run-ref';
+import { AdminServiceClient, CreateWorkflowVersionRequest } from '../../protoc/v1/workflows';
 import { Api } from '../rest';
 import { WebhookWorkerCreateRequest, WorkflowRunStatus, WorkflowRunStatusList } from '../rest/generated/data-contracts';
-import { ListenerClient } from '../listener/listener-client';
+import { RunListenerClient } from '../listeners/run-listener/child-listener-client';
 type WorkflowMetricsQuery = {
     workflowId?: string;
     workflowName?: string;
@@ -23,30 +24,15 @@ export type WorkflowRun<T = object> = {
         additionalMetadata?: Record<string, string> | undefined;
     };
 };
-/**
- * AdminClient is a client for interacting with the Hatchet Admin API. This allows you to configure, trigger,
- * and monitor workflows.
- * The admin client can be accessed via:
- * ```typescript
- * const hatchet = Hatchet.init()
- * const admin = hatchet.admin as AdminClient;
- *
- * // Now you can use the admin client to interact with the Hatchet Admin API
- * admin.list_workflows().then((res) => {
- *   res.rows?.forEach((row) => {
- *     console.log(row);
- *   });
- * });
- * ```
- */
 export declare class AdminClient {
     config: ClientConfig;
     client: WorkflowServiceClient;
+    v1Client: AdminServiceClient;
     api: Api;
     tenantId: string;
     logger: Logger;
-    listenerClient: ListenerClient;
-    constructor(config: ClientConfig, channel: Channel, factory: ClientFactory, api: Api, tenantId: string, listenerClient: ListenerClient);
+    listenerClient: RunListenerClient;
+    constructor(config: ClientConfig, channel: Channel, factory: ClientFactory, api: Api, tenantId: string, listenerClient: RunListenerClient);
     /**
      * @deprecated use putWorkflow instead
      */
@@ -58,9 +44,18 @@ export declare class AdminClient {
      */
     putWorkflow(workflow: CreateWorkflowVersionOpts): Promise<import("../../protoc/workflows").WorkflowVersion>;
     /**
-     * @deprecated use putRateLimit instead
+     * Creates a new workflow or updates an existing workflow. If the workflow already exists, Hatchet will automatically
+     * determine if the workflow definition has changed and create a new version if necessary.
+     * @param workflow a workflow definition to create
+     */
+    putWorkflowV1(workflow: CreateWorkflowVersionRequest): Promise<import("../../protoc/v1/workflows").CreateWorkflowVersionResponse>;
+    /**
+     * @deprecated use hatchet.ratelimits.upsert instead
      */
     put_rate_limit(key: string, limit: number, duration: RateLimitDuration): Promise<void>;
+    /**
+     * @deprecated use hatchet.ratelimits.upsert instead
+     */
     putRateLimit(key: string, limit: number, duration?: RateLimitDuration): Promise<void>;
     registerWebhook(data: WebhookWorkerCreateRequest): Promise<import("axios").AxiosResponse<import("../rest/generated/data-contracts").WebhookWorkerCreated, any>>;
     /**

package/clients/admin/admin-client.js

@@ -17,26 +17,12 @@ const workflows_1 = require("../../protoc/workflows");
 const hatchet_error_1 = __importDefault(require("../../util/errors/hatchet-error"));
 const retrier_1 = require("../../util/retrier");
 const workflow_run_ref_1 = __importDefault(require("../../util/workflow-run-ref"));
-/**
- * AdminClient is a client for interacting with the Hatchet Admin API. This allows you to configure, trigger,
- * and monitor workflows.
- * The admin client can be accessed via:
- * ```typescript
- * const hatchet = Hatchet.init()
- * const admin = hatchet.admin as AdminClient;
- *
- * // Now you can use the admin client to interact with the Hatchet Admin API
- * admin.list_workflows().then((res) => {
- *   res.rows?.forEach((row) => {
- *     console.log(row);
- *   });
- * });
- * ```
- */
+const workflows_2 = require("../../protoc/v1/workflows");
 class AdminClient {
     constructor(config, channel, factory, api, tenantId, listenerClient) {
         this.config = config;
         this.client = factory.create(workflows_1.WorkflowServiceDefinition, channel);
+        this.v1Client = factory.create(workflows_2.AdminServiceDefinition, channel);
         this.api = api;
         this.tenantId = tenantId;
         this.logger = config.logger(`Admin`, config.log_level);
@@ -66,13 +52,31 @@ class AdminClient {
         });
     }
     /**
-     * @deprecated use putRateLimit instead
+     * Creates a new workflow or updates an existing workflow. If the workflow already exists, Hatchet will automatically
+     * determine if the workflow definition has changed and create a new version if necessary.
+     * @param workflow a workflow definition to create
+     */
+    putWorkflowV1(workflow) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield (0, retrier_1.retrier)(() => __awaiter(this, void 0, void 0, function* () { return this.v1Client.putWorkflow(workflow); }), this.logger);
+            }
+            catch (e) {
+                throw new hatchet_error_1.default(e.message);
+            }
+        });
+    }
+    /**
+     * @deprecated use hatchet.ratelimits.upsert instead
      */
     put_rate_limit(key, limit, duration) {
         return __awaiter(this, void 0, void 0, function* () {
             return this.putRateLimit(key, limit, duration);
         });
     }
+    /**
+     * @deprecated use hatchet.ratelimits.upsert instead
+     */
     putRateLimit(key_1, limit_1) {
         return __awaiter(this, arguments, void 0, function* (key, limit, duration = workflows_1.RateLimitDuration.SECOND) {
             try {

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

@@ -6,12 +6,12 @@ import { Workflow as V0Workflow } from '../../workflow';
 import { V0Worker, WorkerOpts } from '../worker';
 import { AxiosRequestConfig } from 'axios';
 import { Logger } from '../../util/logger';
-import { WorkflowDeclaration as V1Workflow } from '../../v1/workflow';
 import { ClientConfig } from './client-config';
-import { ListenerClient } from '../listener/listener-client';
+import { RunListenerClient } from '../listeners/run-listener/child-listener-client';
 import { Api } from '../rest/generated/Api';
 import { CronClient } from './features/cron-client';
 import { ScheduleClient } from './features/schedule-client';
+import { DurableListenerClient } from '../listeners/durable-listener/durable-listener-client';
 export interface HatchetClientOptions {
     config_path?: string;
     credentials?: ChannelCredentials;
@@ -25,8 +25,9 @@ export declare class InternalHatchetClient {
     dispatcher: DispatcherClient;
     admin: AdminClient;
     api: Api;
-    listener: ListenerClient;
+    listener: RunListenerClient;
     tenantId: string;
+    durableListener: DurableListenerClient;
     logger: Logger;
     cron: CronClient;
     schedule: ScheduleClient;
@@ -34,5 +35,5 @@ export declare class InternalHatchetClient {
     static init(config?: Partial<ClientConfig>, options?: HatchetClientOptions, axiosConfig?: AxiosRequestConfig): InternalHatchetClient;
     run(workflow: string | V0Workflow): Promise<V0Worker>;
     worker(workflow: string | V0Workflow, opts?: Omit<WorkerOpts, 'name'> | number): Promise<V0Worker>;
-    webhooks(workflows: Array<V1Workflow<any, any> | V0Workflow>): import("../worker/handler").WebhookHandler;
+    webhooks(workflows: Array<V0Workflow>): import("../worker/handler").WebhookHandler;
 }

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

@@ -46,12 +46,12 @@ const admin_client_1 = require("../admin/admin-client");
 const nice_grpc_1 = require("nice-grpc");
 const worker_1 = require("../worker");
 const hatchet_logger_1 = require("./hatchet-logger");
-const worker_2 = require("../../v1/client/worker");
 const client_config_1 = require("./client-config");
-const listener_client_1 = require("../listener/listener-client");
+const child_listener_client_1 = require("../listeners/run-listener/child-listener-client");
 const rest_1 = __importDefault(require("../rest"));
 const cron_client_1 = require("./features/cron-client");
 const schedule_client_1 = require("./features/schedule-client");
+const durable_listener_client_1 = require("../listeners/durable-listener/durable-listener-client");
 const channelFactory = (config, credentials) => (0, nice_grpc_1.createChannel)(config.host_port, credentials, {
     'grpc.ssl_target_name_override': config.tls_config.server_name,
     'grpc.keepalive_timeout_ms': 60 * 1000,
@@ -118,8 +118,9 @@ class InternalHatchetClient {
         this.api = (0, rest_1.default)(this.config.api_url, this.config.token, axiosOpts);
         this.event = new event_client_1.EventClient(this.config, (0, exports.channelFactory)(this.config, this.credentials), clientFactory);
         this.dispatcher = new dispatcher_client_1.DispatcherClient(this.config, (0, exports.channelFactory)(this.config, this.credentials), clientFactory);
-        this.listener = new listener_client_1.ListenerClient(this.config, (0, exports.channelFactory)(this.config, this.credentials), clientFactory, this.api);
+        this.listener = new child_listener_client_1.RunListenerClient(this.config, (0, exports.channelFactory)(this.config, this.credentials), clientFactory, this.api);
         this.admin = new admin_client_1.AdminClient(this.config, (0, exports.channelFactory)(this.config, this.credentials), clientFactory, this.api, this.tenantId, this.listener);
+        this.durableListener = new durable_listener_client_1.DurableListenerClient(this.config, (0, exports.channelFactory)(this.config, this.credentials), clientFactory, this.api);
         this.logger = this.config.logger('HatchetClient', this.config.log_level);
         this.logger.debug(`Initialized HatchetClient`);
         // Feature Clients
@@ -160,10 +161,11 @@ class InternalHatchetClient {
         });
     }
     webhooks(workflows) {
+        // TODO v1 workflows
         const worker = new worker_1.V0Worker(this, {
             name: 'webhook-worker',
         });
-        return worker.getHandler(workflows.map(worker_2.toV0Workflow));
+        return worker.getHandler(workflows);
     }
 }
 exports.InternalHatchetClient = InternalHatchetClient;

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

@@ -0,0 +1,25 @@
+import { Channel, ClientFactory } from 'nice-grpc';
+import { ClientConfig } from '../../hatchet-client/client-config';
+import { Logger } from '../../../util/logger';
+import { V1DispatcherClient } from '../../../protoc/v1/dispatcher';
+import { SleepMatchCondition, UserEventMatchCondition } from '../../../protoc/v1/shared/condition';
+import { Api } from '../../rest';
+import { DurableEventGrpcPooledListener } from './pooled-durable-listener-client';
+export declare class DurableListenerClient {
+    config: ClientConfig;
+    client: V1DispatcherClient;
+    logger: Logger;
+    api: Api;
+    pooledListener: DurableEventGrpcPooledListener | undefined;
+    constructor(config: ClientConfig, channel: Channel, factory: ClientFactory, api: Api);
+    subscribe(request: {
+        taskId: string;
+        signalKey: string;
+    }): import("./pooled-durable-listener-client").DurableEventStreamable;
+    registerDurableEvent(request: {
+        taskId: string;
+        signalKey: string;
+        sleepConditions: Array<SleepMatchCondition>;
+        userEventConditions: Array<UserEventMatchCondition>;
+    }): Promise<import("../../../protoc/v1/dispatcher").RegisterDurableEventResponse>;
+}

package/clients/listeners/durable-listener/durable-listener-client.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DurableListenerClient = void 0;
+const dispatcher_1 = require("../../../protoc/v1/dispatcher");
+const pooled_durable_listener_client_1 = require("./pooled-durable-listener-client");
+class DurableListenerClient {
+    constructor(config, channel, factory, api) {
+        this.config = config;
+        this.client = factory.create(dispatcher_1.V1DispatcherDefinition, channel);
+        this.logger = config.logger(`Listener`, config.log_level);
+        this.api = api;
+    }
+    subscribe(request) {
+        if (!this.pooledListener) {
+            this.pooledListener = new pooled_durable_listener_client_1.DurableEventGrpcPooledListener(this, () => {
+                this.pooledListener = undefined;
+            });
+        }
+        return this.pooledListener.subscribe(request);
+    }
+    registerDurableEvent(request) {
+        if (!this.pooledListener) {
+            this.pooledListener = new pooled_durable_listener_client_1.DurableEventGrpcPooledListener(this, () => {
+                this.pooledListener = undefined;
+            });
+        }
+        return this.pooledListener.registerDurableEvent(request);
+    }
+}
+exports.DurableListenerClient = DurableListenerClient;

package/clients/listeners/durable-listener/pooled-durable-listener-client.d.ts

@@ -0,0 +1,43 @@
+import { EventEmitter } from 'events';
+import { DurableEvent, RegisterDurableEventResponse } from '../../../protoc/v1/dispatcher';
+import { SleepMatchCondition, UserEventMatchCondition } from '../../../protoc/v1/shared/condition';
+import { DurableListenerClient } from './durable-listener-client';
+export declare class DurableEventStreamable {
+    listener: AsyncIterable<DurableEvent>;
+    taskId: string;
+    signalKey: string;
+    responseEmitter: EventEmitter<[never]>;
+    constructor(listener: AsyncIterable<DurableEvent>, taskId: string, signalKey: string);
+    get(): Promise<DurableEvent>;
+}
+export declare class DurableEventGrpcPooledListener {
+    listener: AsyncIterable<DurableEvent> | undefined;
+    requestEmitter: EventEmitter<[never]>;
+    signal: AbortController;
+    client: DurableListenerClient;
+    subscribers: Record<string, DurableEventStreamable>;
+    taskSignalKeyToSubscriptionIds: Record<string, string[]>;
+    onFinish: () => void;
+    private subscriptionCounter;
+    private currRequester;
+    private readonly DEFAULT_INTERRUPT_INTERVAL;
+    constructor(client: DurableListenerClient, onFinish: () => void);
+    private scheduleInterrupt;
+    private init;
+    subscribe(request: {
+        taskId: string;
+        signalKey: string;
+    }): DurableEventStreamable;
+    result(request: {
+        taskId: string;
+        signalKey: string;
+    }): Promise<DurableEvent>;
+    registerDurableEvent(request: {
+        taskId: string;
+        signalKey: string;
+        sleepConditions: Array<SleepMatchCondition>;
+        userEventConditions: Array<UserEventMatchCondition>;
+    }): Promise<RegisterDurableEventResponse>;
+    replayRequests(): void;
+    private request;
+}

package/clients/listeners/durable-listener/pooled-durable-listener-client.js

@@ -0,0 +1,241 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DurableEventGrpcPooledListener = exports.DurableEventStreamable = void 0;
+// eslint-disable-next-line max-classes-per-file
+const events_1 = require("events");
+const abort_controller_x_1 = require("abort-controller-x");
+const sleep_1 = __importDefault(require("../../../util/sleep"));
+class DurableEventStreamable {
+    constructor(listener, taskId, signalKey) {
+        this.responseEmitter = new events_1.EventEmitter();
+        this.listener = listener;
+        this.taskId = taskId;
+        this.signalKey = signalKey;
+    }
+    get() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve) => {
+                this.responseEmitter.once('response', resolve);
+            });
+        });
+    }
+}
+exports.DurableEventStreamable = DurableEventStreamable;
+class DurableEventGrpcPooledListener {
+    constructor(client, onFinish) {
+        this.requestEmitter = new events_1.EventEmitter();
+        this.signal = new AbortController();
+        this.subscribers = {};
+        this.taskSignalKeyToSubscriptionIds = {};
+        this.onFinish = () => { };
+        this.subscriptionCounter = 0;
+        this.currRequester = 0;
+        this.DEFAULT_INTERRUPT_INTERVAL = 15 * 60 * 1000; // 15 minutes in milliseconds
+        this.client = client;
+        this.init();
+        this.onFinish = onFinish;
+        this.scheduleInterrupt();
+    }
+    scheduleInterrupt() {
+        setTimeout(() => {
+            if (this.signal) {
+                this.signal.abort();
+                this.init(0);
+            }
+            this.scheduleInterrupt();
+        }, this.DEFAULT_INTERRUPT_INTERVAL);
+    }
+    init() {
+        return __awaiter(this, arguments, void 0, function* (retries = 0) {
+            var _a, e_1, _b, _c;
+            let retryCount = retries;
+            const MAX_RETRY_INTERVAL = 5000; // 5 seconds in milliseconds
+            const BASE_RETRY_INTERVAL = 100; // 0.1 seconds in milliseconds
+            const MAX_RETRY_COUNT = 5;
+            if (retries > 0) {
+                const backoffTime = Math.min(BASE_RETRY_INTERVAL * 2 ** (retries - 1), MAX_RETRY_INTERVAL);
+                this.client.logger.info(`Retrying in ... ${backoffTime / 1000} seconds`);
+                yield (0, sleep_1.default)(backoffTime);
+            }
+            if (retries > MAX_RETRY_COUNT) {
+                this.client.logger.error('Max retry count exceeded for durable event listener');
+                return;
+            }
+            try {
+                this.client.logger.debug('Initializing durable-event-listener');
+                this.signal = new AbortController();
+                // eslint-disable-next-line no-plusplus
+                this.currRequester++;
+                this.listener = this.client.client.listenForDurableEvent(this.request(), {
+                    signal: this.signal.signal,
+                });
+                if (retries > 0)
+                    setTimeout(() => this.replayRequests(), 100);
+                try {
+                    for (var _d = true, _e = __asyncValues(this.listener), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                        _c = _f.value;
+                        _d = false;
+                        const event = _c;
+                        retryCount = 0;
+                        const subscriptionKey = keyHelper(event.taskId, event.signalKey);
+                        const subscriptionIds = this.taskSignalKeyToSubscriptionIds[subscriptionKey] || [];
+                        for (const subId of subscriptionIds) {
+                            const emitter = this.subscribers[subId];
+                            if (emitter) {
+                                emitter.responseEmitter.emit('response', event);
+                                delete this.subscribers[subId];
+                                // Remove this subscription from the mapping
+                                this.taskSignalKeyToSubscriptionIds[subscriptionKey] =
+                                    this.taskSignalKeyToSubscriptionIds[subscriptionKey].filter((id) => id !== subId);
+                                if (this.taskSignalKeyToSubscriptionIds[subscriptionKey].length === 0) {
+                                    delete this.taskSignalKeyToSubscriptionIds[subscriptionKey];
+                                }
+                            }
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+                this.client.logger.debug('Durable event listener finished');
+            }
+            catch (e) {
+                if ((0, abort_controller_x_1.isAbortError)(e)) {
+                    this.client.logger.debug('Durable event listener aborted');
+                    return;
+                }
+                this.client.logger.error(`Error in durable-event-listener: ${e.message}`);
+            }
+            finally {
+                const subscriberCount = Object.keys(this.subscribers).length;
+                if (subscriberCount > 0) {
+                    this.client.logger.debug(`Durable event listener loop exited with ${subscriberCount} subscribers`);
+                    this.client.logger.debug(`Restarting durable event listener retry ${retryCount + 1}`);
+                    this.init(retryCount + 1);
+                }
+            }
+        });
+    }
+    subscribe(request) {
+        const { taskId, signalKey } = request;
+        if (!this.listener)
+            throw new Error('listener not initialized');
+        // eslint-disable-next-line no-plusplus
+        const subscriptionId = (this.subscriptionCounter++).toString();
+        const subscriber = new DurableEventStreamable(this.listener, taskId, signalKey);
+        this.subscribers[subscriptionId] = subscriber;
+        const key = keyHelper(taskId, signalKey);
+        if (!this.taskSignalKeyToSubscriptionIds[key]) {
+            this.taskSignalKeyToSubscriptionIds[key] = [];
+        }
+        this.taskSignalKeyToSubscriptionIds[key].push(subscriptionId);
+        this.requestEmitter.emit('subscribe', { taskId, signalKey });
+        return subscriber;
+    }
+    result(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const subscriber = this.subscribe(request);
+            const event = yield subscriber.get();
+            return event;
+        });
+    }
+    registerDurableEvent(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const conditions = {
+                sleepConditions: request.sleepConditions,
+                userEventConditions: request.userEventConditions,
+            };
+            const registerRequest = {
+                taskId: request.taskId,
+                signalKey: request.signalKey,
+                conditions,
+            };
+            return this.client.client.registerDurableEvent(registerRequest);
+        });
+    }
+    replayRequests() {
+        const subscriptionEntries = Object.entries(this.taskSignalKeyToSubscriptionIds);
+        this.client.logger.debug(`Replaying ${subscriptionEntries.length} requests...`);
+        for (const [key, _] of subscriptionEntries) {
+            const [taskId, signalKey] = key.split('-');
+            this.requestEmitter.emit('subscribe', { taskId, signalKey });
+        }
+    }
+    request() {
+        return __asyncGenerator(this, arguments, function* request_1() {
+            var _a, e_2, _b, _c;
+            const { currRequester } = this;
+            // Replay existing subscriptions
+            const existingSubscriptions = new Set();
+            for (const key in this.taskSignalKeyToSubscriptionIds) {
+                if (this.taskSignalKeyToSubscriptionIds[key].length > 0) {
+                    const [taskId, signalKey] = key.split('-');
+                    existingSubscriptions.add(key);
+                    yield yield __await({ taskId, signalKey });
+                }
+            }
+            try {
+                for (var _d = true, _e = __asyncValues((0, events_1.on)(this.requestEmitter, 'subscribe')), _f; _f = yield __await(_e.next()), _a = _f.done, !_a; _d = true) {
+                    _c = _f.value;
+                    _d = false;
+                    const e = _c;
+                    // Stop if this requester is outdated
+                    if (currRequester !== this.currRequester)
+                        break;
+                    const request = e[0];
+                    const key = keyHelper(request.taskId, request.signalKey);
+                    // Only send unique subscriptions
+                    if (!existingSubscriptions.has(key)) {
+                        existingSubscriptions.add(key);
+                        yield yield __await(request);
+                    }
+                }
+            }
+            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.DurableEventGrpcPooledListener = DurableEventGrpcPooledListener;
+const keyHelper = (taskId, signalKey) => `${taskId}-${signalKey}`;

package/clients/{listener/listener-client.d.ts → listeners/run-listener/child-listener-client.d.ts}

@@ -1,10 +1,10 @@
 import { Channel, ClientFactory } from 'nice-grpc';
 import { EventEmitter } from 'events';
-import { DispatcherClient as PbDispatcherClient, DispatcherClient, WorkflowEvent } from '../../protoc/dispatcher';
-import { ClientConfig } from '../hatchet-client/client-config';
-import { Logger } from '../../util/logger';
-import { Api } from '../rest';
-import { GrpcPooledListener } from './child-listener-client';
+import { DispatcherClient as PbDispatcherClient, DispatcherClient, WorkflowEvent } from '../../../protoc/dispatcher';
+import { ClientConfig } from '../../hatchet-client/client-config';
+import { Logger } from '../../../util/logger';
+import { Api } from '../../rest';
+import { RunGrpcPooledListener } from './pooled-child-listener-client';
 export declare enum RunEventType {
     STEP_RUN_EVENT_TYPE_STARTED = "STEP_RUN_EVENT_TYPE_STARTED",
     STEP_RUN_EVENT_TYPE_COMPLETED = "STEP_RUN_EVENT_TYPE_COMPLETED",
@@ -39,14 +39,14 @@ export declare class RunEventListener {
     retrySubscribe(listenerFactory: () => AsyncIterable<WorkflowEvent>): Promise<AsyncIterable<WorkflowEvent>>;
     stream(): AsyncGenerator<StepRunEvent, void, unknown>;
 }
-export declare class ListenerClient {
+export declare class RunListenerClient {
     config: ClientConfig;
     client: PbDispatcherClient;
     logger: Logger;
     api: Api;
-    pooledListener: GrpcPooledListener | undefined;
+    pooledListener: RunGrpcPooledListener | undefined;
     constructor(config: ClientConfig, channel: Channel, factory: ClientFactory, api: Api);
-    get(workflowRunId: string): import("./child-listener-client").Streamable;
+    get(workflowRunId: string): import("./pooled-child-listener-client").Streamable;
     stream(workflowRunId: string): Promise<AsyncGenerator<StepRunEvent, void, unknown>>;
     streamByRunId(workflowRunId: string): Promise<AsyncGenerator<StepRunEvent, void, unknown>>;
     streamByAdditionalMeta(key: string, value: string): Promise<AsyncGenerator<StepRunEvent, void, unknown>>;

package/clients/{listener/listener-client.js → listeners/run-listener/child-listener-client.js}

@@ -32,18 +32,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ListenerClient = exports.RunEventListener = exports.RunEventType = void 0;
+exports.RunListenerClient = exports.RunEventListener = 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 sleep_1 = __importDefault(require("../../util/sleep"));
-const data_contracts_1 = require("../rest/generated/data-contracts");
-const child_listener_client_1 = require("./child-listener-client");
+const dispatcher_1 = require("../../../protoc/dispatcher");
+const hatchet_error_1 = __importDefault(require("../../../util/errors/hatchet-error"));
+const sleep_1 = __importDefault(require("../../../util/sleep"));
+const pooled_child_listener_client_1 = require("./pooled-child-listener-client");
 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 RunEventType;
 (function (RunEventType) {
@@ -85,15 +83,6 @@ const resourceTypeMap = {
     [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,
-    [data_contracts_1.WorkflowRunStatus.QUEUED]: undefined,
-    [data_contracts_1.WorkflowRunStatus.BACKOFF]: undefined,
-};
 class RunEventListener {
     constructor(client) {
         this.q = [];
@@ -213,7 +202,7 @@ class RunEventListener {
     }
 }
 exports.RunEventListener = RunEventListener;
-class ListenerClient {
+class RunListenerClient {
     constructor(config, channel, factory, api) {
         this.config = config;
         this.client = factory.create(dispatcher_1.DispatcherDefinition, channel);
@@ -222,7 +211,7 @@ class ListenerClient {
     }
     get(workflowRunId) {
         if (!this.pooledListener) {
-            this.pooledListener = new child_listener_client_1.GrpcPooledListener(this, () => {
+            this.pooledListener = new pooled_child_listener_client_1.RunGrpcPooledListener(this, () => {
                 this.pooledListener = undefined;
             });
         }
@@ -248,4 +237,4 @@ class ListenerClient {
         });
     }
 }
-exports.ListenerClient = ListenerClient;
+exports.RunListenerClient = RunListenerClient;