@hatchet-dev/typescript-sdk 0.0.1

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

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

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

@@ -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/util/config-loader/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/util/config-loader/index.ts

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

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

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

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

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

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

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

package/hatchet/util/logger/logger.ts

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

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

package/hatchet/workflow.ts

@@ -0,0 +1,30 @@
+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>[];
+}

package/jest.config.ts

@@ -0,0 +1,205 @@
+/**
+ * For a detailed explanation regarding each configuration property, visit:
+ * https://jestjs.io/docs/configuration
+ */
+
+import type { Config } from 'jest';
+
+const config: Config = {
+  // All imported modules in your tests should be mocked automatically
+  // automock: false,
+
+  // Stop running tests after `n` failures
+  // bail: 0,
+
+  // The directory where Jest should store its cached dependency information
+  // cacheDirectory: "/private/var/folders/tx/gj6zfqv915j4ww47qf9wsz7m0000gn/T/jest_dx",
+
+  // Automatically clear mock calls, instances, contexts and results before every test
+  clearMocks: true,
+
+  // Indicates whether the coverage information should be collected while executing the test
+  collectCoverage: false,
+
+  // An array of glob patterns indicating a set of files for which coverage information should be collected
+  // collectCoverageFrom: undefined,
+
+  // The directory where Jest should output its coverage files
+  coverageDirectory: 'coverage',
+
+  // An array of regexp pattern strings used to skip coverage collection
+  // coveragePathIgnorePatterns: [
+  //   "/node_modules/"
+  // ],
+
+  // Indicates which provider should be used to instrument code for coverage
+  coverageProvider: 'v8',
+
+  // A list of reporter names that Jest uses when writing coverage reports
+  // coverageReporters: [
+  //   "json",
+  //   "text",
+  //   "lcov",
+  //   "clover"
+  // ],
+
+  // An object that configures minimum threshold enforcement for coverage results
+  // coverageThreshold: undefined,
+
+  // A path to a custom dependency extractor
+  // dependencyExtractor: undefined,
+
+  // Make calling deprecated APIs throw helpful error messages
+  // errorOnDeprecated: false,
+
+  // The default configuration for fake timers
+  // fakeTimers: {
+  //   "enableGlobally": false
+  // },
+
+  // Force coverage collection from ignored files using an array of glob patterns
+  // forceCoverageMatch: [],
+
+  // A path to a module which exports an async function that is triggered once before all test suites
+  // globalSetup: undefined,
+
+  // A path to a module which exports an async function that is triggered once after all test suites
+  // globalTeardown: undefined,
+
+  // A set of global variables that need to be available in all test environments
+  // globals: {},
+
+  // The maximum amount of workers used to run your tests. Can be specified as % or a number. E.g. maxWorkers: 10% will use 10% of your CPU amount + 1 as the maximum worker number. maxWorkers: 2 will use a maximum of 2 workers.
+  // maxWorkers: "50%",
+
+  // An array of directory names to be searched recursively up from the requiring module's location
+  // moduleDirectories: [
+  //   "node_modules"
+  // ],
+
+  // An array of file extensions your modules use
+  // moduleFileExtensions: [
+  //   "js",
+  //   "mjs",
+  //   "cjs",
+  //   "jsx",
+  //   "ts",
+  //   "tsx",
+  //   "json",
+  //   "node"
+  // ],
+
+  // A map from regular expressions to module names or to arrays of module names that allow to stub out resources with a single module
+  // moduleNameMapper: {},
+
+  // An array of regexp pattern strings, matched against all module paths before considered 'visible' to the module loader
+  // modulePathIgnorePatterns: [],
+
+  // Activates notifications for test results
+  // notify: false,
+
+  // An enum that specifies notification mode. Requires { notify: true }
+  // notifyMode: "failure-change",
+
+  // A preset that is used as a base for Jest's configuration
+  // preset: undefined,
+
+  // Run tests from one or more projects
+  // projects: undefined,
+
+  // Use this configuration option to add custom reporters to Jest
+  // reporters: undefined,
+
+  // Automatically reset mock state before every test
+  // resetMocks: false,
+
+  // Reset the module registry before running each individual test
+  // resetModules: false,
+
+  // A path to a custom resolver
+  // resolver: undefined,
+
+  // Automatically restore mock state and implementation before every test
+  // restoreMocks: false,
+
+  // The root directory that Jest should scan for tests and modules within
+  // rootDir: undefined,
+
+  // A list of paths to directories that Jest should use to search for files in
+  // roots: [
+  //   "<rootDir>"
+  // ],
+
+  // Allows you to use a custom runner instead of Jest's default test runner
+  // runner: "jest-runner",
+
+  // The paths to modules that run some code to configure or set up the testing environment before each test
+  // setupFiles: [],
+
+  // A list of paths to modules that run some code to configure or set up the testing framework before each test
+  // setupFilesAfterEnv: [],
+
+  // The number of seconds after which a test is considered as slow and reported as such in the results.
+  // slowTestThreshold: 5,
+
+  // A list of paths to snapshot serializer modules Jest should use for snapshot testing
+  // snapshotSerializers: [],
+
+  // The test environment that will be used for testing
+  // testEnvironment: "jest-environment-node",
+
+  // Options that will be passed to the testEnvironment
+  // testEnvironmentOptions: {},
+
+  // Adds a location field to test results
+  // testLocationInResults: false,
+
+  // The glob patterns Jest uses to detect test files
+  // testMatch: [
+  //   "**/__tests__/**/*.[jt]s?(x)",
+  //   "**/?(*.)+(spec|test).[tj]s?(x)"
+  // ],
+
+  // An array of regexp pattern strings that are matched against all test paths, matched tests are skipped
+  testPathIgnorePatterns: ['/node_modules/', '/dist/'],
+
+  // The regexp pattern or array of patterns that Jest uses to detect test files
+  // testRegex: [],
+
+  // This option allows the use of a custom results processor
+  // testResultsProcessor: undefined,
+
+  // This option allows use of a custom test runner
+  // testRunner: "jest-circus/runner",
+
+  // A map from regular expressions to paths to transformers
+  transform: {
+    '^.+\\.(js|ts)$': ['ts-jest', { tsconfig: './tsconfig.json' }],
+  },
+  moduleNameMapper: {
+    '^@hatchet(.*)$': '<rootDir>/hatchet$1',
+    '^@protoc/(.*)$': '<rootDir>/protoc/$1',
+    '^@util/(.*)$': '<rootDir>/hatchet/util/$1',
+    '^@models/(.*)$': '<rootDir>/hatchet/models/$1',
+    '^@clients/(.*)$': '<rootDir>/hatchet/clients/$1',
+  },
+  // An array of regexp pattern strings that are matched against all source file paths, matched files will skip transformation
+  // transformIgnorePatterns: [
+  //   "/node_modules/",
+  //   "\\.pnp\\.[^\\/]+$"
+  // ],
+
+  // An array of regexp pattern strings that are matched against all modules before the module loader will automatically return a mock for them
+  // unmockedModulePathPatterns: undefined,
+
+  // Indicates whether each individual test should be reported during the run
+  // verbose: undefined,
+
+  // An array of regexp patterns that are matched against all source file paths before re-running tests in watch mode
+  // watchPathIgnorePatterns: [],
+
+  // Whether to use watchman for file crawling
+  // watchman: true,
+};
+
+export default config;

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@hatchet-dev/typescript-sdk",
+  "version": "0.0.1",
+  "description": "Background task orchestration & visibility for developers",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hatchet-dev/hatchet.git"
+  },
+  "publishConfig": {
+    "@hatchet:registry": "https://npm.pkg.github.com"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/jest": "^29.5.11",
+    "@typescript-eslint/eslint-plugin": "^6.4.0",
+    "autoprefixer": "^10.4.16",
+    "dotenv-cli": "^7.3.0",
+    "eslint": "^8.56.0",
+    "eslint-config-airbnb-typescript": "^17.1.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-config-standard-with-typescript": "^43.0.0",
+    "eslint-import-resolver-typescript": "^3.6.1",
+    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-jest": "^27.6.3",
+    "eslint-plugin-n": "^15.0.0 || ^16.0.0 ",
+    "eslint-plugin-prettier": "^5.0.1",
+    "eslint-plugin-promise": "^6.0.0",
+    "eslint-plugin-unused-imports": "^3.0.0",
+    "grpc-tools": "^1.12.4",
+    "jest": "^29.7.0",
+    "prettier": "^3.1.1",
+    "ts-jest": "^29.1.1",
+    "ts-node": "^10.9.2",
+    "ts-proto": "^1.167.0",
+    "typescript": "^5.3.3"
+  },
+  "dependencies": {
+    "long": "^5.2.3",
+    "nice-grpc": "^2.1.7",
+    "nice-grpc-common": "^2.0.2",
+    "protobufjs": "^7.2.6",
+    "yaml": "^2.3.4",
+    "zod": "^3.22.4"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "generate": "./generate-protoc.sh",
+    "lint:check": "npm run eslint:check && npm run prettier:check",
+    "lint:fix": "npm run eslint:fix && npm run prettier:fix",
+    "eslint:check": "eslint \"{hatchet,tests}/**/*.{ts,tsx,js}\"",
+    "eslint:fix": "eslint \"{hatchet,tests}/**/*.{ts,tsx,js}\" --fix",
+    "prettier:check": "prettier \"hatchet/**/*.{ts,tsx}\" --list-different",
+    "prettier:fix": "prettier \"hatchet/**/*.{ts,tsx}\" --write",
+    "exec": "npx dotenv -- ts-node -r tsconfig-paths/register --project tsconfig.json",
+    "example:event": "npm run exec -- ./examples/example-event.ts",
+    "worker:simple": "npm run exec -- ./examples/simple-worker.ts",
+    "worker:dag": "npm run exec -- ./examples/dag-worker.ts"
+  }
+}