@hatchet-dev/typescript-sdk 0.1.14 → 0.1.16

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

@@ -1,6 +1,7 @@
 import { Channel, ClientFactory } from 'nice-grpc';
 import { CreateWorkflowVersionOpts, WorkflowServiceClient } from '../../protoc/workflows';
 import { ClientConfig } from '../hatchet-client/client-config';
+import { Logger } from '../../util/logger';
 import { Api } from '../rest';
 /**
  * AdminClient is a client for interacting with the Hatchet Admin API. This allows you to configure, trigger,
@@ -23,6 +24,7 @@ export declare class AdminClient {
     client: WorkflowServiceClient;
     api: Api;
     tenantId: string;
+    logger: Logger;
     constructor(config: ClientConfig, channel: Channel, factory: ClientFactory, api: Api, tenantId: string);
     /**
      * Creates a new workflow or updates an existing workflow. If the workflow already exists, Hatchet will automatically

package/clients/admin/admin-client.js

@@ -15,6 +15,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AdminClient = void 0;
 const workflows_1 = require("../../protoc/workflows");
 const hatchet_error_1 = __importDefault(require("../../util/errors/hatchet-error"));
+const logger_1 = require("../../util/logger");
+const retrier_1 = require("../../util/retrier");
 /**
  * AdminClient is a client for interacting with the Hatchet Admin API. This allows you to configure, trigger,
  * and monitor workflows.
@@ -37,6 +39,7 @@ class AdminClient {
         this.client = factory.create(workflows_1.WorkflowServiceDefinition, channel);
         this.api = api;
         this.tenantId = tenantId;
+        this.logger = new logger_1.Logger(`Admin`, config.log_level);
     }
     /**
      * Creates a new workflow or updates an existing workflow. If the workflow already exists, Hatchet will automatically
@@ -46,9 +49,7 @@ class AdminClient {
     put_workflow(workflow) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                yield this.client.putWorkflow({
-                    opts: workflow,
-                });
+                yield (0, retrier_1.retrier)(() => __awaiter(this, void 0, void 0, function* () { return this.client.putWorkflow({ opts: workflow }); }), this.logger);
             }
             catch (e) {
                 throw new hatchet_error_1.default(e.message);

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

@@ -1,5 +1,6 @@
 import { DispatcherClient as PbDispatcherClient, AssignedAction } from '../../protoc/dispatcher';
 import { ClientConfig } from '../hatchet-client/client-config';
+import { Logger } from '../../util/logger';
 import { DispatcherClient } from './dispatcher-client';
 export interface Action {
     tenantId: string;
@@ -17,10 +18,15 @@ export interface Action {
 export declare class ActionListener {
     config: ClientConfig;
     client: PbDispatcherClient;
-    listener: AsyncIterable<AssignedAction>;
     workerId: string;
-    constructor(client: DispatcherClient, listener: AsyncIterable<AssignedAction>, workerId: string);
+    logger: Logger;
+    lastConnectionAttempt: number;
+    retries: number;
+    retryInterval: number;
+    retryCount: number;
+    constructor(client: DispatcherClient, workerId: string, retryInterval?: number, retryCount?: number);
     actions: () => AsyncGenerator<Action, void, unknown>;
-    retrySubscribe(): Promise<void>;
+    incrementRetries(): Promise<void>;
+    getListenClient(): Promise<AsyncIterable<AssignedAction>>;
     unregister(): Promise<import("../../protoc/dispatcher").WorkerUnsubscribeResponse>;
 }

package/clients/dispatcher/action-listener.js

@@ -8,6 +8,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
 var __asyncValues = (this && this.__asyncValues) || function (o) {
     if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
     var m = o[Symbol.asyncIterator], i;
@@ -15,7 +16,6 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
     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 = [];
@@ -36,17 +36,22 @@ exports.ActionListener = void 0;
 const nice_grpc_1 = require("nice-grpc");
 const sleep_1 = __importDefault(require("../../util/sleep"));
 const hatchet_error_1 = __importDefault(require("../../util/errors/hatchet-error"));
-const DEFAULT_ACTION_LISTENER_RETRY_INTERVAL = 5; // seconds
+const logger_1 = require("../../util/logger");
+const DEFAULT_ACTION_LISTENER_RETRY_INTERVAL = 5000; // milliseconds
 const DEFAULT_ACTION_LISTENER_RETRY_COUNT = 5;
 class ActionListener {
-    constructor(client, listener, workerId) {
+    constructor(client, workerId, retryInterval = DEFAULT_ACTION_LISTENER_RETRY_INTERVAL, retryCount = DEFAULT_ACTION_LISTENER_RETRY_COUNT) {
+        this.lastConnectionAttempt = 0;
+        this.retries = 0;
+        this.retryInterval = DEFAULT_ACTION_LISTENER_RETRY_INTERVAL;
+        this.retryCount = DEFAULT_ACTION_LISTENER_RETRY_COUNT;
         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) {
+                            for (var _d = true, _e = (e_1 = void 0, __asyncValues(yield __await(client.getListenClient()))), _f; _f = yield __await(_e.next()), _a = _f.done, !_a; _d = true) {
                                 _c = _f.value;
                                 _d = false;
                                 const assignedAction = _c;
@@ -63,38 +68,55 @@ class ActionListener {
                         }
                     }
                     catch (e) {
+                        // if this is a HatchetError, we should throw this error
+                        if (e instanceof hatchet_error_1.default) {
+                            throw e;
+                        }
                         if (e.code === nice_grpc_1.Status.CANCELLED) {
                             break;
                         }
-                        if (e.code === nice_grpc_1.Status.UNAVAILABLE) {
-                            client.retrySubscribe();
-                        }
-                        break;
+                        client.incrementRetries();
                     }
                 }
             });
         })(this);
         this.config = client.config;
         this.client = client.client;
-        this.listener = listener;
         this.workerId = workerId;
+        this.logger = new logger_1.Logger(`ActionListener`, this.config.log_level);
+        this.retryInterval = retryInterval;
+        this.retryCount = retryCount;
     }
-    retrySubscribe() {
+    incrementRetries() {
         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;
-                }
+            this.retries += 1;
+        });
+    }
+    getListenClient() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentTime = Math.floor(Date.now());
+            // subtract 1000 from the last connection attempt to account for the time it takes to establish the listener
+            if (currentTime - this.lastConnectionAttempt - 1000 > this.retryInterval) {
+                this.retries = 0;
+            }
+            this.lastConnectionAttempt = currentTime;
+            if (this.retries > DEFAULT_ACTION_LISTENER_RETRY_COUNT) {
+                throw new hatchet_error_1.default(`Could not subscribe to the worker after ${DEFAULT_ACTION_LISTENER_RETRY_COUNT} retries`);
+            }
+            this.logger.info(`Connecting to Hatchet to establish listener for actions... ${this.retries}/${DEFAULT_ACTION_LISTENER_RETRY_COUNT} (last attempt: ${this.lastConnectionAttempt})`);
+            if (this.retries >= 1) {
+                yield (0, sleep_1.default)(DEFAULT_ACTION_LISTENER_RETRY_INTERVAL);
+            }
+            try {
+                return this.client.listen({
+                    workerId: this.workerId,
+                });
+            }
+            catch (e) {
+                this.retries += 1;
+                this.logger.error(`Attempt ${this.retries}: Failed to connect, retrying...`); // Optional: log retry attempt
+                return this.getListenClient();
             }
-            throw new hatchet_error_1.default(`Could not subscribe to the worker after ${DEFAULT_ACTION_LISTENER_RETRY_COUNT} retries`);
         });
     }
     unregister() {

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

@@ -7,6 +7,7 @@ interface GetActionListenerOptions {
     workerName: string;
     services: string[];
     actions: string[];
+    maxRuns?: number;
 }
 export declare class DispatcherClient {
     config: ClientConfig;

package/clients/dispatcher/dispatcher-client.js

@@ -16,6 +16,7 @@ exports.DispatcherClient = void 0;
 const dispatcher_1 = require("../../protoc/dispatcher");
 const hatchet_error_1 = __importDefault(require("../../util/errors/hatchet-error"));
 const logger_1 = require("../../util/logger");
+const retrier_1 = require("../../util/retrier");
 const action_listener_1 = require("./action-listener");
 class DispatcherClient {
     constructor(config, channel, factory) {
@@ -27,17 +28,13 @@ class DispatcherClient {
         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);
+            return new action_listener_1.ActionListener(this, registration.workerId);
         });
     }
     sendStepActionEvent(in_) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                return this.client.sendStepActionEvent(in_);
+                return (0, retrier_1.retrier)(() => __awaiter(this, void 0, void 0, function* () { return this.client.sendStepActionEvent(in_); }), this.logger);
             }
             catch (e) {
                 throw new hatchet_error_1.default(e.message);
@@ -47,7 +44,7 @@ class DispatcherClient {
     sendGroupKeyActionEvent(in_) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                return this.client.sendGroupKeyActionEvent(in_);
+                return (0, retrier_1.retrier)(() => __awaiter(this, void 0, void 0, function* () { return this.client.sendGroupKeyActionEvent(in_); }), this.logger);
             }
             catch (e) {
                 throw new hatchet_error_1.default(e.message);

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

@@ -25,8 +25,7 @@ export declare class HatchetClient {
     tenantId: string;
     logger: Logger;
     constructor(config?: Partial<ClientConfig>, options?: HatchetClientOptions, axiosOpts?: AxiosRequestConfig);
-    static with_host_port(host: string, port: number, config?: Partial<ClientConfig>, options?: HatchetClientOptions): HatchetClient;
     static init(config?: Partial<ClientConfig>, options?: HatchetClientOptions, axiosConfig?: AxiosRequestConfig): HatchetClient;
     run(workflow: string | Workflow): Promise<Worker>;
-    worker(workflow: string | Workflow): Promise<Worker>;
+    worker(workflow: string | Workflow, maxRuns?: number): Promise<Worker>;
 }

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

@@ -80,11 +80,11 @@ class HatchetClient {
         // 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.loadClientConfig({
+        const loaded = config_loader_1.ConfigLoader.loadClientConfig(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) })));
+            const valid = client_config_1.ClientConfigSchema.parse(loaded);
             this.config = valid;
         }
         catch (e) {
@@ -97,6 +97,12 @@ class HatchetClient {
             (_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,
+            'grpc.keepalive_timeout_ms': 60 * 1000,
+            'grpc.client_idle_timeout_ms': 60 * 1000,
+            // Send keepalive pings every 10 seconds, default is 2 hours.
+            'grpc.keepalive_time_ms': 10 * 1000,
+            // Allow keepalive pings when there are no gRPC calls.
+            'grpc.keepalive_permit_without_calls': 1,
         });
         const clientFactory = (0, nice_grpc_1.createClientFactory)().use(addTokenMiddleware(this.config.token));
         this.tenantId = this.config.tenant_id;
@@ -108,12 +114,10 @@ class HatchetClient {
         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, axiosConfig) {
         return new HatchetClient(config, options, axiosConfig);
     }
+    // @deprecated
     run(workflow) {
         return __awaiter(this, void 0, void 0, function* () {
             const worker = yield this.worker(workflow);
@@ -121,11 +125,12 @@ class HatchetClient {
             return worker;
         });
     }
-    worker(workflow) {
+    worker(workflow, maxRuns) {
         return __awaiter(this, void 0, void 0, function* () {
             const name = typeof workflow === 'string' ? workflow : workflow.id;
             const worker = new worker_1.Worker(this, {
                 name,
+                maxRuns,
             });
             if (typeof workflow !== 'string') {
                 yield worker.registerWorkflow(workflow);

package/clients/worker/worker.d.ts

@@ -16,10 +16,12 @@ export declare class Worker {
     listener: ActionListener | undefined;
     futures: Record<Action['stepRunId'], HatchetPromise<any>>;
     contexts: Record<Action['stepRunId'], Context<any, any>>;
+    maxRuns?: number;
     logger: Logger;
     constructor(client: HatchetClient, options: {
         name: string;
         handleKill?: boolean;
+        maxRuns?: number;
     });
     registerWorkflow(workflow: Workflow): Promise<void>;
     registerAction<T, K>(actionId: string, action: StepRunFunction<T, K>): void;

package/clients/worker/worker.js

@@ -25,7 +25,7 @@ const dispatcher_1 = require("../../protoc/dispatcher");
 const hatchet_promise_1 = __importDefault(require("../../util/hatchet-promise/hatchet-promise"));
 const workflows_1 = require("../../protoc/workflows");
 const logger_1 = require("../../util/logger");
-const sleep_1 = __importDefault(require("../../util/sleep"));
+// import sleep from '../../util/sleep.js';
 const step_1 = require("../../step");
 class Worker {
     constructor(client, options) {
@@ -35,6 +35,7 @@ class Worker {
         this.client = client;
         this.name = options.name;
         this.action_registry = {};
+        this.maxRuns = options.maxRuns;
         process.on('SIGTERM', () => this.exitGracefully());
         process.on('SIGINT', () => this.exitGracefully());
         this.killing = false;
@@ -97,7 +98,7 @@ class Worker {
     }
     handleStartStepRun(action) {
         const { actionId } = action;
-        const context = new step_1.Context(action.actionPayload);
+        const context = new step_1.Context(action);
         this.contexts[action.stepRunId] = context;
         const step = this.action_registry[actionId];
         if (!step) {
@@ -146,7 +147,7 @@ class Worker {
     }
     handleStartGroupKeyRun(action) {
         const { actionId } = action;
-        const context = new step_1.Context(action.actionPayload);
+        const context = new step_1.Context(action);
         const key = action.getGroupKeyRunId;
         this.contexts[key] = context;
         this.logger.debug(`Starting group key run ${key}`);
@@ -269,57 +270,46 @@ class Worker {
     start() {
         var _a, e_1, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
-            let retries = 0;
-            while (retries < 5) {
+            try {
+                this.listener = yield this.client.dispatcher.getActionListener({
+                    workerName: this.name,
+                    services: ['default'],
+                    actions: Object.keys(this.action_registry),
+                    maxRuns: this.maxRuns,
+                });
+                const generator = this.listener.actions();
+                this.logger.info(`Worker ${this.name} listening for actions`);
                 try {
-                    this.listener = yield this.client.dispatcher.getActionListener({
-                        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`);
-                    try {
-                        for (var _d = true, generator_1 = (e_1 = void 0, __asyncValues(generator)), generator_1_1; generator_1_1 = yield generator_1.next(), _a = generator_1_1.done, !_a; _d = true) {
-                            _c = generator_1_1.value;
-                            _d = false;
-                            const action = _c;
-                            this.logger.info(`Worker ${this.name} received action ${action.actionId}:${action.actionType}`);
-                            if (action.actionType === dispatcher_1.ActionType.START_STEP_RUN) {
-                                this.handleStartStepRun(action);
-                            }
-                            else if (action.actionType === dispatcher_1.ActionType.CANCEL_STEP_RUN) {
-                                this.handleCancelStepRun(action);
-                            }
-                            else if (action.actionType === dispatcher_1.ActionType.START_GET_GROUP_KEY) {
-                                this.handleStartGroupKeyRun(action);
-                            }
-                            else {
-                                this.logger.error(`Worker ${this.name} received unknown action type ${action.actionType}`);
-                            }
+                    for (var _d = true, generator_1 = __asyncValues(generator), generator_1_1; generator_1_1 = yield generator_1.next(), _a = generator_1_1.done, !_a; _d = true) {
+                        _c = generator_1_1.value;
+                        _d = false;
+                        const action = _c;
+                        this.logger.info(`Worker ${this.name} received action ${action.actionId}:${action.actionType}`);
+                        if (action.actionType === dispatcher_1.ActionType.START_STEP_RUN) {
+                            this.handleStartStepRun(action);
                         }
-                    }
-                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                    finally {
-                        try {
-                            if (!_d && !_a && (_b = generator_1.return)) yield _b.call(generator_1);
+                        else if (action.actionType === dispatcher_1.ActionType.CANCEL_STEP_RUN) {
+                            this.handleCancelStepRun(action);
+                        }
+                        else if (action.actionType === dispatcher_1.ActionType.START_GET_GROUP_KEY) {
+                            this.handleStartGroupKeyRun(action);
+                        }
+                        else {
+                            this.logger.error(`Worker ${this.name} received unknown action type ${action.actionType}`);
                         }
-                        finally { if (e_1) throw e_1.error; }
                     }
-                    break;
                 }
-                catch (e) {
-                    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`);
-                    yield (0, sleep_1.default)(wait);
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = generator_1.return)) yield _b.call(generator_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
                 }
             }
-            if (this.killing)
-                return;
-            if (retries > 5) {
-                throw new hatchet_error_1.default('Could not start worker after 5 retries');
+            catch (e) {
+                this.logger.error(`Could not run worker: ${e.message}`);
+                throw new hatchet_error_1.default(`Could not run worker: ${e.message}`);
             }
         });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "description": "Background task orchestration & visibility for developers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -31,8 +31,10 @@
     "worker:simple": "npm run exec -- ./examples/simple-worker.ts",
     "manual:trigger": "npm run exec -- ./examples/manual-trigger.ts",
     "worker:dag": "npm run exec -- ./examples/dag-worker.ts",
-    "worker:concurrency": "npm run exec -- ./examples/concurrency/concurrency-worker.ts",
-    "event:concurrency": "npm run exec -- ./examples/concurrency/concurrency-event.ts",
+    "worker:concurrency": "npm run exec -- ./examples/concurrency/cancel-in-progress/concurrency-worker.ts",
+    "event:concurrency": "npm run exec -- ./examples/concurrency/cancel-in-progress/concurrency-event.ts",
+    "worker:concurrency:rr": "npm run exec -- ./examples/concurrency/group-round-robin/concurrency-worker.ts",
+    "event:concurrency:rr": "npm run exec -- ./examples/concurrency/group-round-robin/concurrency-event.ts",
     "worker:retries": "npm run exec -- ./examples/retries-worker.ts",
     "api": "npm run exec -- ./examples/api.ts",
     "prepublish": "cp package.json dist/package.json;",

package/protoc/dispatcher/dispatcher.d.ts

@@ -53,6 +53,8 @@ export interface WorkerRegisterRequest {
     actions: string[];
     /** (optional) the services for this worker */
     services: string[];
