@hatchet-dev/typescript-sdk 0.0.1 → 0.0.3

package/hatchet/clients/worker/worker.ts

@@ -1,229 +0,0 @@
-import { HatchetClient } from '@clients/hatchet-client';
-import HatchetError from '@util/errors/hatchet-error';
-import { Action, ActionListener } from '@clients/dispatcher/action-listener';
-import { ActionEvent, ActionEventType, ActionType } from '@protoc/dispatcher';
-import HatchetPromise from '@util/hatchet-promise/hatchet-promise';
-import { Workflow } from '@hatchet/workflow';
-import { CreateWorkflowStepOpts } from '@protoc/workflows';
-import { Logger } from '@hatchet/util/logger';
-import sleep from '@hatchet/util/sleep';
-import { Context } from '../../step';
-
-export type ActionRegistry = Record<Action['actionId'], Function>;
-
-export class Worker {
-  serviceName = 'default';
-  client: HatchetClient;
-  name: string;
-  killing: boolean;
-  handle_kill: boolean;
-
-  action_registry: ActionRegistry;
-  listener: ActionListener | undefined;
-  futures: Record<Action['stepRunId'], HatchetPromise<any>> = {};
-
-  logger: Logger;
-
-  constructor(client: HatchetClient, options: { name: string; handleKill?: boolean }) {
-    this.client = client;
-    this.name = options.name;
-    this.action_registry = {};
-
-    process.on('SIGTERM', () => this.exit_gracefully());
-    process.on('SIGINT', () => this.exit_gracefully());
-
-    this.killing = false;
-    this.handle_kill = options.handleKill === undefined ? true : options.handleKill;
-
-    this.logger = new Logger(`Worker/${this.name}`, this.client.config.log_level);
-  }
-
-  async register_workflow(workflow: Workflow, options?: { autoVersion?: boolean }) {
-    try {
-      await this.client.admin.put_workflow(
-        {
-          name: workflow.id,
-          description: workflow.description,
-          version: 'v0.55.0', // FIXME  workflow.version,
-          eventTriggers: workflow.on.event ? [workflow.on.event] : [],
-          cronTriggers: workflow.on.cron ? [workflow.on.cron] : [],
-          scheduledTriggers: [],
-          jobs: [
-            {
-              name: 'my-job', // FIXME variable names
-              timeout: '60s',
-              description: 'my-job',
-              steps: workflow.steps.map<CreateWorkflowStepOpts>((step) => ({
-                readableId: step.name,
-                action: `${this.serviceName}:${step.name}`,
-                timeout: '60s',
-                inputs: '{}',
-                parents: step.parents ?? [],
-              })),
-            },
-          ],
-        },
-        {
-          autoVersion: !options?.autoVersion,
-        }
-      );
-    } catch (e: any) {
-      throw new HatchetError(`Could not register workflow: ${e.message}`);
-    }
-
-    this.action_registry = workflow.steps.reduce<ActionRegistry>((acc, step) => {
-      acc[`${this.serviceName}:${step.name}`] = step.run;
-      return acc;
-    }, {});
-  }
-
-  handle_start_step_run(action: Action) {
-    const { actionId } = action;
-    const context = new Context(action.actionPayload);
-
-    const step = this.action_registry[actionId];
-    if (!step) {
-      this.logger.error(`Could not find step '${actionId}'`);
-      return;
-    }
-
-    const run = async () => {
-      return step(context);
-    };
-
-    const success = (result: any) => {
-      this.logger.info(`Step run ${action.stepRunId} succeeded`);
-
-      try {
-        // Send the action event to the dispatcher
-        const event = this.get_action_event(
-          action,
-          ActionEventType.STEP_EVENT_TYPE_COMPLETED,
-          result
-        );
-        this.client.dispatcher.send_action_event(event);
-
-        // delete the run from the futures
-        delete this.futures[action.stepRunId];
-      } catch (e: any) {
-        this.logger.error(`Could not send action event: ${e.message}`);
-      }
-    };
-
-    const failure = (error: any) => {
-      this.logger.error(`Step run ${action.stepRunId} failed: ${error.message}`);
-
-      try {
-        // Send the action event to the dispatcher
-        const event = this.get_action_event(action, ActionEventType.STEP_EVENT_TYPE_FAILED, error);
-        this.client.dispatcher.send_action_event(event);
-        // delete the run from the futures
-        delete this.futures[action.stepRunId];
-      } catch (e: any) {
-        this.logger.error(`Could not send action event: ${e.message}`);
-      }
-    };
-
-    const future = new HatchetPromise(run().then(success).catch(failure));
-    this.futures[action.stepRunId] = future;
-
-    try {
-      // Send the action event to the dispatcher
-      const event = this.get_action_event(action, ActionEventType.STEP_EVENT_TYPE_STARTED);
-      this.client.dispatcher.send_action_event(event);
-    } catch (e: any) {
-      this.logger.error(`Could not send action event: ${e.message}`);
-    }
-  }
-
-  get_action_event(action: Action, eventType: ActionEventType, payload: any = ''): ActionEvent {
-    return {
-      workerId: this.name,
-      jobId: action.jobId,
-      jobRunId: action.jobRunId,
-      stepId: action.stepId,
-      stepRunId: action.stepRunId,
-      actionId: action.actionId,
-      eventTimestamp: new Date(),
-      eventType,
-      eventPayload: JSON.stringify(payload),
-    };
-  }
-
-  handle_cancel_step_run(action: Action) {
-    const { stepRunId } = action;
-    const future = this.futures[stepRunId];
-    if (future) {
-      future.cancel();
-      delete this.futures[stepRunId];
-    }
-  }
-
-  async stop() {
-    await this.exit_gracefully();
-  }
-
-  async exit_gracefully() {
-    this.killing = true;
-
-    this.logger.info('Starting to exit...');
-
-    try {
-      this.listener?.unregister();
-    } catch (e: any) {
-      this.logger.error(`Could not unregister listener: ${e.message}`);
-    }
-
-    this.logger.info('Gracefully exiting hatchet worker, running tasks will attempt to finish...');
-
-    // attempt to wait for futures to finish
-    await Promise.all(Object.values(this.futures).map(({ promise }) => promise));
-
-    if (this.handle_kill) {
-      this.logger.info('Exiting hatchet worker...');
-      process.exit(0);
-    }
-  }
-
-  async start() {
-    let retries = 0;
-
-    while (retries < 5) {
-      try {
-        this.listener = await this.client.dispatcher.get_action_listener({
-          workerName: this.name,
-          services: ['default'],
-          actions: Object.keys(this.action_registry),
-        });
-
-        const generator = this.listener.actions();
-
-        this.logger.info(`Worker ${this.name} listening for actions`);
-
-        for await (const action of generator) {
-          this.logger.info(`Worker ${this.name} received action ${action.actionId}`);
-
-          if (action.actionType === ActionType.START_STEP_RUN) {
-            this.handle_start_step_run(action);
-          } else if (action.actionType === ActionType.CANCEL_STEP_RUN) {
-            this.handle_cancel_step_run(action);
-          }
-        }
-
-        break;
-      } catch (e: any) {
-        this.logger.error(`Could not start worker: ${e.message}`);
-        retries += 1;
-        const wait = 500;
-        this.logger.error(`Could not start worker, retrying in ${500} seconds`);
-        await sleep(wait);
-      }
-    }
-
-    if (this.killing) return;
-
-    if (retries > 5) {
-      throw new HatchetError('Could not start worker after 5 retries');
-    }
-  }
-}

