@hatchet-dev/typescript-sdk 0.1.1 → 0.1.4

package/clients/admin/admin-client.d.ts

@@ -0,0 +1,12 @@
+import { Channel, ClientFactory } from 'nice-grpc';
+import { CreateWorkflowVersionOpts, WorkflowServiceClient } from '../../../../src/protoc/workflows';
+import { ClientConfig } from '../../../../src/clients/hatchet-client/client-config';
+export declare class AdminClient {
+    config: ClientConfig;
+    client: WorkflowServiceClient;
+    constructor(config: ClientConfig, channel: Channel, factory: ClientFactory);
+    put_workflow(workflow: CreateWorkflowVersionOpts): Promise<void>;
+    schedule_workflow(workflowId: string, options?: {
+        schedules?: Date[];
+    }): void;
+}

package/clients/admin/admin-client.js

@@ -0,0 +1,47 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminClient = void 0;
+const workflows_1 = require("../../../../src/protoc/workflows");
+const hatchet_error_1 = __importDefault(require("../../../../src/util/errors/hatchet-error"));
+class AdminClient {
+    constructor(config, channel, factory) {
+        this.config = config;
+        this.client = factory.create(workflows_1.WorkflowServiceDefinition, channel);
+    }
+    put_workflow(workflow) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.client.putWorkflow({
+                    opts: workflow,
+                });
+            }
+            catch (e) {
+                throw new hatchet_error_1.default(e.message);
+            }
+        });
+    }
+    schedule_workflow(workflowId, options) {
+        try {
+            this.client.scheduleWorkflow({
+                workflowId,
+                schedules: options === null || options === void 0 ? void 0 : options.schedules,
+            });
+        }
+        catch (e) {
+            throw new hatchet_error_1.default(e.message);
+        }
+    }
+}
+exports.AdminClient = AdminClient;

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

@@ -0,0 +1,26 @@
+import { DispatcherClient as PbDispatcherClient, AssignedAction } from '../../../../src/protoc/dispatcher';
+import { ClientConfig } from '../../../../src/clients/hatchet-client/client-config';
+import { DispatcherClient } from './dispatcher-client';
+export interface Action {
+    tenantId: string;
+    jobId: string;
+    jobName: string;
+    jobRunId: string;
+    stepId: string;
+    stepRunId: string;
+    actionId: string;
+    actionType: number;
+    actionPayload: string;
+    workflowRunId: string;
+    getGroupKeyRunId: string;
+}
+export declare class ActionListener {
+    config: ClientConfig;
+    client: PbDispatcherClient;
+    listener: AsyncIterable<AssignedAction>;
+    workerId: string;
+    constructor(client: DispatcherClient, listener: AsyncIterable<AssignedAction>, workerId: string);
+    actions: () => AsyncGenerator<Action, void, unknown>;
+    retrySubscribe(): Promise<void>;
+    unregister(): Promise<import("../../../../src/protoc/dispatcher").WorkerUnsubscribeResponse>;
+}

package/clients/dispatcher/action-listener.js

