@hatchet-dev/typescript-sdk 0.0.1

package/.eslintrc.json

@@ -0,0 +1,36 @@
+{
+  "env": {
+    "es6": true,
+    "node": true,
+    "jest": true
+  },
+  "extends": ["airbnb-base", "prettier", "plugin:prettier/recommended"],
+  "globals": {
+    "Atomics": "readonly",
+    "SharedArrayBuffer": "readonly"
+  },
+  "parser": "@typescript-eslint/parser",
+  "parserOptions": {
+    "ecmaVersion": 11,
+    "sourceType": "module"
+  },
+  "plugins": ["@typescript-eslint", "import", "unused-imports", "prettier", "eslint-plugin-jest"],
+  "rules": {
+    "@typescript-eslint/no-shadow": "off",
+    "@typescript-eslint/no-throw-literal": "off",
+    "no-use-before-define": "off",
+    "@typescript-eslint/no-use-before-define": "off",
+    "import/extensions": "off",
+    "unused-imports/no-unused-imports": "error",
+    "no-unused-vars": "off",
+    "prettier/prettier": "error",
+    "@typescript-eslint/no-unused-vars": "warn",
+    "curly": "error",
+    "import/prefer-default-export": "off",
+    "import/no-unresolved": "off",
+    "lines-between-class-members": "off",
+    "class-methods-use-this": "off",
+    "no-await-in-loop": "off",
+    "no-restricted-syntax": "off"
+  }
+}

package/.prettierrc.json

@@ -0,0 +1,6 @@
+{
+  "printWidth": 100,
+  "tabWidth": 2,
+  "singleQuote": true,
+  "trailingComma": "es5"
+}

package/README.md

@@ -0,0 +1,4 @@
+# Hatchet - Typescript Client
+
+Required Dependencies:
+https://google.github.io/proto-lens/installing-protoc.html

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

@@ -0,0 +1,14 @@
+import { Channel, ClientFactory } from 'nice-grpc';
+import { CreateWorkflowVersionOpts, WorkflowServiceClient } from '@protoc/workflows';
+import { ClientConfig } from '@clients/hatchet-client/client-config';
+export declare class AdminClient {
+    config: ClientConfig;
+    client: WorkflowServiceClient;
+    constructor(config: ClientConfig, channel: Channel, factory: ClientFactory);
+    put_workflow(workflow: CreateWorkflowVersionOpts, options?: {
+        autoVersion?: boolean;
+    }): Promise<void>;
+    schedule_workflow(workflowId: string, options?: {
+        schedules?: Date[];
+    }): void;
+}

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

@@ -0,0 +1,50 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminClient = void 0;
+const workflows_1 = require("@protoc/workflows");
+const hatchet_error_1 = __importDefault(require("@util/errors/hatchet-error"));
+class AdminClient {
+    constructor(config, channel, factory) {
+        this.config = config;
+        this.client = factory.create(workflows_1.WorkflowServiceDefinition, channel);
+    }
+    put_workflow(workflow, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (workflow.version === '' && !(options === null || options === void 0 ? void 0 : options.autoVersion)) {
+                throw new hatchet_error_1.default('PutWorkflow error: workflow version is required, or use autoVersion');
+            }
+            try {
+                yield this.client.putWorkflow({
+                    opts: workflow,
+                });
+            }
+            catch (e) {
+                throw new hatchet_error_1.default(e.message);
+            }
+        });
+    }
+    schedule_workflow(workflowId, options) {
+        try {
+            this.client.scheduleWorkflow({
+                workflowId,
+                schedules: options === null || options === void 0 ? void 0 : options.schedules,
+            });
+        }
+        catch (e) {
+            throw new hatchet_error_1.default(e.message);
+        }
+    }
+}
+exports.AdminClient = AdminClient;

package/dist/hatchet/clients/admin/admin-client.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hatchet/clients/admin/admin-client.test.js