package/hatchet/index.ts

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

package/hatchet/sdk.ts

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

package/hatchet/step.ts

@@ -1,48 +0,0 @@
-import HatchetError from '@util/errors/hatchet-error';
-import * as z from 'zod';
-
-export const CreateStepSchema = z.object({
-  name: z.string(),
-  parents: z.array(z.string()).optional(),
-});
-
-export type NextStep = { [key: string]: string };
-
-interface ContextData<T = unknown> {
-  input: T;
-  parents: Record<string, any>;
-  triggered_by_event: string;
-}
-
-export class Context<T = unknown> {
-  data: ContextData<T>;
-  constructor(payload: string) {
-    try {
-      this.data = JSON.parse(JSON.parse(payload));
-    } catch (e: any) {
-      throw new HatchetError(`Could not parse payload: ${e.message}`);
-    }
-  }
-
-  stepOutput(step: string): string {
-    if (!this.data.parents) {
-      throw new HatchetError('Step output not found');
-    }
-    if (!this.data.parents[step]) {
-      throw new HatchetError(`Step output for '${step}' not found`);
-    }
-    return this.data.parents[step];
-  }
-
-  triggeredByEvent(): boolean {
-    return this.data?.triggered_by_event === 'event';
-  }
-
-  workflowInput(): any {
-    return this.data?.input || {};
-  }
-}
-
-export interface CreateStep<T> extends z.infer<typeof CreateStepSchema> {
-  run: (ctx: Context) => Promise<NextStep> | NextStep | void;
-}

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