@@ -0,0 +1,113 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionListener = void 0;
+const nice_grpc_1 = require("nice-grpc");
+const sleep_1 = __importDefault(require("../../../../src/util/sleep"));
+const hatchet_error_1 = __importDefault(require("../../../../src/util/errors/hatchet-error"));
+const DEFAULT_ACTION_LISTENER_RETRY_INTERVAL = 5; // seconds
+const DEFAULT_ACTION_LISTENER_RETRY_COUNT = 5;
+class ActionListener {
+    constructor(client, listener, workerId) {
+        this.actions = () => (function gen(client) {
+            return __asyncGenerator(this, arguments, function* gen_1() {
+                var _a, e_1, _b, _c;
+                while (true) {
+                    try {
+                        try {
+                            for (var _d = true, _e = (e_1 = void 0, __asyncValues(client.listener)), _f; _f = yield __await(_e.next()), _a = _f.done, !_a; _d = true) {
+                                _c = _f.value;
+                                _d = false;
+                                const assignedAction = _c;
+                                const action = Object.assign({}, assignedAction);
+                                yield yield __await(action);
+                            }
+                        }
+                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                        finally {
+                            try {
+                                if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                        }
+                    }
+                    catch (e) {
+                        if (e.code === nice_grpc_1.Status.CANCELLED) {
+                            break;
+                        }
+                        if (e.code === nice_grpc_1.Status.UNAVAILABLE) {
+                            client.retrySubscribe();
+                        }
+                        break;
+                    }
+                }
+            });
+        })(this);
+        this.config = client.config;
+        this.client = client.client;
+        this.listener = listener;
+        this.workerId = workerId;
+    }
+    retrySubscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let retries = 0;
+            while (retries < DEFAULT_ACTION_LISTENER_RETRY_COUNT) {
+                try {
+                    yield (0, sleep_1.default)(DEFAULT_ACTION_LISTENER_RETRY_INTERVAL);
+                    this.listener = this.client.listen({
+                        workerId: this.workerId,
+                    });
+                    return;
+                }
+                catch (e) {
+                    retries += 1;
+                }
+            }
+            throw new hatchet_error_1.default(`Could not subscribe to the worker after ${DEFAULT_ACTION_LISTENER_RETRY_COUNT} retries`);
+        });
+    }
+    unregister() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return this.client.unsubscribe({
+                    workerId: this.workerId,
+                });
+            }
+            catch (e) {
+                throw new hatchet_error_1.default(`Failed to unsubscribe: ${e.message}`);
+            }
+        });
+    }
+}
+exports.ActionListener = ActionListener;

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

@@ -0,0 +1,20 @@
+import { Channel, ClientFactory } from 'nice-grpc';
+import { DispatcherClient as PbDispatcherClient, StepActionEvent, GroupKeyActionEvent } from '../../../../src/protoc/dispatcher';
+import { ClientConfig } from '../../../../src/clients/hatchet-client/client-config';
+import { Logger } from '../../../../src/util/logger';
+import { ActionListener } from './action-listener';
+interface GetActionListenerOptions {
+    workerName: string;
+    services: string[];
+    actions: string[];
+}
+export declare class DispatcherClient {
+    config: ClientConfig;
+    client: PbDispatcherClient;
+    logger: Logger;
+    constructor(config: ClientConfig, channel: Channel, factory: ClientFactory);
+    getActionListener(options: GetActionListenerOptions): Promise<ActionListener>;
+    sendStepActionEvent(in_: StepActionEvent): Promise<import("../../../../src/protoc/dispatcher").ActionEventResponse>;
+    sendGroupKeyActionEvent(in_: GroupKeyActionEvent): Promise<import("../../../../src/protoc/dispatcher").ActionEventResponse>;
+}
+export {};

package/clients/dispatcher/dispatcher-client.js

@@ -0,0 +1,58 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DispatcherClient = void 0;
+const dispatcher_1 = require("../../../../src/protoc/dispatcher");
+const hatchet_error_1 = __importDefault(require("../../../../src/util/errors/hatchet-error"));
+const logger_1 = require("../../../../src/util/logger");
+const action_listener_1 = require("./action-listener");
+class DispatcherClient {
+    constructor(config, channel, factory) {
+        this.config = config;
+        this.client = factory.create(dispatcher_1.DispatcherDefinition, channel);
+        this.logger = new logger_1.Logger(`Dispatcher`, config.log_level);
+    }
+    getActionListener(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Register the worker
+            const registration = yield this.client.register(Object.assign({}, options));
+            // Subscribe to the worker
+            const listener = this.client.listen({
+                workerId: registration.workerId,
+            });
+            return new action_listener_1.ActionListener(this, listener, registration.workerId);
+        });
+    }
+    sendStepActionEvent(in_) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return this.client.sendStepActionEvent(in_);
+            }
+            catch (e) {
+                throw new hatchet_error_1.default(e.message);
+            }
+        });
+    }
+    sendGroupKeyActionEvent(in_) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return this.client.sendGroupKeyActionEvent(in_);
+            }
+            catch (e) {
+                throw new hatchet_error_1.default(e.message);
+            }
+        });
+    }
+}
+exports.DispatcherClient = DispatcherClient;

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