@@ -0,0 +1,101 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const admin_client_1 = require("./admin-client");
+const hatchet_client_test_1 = require("../hatchet-client/hatchet-client.test");
+describe('AdminClient', () => {
+    let client;
+    it('should create a client', () => {
+        const x = new admin_client_1.AdminClient({
+            token: 'TOKEN',
+            host_port: 'HOST_PORT',
+            tls_config: {
+                cert_file: 'TLS_CERT_FILE',
+                key_file: 'TLS_KEY_FILE',
+                ca_file: 'TLS_ROOT_CA_FILE',
+                server_name: 'TLS_SERVER_NAME',
+            },
+        }, hatchet_client_test_1.mockChannel, hatchet_client_test_1.mockFactory);
+        expect(x).toBeDefined();
+    });
+    beforeEach(() => {
+        client = new admin_client_1.AdminClient({
+            token: 'TOKEN',
+            host_port: 'HOST_PORT',
+            tls_config: {
+                cert_file: 'TLS_CERT_FILE',
+                key_file: 'TLS_KEY_FILE',
+                ca_file: 'TLS_ROOT_CA_FILE',
+                server_name: 'TLS_SERVER_NAME',
+            },
+        }, hatchet_client_test_1.mockChannel, hatchet_client_test_1.mockFactory);
+    });
+    describe('put_workflow', () => {
+        it('should throw an error if no version and not auto version', () => __awaiter(void 0, void 0, void 0, function* () {
+            const workflow = {
+                name: 'workflow1',
+                version: '',
+                description: 'description1',
+                eventTriggers: [],
+                cronTriggers: [],
+                scheduledTriggers: [],
+                jobs: [],
+            };
+            expect(() => client.put_workflow(workflow, { autoVersion: false })).rejects.toThrow('PutWorkflow error: workflow version is required, or use autoVersion');
+        }));
+        it('should attempt to put the workflow', () => __awaiter(void 0, void 0, void 0, function* () {
+            const workflow = {
+                name: 'workflow1',
+                version: 'v0.0.1',
+                description: 'description1',
+                eventTriggers: [],
+                cronTriggers: [],
+                scheduledTriggers: [],
+                jobs: [],
+            };
+            const putSpy = jest.spyOn(client.client, 'putWorkflow').mockResolvedValue({
+                id: 'workflow1',
+                version: 'v0.1.0',
+                order: 1,
+                workflowId: 'workflow1',
+                jobs: [],
+                createdAt: undefined,
+                updatedAt: undefined,
+                triggers: undefined,
+            });
+            yield client.put_workflow(workflow);
+            expect(putSpy).toHaveBeenCalled();
+        }));
+    });
+    describe('schedule_workflow', () => {
+        it('should schedule a workflow', () => {
+            const res = {
+                id: 'string',
+                version: 'v0.0.1',
+                order: 1,
+                workflowId: 'string',
+                jobs: [],
+                createdAt: undefined,
+                updatedAt: undefined,
+                triggers: undefined,
+            };
+            const spy = jest.spyOn(client.client, 'scheduleWorkflow').mockResolvedValue(res);
+            const now = new Date();
+            client.schedule_workflow('workflowId', {
+                schedules: [now],
+            });
+            expect(spy).toHaveBeenCalledWith({
+                workflowId: 'workflowId',
+                schedules: [now],
+            });
+        });
+    });
+});

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

