@hatchet-dev/typescript-sdk 0.0.1

package/examples/dag-worker.ts

@@ -0,0 +1,55 @@
+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

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

package/examples/simple-worker.ts

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,10 @@
+# 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

@@ -0,0 +1,116 @@
+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

@@ -0,0 +1,43 @@
+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);
+    }
+  }
+}

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

@@ -0,0 +1,270 @@
+import { ActionType, AssignedAction } from '@protoc/dispatcher';
+import sleep from '@util/sleep';
+import { ServerError, Status } from 'nice-grpc-common';
+import { DispatcherClient } from './dispatcher-client';
+import { ActionListener } from './action-listener';
+import { mockChannel, mockFactory } from '../hatchet-client/hatchet-client.test';
+
+let dispatcher: DispatcherClient;
+
+type AssignActionMock = AssignedAction | Error;
+
+// Mock data for AssignedAction
+const mockAssignedActions: AssignActionMock[] = [
+  {
+    tenantId: 'tenant1',
+    jobId: 'job1',
+    jobName: 'Job One',
+    jobRunId: 'run1',
+    stepId: 'step1',
+    stepRunId: 'runStep1',
+    actionId: 'action1',
+    actionType: ActionType.START_STEP_RUN,
+    actionPayload: 'payload1',
+  },
+  // ... Add more mock AssignedAction objects as needed
+];
+
+// Mock implementation of the listener
+export const mockListener = (fixture: AssignActionMock[]) =>
+  (async function* gen() {
+    for (const action of fixture) {
+      // Simulate asynchronous behavior
+      await sleep(100);
+
+      if (action instanceof Error) {
+        throw action;
+      }
+
+      yield action;
+    }
+  })();
+
+describe('ActionListener', () => {
+  beforeEach(() => {
+    dispatcher = new 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',
+        },
+      },
+      mockChannel,
+      mockFactory
+    );
+  });
+
+  it('should create a client', async () => {
+    const listener = new ActionListener(dispatcher, mockListener(mockAssignedActions), 'WORKER_ID');
+    expect(listener).toBeDefined();
+    expect(listener.workerId).toEqual('WORKER_ID');
+  });
+
+  describe('actions', () => {
+    it('it should "yield" actions', async () => {
+      const listener = new ActionListener(
+        dispatcher,
+        mockListener([...mockAssignedActions, new ServerError(Status.CANCELLED, 'CANCELLED')]),
+        'WORKER_ID'
+      );
+
+      const actions = listener.actions();
+      const res = [];
+      for await (const action of actions) {
+        res.push(action);
+      }
+
+      expect(res[0]).toEqual({
+        tenantId: 'tenant1',
+        jobId: 'job1',
+        jobName: 'Job One',
+        jobRunId: 'run1',
+        stepId: 'step1',
+        stepRunId: 'runStep1',
+        actionId: 'action1',
+        actionType: ActionType.START_STEP_RUN,
+        actionPayload: 'payload1',
+      });
+    });
+
+    it('it should break on grpc CANCELLED', async () => {
+      const listener = new ActionListener(
+        dispatcher,
+        mockListener([...mockAssignedActions, new ServerError(Status.CANCELLED, 'CANCELLED')]),
+        'WORKER_ID'
+      );
+
+      const actions = listener.actions();
+      const retrySpy = jest.spyOn(listener, 'retrySubscribe').mockResolvedValue(undefined);
+
+      const res = [];
+      for await (const action of actions) {
+        res.push(action);
+      }
+
+      expect(res.length).toEqual(1);
+      expect(retrySpy).not.toHaveBeenCalled();
+    });
+
+    it('it should break on unknown error', async () => {
+      const listener = new ActionListener(
+        dispatcher,
+        mockListener([...mockAssignedActions, new Error('Simulated error')]),
+        'WORKER_ID'
+      );
+
+      const actions = listener.actions();
+      const retrySpy = jest.spyOn(listener, 'retrySubscribe').mockResolvedValue(undefined);
+
+      const res = [];
+      for await (const action of actions) {
+        res.push(action);
+      }
+
+      expect(res.length).toEqual(1);
+      expect(retrySpy).not.toHaveBeenCalled();
+    });
+
+    it('it should attempt to re-establish connection on grpc UNAVAILABLE', async () => {
+      const listener = new ActionListener(
+        dispatcher,
+        mockListener([...mockAssignedActions, new ServerError(Status.UNAVAILABLE, 'UNAVAILABLE')]),
+        'WORKER_ID'
+      );
+
+      const retrySpy = jest.spyOn(listener, 'retrySubscribe').mockResolvedValue(undefined);
+
+      const actions = listener.actions();
+
+      const res = [];
+      for await (const action of actions) {
+        res.push(action);
+      }
+
+      expect(res.length).toEqual(1);
+      expect(retrySpy).toHaveBeenCalled();
+    });
+  });
+
+  describe('retry_subscribe', () => {
+    it('should exit after successful connection', async () => {
+      const listener = new ActionListener(
+        dispatcher,
+        mockListener(mockAssignedActions),
+        'WORKER_ID'
+      );
+
+      // Mock the listener to throw an error on the first call
+      const listenSpy = jest
+        .spyOn(listener.client, 'listen')
+        .mockReturnValue(mockListener(mockAssignedActions));
+
+      await listener.retrySubscribe();
+
+      expect(listenSpy).toHaveBeenCalledTimes(1);
+    });
+
+    it('should retry until success', async () => {
+      const listener = new ActionListener(
+        dispatcher,
+        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(() => mockListener(mockAssignedActions));
+
+      await expect(async () => {
+        await listener.retrySubscribe();
+      }).not.toThrow();
+    });
+
+    it('should not throw an error if successful', async () => {
+      const listener = new ActionListener(
+        dispatcher,
+        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(() => mockListener(mockAssignedActions));
+
+      await listener.retrySubscribe();
+      expect(listenSpy).toHaveBeenCalledTimes(2);
+    });
+
+    it('should retry at most COUNT times and throw an error', async () => {
+      const listener = new ActionListener(
+        dispatcher,
+        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(() => mockListener(mockAssignedActions));
+
+      try {
+        await listener.retrySubscribe();
+        expect(listenSpy).toHaveBeenCalledTimes(5);
+      } catch (e: any) {
+        expect(e.message).toEqual(`Could not subscribe to the worker after 5 retries`);
+      }
+    });
+  });
+
+  describe('unregister', () => {
+    it('should unsubscribe itself', async () => {
+      const listener = new ActionListener(
+        dispatcher,
+        mockListener(mockAssignedActions),
+        'WORKER_ID'
+      );
+
+      const unsubscribeSpy = jest.spyOn(listener.client, 'unsubscribe').mockResolvedValue({
+        tenantId: 'TENANT_ID',
+        workerId: 'WORKER_ID',
+      });
+
+      const res = await listener.unregister();
+
+      expect(unsubscribeSpy).toHaveBeenCalled();
+      expect(res.workerId).toEqual('WORKER_ID');
+    });
+  });
+});

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

@@ -0,0 +1,91 @@
+import { DispatcherClient as PbDispatcherClient, AssignedAction } from '@protoc/dispatcher';
+
+import { Status } from 'nice-grpc';
+import { ClientConfig } from '@clients/hatchet-client/client-config';
+import sleep from '@util/sleep';
+import HatchetError from '@util/errors/hatchet-error';
+import { DispatcherClient } from './dispatcher-client';
+
+const DEFAULT_ACTION_LISTENER_RETRY_INTERVAL = 5; // seconds
+const DEFAULT_ACTION_LISTENER_RETRY_COUNT = 5;
+
+export interface Action {
+  tenantId: string;
+  jobId: string;
+  jobName: string;
+  jobRunId: string;
+  stepId: string;
+  stepRunId: string;
+  actionId: string;
+  actionType: number;
+  actionPayload: string;
+}
+
+export class ActionListener {
+  config: ClientConfig;
+  client: PbDispatcherClient;
+  listener: AsyncIterable<AssignedAction>;
+  workerId: string;
+
+  constructor(client: DispatcherClient, listener: AsyncIterable<AssignedAction>, workerId: string) {
+    this.config = client.config;
+    this.client = client.client;
+    this.listener = listener;
+    this.workerId = workerId;
+  }
+
+  actions = () =>
+    (async function* gen(client: ActionListener) {
+      while (true) {
+        try {
+          for await (const assignedAction of client.listener) {
+            const action: Action = {
+              ...assignedAction,
+            };
+
+            yield action;
+          }
+        } catch (e: any) {
+          if (e.code === Status.CANCELLED) {
+            break;
+          }
+          if (e.code === Status.UNAVAILABLE) {
+            client.retrySubscribe();
+          }
+          break;
+        }
+      }
+    })(this);
+
+  async retrySubscribe() {
+    let retries = 0;
+
+    while (retries < DEFAULT_ACTION_LISTENER_RETRY_COUNT) {
+      try {
+        await sleep(DEFAULT_ACTION_LISTENER_RETRY_INTERVAL);
+
+        this.listener = this.client.listen({
+          workerId: this.workerId,
+        });
+
+        return;
+      } catch (e: any) {
+        retries += 1;
+      }
+    }
+
+    throw new HatchetError(
+      `Could not subscribe to the worker after ${DEFAULT_ACTION_LISTENER_RETRY_COUNT} retries`
+    );
+  }
+
+  async unregister() {
+    try {
+      return this.client.unsubscribe({
+        workerId: this.workerId,
+      });
+    } catch (e: any) {
+      throw new HatchetError(`Failed to unsubscribe: ${e.message}`);
+    }
+  }
+}