@@ -0,0 +1,11 @@
+import { Channel, ClientFactory } from 'nice-grpc';
+import { EventsServiceClient } from '../../../../src/protoc/events/events';
+import { ClientConfig } from '../../../../src/clients/hatchet-client/client-config';
+import { Logger } from '../../../../src/util/logger';
+export declare class EventClient {
+    config: ClientConfig;
+    client: EventsServiceClient;
+    logger: Logger;
+    constructor(config: ClientConfig, channel: Channel, factory: ClientFactory);
+    push<T>(type: string, input: T): Promise<import("../../../../src/protoc/events/events").Event>;
+}

package/clients/event/event-client.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventClient = void 0;
+const events_1 = require("../../../../src/protoc/events/events");
+const hatchet_error_1 = __importDefault(require("../../../../src/util/errors/hatchet-error"));
+const logger_1 = require("../../../../src/util/logger");
+class EventClient {
+    constructor(config, channel, factory) {
+        this.config = config;
+        this.client = factory.create(events_1.EventsServiceDefinition, channel);
+        this.logger = new logger_1.Logger(`Dispatcher`, config.log_level);
+    }
+    push(type, input) {
+        const req = {
+            key: type,
+            payload: JSON.stringify(input),
+            eventTimestamp: new Date(),
+        };
+        try {
+            const e = this.client.push(req);
+            this.logger.info(`Event pushed: ${type}`);
+            return e;
+        }
+        catch (e) {
+            throw new hatchet_error_1.default(e.message);
+        }
+    }
+}
+exports.EventClient = EventClient;

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

