@hatchet-dev/typescript-sdk 0.0.1 → 0.0.3

package/dist/hatchet/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("@clients/hatchet-client");
-const dispatcher_1 = require("@protoc/dispatcher");
-const action_listener_1 = require("@clients/dispatcher/action-listener");
-const nice_grpc_common_1 = require("nice-grpc-common");
-const action_listener_test_1 = require("@clients/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/hatchet/index.d.ts

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

package/dist/hatchet/sdk.d.ts

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

package/dist/hatchet/util/config-loader/config-loader.test.d.ts

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

package/dist/hatchet/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/hatchet/util/hatchet-promise/hatchet-promise.test.d.ts

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

package/dist/hatchet/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);
-        }
-    }));
-});

package/examples/dag-worker.ts

@@ -1,55 +0,0 @@
-import Hatchet from '@hatchet/sdk';
-import { Workflow } from '@hatchet/workflow';
-
-const hatchet = Hatchet.init({
-  log_level: 'OFF',
-});
-
-const sleep = (ms: number) =>
-  new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-
-const workflow: Workflow = {
-  id: 'dag-example',
-  description: 'test',
-  on: {
-    event: 'user:create',
-  },
-  steps: [
-    {
-      name: 'dag-step1',
-      run: async (ctx) => {
-        console.log('executed step1!');
-        await sleep(5000);
-        return { step1: 'step1' };
-      },
-    },
-    {
-      name: 'dag-step2',
-      parents: ['dag-step1'],
-      run: (ctx) => {
-        console.log('executed step2!');
-        return { step2: 'step2' };
-      },
-    },
-    {
-      name: 'dag-step3',
-      parents: ['dag-step1', 'dag-step2'],
-      run: (ctx) => {
-        console.log('executed step3!');
-        return { step3: 'step3' };
-      },
-    },
-    {
-      name: 'dag-step4',
-      parents: ['dag-step1', 'dag-step3'],
-      run: (ctx) => {
-        console.log('executed step4!');
-        return { step4: 'step4' };
-      },
-    },
-  ],
-};
-
-hatchet.run(workflow);

package/examples/example-event.ts

@@ -1,7 +0,0 @@
-import Hatchet from '@hatchet/sdk';
-
-const hatchet = Hatchet.init();
-
-hatchet.event.push('user:create', {
-  test: 'test',
-});

package/examples/simple-worker.ts

@@ -1,39 +0,0 @@
-import Hatchet from '@hatchet/sdk';
-import { Workflow } from '@hatchet/workflow';
-
-const hatchet = Hatchet.init();
-
-const sleep = (ms: number) =>
-  new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-
-const workflow: Workflow = {
-  id: 'example',
-  description: 'test',
-  on: {
-    event: 'user:create',
-  },
-  steps: [
-    {
-      name: 'step1',
-      run: async (ctx) => {
-        console.log('starting step1 with the following input', ctx.workflowInput());
-        console.log('waiting 5 seconds...');
-        await sleep(5000);
-        console.log('executed step1!');
-        return { step1: 'step1 results!' };
-      },
-    },
-    {
-      name: 'step2',
-      parents: ['step1'],
-      run: (ctx) => {
-        console.log('executed step2 after step1 returned ', ctx.stepOutput('step1'));
-        return { step2: 'step2 results!' };
-      },
-    },
-  ],
-};
-
-hatchet.run(workflow);

package/generate-protoc.sh

@@ -1,10 +0,0 @@
-# Directory to write generated code to (.js and .d.ts files)
-OUT_DIR="./protoc"
-
-# Generate code
-./node_modules/.bin/grpc_tools_node_protoc \
-  --plugin=protoc-gen-ts_proto=./node_modules/.bin/protoc-gen-ts_proto \
-  --ts_proto_out=$OUT_DIR \
-  --ts_proto_opt=outputServices=nice-grpc,outputServices=generic-definitions,useExactTypes=false \
-  --proto_path=../api-contracts \
-  ../api-contracts/**/*.proto

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

@@ -1,116 +0,0 @@
-import { CreateWorkflowVersionOpts, WorkflowVersion } from '@protoc/workflows';
-import { AdminClient } from './admin-client';
-import { mockChannel, mockFactory } from '../hatchet-client/hatchet-client.test';
-
-describe('AdminClient', () => {
-  let client: AdminClient;
-
-  it('should create a client', () => {
-    const x = new 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',
-        },
-      },
-      mockChannel,
-      mockFactory
-    );
-
-    expect(x).toBeDefined();
-  });
-
-  beforeEach(() => {
-    client = new 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',
-        },
-      },
-      mockChannel,
-      mockFactory
-    );
-  });
-
-  describe('put_workflow', () => {
-    it('should throw an error if no version and not auto version', async () => {
-      const workflow: CreateWorkflowVersionOpts = {
-        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', async () => {
-      const workflow: CreateWorkflowVersionOpts = {
-        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,
-      });
-
-      await client.put_workflow(workflow);
-
-      expect(putSpy).toHaveBeenCalled();
-    });
-  });
-
-  describe('schedule_workflow', () => {
-    it('should schedule a workflow', () => {
-      const res: WorkflowVersion = {
-        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/hatchet/clients/admin/admin-client.ts

@@ -1,43 +0,0 @@
-import { Channel, ClientFactory } from 'nice-grpc';
-import {
-  CreateWorkflowVersionOpts,
-  WorkflowServiceClient,
-  WorkflowServiceDefinition,
-} from '@protoc/workflows';
-import HatchetError from '@util/errors/hatchet-error';
-import { ClientConfig } from '@clients/hatchet-client/client-config';
-
-export class AdminClient {
-  config: ClientConfig;
-  client: WorkflowServiceClient;
-
-  constructor(config: ClientConfig, channel: Channel, factory: ClientFactory) {
-    this.config = config;
-    this.client = factory.create(WorkflowServiceDefinition, channel);
-  }
-
-  async put_workflow(workflow: CreateWorkflowVersionOpts, options?: { autoVersion?: boolean }) {
-    if (workflow.version === '' && !options?.autoVersion) {
-      throw new HatchetError('PutWorkflow error: workflow version is required, or use autoVersion');
-    }
-
-    try {
-      await this.client.putWorkflow({
-        opts: workflow,
-      });
-    } catch (e: any) {
-      throw new HatchetError(e.message);
-    }
-  }
-
-  schedule_workflow(workflowId: string, options?: { schedules?: Date[] }) {
-    try {
-      this.client.scheduleWorkflow({
-        workflowId,
-        schedules: options?.schedules,
-      });
-    } catch (e: any) {
-      throw new HatchetError(e.message);
-    }
-  }
-}