@hatchet-dev/typescript-sdk 0.0.1

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,162 @@
+import { ChannelCredentials, createChannel, createClientFactory } from 'nice-grpc';
+import { HatchetClient } from './hatchet-client';
+
+export const mockChannel = createChannel('localhost:50051');
+export const mockFactory = createClientFactory();
+
+describe('Client', () => {
+  beforeEach(() => {
+    process.env.HATCHET_CLIENT_TOKEN = 'TOKEN_ENV';
+  });
+
+  it('should load from environment variables', () => {
+    const hatchet = new 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: 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 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 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: 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 = 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: 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: HatchetClient;
+
+    beforeEach(() => {
+      hatchet = new 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: 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/hatchet/clients/hatchet-client/hatchet-client.ts

@@ -0,0 +1,136 @@
+import { z } from 'zod';
+import { ConfigLoader } from '@util/config-loader';
+import { EventClient } from '@clients/event/event-client';
+import { DispatcherClient } from '@clients/dispatcher/dispatcher-client';
+import { AdminClient } from '@clients/admin/admin-client';
+import {
+  CallOptions,
+  Channel,
+  ChannelCredentials,
+  ClientMiddlewareCall,
+  Metadata,
+  createChannel,
+  createClientFactory,
+} from 'nice-grpc';
+import { Workflow } from '@hatchet/workflow';
+import { Worker } from '@clients/worker';
+import Logger from '@hatchet/util/logger/logger';
+import { ClientConfig, ClientConfigSchema } from './client-config';
+
+export interface HatchetClientOptions {
+  config_path?: string;
+  credentials?: ChannelCredentials;
+}
+
+const addTokenMiddleware = (token: string) =>
+  async function* _<Request, Response>(
+    call: ClientMiddlewareCall<Request, Response>,
+    options: CallOptions
+  ) {
+    const optionsWithAuth: CallOptions = {
+      ...options,
+      metadata: new Metadata({ authorization: `bearer ${token}` }),
+    };
+
+    if (!call.responseStream) {
+      const response = yield* call.next(call.request, optionsWithAuth);
+
+      return response;
+    }
+
+    for await (const response of call.next(call.request, optionsWithAuth)) {
+      yield response;
+    }
+
+    return undefined;
+  };
+
+export class HatchetClient {
+  config: ClientConfig;
+  credentials: ChannelCredentials;
+  channel: Channel;
+
+  event: EventClient;
+  dispatcher: DispatcherClient;
+  admin: AdminClient;
+
+  logger: Logger;
+
+  constructor(config?: Partial<ClientConfig>, options?: HatchetClientOptions) {
+    // Initializes a new Client instance.
+    // Loads config in the following order: config param > yaml file > env vars
+
+    const loaded = ConfigLoader.load_client_config({
+      path: options?.config_path,
+    });
+
+    try {
+      const valid = ClientConfigSchema.parse({
+        ...loaded,
+        ...{ ...config, tls_config: { ...loaded.tls_config, ...config?.tls_config } },
+      });
+      this.config = valid;
+    } catch (e) {
+      if (e instanceof z.ZodError) {
+        throw new Error(`Invalid client config: ${e.message}`);
+      }
+      throw e;
+    }
+
+    this.credentials =
+      options?.credentials ?? ConfigLoader.createCredentials(this.config.tls_config);
+
+    this.channel = createChannel(this.config.host_port, this.credentials, {
+      'grpc.ssl_target_name_override': this.config.tls_config.server_name,
+    });
+
+    const clientFactory = createClientFactory().use(addTokenMiddleware(this.config.token));
+
+    this.event = new EventClient(this.config, this.channel, clientFactory);
+    this.dispatcher = new DispatcherClient(this.config, this.channel, clientFactory);
+    this.admin = new AdminClient(this.config, this.channel, clientFactory);
+
+    this.logger = new Logger('HatchetClient', this.config.log_level);
+
+    this.logger.info(`Initialized HatchetClient`);
+  }
+
+  static with_host_port(
+    host: string,
+    port: number,
+    config?: Partial<ClientConfig>,
+    options?: HatchetClientOptions
+  ): HatchetClient {
+    return new HatchetClient(
+      {
+        ...config,
+        host_port: `${host}:${port}`,
+      },
+      options
+    );
+  }
+
+  static init(config?: Partial<ClientConfig>, options?: HatchetClientOptions): HatchetClient {
+    return new HatchetClient(config, options);
+  }
+
+  async run(workflow: string | Workflow): Promise<Worker> {
+    const worker = await this.worker(workflow);
+    worker.start();
+    return worker;
+  }
+
+  async worker(workflow: string | Workflow): Promise<Worker> {
+    const name = typeof workflow === 'string' ? workflow : workflow.id;
+    const worker = new Worker(this, {
+      name,
+    });
+
+    if (typeof workflow !== 'string') {
+      await worker.register_workflow(workflow);
+      return worker;
+    }
+
+    return worker;
+  }
+}

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

@@ -0,0 +1,2 @@
+export * from './hatchet-client';
+export * from './client-config';

package/hatchet/clients/worker/index.ts

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