+    /** (optional) the max number of runs this worker can handle */
+    maxRuns?: number | undefined;
 }
 export interface WorkerRegisterResponse {
     /** the tenant id */

package/protoc/dispatcher/dispatcher.js

@@ -253,7 +253,7 @@ function resourceEventTypeToJSON(object) {
 }
 exports.resourceEventTypeToJSON = resourceEventTypeToJSON;
 function createBaseWorkerRegisterRequest() {
-    return { workerName: "", actions: [], services: [] };
+    return { workerName: "", actions: [], services: [], maxRuns: undefined };
 }
 exports.WorkerRegisterRequest = {
     encode(message, writer = _m0.Writer.create()) {
@@ -266,6 +266,9 @@ exports.WorkerRegisterRequest = {
         for (const v of message.services) {
             writer.uint32(26).string(v);
         }
+        if (message.maxRuns !== undefined) {
+            writer.uint32(32).int32(message.maxRuns);
+        }
         return writer;
     },
     decode(input, length) {
@@ -293,6 +296,12 @@ exports.WorkerRegisterRequest = {
                     }
                     message.services.push(reader.string());
                     continue;
+                case 4:
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.maxRuns = reader.int32();
+                    continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -306,6 +315,7 @@ exports.WorkerRegisterRequest = {
             workerName: isSet(object.workerName) ? globalThis.String(object.workerName) : "",
             actions: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.actions) ? object.actions.map((e) => globalThis.String(e)) : [],
             services: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.services) ? object.services.map((e) => globalThis.String(e)) : [],
+            maxRuns: isSet(object.maxRuns) ? globalThis.Number(object.maxRuns) : undefined,
         };
     },
     toJSON(message) {
@@ -320,17 +330,21 @@ exports.WorkerRegisterRequest = {
         if ((_b = message.services) === null || _b === void 0 ? void 0 : _b.length) {
             obj.services = message.services;
         }
+        if (message.maxRuns !== undefined) {
+            obj.maxRuns = Math.round(message.maxRuns);
+        }
         return obj;
     },
     create(base) {
         return exports.WorkerRegisterRequest.fromPartial(base !== null && base !== void 0 ? base : {});
     },
     fromPartial(object) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         const message = createBaseWorkerRegisterRequest();
         message.workerName = (_a = object.workerName) !== null && _a !== void 0 ? _a : "";
         message.actions = ((_b = object.actions) === null || _b === void 0 ? void 0 : _b.map((e) => e)) || [];
         message.services = ((_c = object.services) === null || _c === void 0 ? void 0 : _c.map((e) => e)) || [];
+        message.maxRuns = (_d = object.maxRuns) !== null && _d !== void 0 ? _d : undefined;
         return message;
     },
 };

