@hatchet-dev/typescript-sdk 0.0.2 → 0.0.7

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

@@ -1,18 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./hatchet-client"), exports);
-__exportStar(require("./client-config"), exports);

package/dist/clients/worker/index.d.ts

@@ -1 +0,0 @@
-export * from './worker';

package/dist/clients/worker/index.js

@@ -1,17 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./worker"), exports);

package/dist/clients/worker/worker.d.ts

@@ -1,31 +0,0 @@
-import { HatchetClient } from '../hatchet-client';
-import { Action, ActionListener } from '../dispatcher/action-listener';
-import { ActionEvent, ActionEventType } from '@hatchet/protoc/dispatcher';
-import HatchetPromise from '../../util/hatchet-promise/hatchet-promise';
-import { Workflow } from '@hatchet/workflow';
-import { Logger } from '@hatchet/util/logger';
-export type ActionRegistry = Record<Action['actionId'], Function>;
-export declare class Worker {
-    serviceName: string;
-    client: HatchetClient;
-    name: string;
-    killing: boolean;
-    handle_kill: boolean;
-    action_registry: ActionRegistry;
-    listener: ActionListener | undefined;
-    futures: Record<Action['stepRunId'], HatchetPromise<any>>;
-    logger: Logger;
-    constructor(client: HatchetClient, options: {
-        name: string;
-        handleKill?: boolean;
-    });
-    register_workflow(workflow: Workflow, options?: {
-        autoVersion?: boolean;
-    }): Promise<void>;
-    handle_start_step_run(action: Action): void;
-    get_action_event(action: Action, eventType: ActionEventType, payload?: any): ActionEvent;
-    handle_cancel_step_run(action: Action): void;
-    stop(): Promise<void>;
-    exit_gracefully(): Promise<void>;
-    start(): Promise<void>;
-}

package/dist/clients/worker/worker.js