@@ -1,79 +0,0 @@
-import { ConfigLoader } from './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 = 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(() =>
-      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
-      ConfigLoader.load_client_config({
-        path: './fixtures/.hatchet-invalid.yaml',
-      })
-    ).toThrow();
-  });
-
-  it('should favor yaml config over env vars', () => {
-    const config = 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 = 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/hatchet/util/config-loader/config-loader.ts

@@ -1,91 +0,0 @@
-import { parse } from 'yaml';
-import { readFileSync } from 'fs';
-import * as p from 'path';
-import { z } from 'zod';
-import { ClientConfig, ClientConfigSchema } from '@clients/hatchet-client';
-import { ChannelCredentials } from 'nice-grpc';
-import { LogLevel } from '../logger/logger';
-
-type EnvVars =
-  | 'HATCHET_CLIENT_TOKEN'
-  | 'HATCHET_CLIENT_TLS_STRATEGY'
-  | 'HATCHET_CLIENT_HOST_PORT'
-  | 'HATCHET_CLIENT_TLS_CERT_FILE'
-  | 'HATCHET_CLIENT_TLS_KEY_FILE'
-  | 'HATCHET_CLIENT_TLS_ROOT_CA_FILE'
-  | 'HATCHET_CLIENT_TLS_SERVER_NAME'
-  | 'HATCHET_CLIENT_LOG_LEVEL';
-
-type TLSStrategy = 'tls' | 'mtls';
-
-interface LoadClientConfigOptions {
-  path?: string;
-}
-
-const DEFAULT_CONFIG_FILE = '.hatchet.yaml';
-
-export class ConfigLoader {
-  static load_client_config(config?: LoadClientConfigOptions): Partial<ClientConfig> {
-    const yaml = this.load_yaml_config(config?.path);
-    const tlsConfig = {
-      tls_strategy:
-        yaml?.tls_config?.tls_strategy ??
-        (this.env('HATCHET_CLIENT_TLS_STRATEGY') as TLSStrategy | undefined) ??
-        'tls',
-      cert_file: yaml?.tls_config?.cert_file ?? this.env('HATCHET_CLIENT_TLS_CERT_FILE')!,
-      key_file: yaml?.tls_config?.key_file ?? this.env('HATCHET_CLIENT_TLS_KEY_FILE')!,
-      ca_file: yaml?.tls_config?.ca_file ?? this.env('HATCHET_CLIENT_TLS_ROOT_CA_FILE')!,
-      server_name: yaml?.tls_config?.server_name ?? this.env('HATCHET_CLIENT_TLS_SERVER_NAME')!,
-    };
-
-    return {
-      token: yaml?.token ?? this.env('HATCHET_CLIENT_TOKEN'),
-      host_port: yaml?.host_port ?? this.env('HATCHET_CLIENT_HOST_PORT'),
-      tls_config: tlsConfig,
-      log_level: yaml?.log_level ?? (this.env('HATCHET_CLIENT_LOG_LEVEL') as LogLevel) ?? 'INFO',
-    };
-  }
-
-  static get default_yaml_config_path() {
-    return p.join(process.cwd(), DEFAULT_CONFIG_FILE);
-  }
-
-  static createCredentials(config: ClientConfig['tls_config']): ChannelCredentials {
-    if (config.tls_strategy === 'tls') {
-      const rootCerts = config.ca_file ? readFileSync(config.ca_file) : undefined;
-      return ChannelCredentials.createSsl(rootCerts);
-    }
-
-    const rootCerts = config.ca_file ? readFileSync(config.ca_file) : null;
-    const privateKey = config.key_file ? readFileSync(config.key_file) : null;
-    const certChain = config.cert_file ? readFileSync(config.cert_file) : null;
-    return ChannelCredentials.createSsl(rootCerts, privateKey, certChain);
-  }
-
-  static load_yaml_config(path?: string): ClientConfig | undefined {
-    try {
-      const configFile = readFileSync(
-        p.join(__dirname, path ?? this.default_yaml_config_path),
-        'utf8'
-      );
-
-      const config = parse(configFile);
-
-      ClientConfigSchema.partial().parse(config);
-
-      return config as ClientConfig;
-    } catch (e) {
-      if (!path) return undefined;
-
-      if (e instanceof z.ZodError) {
-        throw new Error(`Invalid yaml config: ${e.message}`);
-      }
-
-      throw e;
-    }
-  }
-
-  private static env(name: EnvVars): string | undefined {
-    return process.env[name];
-  }
-}

package/hatchet/util/config-loader/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/util/config-loader/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'

package/hatchet/util/config-loader/index.ts

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

package/hatchet/util/errors/hatchet-error.ts

@@ -1,8 +0,0 @@
-class HatchetError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = 'HatchetError';
-  }
-}
-
-export default HatchetError;

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