@@ -0,0 +1,24 @@
+import { DispatcherClient as PbDispatcherClient, AssignedAction } from '@protoc/dispatcher';
+import { ClientConfig } from '@clients/hatchet-client/client-config';
+import { DispatcherClient } from './dispatcher-client';
+export interface Action {
+    tenantId: string;
+    jobId: string;
+    jobName: string;
+    jobRunId: string;
+    stepId: string;
+    stepRunId: string;
+    actionId: string;
+    actionType: number;
+    actionPayload: string;
+}
+export declare class ActionListener {
+    config: ClientConfig;
+    client: PbDispatcherClient;
+    listener: AsyncIterable<AssignedAction>;
+    workerId: string;
+    constructor(client: DispatcherClient, listener: AsyncIterable<AssignedAction>, workerId: string);
+    actions: () => AsyncGenerator<Action, void, unknown>;
+    retrySubscribe(): Promise<void>;
+    unregister(): Promise<import("@protoc/dispatcher").WorkerUnsubscribeResponse>;
+}

package/dist/hatchet/clients/dispatcher/action-listener.js

@@ -0,0 +1,113 @@
+"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 = {}, 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.ActionListener = void 0;
+const nice_grpc_1 = require("nice-grpc");
+const sleep_1 = __importDefault(require("@util/sleep"));
+const hatchet_error_1 = __importDefault(require("@util/errors/hatchet-error"));
+const DEFAULT_ACTION_LISTENER_RETRY_INTERVAL = 5; // seconds
+const DEFAULT_ACTION_LISTENER_RETRY_COUNT = 5;
+class ActionListener {
+    constructor(client, listener, workerId) {
+        this.actions = () => (function gen(client) {
+            return __asyncGenerator(this, arguments, function* gen_1() {
+                var _a, e_1, _b, _c;
+                while (true) {
+                    try {
+                        try {
+                            for (var _d = true, _e = (e_1 = void 0, __asyncValues(client.listener)), _f; _f = yield __await(_e.next()), _a = _f.done, !_a; _d = true) {
+                                _c = _f.value;
+                                _d = false;
+                                const assignedAction = _c;
+                                const action = Object.assign({}, assignedAction);
+                                yield yield __await(action);
+                            }
+                        }
+                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                        finally {
+                            try {
+                                if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                        }
+                    }
+                    catch (e) {
+                        if (e.code === nice_grpc_1.Status.CANCELLED) {
+                            break;
+                        }
+                        if (e.code === nice_grpc_1.Status.UNAVAILABLE) {
+                            client.retrySubscribe();
+                        }
+                        break;
+                    }
+                }
+            });
+        })(this);
+        this.config = client.config;
+        this.client = client.client;
+        this.listener = listener;
+        this.workerId = workerId;
+    }
+    retrySubscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let retries = 0;
+            while (retries < DEFAULT_ACTION_LISTENER_RETRY_COUNT) {
+                try {
+                    yield (0, sleep_1.default)(DEFAULT_ACTION_LISTENER_RETRY_INTERVAL);
+                    this.listener = this.client.listen({
+                        workerId: this.workerId,
+                    });
+                    return;
+                }
+                catch (e) {
+                    retries += 1;
+                }
+            }
+            throw new hatchet_error_1.default(`Could not subscribe to the worker after ${DEFAULT_ACTION_LISTENER_RETRY_COUNT} retries`);
+        });
+    }
+    unregister() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return this.client.unsubscribe({
+                    workerId: this.workerId,
+                });
+            }
+            catch (e) {
+                throw new hatchet_error_1.default(`Failed to unsubscribe: ${e.message}`);
+            }
+        });
+    }
+}
+exports.ActionListener = ActionListener;

package/dist/hatchet/clients/dispatcher/action-listener.test.d.ts

@@ -0,0 +1,4 @@
+import { AssignedAction } from '@protoc/dispatcher';
+type AssignActionMock = AssignedAction | Error;
+export declare const mockListener: (fixture: AssignActionMock[]) => AsyncGenerator<AssignedAction, void, unknown>;
+export {};

package/dist/hatchet/clients/dispatcher/action-listener.test.js