@@ -1,228 +0,0 @@
-"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 __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Worker = void 0;
-const hatchet_error_1 = __importDefault(require("../../util/errors/hatchet-error"));
-const dispatcher_1 = require("@hatchet/protoc/dispatcher");
-const hatchet_promise_1 = __importDefault(require("../../util/hatchet-promise/hatchet-promise"));
-const logger_1 = require("@hatchet/util/logger");
-const sleep_1 = __importDefault(require("@hatchet/util/sleep"));
-const step_1 = require("../../step");
-class Worker {
-    constructor(client, options) {
-        this.serviceName = 'default';
-        this.futures = {};
-        this.client = client;
-        this.name = options.name;
-        this.action_registry = {};
-        process.on('SIGTERM', () => this.exit_gracefully());
-        process.on('SIGINT', () => this.exit_gracefully());
-        this.killing = false;
-        this.handle_kill = options.handleKill === undefined ? true : options.handleKill;
-        this.logger = new logger_1.Logger(`Worker/${this.name}`, this.client.config.log_level);
-    }
-    register_workflow(workflow, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield this.client.admin.put_workflow({
-                    name: workflow.id,
-                    description: workflow.description,
-                    version: 'v0.55.0', // FIXME  workflow.version,
-                    eventTriggers: workflow.on.event ? [workflow.on.event] : [],
-                    cronTriggers: workflow.on.cron ? [workflow.on.cron] : [],
-                    scheduledTriggers: [],
-                    jobs: [
-                        {
-                            name: 'my-job', // FIXME variable names
-                            timeout: '60s',
-                            description: 'my-job',
-                            steps: workflow.steps.map((step) => {
-                                var _a;
-                                return ({
-                                    readableId: step.name,
-                                    action: `${this.serviceName}:${step.name}`,
-                                    timeout: '60s',
-                                    inputs: '{}',
-                                    parents: (_a = step.parents) !== null && _a !== void 0 ? _a : [],
-                                });
-                            }),
-                        },
-                    ],
-                }, {
-                    autoVersion: !(options === null || options === void 0 ? void 0 : options.autoVersion),
-                });
-            }
-            catch (e) {
-                throw new hatchet_error_1.default(`Could not register workflow: ${e.message}`);
-            }
-            this.action_registry = workflow.steps.reduce((acc, step) => {
-                acc[`${this.serviceName}:${step.name}`] = step.run;
-                return acc;
-            }, {});
-        });
-    }
-    handle_start_step_run(action) {
-        const { actionId } = action;
-        const context = new step_1.Context(action.actionPayload);
-        const step = this.action_registry[actionId];
-        if (!step) {
-            this.logger.error(`Could not find step '${actionId}'`);
-            return;
-        }
-        const run = () => __awaiter(this, void 0, void 0, function* () {
-            return step(context);
-        });
-        const success = (result) => {
-            this.logger.info(`Step run ${action.stepRunId} succeeded`);
-            try {
-                // Send the action event to the dispatcher
-                const event = this.get_action_event(action, dispatcher_1.ActionEventType.STEP_EVENT_TYPE_COMPLETED, result);
-                this.client.dispatcher.send_action_event(event);
-                // delete the run from the futures
-                delete this.futures[action.stepRunId];
-            }
-            catch (e) {
-                this.logger.error(`Could not send action event: ${e.message}`);
-            }
-        };
-        const failure = (error) => {
-            this.logger.error(`Step run ${action.stepRunId} failed: ${error.message}`);
-            try {
-                // Send the action event to the dispatcher
-                const event = this.get_action_event(action, dispatcher_1.ActionEventType.STEP_EVENT_TYPE_FAILED, error);
-                this.client.dispatcher.send_action_event(event);
-                // delete the run from the futures
-                delete this.futures[action.stepRunId];
-            }
-            catch (e) {
-                this.logger.error(`Could not send action event: ${e.message}`);
-            }
-        };
-        const future = new hatchet_promise_1.default(run().then(success).catch(failure));
-        this.futures[action.stepRunId] = future;
-        try {
-            // Send the action event to the dispatcher
-            const event = this.get_action_event(action, dispatcher_1.ActionEventType.STEP_EVENT_TYPE_STARTED);
-            this.client.dispatcher.send_action_event(event);
-        }
-        catch (e) {
-            this.logger.error(`Could not send action event: ${e.message}`);
-        }
-    }
-    get_action_event(action, eventType, payload = '') {
-        return {
-            workerId: this.name,
-            jobId: action.jobId,
-            jobRunId: action.jobRunId,
-            stepId: action.stepId,
-            stepRunId: action.stepRunId,
-            actionId: action.actionId,
-            eventTimestamp: new Date(),
-            eventType,
-            eventPayload: JSON.stringify(payload),
-        };
-    }
-    handle_cancel_step_run(action) {
-        const { stepRunId } = action;
-        const future = this.futures[stepRunId];
-        if (future) {
-            future.cancel();
-            delete this.futures[stepRunId];
-        }
-    }
-    stop() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.exit_gracefully();
-        });
-    }
-    exit_gracefully() {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            this.killing = true;
-            this.logger.info('Starting to exit...');
-            try {
-                (_a = this.listener) === null || _a === void 0 ? void 0 : _a.unregister();
-            }
-            catch (e) {
-                this.logger.error(`Could not unregister listener: ${e.message}`);
-            }
-            this.logger.info('Gracefully exiting hatchet worker, running tasks will attempt to finish...');
-            // attempt to wait for futures to finish
-            yield Promise.all(Object.values(this.futures).map(({ promise }) => promise));
-            if (this.handle_kill) {
-                this.logger.info('Exiting hatchet worker...');
-                process.exit(0);
-            }
-        });
-    }
-    start() {
-        var _a, e_1, _b, _c;
-        return __awaiter(this, void 0, void 0, function* () {
-            let retries = 0;
-            while (retries < 5) {
-                try {
-                    this.listener = yield this.client.dispatcher.get_action_listener({
-                        workerName: this.name,
-                        services: ['default'],
-                        actions: Object.keys(this.action_registry),
-                    });
-                    const generator = this.listener.actions();
-                    this.logger.info(`Worker ${this.name} listening for actions`);
-                    try {
-                        for (var _d = true, generator_1 = (e_1 = void 0, __asyncValues(generator)), generator_1_1; generator_1_1 = yield generator_1.next(), _a = generator_1_1.done, !_a; _d = true) {
-                            _c = generator_1_1.value;
-                            _d = false;
-                            const action = _c;
-                            this.logger.info(`Worker ${this.name} received action ${action.actionId}`);
-                            if (action.actionType === dispatcher_1.ActionType.START_STEP_RUN) {
-                                this.handle_start_step_run(action);
-                            }
-                            else if (action.actionType === dispatcher_1.ActionType.CANCEL_STEP_RUN) {
-                                this.handle_cancel_step_run(action);
-                            }
-                        }
-                    }
-                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                    finally {
-                        try {
-                            if (!_d && !_a && (_b = generator_1.return)) yield _b.call(generator_1);
-                        }
-                        finally { if (e_1) throw e_1.error; }
-                    }
-                    break;
-                }
-                catch (e) {
-                    this.logger.error(`Could not start worker: ${e.message}`);
-                    retries += 1;
-                    const wait = 500;
-                    this.logger.error(`Could not start worker, retrying in ${500} seconds`);
-                    yield (0, sleep_1.default)(wait);
-                }
-            }
-            if (this.killing)
-                return;
-            if (retries > 5) {
-                throw new hatchet_error_1.default('Could not start worker after 5 retries');
-            }
-        });
-    }
-}
-exports.Worker = Worker;