@@ -1,32 +0,0 @@
-import HatchetPromise from './hatchet-promise';
-
-describe('HatchetPromise', () => {
-  it('should resolve the original promise if not canceled', async () => {
-    const hatchetPromise = new HatchetPromise(
-      new Promise((resolve) => {
-        setTimeout(() => resolve('RESOLVED'), 500);
-      })
-    );
-    const result = await hatchetPromise.promise;
-    expect(result).toEqual('RESOLVED');
-  });
-  it('should resolve the cancel promise if canceled', async () => {
-    const hatchetPromise = new HatchetPromise(
-      new Promise((resolve) => {
-        setTimeout(() => resolve('RESOLVED'), 500);
-      })
-    );
-
-    const result = hatchetPromise.promise;
-    setTimeout(() => {
-      hatchetPromise.cancel();
-    }, 100);
-
-    try {
-      await result;
-      expect(true).toEqual(false); // this should not be reached
-    } catch (e) {
-      expect(e).toEqual(undefined);
-    }
-  });
-});

package/hatchet/util/hatchet-promise/hatchet-promise.ts

@@ -1,13 +0,0 @@
-class HatchetPromise<T> {
-  cancel: Function = (reason: any) => {};
-  promise: Promise<T>;
-
-  constructor(promise: Promise<T>) {
-    this.promise = new Promise((resolve, reject) => {
-      this.cancel = reject;
-      Promise.resolve(promise).then(resolve).catch(reject);
-    });
-  }
-}
-
-export default HatchetPromise;

package/hatchet/util/logger/index.ts

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

package/hatchet/util/logger/logger.ts

@@ -1,44 +0,0 @@
-export type LogLevel = 'OFF' | 'DEBUG' | 'INFO' | 'WARN' | 'ERROR';
-
-// eslint-disable-next-line no-shadow
-enum LogLevelEnum {
-  OFF = -1,
-  DEBUG = 0,
-  INFO = 1,
-  WARN = 2,
-  ERROR = 3,
-}
-
-export class Logger {
-  private logLevel: LogLevel;
-  private context: string;
-
-  constructor(context: string, logLevel: LogLevel = 'INFO') {
-    this.logLevel = logLevel;
-    this.context = context;
-  }
-
-  private log(level: LogLevel, message: string): void {
-    if (LogLevelEnum[level] >= LogLevelEnum[this.logLevel]) {
-      console.log(`🪓 [${level}/${this.context}] ${message}`);
-    }
-  }
-
-  debug(message: string): void {
-    this.log('DEBUG', message);
-  }
-
-  info(message: string): void {
-    this.log('INFO', message);
-  }
-
-  warn(message: string): void {
-    this.log('WARN', message);
-  }
-
-  error(message: string): void {
-    this.log('ERROR', message);
-  }
-}
-
-export default Logger;

package/hatchet/util/sleep.ts

@@ -1,6 +0,0 @@
-const sleep = (ms: number) =>
-  new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-
-export default sleep;

package/hatchet/workflow.ts

@@ -1,30 +0,0 @@
-import * as z from 'zod';
-
-import { CreateStep, CreateStepSchema } from './step';
-
-const CronConfigSchema = z.object({
-  cron: z.string(),
-  event: z.undefined(),
-});
-
-const EventConfigSchema = z.object({
-  cron: z.undefined(),
-  event: z.string(),
-});
-
-const OnConfigSchema = z.union([CronConfigSchema, EventConfigSchema]);
-
-const StepsSchema = z.array(CreateStepSchema);
-
-export type Steps = z.infer<typeof StepsSchema>;
-
-export const CreateWorkflowSchema = z.object({
-  id: z.string(),
-  description: z.string(),
-  on: OnConfigSchema,
-  steps: StepsSchema,
-});
-
-export interface Workflow extends z.infer<typeof CreateWorkflowSchema> {
-  steps: CreateStep<any>[];
-}