package/protoc/workflows/workflows.d.ts

@@ -5,6 +5,7 @@ export declare enum ConcurrencyLimitStrategy {
     CANCEL_IN_PROGRESS = 0,
     DROP_NEWEST = 1,
     QUEUE_NEWEST = 2,
+    GROUP_ROUND_ROBIN = 3,
     UNRECOGNIZED = -1
 }
 export declare function concurrencyLimitStrategyFromJSON(object: any): ConcurrencyLimitStrategy;

package/protoc/workflows/workflows.js

@@ -33,6 +33,7 @@ var ConcurrencyLimitStrategy;
     ConcurrencyLimitStrategy[ConcurrencyLimitStrategy["CANCEL_IN_PROGRESS"] = 0] = "CANCEL_IN_PROGRESS";
     ConcurrencyLimitStrategy[ConcurrencyLimitStrategy["DROP_NEWEST"] = 1] = "DROP_NEWEST";
     ConcurrencyLimitStrategy[ConcurrencyLimitStrategy["QUEUE_NEWEST"] = 2] = "QUEUE_NEWEST";
+    ConcurrencyLimitStrategy[ConcurrencyLimitStrategy["GROUP_ROUND_ROBIN"] = 3] = "GROUP_ROUND_ROBIN";
     ConcurrencyLimitStrategy[ConcurrencyLimitStrategy["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
 })(ConcurrencyLimitStrategy || (exports.ConcurrencyLimitStrategy = ConcurrencyLimitStrategy = {}));
 function concurrencyLimitStrategyFromJSON(object) {
@@ -46,6 +47,9 @@ function concurrencyLimitStrategyFromJSON(object) {
         case 2:
         case "QUEUE_NEWEST":
             return ConcurrencyLimitStrategy.QUEUE_NEWEST;
+        case 3:
+        case "GROUP_ROUND_ROBIN":
+            return ConcurrencyLimitStrategy.GROUP_ROUND_ROBIN;
         case -1:
         case "UNRECOGNIZED":
         default:
@@ -61,6 +65,8 @@ function concurrencyLimitStrategyToJSON(object) {
             return "DROP_NEWEST";
         case ConcurrencyLimitStrategy.QUEUE_NEWEST:
             return "QUEUE_NEWEST";
+        case ConcurrencyLimitStrategy.GROUP_ROUND_ROBIN:
+            return "GROUP_ROUND_ROBIN";
         case ConcurrencyLimitStrategy.UNRECOGNIZED:
         default:
             return "UNRECOGNIZED";

package/step.d.ts

@@ -1,4 +1,5 @@
 import * as z from 'zod';
+import { Action } from './clients/dispatcher/action-listener';
 export declare const CreateStepSchema: z.ZodObject<{
     name: z.ZodString;
     parents: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
@@ -26,8 +27,9 @@ interface ContextData<T, K> {
 }
 export declare class Context<T, K> {
     data: ContextData<T, K>;
+    input: T;
     controller: AbortController;
-    constructor(payload: string);
+    constructor(action: Action);
     stepOutput(step: string): string;
     triggeredByEvent(): boolean;
     workflowInput(): T;

package/step.js

@@ -37,10 +37,18 @@ exports.CreateStepSchema = z.object({
     retries: z.number().optional(),
 });
 class Context {
-    constructor(payload) {
+    constructor(action) {
         this.controller = new AbortController();
         try {
-            this.data = JSON.parse(JSON.parse(payload));
+            const data = JSON.parse(JSON.parse(action.actionPayload));
+            this.data = data;
+            // if this is a getGroupKeyRunId, the data is the workflow input
+            if (action.getGroupKeyRunId !== '') {
+                this.input = data;
+            }
+            else {
+                this.input = data.input;
+            }
         }
         catch (e) {
             throw new hatchet_error_1.default(`Could not parse payload: ${e.message}`);
@@ -60,8 +68,7 @@ class Context {
         return ((_a = this.data) === null || _a === void 0 ? void 0 : _a.triggered_by) === 'event';
     }
     workflowInput() {
-        var _a;
-        return (_a = this.data) === null || _a === void 0 ? void 0 : _a.input;
+        return this.input;
     }
     userData() {
         var _a;

package/util/config-loader/config-loader.d.ts

@@ -4,7 +4,7 @@ interface LoadClientConfigOptions {
     path?: string;
 }
 export declare class ConfigLoader {
-    static loadClientConfig(config?: LoadClientConfigOptions): Partial<ClientConfig>;
+    static loadClientConfig(override?: Partial<ClientConfig>, config?: LoadClientConfigOptions): Partial<ClientConfig>;
     static get default_yaml_config_path(): string;
     static createCredentials(config: ClientConfig['tls_config']): ChannelCredentials;
     static loadYamlConfig(path?: string): ClientConfig | undefined;

package/util/config-loader/config-loader.js

@@ -33,17 +33,17 @@ const nice_grpc_1 = require("nice-grpc");
 const token_1 = require("./token");
 const DEFAULT_CONFIG_FILE = '.hatchet.yaml';
 class ConfigLoader {
-    static loadClientConfig(config) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w;
+    static loadClientConfig(override, config) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2;
         const yaml = this.loadYamlConfig(config === null || config === void 0 ? void 0 : config.path);
-        const tlsConfig = {
-            tls_strategy: (_c = (_b = (_a = yaml === null || yaml === void 0 ? void 0 : yaml.tls_config) === null || _a === void 0 ? void 0 : _a.tls_strategy) !== null && _b !== void 0 ? _b : this.env('HATCHET_CLIENT_TLS_STRATEGY')) !== null && _c !== void 0 ? _c : 'tls',
-            cert_file: (_e = (_d = yaml === null || yaml === void 0 ? void 0 : yaml.tls_config) === null || _d === void 0 ? void 0 : _d.cert_file) !== null && _e !== void 0 ? _e : this.env('HATCHET_CLIENT_TLS_CERT_FILE'),
-            key_file: (_g = (_f = yaml === null || yaml === void 0 ? void 0 : yaml.tls_config) === null || _f === void 0 ? void 0 : _f.key_file) !== null && _g !== void 0 ? _g : this.env('HATCHET_CLIENT_TLS_KEY_FILE'),
-            ca_file: (_j = (_h = yaml === null || yaml === void 0 ? void 0 : yaml.tls_config) === null || _h === void 0 ? void 0 : _h.ca_file) !== null && _j !== void 0 ? _j : this.env('HATCHET_CLIENT_TLS_ROOT_CA_FILE'),
-            server_name: (_l = (_k = yaml === null || yaml === void 0 ? void 0 : yaml.tls_config) === null || _k === void 0 ? void 0 : _k.server_name) !== null && _l !== void 0 ? _l : this.env('HATCHET_CLIENT_TLS_SERVER_NAME'),
+        const tlsConfig = (_a = override === null || override === void 0 ? void 0 : override.tls_config) !== null && _a !== void 0 ? _a : {
+            tls_strategy: (_d = (_c = (_b = yaml === null || yaml === void 0 ? void 0 : yaml.tls_config) === null || _b === void 0 ? void 0 : _b.tls_strategy) !== null && _c !== void 0 ? _c : this.env('HATCHET_CLIENT_TLS_STRATEGY')) !== null && _d !== void 0 ? _d : 'tls',
+            cert_file: (_f = (_e = yaml === null || yaml === void 0 ? void 0 : yaml.tls_config) === null || _e === void 0 ? void 0 : _e.cert_file) !== null && _f !== void 0 ? _f : this.env('HATCHET_CLIENT_TLS_CERT_FILE'),
+            key_file: (_h = (_g = yaml === null || yaml === void 0 ? void 0 : yaml.tls_config) === null || _g === void 0 ? void 0 : _g.key_file) !== null && _h !== void 0 ? _h : this.env('HATCHET_CLIENT_TLS_KEY_FILE'),
+            ca_file: (_k = (_j = yaml === null || yaml === void 0 ? void 0 : yaml.tls_config) === null || _j === void 0 ? void 0 : _j.ca_file) !== null && _k !== void 0 ? _k : this.env('HATCHET_CLIENT_TLS_ROOT_CA_FILE'),
+            server_name: (_m = (_l = yaml === null || yaml === void 0 ? void 0 : yaml.tls_config) === null || _l === void 0 ? void 0 : _l.server_name) !== null && _m !== void 0 ? _m : this.env('HATCHET_CLIENT_TLS_SERVER_NAME'),
         };
-        const token = (_m = yaml === null || yaml === void 0 ? void 0 : yaml.token) !== null && _m !== void 0 ? _m : this.env('HATCHET_CLIENT_TOKEN');
+        const token = (_p = (_o = override === null || override === void 0 ? void 0 : override.token) !== null && _o !== void 0 ? _o : yaml === null || yaml === void 0 ? void 0 : yaml.token) !== null && _p !== void 0 ? _p : this.env('HATCHET_CLIENT_TOKEN');
         let grpcBroadcastAddress;
         let apiUrl;
         const tenantId = (0, token_1.getTenantIdFromJWT)(token);
@@ -53,19 +53,20 @@ class ConfigLoader {
         try {
             const addresses = (0, token_1.getAddressesFromJWT)(token);
             grpcBroadcastAddress =
-                (_p = (_o = yaml === null || yaml === void 0 ? void 0 : yaml.host_port) !== null && _o !== void 0 ? _o : this.env('HATCHET_CLIENT_HOST_PORT')) !== null && _p !== void 0 ? _p : addresses.grpcBroadcastAddress;
-            apiUrl = (_r = (_q = yaml === null || yaml === void 0 ? void 0 : yaml.api_url) !== null && _q !== void 0 ? _q : this.env('HATCHET_CLIENT_API_URL')) !== null && _r !== void 0 ? _r : addresses.serverUrl;
+                (_r = (_q = yaml === null || yaml === void 0 ? void 0 : yaml.host_port) !== null && _q !== void 0 ? _q : this.env('HATCHET_CLIENT_HOST_PORT')) !== null && _r !== void 0 ? _r : addresses.grpcBroadcastAddress;
+            apiUrl =
+                (_u = (_t = (_s = override === null || override === void 0 ? void 0 : override.api_url) !== null && _s !== void 0 ? _s : yaml === null || yaml === void 0 ? void 0 : yaml.api_url) !== null && _t !== void 0 ? _t : this.env('HATCHET_CLIENT_API_URL')) !== null && _u !== void 0 ? _u : addresses.serverUrl;
         }
         catch (e) {
-            grpcBroadcastAddress = (_s = yaml === null || yaml === void 0 ? void 0 : yaml.host_port) !== null && _s !== void 0 ? _s : this.env('HATCHET_CLIENT_HOST_PORT');
-            apiUrl = (_t = yaml === null || yaml === void 0 ? void 0 : yaml.api_url) !== null && _t !== void 0 ? _t : this.env('HATCHET_CLIENT_API_URL');
+            grpcBroadcastAddress = (_v = yaml === null || yaml === void 0 ? void 0 : yaml.host_port) !== null && _v !== void 0 ? _v : this.env('HATCHET_CLIENT_HOST_PORT');
+            apiUrl = (_x = (_w = override === null || override === void 0 ? void 0 : override.api_url) !== null && _w !== void 0 ? _w : yaml === null || yaml === void 0 ? void 0 : yaml.api_url) !== null && _x !== void 0 ? _x : this.env('HATCHET_CLIENT_API_URL');
         }
         return {
-            token: (_u = yaml === null || yaml === void 0 ? void 0 : yaml.token) !== null && _u !== void 0 ? _u : this.env('HATCHET_CLIENT_TOKEN'),
+            token: (_z = (_y = override === null || override === void 0 ? void 0 : override.token) !== null && _y !== void 0 ? _y : yaml === null || yaml === void 0 ? void 0 : yaml.token) !== null && _z !== void 0 ? _z : this.env('HATCHET_CLIENT_TOKEN'),
             host_port: grpcBroadcastAddress,
             api_url: apiUrl,
             tls_config: tlsConfig,
-            log_level: (_w = (_v = yaml === null || yaml === void 0 ? void 0 : yaml.log_level) !== null && _v !== void 0 ? _v : this.env('HATCHET_CLIENT_LOG_LEVEL')) !== null && _w !== void 0 ? _w : 'INFO',
+            log_level: (_2 = (_1 = (_0 = override === null || override === void 0 ? void 0 : override.log_level) !== null && _0 !== void 0 ? _0 : yaml === null || yaml === void 0 ? void 0 : yaml.log_level) !== null && _1 !== void 0 ? _1 : this.env('HATCHET_CLIENT_LOG_LEVEL')) !== null && _2 !== void 0 ? _2 : 'INFO',
             tenant_id: tenantId,
         };
     }

package/util/retrier.d.ts

@@ -0,0 +1,2 @@
+import { Logger } from './logger';
+export declare function retrier<T>(fn: () => Promise<T>, logger: Logger, retries?: number, interval?: number): Promise<T>;

package/util/retrier.js

@@ -0,0 +1,36 @@
+"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.retrier = void 0;
+const sleep_1 = __importDefault(require("./sleep"));
+const DEFAULT_RETRY_INTERVAL = 5;
+const DEFAULT_RETRY_COUNT = 5;
+function retrier(fn, logger, retries = DEFAULT_RETRY_COUNT, interval = DEFAULT_RETRY_INTERVAL) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let lastError;
+        // eslint-disable-next-line no-plusplus
+        for (let i = 0; i < retries; i++) {
+            try {
+                return yield fn();
+            }
+            catch (e) {
+                lastError = e;
+                logger.error(`Error: ${e.message}`);
+                yield (0, sleep_1.default)(interval * 1000);
+            }
+        }
+        throw lastError;
+    });
+}
+exports.retrier = retrier;