@@ -0,0 +1,277 @@
+"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 __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 = {}, 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 __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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockListener = void 0;
+const dispatcher_1 = require("@protoc/dispatcher");
+const sleep_1 = __importDefault(require("@util/sleep"));
+const nice_grpc_common_1 = require("nice-grpc-common");
+const dispatcher_client_1 = require("./dispatcher-client");
+const action_listener_1 = require("./action-listener");
+const hatchet_client_test_1 = require("../hatchet-client/hatchet-client.test");
+let dispatcher;
+// Mock data for AssignedAction
+const mockAssignedActions = [
+    {
+        tenantId: 'tenant1',
+        jobId: 'job1',
+        jobName: 'Job One',
+        jobRunId: 'run1',
+        stepId: 'step1',
+        stepRunId: 'runStep1',
+        actionId: 'action1',
+        actionType: dispatcher_1.ActionType.START_STEP_RUN,
+        actionPayload: 'payload1',
+    },
+    // ... Add more mock AssignedAction objects as needed
+];
+// Mock implementation of the listener
+const mockListener = (fixture) => (function gen() {
+    return __asyncGenerator(this, arguments, function* gen_1() {
+        for (const action of fixture) {
+            // Simulate asynchronous behavior
+            yield __await((0, sleep_1.default)(100));
+            if (action instanceof Error) {
+                throw action;
+            }
+            yield yield __await(action);
+        }
+    });
+})();
+exports.mockListener = mockListener;
+describe('ActionListener', () => {
+    beforeEach(() => {
+        dispatcher = new dispatcher_client_1.DispatcherClient({
+            token: 'TOKEN',
+            host_port: 'HOST_PORT',
+            log_level: 'OFF',
+            tls_config: {
+                cert_file: 'TLS_CERT_FILE',
+                key_file: 'TLS_KEY_FILE',
+                ca_file: 'TLS_ROOT_CA_FILE',
+                server_name: 'TLS_SERVER_NAME',
+            },
+        }, hatchet_client_test_1.mockChannel, hatchet_client_test_1.mockFactory);
+    });
+    it('should create a client', () => __awaiter(void 0, void 0, void 0, function* () {
+        const listener = new action_listener_1.ActionListener(dispatcher, (0, exports.mockListener)(mockAssignedActions), 'WORKER_ID');
+        expect(listener).toBeDefined();
+        expect(listener.workerId).toEqual('WORKER_ID');
+    }));
+    describe('actions', () => {
+        it('it should "yield" actions', () => __awaiter(void 0, void 0, void 0, function* () {
+            var _a, e_1, _b, _c;
+            const listener = new action_listener_1.ActionListener(dispatcher, (0, exports.mockListener)([...mockAssignedActions, new nice_grpc_common_1.ServerError(nice_grpc_common_1.Status.CANCELLED, 'CANCELLED')]), 'WORKER_ID');
+            const actions = listener.actions();
+            const res = [];
+            try {
+                for (var _d = true, actions_1 = __asyncValues(actions), actions_1_1; actions_1_1 = yield actions_1.next(), _a = actions_1_1.done, !_a; _d = true) {
+                    _c = actions_1_1.value;
+                    _d = false;
+                    const action = _c;
+                    res.push(action);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = actions_1.return)) yield _b.call(actions_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            expect(res[0]).toEqual({
+                tenantId: 'tenant1',
+                jobId: 'job1',
+                jobName: 'Job One',
+                jobRunId: 'run1',
+                stepId: 'step1',
+                stepRunId: 'runStep1',
+                actionId: 'action1',
+                actionType: dispatcher_1.ActionType.START_STEP_RUN,
+                actionPayload: 'payload1',
+            });
+        }));
+        it('it should break on grpc CANCELLED', () => __awaiter(void 0, void 0, void 0, function* () {
+            var _e, e_2, _f, _g;
+            const listener = new action_listener_1.ActionListener(dispatcher, (0, exports.mockListener)([...mockAssignedActions, new nice_grpc_common_1.ServerError(nice_grpc_common_1.Status.CANCELLED, 'CANCELLED')]), 'WORKER_ID');
+            const actions = listener.actions();
+            const retrySpy = jest.spyOn(listener, 'retrySubscribe').mockResolvedValue(undefined);
+            const res = [];
+            try {
+                for (var _h = true, actions_2 = __asyncValues(actions), actions_2_1; actions_2_1 = yield actions_2.next(), _e = actions_2_1.done, !_e; _h = true) {
+                    _g = actions_2_1.value;
+                    _h = false;
+                    const action = _g;
+                    res.push(action);
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (!_h && !_e && (_f = actions_2.return)) yield _f.call(actions_2);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            expect(res.length).toEqual(1);
+            expect(retrySpy).not.toHaveBeenCalled();
+        }));
+        it('it should break on unknown error', () => __awaiter(void 0, void 0, void 0, function* () {
+            var _j, e_3, _k, _l;
+            const listener = new action_listener_1.ActionListener(dispatcher, (0, exports.mockListener)([...mockAssignedActions, new Error('Simulated error')]), 'WORKER_ID');
+            const actions = listener.actions();
+            const retrySpy = jest.spyOn(listener, 'retrySubscribe').mockResolvedValue(undefined);
+            const res = [];
+            try {
+                for (var _m = true, actions_3 = __asyncValues(actions), actions_3_1; actions_3_1 = yield actions_3.next(), _j = actions_3_1.done, !_j; _m = true) {
+                    _l = actions_3_1.value;
+                    _m = false;
+                    const action = _l;
+                    res.push(action);
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (!_m && !_j && (_k = actions_3.return)) yield _k.call(actions_3);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+            expect(res.length).toEqual(1);
+            expect(retrySpy).not.toHaveBeenCalled();
+        }));
+        it('it should attempt to re-establish connection on grpc UNAVAILABLE', () => __awaiter(void 0, void 0, void 0, function* () {
+            var _o, e_4, _p, _q;
+            const listener = new action_listener_1.ActionListener(dispatcher, (0, exports.mockListener)([...mockAssignedActions, new nice_grpc_common_1.ServerError(nice_grpc_common_1.Status.UNAVAILABLE, 'UNAVAILABLE')]), 'WORKER_ID');
+            const retrySpy = jest.spyOn(listener, 'retrySubscribe').mockResolvedValue(undefined);
+            const actions = listener.actions();
+            const res = [];
+            try {
+                for (var _r = true, actions_4 = __asyncValues(actions), actions_4_1; actions_4_1 = yield actions_4.next(), _o = actions_4_1.done, !_o; _r = true) {
+                    _q = actions_4_1.value;
+                    _r = false;
+                    const action = _q;
+                    res.push(action);
+                }
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (!_r && !_o && (_p = actions_4.return)) yield _p.call(actions_4);
+                }
+                finally { if (e_4) throw e_4.error; }
+            }
+            expect(res.length).toEqual(1);
+            expect(retrySpy).toHaveBeenCalled();
+        }));
+    });
+    describe('retry_subscribe', () => {
+        it('should exit after successful connection', () => __awaiter(void 0, void 0, void 0, function* () {
+            const listener = new action_listener_1.ActionListener(dispatcher, (0, exports.mockListener)(mockAssignedActions), 'WORKER_ID');
+            // Mock the listener to throw an error on the first call
+            const listenSpy = jest
+                .spyOn(listener.client, 'listen')
+                .mockReturnValue((0, exports.mockListener)(mockAssignedActions));
+            yield listener.retrySubscribe();
+            expect(listenSpy).toHaveBeenCalledTimes(1);
+        }));
+        it('should retry until success', () => __awaiter(void 0, void 0, void 0, function* () {
+            const listener = new action_listener_1.ActionListener(dispatcher, (0, exports.mockListener)(mockAssignedActions), 'WORKER_ID');
+            // Mock the listener to throw an error on the first call
+            const listenSpy = jest
+                .spyOn(listener.client, 'listen')
+                .mockImplementationOnce(() => {
+                throw new Error('Simulated error');
+            })
+                .mockImplementationOnce(() => (0, exports.mockListener)(mockAssignedActions));
+            yield expect(() => __awaiter(void 0, void 0, void 0, function* () {
+                yield listener.retrySubscribe();
+            })).not.toThrow();
+        }));
+        it('should not throw an error if successful', () => __awaiter(void 0, void 0, void 0, function* () {
+            const listener = new action_listener_1.ActionListener(dispatcher, (0, exports.mockListener)(mockAssignedActions), 'WORKER_ID');
+            // Mock the listener to throw an error on the first call
+            const listenSpy = jest
+                .spyOn(listener.client, 'listen')
+                .mockImplementationOnce(() => {
+                throw new Error('Simulated error');
+            })
+                .mockImplementationOnce(() => (0, exports.mockListener)(mockAssignedActions));
+            yield listener.retrySubscribe();
+            expect(listenSpy).toHaveBeenCalledTimes(2);
+        }));
+        it('should retry at most COUNT times and throw an error', () => __awaiter(void 0, void 0, void 0, function* () {
+            const listener = new action_listener_1.ActionListener(dispatcher, (0, exports.mockListener)(mockAssignedActions), 'WORKER_ID');
+            // Mock the listener to throw an error on the first call
+            const listenSpy = jest
+                .spyOn(listener.client, 'listen')
+                .mockImplementationOnce(() => {
+                throw new Error('Simulated error');
+            })
+                .mockImplementationOnce(() => {
+                throw new Error('Simulated error');
+            })
+                .mockImplementationOnce(() => {
+                throw new Error('Simulated error');
+            })
+                .mockImplementationOnce(() => {
+                throw new Error('Simulated error');
+            })
+                .mockImplementationOnce(() => {
+                throw new Error('Simulated error');
+            })
+                .mockImplementationOnce(() => {
+                throw new Error('Simulated error');
+            })
+                .mockImplementationOnce(() => (0, exports.mockListener)(mockAssignedActions));
+            try {
+                yield listener.retrySubscribe();
+                expect(listenSpy).toHaveBeenCalledTimes(5);
+            }
+            catch (e) {
+                expect(e.message).toEqual(`Could not subscribe to the worker after 5 retries`);
+            }
+        }));
+    });
+    describe('unregister', () => {
+        it('should unsubscribe itself', () => __awaiter(void 0, void 0, void 0, function* () {
+            const listener = new action_listener_1.ActionListener(dispatcher, (0, exports.mockListener)(mockAssignedActions), 'WORKER_ID');
+            const unsubscribeSpy = jest.spyOn(listener.client, 'unsubscribe').mockResolvedValue({
+                tenantId: 'TENANT_ID',
+                workerId: 'WORKER_ID',
+            });
+            const res = yield listener.unregister();
+            expect(unsubscribeSpy).toHaveBeenCalled();
+            expect(res.workerId).toEqual('WORKER_ID');
+        }));
+    });
+});

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

@@ -0,0 +1,17 @@
+import { Channel, ClientFactory } from 'nice-grpc';
+import { DispatcherClient as PbDispatcherClient, ActionEvent } from '@protoc/dispatcher';
+import { ClientConfig } from '@clients/hatchet-client/client-config';
+import { ActionListener } from './action-listener';
+interface GetActionListenerOptions {
+    workerName: string;
+    services: string[];
+    actions: string[];
+}
+export declare class DispatcherClient {
+    config: ClientConfig;
+    client: PbDispatcherClient;
+    constructor(config: ClientConfig, channel: Channel, factory: ClientFactory);
+    get_action_listener(options: GetActionListenerOptions): Promise<ActionListener>;
+    send_action_event(in_: ActionEvent): Promise<import("@protoc/dispatcher").ActionEventResponse>;
+}
+export {};