@@ -0,0 +1,72 @@
+import { ChannelCredentials } from 'nice-grpc';
+import { z } from 'zod';
+declare const ClientTLSConfigSchema: z.ZodObject<{
+    tls_strategy: z.ZodOptional<z.ZodEnum<["tls", "mtls"]>>;
+    cert_file: z.ZodOptional<z.ZodString>;
+    ca_file: z.ZodOptional<z.ZodString>;
+    key_file: z.ZodOptional<z.ZodString>;
+    server_name: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    tls_strategy?: "tls" | "mtls" | undefined;
+    cert_file?: string | undefined;
+    ca_file?: string | undefined;
+    key_file?: string | undefined;
+    server_name?: string | undefined;
+}, {
+    tls_strategy?: "tls" | "mtls" | undefined;
+    cert_file?: string | undefined;
+    ca_file?: string | undefined;
+    key_file?: string | undefined;
+    server_name?: string | undefined;
+}>;
+export declare const ClientConfigSchema: z.ZodObject<{
+    token: z.ZodString;
+    tls_config: z.ZodObject<{
+        tls_strategy: z.ZodOptional<z.ZodEnum<["tls", "mtls"]>>;
+        cert_file: z.ZodOptional<z.ZodString>;
+        ca_file: z.ZodOptional<z.ZodString>;
+        key_file: z.ZodOptional<z.ZodString>;
+        server_name: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        tls_strategy?: "tls" | "mtls" | undefined;
+        cert_file?: string | undefined;
+        ca_file?: string | undefined;
+        key_file?: string | undefined;
+        server_name?: string | undefined;
+    }, {
+        tls_strategy?: "tls" | "mtls" | undefined;
+        cert_file?: string | undefined;
+        ca_file?: string | undefined;
+        key_file?: string | undefined;
+        server_name?: string | undefined;
+    }>;
+    host_port: z.ZodString;
+    log_level: z.ZodOptional<z.ZodEnum<["OFF", "DEBUG", "INFO", "WARN", "ERROR"]>>;
+}, "strip", z.ZodTypeAny, {
+    token: string;
+    tls_config: {
+        tls_strategy?: "tls" | "mtls" | undefined;
+        cert_file?: string | undefined;
+        ca_file?: string | undefined;
+        key_file?: string | undefined;
+        server_name?: string | undefined;
+    };
+    host_port: string;
+    log_level?: "OFF" | "DEBUG" | "INFO" | "WARN" | "ERROR" | undefined;
+}, {
+    token: string;
+    tls_config: {
+        tls_strategy?: "tls" | "mtls" | undefined;
+        cert_file?: string | undefined;
+        ca_file?: string | undefined;
+        key_file?: string | undefined;
+        server_name?: string | undefined;
+    };
+    host_port: string;
+    log_level?: "OFF" | "DEBUG" | "INFO" | "WARN" | "ERROR" | undefined;
+}>;
+export type ClientConfig = z.infer<typeof ClientConfigSchema> & {
+    credentials?: ChannelCredentials;
+};
+export type ClientTLSConfig = z.infer<typeof ClientTLSConfigSchema>;
+export {};

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientConfigSchema = void 0;
+const zod_1 = require("zod");
+const ClientTLSConfigSchema = zod_1.z.object({
+    tls_strategy: zod_1.z.enum(['tls', 'mtls']).optional(),
+    cert_file: zod_1.z.string().optional(),
+    ca_file: zod_1.z.string().optional(),
+    key_file: zod_1.z.string().optional(),
+    server_name: zod_1.z.string().optional(),
+});
+exports.ClientConfigSchema = zod_1.z.object({
+    token: zod_1.z.string(),
+    tls_config: ClientTLSConfigSchema,
+    host_port: zod_1.z.string(),
+    log_level: zod_1.z.enum(['OFF', 'DEBUG', 'INFO', 'WARN', 'ERROR']).optional(),
+});

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

@@ -0,0 +1,26 @@
+import { EventClient } from '../../../../src/clients/event/event-client';
+import { DispatcherClient } from '../../../../src/clients/dispatcher/dispatcher-client';
+import { AdminClient } from '../../../../src/clients/admin/admin-client';
+import { Channel, ChannelCredentials } from 'nice-grpc';
+import { Workflow } from '../../../../src/workflow';
+import { Worker } from '../../../../src/clients/worker';
+import Logger from '../../../../src/util/logger/logger';
+import { ClientConfig } from './client-config';
+export interface HatchetClientOptions {
+    config_path?: string;
+    credentials?: ChannelCredentials;
+}
+export declare class HatchetClient {
+    config: ClientConfig;
+    credentials: ChannelCredentials;
+    channel: Channel;
+    event: EventClient;
+    dispatcher: DispatcherClient;
+    admin: AdminClient;
+    logger: Logger;
+    constructor(config?: Partial<ClientConfig>, options?: HatchetClientOptions);
+    static with_host_port(host: string, port: number, config?: Partial<ClientConfig>, options?: HatchetClientOptions): HatchetClient;
+    static init(config?: Partial<ClientConfig>, options?: HatchetClientOptions): HatchetClient;
+    run(workflow: string | Workflow): Promise<Worker>;
+    worker(workflow: string | Workflow): Promise<Worker>;
+}

package/clients/hatchet-client/hatchet-client.js

