@hatchet-dev/typescript-sdk 0.0.2 → 0.0.3

package/README.md

@@ -1,4 +1,3 @@
-# Hatchet - Typescript Client
+# Hatchet - Typescript SDK
 
-Required Dependencies:
-https://google.github.io/proto-lens/installing-protoc.html
+Please refer to the [Hatchet Typescript SDK documentation](https://docs.hatchet.run/typescript-sdk/setup) for setup instructions and usage details.

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

@@ -1,5 +1,5 @@
 import { Channel, ClientFactory } from 'nice-grpc';
-import { CreateWorkflowVersionOpts, WorkflowServiceClient } from '@hatchet/protoc/workflows';
+import { CreateWorkflowVersionOpts, WorkflowServiceClient } from '../../protoc/workflows';
 import { ClientConfig } from '../hatchet-client/client-config';
 export declare class AdminClient {
     config: ClientConfig;

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

@@ -13,7 +13,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AdminClient = void 0;
-const workflows_1 = require("@hatchet/protoc/workflows");
+const workflows_1 = require("../../protoc/workflows");
 const hatchet_error_1 = __importDefault(require("../../util/errors/hatchet-error"));
 class AdminClient {
     constructor(config, channel, factory) {

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

@@ -1,4 +1,4 @@
-import { DispatcherClient as PbDispatcherClient, AssignedAction } from '@hatchet/protoc/dispatcher';
+import { DispatcherClient as PbDispatcherClient, AssignedAction } from '../../protoc/dispatcher';
 import { ClientConfig } from '../hatchet-client/client-config';
 import { DispatcherClient } from './dispatcher-client';
 export interface Action {
@@ -20,5 +20,5 @@ export declare class ActionListener {
     constructor(client: DispatcherClient, listener: AsyncIterable<AssignedAction>, workerId: string);
     actions: () => AsyncGenerator<Action, void, unknown>;
     retrySubscribe(): Promise<void>;
-    unregister(): Promise<import("@hatchet/protoc/dispatcher").WorkerUnsubscribeResponse>;
+    unregister(): Promise<import("../../protoc/dispatcher").WorkerUnsubscribeResponse>;
 }

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

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

package/dist/clients/dispatcher/dispatcher-client.js

@@ -13,7 +13,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DispatcherClient = void 0;
-const dispatcher_1 = require("@hatchet/protoc/dispatcher");
+const dispatcher_1 = require("../../protoc/dispatcher");
 const hatchet_error_1 = __importDefault(require("../../util/errors/hatchet-error"));
 const action_listener_1 = require("./action-listener");
 class DispatcherClient {

package/dist/clients/event/event-client.d.ts

@@ -1,9 +1,9 @@
 import { Channel, ClientFactory } from 'nice-grpc';
-import { EventsServiceClient } from '@hatchet/protoc/events/events';
+import { EventsServiceClient } from '../../protoc/events/events';
 import { ClientConfig } from '../hatchet-client/client-config';
 export declare class EventClient {
     config: ClientConfig;
     client: EventsServiceClient;
     constructor(config: ClientConfig, channel: Channel, factory: ClientFactory);
-    push<T>(type: string, input: T): Promise<import("@hatchet/protoc/events/events").Event>;
+    push<T>(type: string, input: T): Promise<import("../../protoc/events/events").Event>;
 }

package/dist/clients/event/event-client.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventClient = void 0;
-const events_1 = require("@hatchet/protoc/events/events");
+const events_1 = require("../../protoc/events/events");
 const hatchet_error_1 = __importDefault(require("../../util/errors/hatchet-error"));
 class EventClient {
     constructor(config, channel, factory) {

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

@@ -2,9 +2,9 @@ import { EventClient } from '../event/event-client';
 import { DispatcherClient } from '../dispatcher/dispatcher-client';
 import { AdminClient } from '../admin/admin-client';
 import { Channel, ChannelCredentials } from 'nice-grpc';
-import { Workflow } from '@hatchet/workflow';
+import { Workflow } from '../../workflow';
 import { Worker } from '../worker';
-import Logger from '@hatchet/util/logger/logger';
+import Logger from '../../util/logger/logger';
 import { ClientConfig } from './client-config';
 export interface HatchetClientOptions {
     config_path?: string;

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

@@ -45,7 +45,7 @@ const dispatcher_client_1 = require("../dispatcher/dispatcher-client");
 const admin_client_1 = require("../admin/admin-client");
 const nice_grpc_1 = require("nice-grpc");
 const worker_1 = require("../worker");
-const logger_1 = __importDefault(require("@hatchet/util/logger/logger"));
+const logger_1 = __importDefault(require("../../util/logger/logger"));
 const client_config_1 = require("./client-config");
 const addTokenMiddleware = (token) => function _(call, options) {
     return __asyncGenerator(this, arguments, function* _1() {

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

@@ -1,9 +1,9 @@
 import { HatchetClient } from '../hatchet-client';
 import { Action, ActionListener } from '../dispatcher/action-listener';
-import { ActionEvent, ActionEventType } from '@hatchet/protoc/dispatcher';
+import { ActionEvent, ActionEventType } from '../../protoc/dispatcher';
 import HatchetPromise from '../../util/hatchet-promise/hatchet-promise';
-import { Workflow } from '@hatchet/workflow';
-import { Logger } from '@hatchet/util/logger';
+import { Workflow } from '../../workflow';
+import { Logger } from '../../util/logger';
 export type ActionRegistry = Record<Action['actionId'], Function>;
 export declare class Worker {
     serviceName: string;

package/dist/clients/worker/worker.js

@@ -21,10 +21,10 @@ var __importDefault = (this && this.__importDefault) || function (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 dispatcher_1 = require("../../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 logger_1 = require("../../util/logger");
+const sleep_1 = __importDefault(require("../../util/sleep"));
 const step_1 = require("../../step");
 class Worker {
     constructor(client, options) {

package/package.json

@@ -1,11 +1,13 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "Background task orchestration & visibility for developers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
-    "dist"
+    "dist",
+    "!**/*.test.js",
+    "!**/*.test.d.ts"
   ],
   "repository": {
     "type": "git",

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

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

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

@@ -1,101 +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());
-    });
-};
-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/clients/dispatcher/action-listener.test.d.ts

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

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

@@ -1,277 +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 __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("@hatchet/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/clients/dispatcher/dispatcher-client.test.d.ts

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

package/dist/clients/dispatcher/dispatcher-client.test.js

@@ -1,99 +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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const dispatcher_1 = require("@hatchet/protoc/dispatcher");
-const dispatcher_client_1 = require("./dispatcher-client");
-const hatchet_client_test_1 = require("../hatchet-client/hatchet-client.test");
-let client;
-describe('DispatcherClient', () => {
-    it('should create a client', () => {
-        const x = 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);
-        expect(x).toBeDefined();
-    });
-    beforeEach(() => {
-        client = 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);
-    });
-    describe('get_action_listener', () => {
-        it('should register the worker', () => __awaiter(void 0, void 0, void 0, function* () {
-            const clientSpy = jest.spyOn(client.client, 'register').mockResolvedValue({
-                workerId: 'WORKER_ID',
-                tenantId: 'TENANT_ID',
-                workerName: 'WORKER_NAME',
-            });
-            const listenerSpy = jest.spyOn(client.client, 'listen');
-            const listener = yield client.get_action_listener({
-                workerName: 'WORKER_NAME',
-                services: ['SERVICE'],
-                actions: ['ACTION'],
-            });
-            expect(clientSpy).toHaveBeenCalledWith({
-                workerName: 'WORKER_NAME',
-                services: ['SERVICE'],
-                actions: ['ACTION'],
-            });
-            expect(listenerSpy).toHaveBeenCalledWith({
-                workerId: 'WORKER_ID',
-            });
-            expect(listener).toBeDefined();
-            expect(listener.workerId).toEqual('WORKER_ID');
-        }));
-    });
-    describe('send_action_event', () => {
-        it('should send action events', () => {
-            const clientSpy = jest.spyOn(client.client, 'sendActionEvent').mockResolvedValue({
-                tenantId: 'TENANT_ID',
-                workerId: 'WORKER_ID',
-            });
-            client.send_action_event({
-                workerId: 'WORKER_ID',
-                actionId: 'ACTION_ID',
-                eventType: dispatcher_1.ActionEventType.STEP_EVENT_TYPE_COMPLETED,
-                eventPayload: '{"foo":"bar"}',
-                eventTimestamp: new Date(),
-                jobId: 'a',
-                jobRunId: 'b',
-                stepId: 'c',
-                stepRunId: 'd',
-            });
-            expect(clientSpy).toHaveBeenCalledWith({
-                workerId: 'WORKER_ID',
-                actionId: 'ACTION_ID',
-                eventType: dispatcher_1.ActionEventType.STEP_EVENT_TYPE_COMPLETED,
-                eventPayload: '{"foo":"bar"}',
-                jobId: 'a',
-                jobRunId: 'b',
-                stepId: 'c',
-                stepRunId: 'd',
-                eventTimestamp: expect.any(Object),
-            });
-        });
-    });
-});

package/dist/clients/event/event-client.test.d.ts

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

package/dist/clients/event/event-client.test.js

@@ -1,60 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const hatchet_error_1 = __importDefault(require("../../util/errors/hatchet-error"));
-const event_client_1 = require("./event-client");
-const hatchet_client_test_1 = require("../hatchet-client/hatchet-client.test");
-let client;
-describe('EventClient', () => {
-    it('should create a client', () => {
-        const x = new event_client_1.EventClient({
-            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 event_client_1.EventClient({
-            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);
-    });
-    it('should push events', () => {
-        const clientSpy = jest.spyOn(client.client, 'push').mockResolvedValue({
-            tenantId: 'x',
-            eventId: 'y',
-            key: 'z',
-            eventTimestamp: new Date(),
-            payload: 'string',
-        });
-        client.push('type', { foo: 'bar' });
-        expect(clientSpy).toHaveBeenCalledWith({
-            key: 'type',
-            payload: '{"foo":"bar"}',
-            eventTimestamp: expect.any(Date),
-        });
-    });
-    it('should throw an error when push fails', () => {
-        const clientSpy = jest.spyOn(client.client, 'push');
-        clientSpy.mockImplementation(() => {
-            throw new Error('foo');
-        });
-        expect(() => {
-            client.push('type', { foo: 'bar' });
-        }).toThrow(new hatchet_error_1.default('foo'));
-    });
-});

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

@@ -1,2 +0,0 @@
-export declare const mockChannel: import("nice-grpc").Channel;
-export declare const mockFactory: import("nice-grpc").ClientFactory<{}>;

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

@@ -1,135 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mockFactory = exports.mockChannel = void 0;
-const nice_grpc_1 = require("nice-grpc");
-const hatchet_client_1 = require("./hatchet-client");
-exports.mockChannel = (0, nice_grpc_1.createChannel)('localhost:50051');
-exports.mockFactory = (0, nice_grpc_1.createClientFactory)();
-describe('Client', () => {
-    beforeEach(() => {
-        process.env.HATCHET_CLIENT_TOKEN = 'TOKEN_ENV';
-    });
-    it('should load from environment variables', () => {
-        const hatchet = new hatchet_client_1.HatchetClient({
-            token: 'TOKEN_ENV',
-            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',
-            },
-        }, {
-            credentials: nice_grpc_1.ChannelCredentials.createInsecure(),
-        });
-        expect(hatchet.config).toEqual({
-            token: 'TOKEN_ENV',
-            host_port: 'HOST_PORT',
-            log_level: 'OFF',
-            tls_config: {
-                tls_strategy: 'tls',
-                cert_file: 'TLS_CERT_FILE',
-                key_file: 'TLS_KEY_FILE',
-                ca_file: 'TLS_ROOT_CA_FILE',
-                server_name: 'TLS_SERVER_NAME',
-            },
-        });
-    });
-    it('should throw an error if the config param is invalid', () => {
-        expect(() => new hatchet_client_1.HatchetClient({
-            host_port: 'HOST_PORT',
-            tls_config: {
-                tls_strategy: 'tls',
-                cert_file: 'TLS_CERT_FILE',
-                key_file: 'TLS_KEY_FILE',
-                ca_file: 'TLS_ROOT_CA_FILE',
-                // @ts-ignore
-                server_name: undefined,
-            },
-        })).toThrow();
-    });
-    it('should favor config param over yaml over env vars ', () => {
-        const hatchet = new hatchet_client_1.HatchetClient({
-            tls_config: {
-                cert_file: 'TLS_CERT_FILE',
-                key_file: 'TLS_KEY_FILE',
-                ca_file: 'TLS_ROOT_CA_FILE',
-                server_name: 'TLS_SERVER_NAME',
-            },
-        }, {
-            config_path: './fixtures/.hatchet.yaml',
-            credentials: nice_grpc_1.ChannelCredentials.createInsecure(),
-        });
-        expect(hatchet.config).toEqual({
-            token: 'TOKEN_YAML',
-            host_port: 'HOST_PORT_YAML',
-            log_level: 'INFO',
-            tls_config: {
-                tls_strategy: 'tls',
-                cert_file: 'TLS_CERT_FILE',
-                key_file: 'TLS_KEY_FILE',
-                ca_file: 'TLS_ROOT_CA_FILE',
-                server_name: 'TLS_SERVER_NAME',
-            },
-        });
-    });
-    describe('with_host_port', () => {
-        it('should set the host_port', () => {
-            const hatchet = hatchet_client_1.HatchetClient.with_host_port('HOST', 1234, {
-                token: 'TOKEN',
-                tls_config: {
-                    tls_strategy: 'tls',
-                    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(),
-            });
-            expect(hatchet.config).toEqual({
-                token: 'TOKEN',
-                host_port: 'HOST:1234',
-                log_level: 'INFO',
-                tls_config: {
-                    tls_strategy: 'tls',
-                    cert_file: 'TLS_CERT_FILE',
-                    key_file: 'TLS_KEY_FILE',
-                    ca_file: 'TLS_ROOT_CA_FILE',
-                    server_name: 'TLS_SERVER_NAME',
-                },
-            });
-        });
-    });
-    describe('Worker', () => {
-        let hatchet;
-        beforeEach(() => {
-            hatchet = new hatchet_client_1.HatchetClient({
-                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',
-                },
-            }, {
-                credentials: nice_grpc_1.ChannelCredentials.createInsecure(),
-            });
-        });
-        describe('run', () => {
-            xit('should start a worker', () => {
-                const worker = hatchet.run('workflow1');
-                expect(worker).toBeDefined();
-            });
-        });
-        describe('worker', () => {
-            it('should start a worker', () => {
-                const worker = hatchet.worker('workflow1');
-                expect(worker).toBeDefined();
-            });
-        });
-    });
-});

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/util/config-loader/config-loader.test.d.ts

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

package/dist/util/config-loader/config-loader.test.js

@@ -1,72 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const config_loader_1 = require("./config-loader");
-fdescribe('ConfigLoader', () => {
-    beforeEach(() => {
-        process.env.HATCHET_CLIENT_HOST_PORT = 'HOST_PORT';
-        process.env.HATCHET_CLIENT_TLS_CERT_FILE = 'TLS_CERT_FILE';
-        process.env.HATCHET_CLIENT_TLS_KEY_FILE = 'TLS_KEY_FILE';
-        process.env.HATCHET_CLIENT_TLS_ROOT_CA_FILE = 'TLS_ROOT_CA_FILE';
-        process.env.HATCHET_CLIENT_TLS_SERVER_NAME = 'TLS_SERVER_NAME';
-    });
-    it('should load from environment variables', () => {
-        const config = config_loader_1.ConfigLoader.load_client_config();
-        expect(config).toEqual({
-            host_port: 'HOST_PORT',
-            log_level: 'INFO',
-            tls_config: {
-                tls_strategy: 'tls',
-                cert_file: 'TLS_CERT_FILE',
-                key_file: 'TLS_KEY_FILE',
-                ca_file: 'TLS_ROOT_CA_FILE',
-                server_name: 'TLS_SERVER_NAME',
-            },
-        });
-    });
-    it('should throw an error if the file is not found', () => {
-        expect(() => config_loader_1.ConfigLoader.load_client_config({
-            path: './fixtures/not-found.yaml',
-        })).toThrow();
-    });
-    xit('should throw an error if the yaml file fails validation', () => {
-        expect(() => 
-        // This test is failing because there is no invalid state of the yaml file, need to update with tls and mtls settings
-        config_loader_1.ConfigLoader.load_client_config({
-            path: './fixtures/.hatchet-invalid.yaml',
-        })).toThrow();
-    });
-    it('should favor yaml config over env vars', () => {
-        const config = config_loader_1.ConfigLoader.load_client_config({
-            path: './fixtures/.hatchet.yaml',
-        });
-        expect(config).toEqual({
-            token: 'TOKEN_YAML',
-            host_port: 'HOST_PORT_YAML',
-            log_level: 'INFO',
-            tls_config: {
-                tls_strategy: 'tls',
-                cert_file: 'TLS_CERT_FILE_YAML',
-                key_file: 'TLS_KEY_FILE_YAML',
-                ca_file: 'TLS_ROOT_CA_FILE_YAML',
-                server_name: 'TLS_SERVER_NAME_YAML',
-            },
-        });
-    });
-    xit('should attempt to load the root .hatchet.yaml config', () => {
-        //  i'm not sure the best way to test this, maybe spy on readFileSync called with
-        const config = config_loader_1.ConfigLoader.load_client_config({
-            path: './fixtures/.hatchet.yaml',
-        });
-        expect(config).toEqual({
-            token: 'TOKEN_YAML',
-            host_port: 'HOST_PORT_YAML',
-            tls_config: {
-                tls_strategy: 'tls',
-                cert_file: 'TLS_CERT_FILE_YAML',
-                key_file: 'TLS_KEY_FILE_YAML',
-                ca_file: 'TLS_ROOT_CA_FILE_YAML',
-                server_name: 'TLS_SERVER_NAME_YAML',
-            },
-        });
-    });
-});

package/dist/util/hatchet-promise/hatchet-promise.test.d.ts

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

package/dist/util/hatchet-promise/hatchet-promise.test.js

@@ -1,40 +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_promise_1 = __importDefault(require("./hatchet-promise"));
-describe('HatchetPromise', () => {
-    it('should resolve the original promise if not canceled', () => __awaiter(void 0, void 0, void 0, function* () {
-        const hatchetPromise = new hatchet_promise_1.default(new Promise((resolve) => {
-            setTimeout(() => resolve('RESOLVED'), 500);
-        }));
-        const result = yield hatchetPromise.promise;
-        expect(result).toEqual('RESOLVED');
-    }));
-    it('should resolve the cancel promise if canceled', () => __awaiter(void 0, void 0, void 0, function* () {
-        const hatchetPromise = new hatchet_promise_1.default(new Promise((resolve) => {
-            setTimeout(() => resolve('RESOLVED'), 500);
-        }));
-        const result = hatchetPromise.promise;
-        setTimeout(() => {
-            hatchetPromise.cancel();
-        }, 100);
-        try {
-            yield result;
-            expect(true).toEqual(false); // this should not be reached
-        }
-        catch (e) {
-            expect(e).toEqual(undefined);
-        }
-    }));
-});