package/dist/clients/worker/worker.test.d.ts

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

package/dist/clients/worker/worker.test.js

@@ -1,256 +0,0 @@
-"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 });
-const hatchet_client_1 = require("../hatchet-client");
-const dispatcher_1 = require("@hatchet/protoc/dispatcher");
-const action_listener_1 = require("../dispatcher/action-listener");
-const nice_grpc_common_1 = require("nice-grpc-common");
-const action_listener_test_1 = require("../dispatcher/action-listener.test");
-const zod_1 = require("zod");
-const sleep_1 = __importDefault(require("../../util/sleep"));
-const nice_grpc_1 = require("nice-grpc");
-const worker_1 = require("./worker");
-const mockStart = {
-    tenantId: 'TENANT_ID',
-    jobId: 'job1',
-    jobName: 'Job One',
-    jobRunId: 'run1',
-    stepId: 'step1',
-    stepRunId: 'runStep1',
-    actionId: 'action1',
-    actionType: dispatcher_1.ActionType.START_STEP_RUN,
-    actionPayload: JSON.stringify('{"input": {"data": 1}}'),
-};
-const mockCancel = Object.assign(Object.assign({}, mockStart), { actionType: dispatcher_1.ActionType.CANCEL_STEP_RUN });
-describe('Worker', () => {
-    let hatchet;
-    beforeEach(() => {
-        hatchet = new hatchet_client_1.HatchetClient({
-            token: 'TOKEN',
-            log_level: 'OFF',
-            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',
-            },
-        }, {
-            credentials: nice_grpc_1.ChannelCredentials.createInsecure(),
-        });
-    });
-    describe('register_workflow', () => {
-        it('should update the registry', () => __awaiter(void 0, void 0, void 0, function* () {
-            const worker = new worker_1.Worker(hatchet, { name: 'WORKER_NAME' });
-            const putWorkflowSpy = jest.spyOn(worker.client.admin, 'put_workflow').mockResolvedValue();
-            const workflow = {
-                id: 'workflow1',
-                description: 'test',
-                on: {
-                    event: 'user:create',
-                },
-                steps: [
-                    {
-                        name: 'step1',
-                        run: (ctx) => {
-                            return { test: 'test' };
-                        },
-                    },
-                ],
-            };
-            yield worker.register_workflow(workflow);
-            expect(putWorkflowSpy).toHaveBeenCalledTimes(1);
-            expect(worker.action_registry).toEqual({
-                [`default:step1`]: workflow.steps[0].run,
-            });
-        }));
-    });
-    describe('handle_start_step_run', () => {
-        it('should start a step run', () => __awaiter(void 0, void 0, void 0, function* () {
-            const worker = new worker_1.Worker(hatchet, { name: 'WORKER_NAME' });
-            const putWorkflowSpy = jest.spyOn(worker.client.admin, 'put_workflow').mockResolvedValue();
-            const getActionEventSpy = jest.spyOn(worker, 'get_action_event');
-            const sendActionEventSpy = jest
-                .spyOn(worker.client.dispatcher, 'send_action_event')
-                .mockResolvedValue({
-                tenantId: 'TENANT_ID',
-                workerId: 'WORKER_ID',
-            });
-            const startSpy = jest.fn().mockReturnValue({ data: 4 });
-            worker.action_registry = {
-                [mockStart.actionId]: startSpy,
-            };
-            worker.handle_start_step_run(mockStart);
-            yield (0, sleep_1.default)(100);
-            expect(startSpy).toHaveBeenCalledTimes(1);
-            expect(getActionEventSpy).toHaveBeenNthCalledWith(2, expect.anything(), dispatcher_1.ActionEventType.STEP_EVENT_TYPE_COMPLETED, { data: 4 });
-            expect(worker.futures[mockStart.stepRunId]).toBeUndefined();
-            expect(sendActionEventSpy).toHaveBeenCalledTimes(2);
-        }));
-        it('should fail gracefully', () => __awaiter(void 0, void 0, void 0, function* () {
-            const worker = new worker_1.Worker(hatchet, { name: 'WORKER_NAME' });
-            const getActionEventSpy = jest.spyOn(worker, 'get_action_event');
-            const sendActionEventSpy = jest
-                .spyOn(worker.client.dispatcher, 'send_action_event')
-                .mockResolvedValue({
-                tenantId: 'TENANT_ID',
-                workerId: 'WORKER_ID',
-            });
-            const startSpy = jest.fn().mockRejectedValue(new Error('ERROR'));
-            worker.action_registry = {
-                [mockStart.actionId]: startSpy,
-            };
-            worker.handle_start_step_run(mockStart);
-            yield (0, sleep_1.default)(100);
-            expect(startSpy).toHaveBeenCalledTimes(1);
-            expect(getActionEventSpy).toHaveBeenNthCalledWith(2, expect.anything(), dispatcher_1.ActionEventType.STEP_EVENT_TYPE_FAILED, expect.anything());
-            expect(worker.futures[mockStart.stepRunId]).toBeUndefined();
-            expect(sendActionEventSpy).toHaveBeenCalledTimes(2);
-        }));
-    });
-    describe('handle_cancel_step_run', () => {
-        it('should cancel a step run', () => {
-            const worker = new worker_1.Worker(hatchet, { name: 'WORKER_NAME' });
-            const cancelSpy = jest.fn().mockReturnValue(undefined);
-            worker.futures = {
-                [mockCancel.stepRunId]: {
-                    cancel: cancelSpy,
-                },
-            };
-            worker.handle_cancel_step_run(mockCancel);
-            expect(cancelSpy).toHaveBeenCalledTimes(1);
-            expect(worker.futures[mockCancel.stepRunId]).toBeUndefined();
-        });
-    });
-    describe('exit_gracefully', () => {
-        xit('should call exit_gracefully on SIGTERM', () => __awaiter(void 0, void 0, void 0, function* () {
-            const worker = new worker_1.Worker(hatchet, { name: 'WORKER_NAME' });
-            // the spy is not working and the test is killing the test process
-            const exitSpy = jest.spyOn(worker, 'exit_gracefully').mockImplementationOnce(() => {
-                throw new Error('Simulated error');
-            });
-            process.emit('SIGTERM', 'SIGTERM');
-            expect(exitSpy).toHaveBeenCalledTimes(1);
-        }));
-        xit('should call exit_gracefully on SIGINT', () => __awaiter(void 0, void 0, void 0, function* () {
-            const worker = new worker_1.Worker(hatchet, { name: 'WORKER_NAME' });
-            // This is killing the process (as it should) fix the spy at some point
-            const exitSpy = jest.spyOn(worker, 'exit_gracefully').mockResolvedValue();
-            process.emit('SIGINT', 'SIGINT');
-            expect(exitSpy).toHaveBeenCalledTimes(1);
-        }));
-        xit('should unregister the listener and exit', () => __awaiter(void 0, void 0, void 0, function* () {
-            const worker = new worker_1.Worker(hatchet, { name: 'WORKER_NAME' });
-            jest.spyOn(process, 'exit').mockImplementation((number) => {
-                throw new Error(`EXIT ${number}`);
-            }); // This is killing the process (as it should) fix the spy at some point
-            const mockActionListener = new action_listener_1.ActionListener(hatchet.dispatcher, (0, action_listener_test_1.mockListener)([mockStart, mockStart, new nice_grpc_common_1.ServerError(nice_grpc_common_1.Status.CANCELLED, 'CANCELLED')]), 'WORKER_ID');
-            mockActionListener.unregister = jest.fn().mockResolvedValue((0, zod_1.never)());
-            worker.listener = mockActionListener;
-            expect(() => __awaiter(void 0, void 0, void 0, function* () {
-                yield worker.exit_gracefully();
-            })).toThrow('EXIT 0');
-            expect(mockActionListener.unregister).toHaveBeenCalledTimes(1);
-        }));
-        it('should exit the process if handle_kill is true', () => __awaiter(void 0, void 0, void 0, function* () {
-            const worker = new worker_1.Worker(hatchet, { name: 'WORKER_NAME' });
-            const exitSpy = jest.spyOn(process, 'exit').mockReturnValue(undefined);
-            yield worker.exit_gracefully();
-            expect(exitSpy).toHaveBeenCalledTimes(1);
-        }));
-    });
-    describe('start', () => {
-        xit('should get actions and start runs', () => __awaiter(void 0, void 0, void 0, function* () {
-            const worker = new worker_1.Worker(hatchet, { name: 'WORKER_NAME' });
-            const startSpy = jest.spyOn(worker, 'handle_start_step_run').mockReturnValue();
-            const cancelSpy = jest.spyOn(worker, 'handle_cancel_step_run').mockReturnValue();
-            const mockActionListener = new action_listener_1.ActionListener(hatchet.dispatcher, (0, action_listener_test_1.mockListener)([mockStart, mockStart, new nice_grpc_common_1.ServerError(nice_grpc_common_1.Status.CANCELLED, 'CANCELLED')]), 'WORKER_ID');
-            const getActionListenerSpy = jest
-                .spyOn(worker.client.dispatcher, 'get_action_listener')
-                .mockResolvedValue(mockActionListener);
-            yield worker.start();
-            expect(getActionListenerSpy).toHaveBeenCalledTimes(1);
-            expect(startSpy).toHaveBeenCalledTimes(2);
-            expect(cancelSpy).toHaveBeenCalledTimes(0);
-        }));
-        it('should get actions and cancel runs', () => __awaiter(void 0, void 0, void 0, function* () {
-            const worker = new worker_1.Worker(hatchet, { name: 'WORKER_NAME' });
-            const startSpy = jest.spyOn(worker, 'handle_start_step_run').mockReturnValue();
-            const cancelSpy = jest.spyOn(worker, 'handle_cancel_step_run').mockReturnValue();
-            const mockActionListner = new action_listener_1.ActionListener(hatchet.dispatcher, (0, action_listener_test_1.mockListener)([mockStart, mockCancel, new nice_grpc_common_1.ServerError(nice_grpc_common_1.Status.CANCELLED, 'CANCELLED')]), 'WORKER_ID');
-            const getActionListenerSpy = jest
-                .spyOn(worker.client.dispatcher, 'get_action_listener')
-                .mockResolvedValue(mockActionListner);
-            yield worker.start();
-            expect(getActionListenerSpy).toHaveBeenCalledTimes(1);
-            expect(startSpy).toHaveBeenCalledTimes(1);
-            expect(cancelSpy).toHaveBeenCalledTimes(1);
-        }));
-        it('should retry 5 times to start a worker then throw an error', () => __awaiter(void 0, void 0, void 0, function* () {
-            const worker = new worker_1.Worker(hatchet, { name: 'WORKER_NAME' });
-            const startSpy = jest.spyOn(worker, 'handle_start_step_run').mockReturnValue();
-            const cancelSpy = jest.spyOn(worker, 'handle_cancel_step_run').mockReturnValue();
-            const mockActionListner = new action_listener_1.ActionListener(hatchet.dispatcher, (0, action_listener_test_1.mockListener)([mockStart, mockCancel, new nice_grpc_common_1.ServerError(nice_grpc_common_1.Status.CANCELLED, 'CANCELLED')]), 'WORKER_ID');
-            const getActionListenerSpy = jest
-                .spyOn(worker.client.dispatcher, 'get_action_listener')
-                .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');
-            });
-            yield worker.start();
-            expect(getActionListenerSpy).toHaveBeenCalledTimes(5);
-            expect(startSpy).toHaveBeenCalledTimes(0);
-            expect(cancelSpy).toHaveBeenCalledTimes(0);
-        }));
-        it('should successfully run after retrying < 5 times', () => __awaiter(void 0, void 0, void 0, function* () {
-            const worker = new worker_1.Worker(hatchet, { name: 'WORKER_NAME' });
-            const startSpy = jest.spyOn(worker, 'handle_start_step_run').mockReturnValue();
-            const cancelSpy = jest.spyOn(worker, 'handle_cancel_step_run').mockReturnValue();
-            const mockActionLister = new action_listener_1.ActionListener(hatchet.dispatcher, (0, action_listener_test_1.mockListener)([mockStart, mockCancel, new nice_grpc_common_1.ServerError(nice_grpc_common_1.Status.CANCELLED, 'CANCELLED')]), 'WORKER_ID');
-            const getActionListenerSpy = jest
-                .spyOn(worker.client.dispatcher, 'get_action_listener')
-                .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(() => __awaiter(void 0, void 0, void 0, function* () { return mockActionLister; }));
-            yield worker.start();
-            expect(getActionListenerSpy).toHaveBeenCalledTimes(5);
-            expect(startSpy).toHaveBeenCalledTimes(1);
-            expect(cancelSpy).toHaveBeenCalledTimes(1);
-        }));
-    });
-});

package/dist/index.d.ts

@@ -1,2 +0,0 @@
-import { HatchetClient as Hatchet } from './clients/hatchet-client';
-export default Hatchet;

package/dist/index.js

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const hatchet_client_1 = require("./clients/hatchet-client");
-exports.default = hatchet_client_1.HatchetClient;