@@ -0,0 +1,133 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncDelegator = (this && this.__asyncDelegator) || function (o) {
+    var i, p;
+    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }
+};
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HatchetClient = void 0;
+const zod_1 = require("zod");
+const config_loader_1 = require("../../../../src/util/config-loader");
+const event_client_1 = require("../../../../src/clients/event/event-client");
+const dispatcher_client_1 = require("../../../../src/clients/dispatcher/dispatcher-client");
+const admin_client_1 = require("../../../../src/clients/admin/admin-client");
+const nice_grpc_1 = require("nice-grpc");
+const worker_1 = require("../../../../src/clients/worker");
+const logger_1 = __importDefault(require("../../../../src/util/logger/logger"));
+const client_config_1 = require("./client-config");
+const addTokenMiddleware = (token) => function _(call, options) {
+    return __asyncGenerator(this, arguments, function* _1() {
+        var _a, e_1, _b, _c;
+        const optionsWithAuth = Object.assign(Object.assign({}, options), { metadata: new nice_grpc_1.Metadata({ authorization: `bearer ${token}` }) });
+        if (!call.responseStream) {
+            const response = yield __await(yield* __asyncDelegator(__asyncValues(call.next(call.request, optionsWithAuth))));
+            return yield __await(response);
+        }
+        try {
+            for (var _d = true, _e = __asyncValues(call.next(call.request, optionsWithAuth)), _f; _f = yield __await(_e.next()), _a = _f.done, !_a; _d = true) {
+                _c = _f.value;
+                _d = false;
+                const response = _c;
+                yield yield __await(response);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return yield __await(undefined);
+    });
+};
+class HatchetClient {
+    constructor(config, options) {
+        // Initializes a new Client instance.
+        // Loads config in the following order: config param > yaml file > env vars
+        var _a;
+        const loaded = config_loader_1.ConfigLoader.load_client_config({
+            path: options === null || options === void 0 ? void 0 : options.config_path,
+        });
+        try {
+            const valid = client_config_1.ClientConfigSchema.parse(Object.assign(Object.assign({}, loaded), Object.assign(Object.assign({}, config), { tls_config: Object.assign(Object.assign({}, loaded.tls_config), config === null || config === void 0 ? void 0 : config.tls_config) })));
+            this.config = valid;
+        }
+        catch (e) {
+            if (e instanceof zod_1.z.ZodError) {
+                throw new Error(`Invalid client config: ${e.message}`);
+            }
+            throw e;
+        }
+        this.credentials =
+            (_a = options === null || options === void 0 ? void 0 : options.credentials) !== null && _a !== void 0 ? _a : config_loader_1.ConfigLoader.createCredentials(this.config.tls_config);
+        this.channel = (0, nice_grpc_1.createChannel)(this.config.host_port, this.credentials, {
+            'grpc.ssl_target_name_override': this.config.tls_config.server_name,
+        });
+        const clientFactory = (0, nice_grpc_1.createClientFactory)().use(addTokenMiddleware(this.config.token));
+        this.event = new event_client_1.EventClient(this.config, this.channel, clientFactory);
+        this.dispatcher = new dispatcher_client_1.DispatcherClient(this.config, this.channel, clientFactory);
+        this.admin = new admin_client_1.AdminClient(this.config, this.channel, clientFactory);
+        this.logger = new logger_1.default('HatchetClient', this.config.log_level);
+        this.logger.info(`Initialized HatchetClient`);
+    }
+    static with_host_port(host, port, config, options) {
+        return new HatchetClient(Object.assign(Object.assign({}, config), { host_port: `${host}:${port}` }), options);
+    }
+    static init(config, options) {
+        return new HatchetClient(config, options);
+    }
+    run(workflow) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const worker = yield this.worker(workflow);
+            worker.start();
+            return worker;
+        });
+    }
+    worker(workflow) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const name = typeof workflow === 'string' ? workflow : workflow.id;
+            const worker = new worker_1.Worker(this, {
+                name,
+            });
+            if (typeof workflow !== 'string') {
+                yield worker.registerWorkflow(workflow);
+                return worker;
+            }
+            return worker;
+        });
+    }
+}
+exports.HatchetClient = HatchetClient;

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

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

package/clients/hatchet-client/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./hatchet-client"), exports);
+__exportStar(require("./client-config"), exports);

package/clients/worker/index.d.ts

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

package/clients/worker/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./worker"), exports);