@hatchet-dev/typescript-sdk 0.0.1 → 0.0.3

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

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

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

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

@@ -1,111 +0,0 @@
-import { ActionEventType } from '@protoc/dispatcher';
-import { DispatcherClient } from './dispatcher-client';
-import { mockChannel, mockFactory } from '../hatchet-client/hatchet-client.test';
-
-let client: DispatcherClient;
-
-describe('DispatcherClient', () => {
-  it('should create a client', () => {
-    const x = 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
-    );
-
-    expect(x).toBeDefined();
-  });
-
-  beforeEach(() => {
-    client = 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
-    );
-  });
-
-  describe('get_action_listener', () => {
-    it('should register the worker', async () => {
-      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 = await 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: 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: ActionEventType.STEP_EVENT_TYPE_COMPLETED,
-        eventPayload: '{"foo":"bar"}',
-        jobId: 'a',
-        jobRunId: 'b',
-        stepId: 'c',
-        stepRunId: 'd',
-        eventTimestamp: expect.any(Object),
-      });
-    });
-  });
-});

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

@@ -1,47 +0,0 @@
-import { Channel, ClientFactory } from 'nice-grpc';
-import {
-  DispatcherClient as PbDispatcherClient,
-  DispatcherDefinition,
-  ActionEvent,
-} from '@protoc/dispatcher';
-import { ClientConfig } from '@clients/hatchet-client/client-config';
-import HatchetError from '@util/errors/hatchet-error';
-import { ActionListener } from './action-listener';
-
-interface GetActionListenerOptions {
-  workerName: string;
-  services: string[];
-  actions: string[];
-}
-
-export class DispatcherClient {
-  config: ClientConfig;
-  client: PbDispatcherClient;
-
-  constructor(config: ClientConfig, channel: Channel, factory: ClientFactory) {
-    this.config = config;
-    this.client = factory.create(DispatcherDefinition, channel);
-  }
-
-  async get_action_listener(options: GetActionListenerOptions) {
-    // Register the worker
-    const registration = await this.client.register({
-      ...options,
-    });
-
-    // Subscribe to the worker
-    const listener = this.client.listen({
-      workerId: registration.workerId,
-    });
-
-    return new ActionListener(this, listener, registration.workerId);
-  }
-
-  async send_action_event(in_: ActionEvent) {
-    try {
-      return this.client.sendActionEvent(in_);
-    } catch (e: any) {
-      throw new HatchetError(e.message);
-    }
-  }
-}

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

@@ -1,72 +0,0 @@
-import HatchetError from '@util/errors/hatchet-error';
-import { EventClient } from './event-client';
-import { mockChannel, mockFactory } from '../hatchet-client/hatchet-client.test';
-
-let client: EventClient;
-
-describe('EventClient', () => {
-  it('should create a client', () => {
-    const x = new 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',
-        },
-      },
-      mockChannel,
-      mockFactory
-    );
-
-    expect(x).toBeDefined();
-  });
-
-  beforeEach(() => {
-    client = new 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',
-        },
-      },
-      mockChannel,
-      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 HatchetError('foo'));
-  });
-});

package/hatchet/clients/event/event-client.ts

@@ -1,32 +0,0 @@
-import { Channel, ClientFactory } from 'nice-grpc';
-import {
-  EventsServiceClient,
-  EventsServiceDefinition,
-  PushEventRequest,
-} from '@protoc/events/events';
-import HatchetError from '@util/errors/hatchet-error';
-import { ClientConfig } from '@clients/hatchet-client/client-config';
-
-export class EventClient {
-  config: ClientConfig;
-  client: EventsServiceClient;
-
-  constructor(config: ClientConfig, channel: Channel, factory: ClientFactory) {
-    this.config = config;
-    this.client = factory.create(EventsServiceDefinition, channel);
-  }
-
-  push<T>(type: string, input: T) {
-    const req: PushEventRequest = {
-      key: type,
-      payload: JSON.stringify(input),
-      eventTimestamp: new Date(),
-    };
-
-    try {
-      return this.client.push(req);
-    } catch (e: any) {
-      throw new HatchetError(e.message);
-    }
-  }
-}

package/hatchet/clients/hatchet-client/client-config.ts

@@ -1,22 +0,0 @@
-import { ChannelCredentials } from 'nice-grpc';
-import { z } from 'zod';
-
-const ClientTLSConfigSchema = z.object({
-  tls_strategy: z.enum(['tls', 'mtls']).optional(),
-  cert_file: z.string().optional(),
-  ca_file: z.string().optional(),
-  key_file: z.string().optional(),
-  server_name: z.string().optional(),
-});
-
-export const ClientConfigSchema = z.object({
-  token: z.string(),
-  tls_config: ClientTLSConfigSchema,
-  host_port: z.string(),
-  log_level: z.enum(['OFF', 'DEBUG', 'INFO', 'WARN', 'ERROR']).optional(),
-});
-
-export type ClientConfig = z.infer<typeof ClientConfigSchema> & {
-  credentials?: ChannelCredentials;
-};
-export type ClientTLSConfig = z.infer<typeof ClientTLSConfigSchema>;

package/hatchet/clients/hatchet-client/fixtures/.hatchet-invalid.yaml

@@ -1,6 +0,0 @@
-tenant_id: 'TENANT_ID_YAML'
-host_port: 'HOST_PORT_YAML'
-tls_config:
-  cert_file: 'TLS_CERT_FILE_YAML'
-  key_file: 'TLS_KEY_FILE_YAML'
-  ca_file: 'TLS_ROOT_CA_FILE_YAML'

package/hatchet/clients/hatchet-client/fixtures/.hatchet.yaml

@@ -1,8 +0,0 @@
-token: 'TOKEN_YAML'
-tenant_id: 'TENANT_ID_YAML'
-host_port: 'HOST_PORT_YAML'
-tls_config:
-  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'