@hatchet-dev/typescript-sdk 0.1.15 → 0.1.18

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.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,7 +25,6 @@ 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, 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,9 +114,6 @@ 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);
     }

package/clients/worker/worker.d.ts

@@ -7,7 +7,6 @@ import { Logger } from '../../util/logger';
 import { Context, StepRunFunction } from '../../step';
 export type ActionRegistry = Record<Action['actionId'], Function>;
 export declare class Worker {
-    serviceName: string;
     client: HatchetClient;
     name: string;
     killing: boolean;

package/clients/worker/worker.js

@@ -25,11 +25,10 @@ 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) {
-        this.serviceName = 'default';
         this.futures = {};
         this.contexts = {};
         this.client = client;
@@ -48,7 +47,7 @@ class Worker {
             try {
                 const concurrency = ((_a = workflow.concurrency) === null || _a === void 0 ? void 0 : _a.name)
                     ? {
-                        action: `${this.serviceName}:${workflow.concurrency.name}`,
+                        action: `${workflow.id}:${workflow.concurrency.name}`,
                         maxRuns: workflow.concurrency.maxRuns || 1,
                         limitStrategy: workflow.concurrency.limitStrategy || workflows_1.ConcurrencyLimitStrategy.CANCEL_IN_PROGRESS,
                     }
@@ -61,6 +60,7 @@ class Worker {
                     cronTriggers: workflow.on.cron ? [workflow.on.cron] : [],
                     scheduledTriggers: [],
                     concurrency,
+                    scheduleTimeout: workflow.scheduleTimeout,
                     jobs: [
                         {
                             name: workflow.id,
@@ -70,7 +70,7 @@ class Worker {
                                 var _a;
                                 return ({
                                     readableId: step.name,
-                                    action: `${this.serviceName}:${step.name}`,
+                                    action: `${workflow.id}:${step.name}`,
                                     timeout: step.timeout || '60s',
                                     inputs: '{}',
                                     parents: (_a = step.parents) !== null && _a !== void 0 ? _a : [],
@@ -85,12 +85,13 @@ class Worker {
             catch (e) {
                 throw new hatchet_error_1.default(`Could not register workflow: ${e.message}`);
             }
-            this.action_registry = workflow.steps.reduce((acc, step) => {
-                acc[`${this.serviceName}:${step.name}`] = step.run;
+            const newActions = workflow.steps.reduce((acc, step) => {
+                acc[`${workflow.id}:${step.name}`] = step.run;
                 return acc;
             }, {});
+            this.action_registry = Object.assign(Object.assign({}, this.action_registry), newActions);
             this.action_registry = ((_b = workflow.concurrency) === null || _b === void 0 ? void 0 : _b.name)
-                ? Object.assign(Object.assign({}, this.action_registry), { [`${this.serviceName}:${workflow.concurrency.name}`]: workflow.concurrency.key }) : Object.assign({}, this.action_registry);
+                ? Object.assign(Object.assign({}, this.action_registry), { [`${workflow.id}:${workflow.concurrency.name}`]: workflow.concurrency.key }) : Object.assign({}, this.action_registry);
         });
     }
     registerAction(actionId, action) {
@@ -270,58 +271,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),
-                        maxRuns: this.maxRuns,
-                    });
-                    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.15",
+  "version": "0.1.18",
   "description": "Background task orchestration & visibility for developers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -36,6 +36,7 @@
     "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",
+    "worker:multi-workflow": "npm run exec -- ./examples/multi-workflow.ts",
     "api": "npm run exec -- ./examples/api.ts",
     "prepublish": "cp package.json dist/package.json;",
     "publish:ci": "rm -rf ./dist && npm run tsc:build && npm run prepublish && cd dist && npm publish --access public --no-git-checks",

package/protoc/workflows/workflows.d.ts

@@ -31,6 +31,8 @@ export interface CreateWorkflowVersionOpts {
     jobs: CreateWorkflowJobOpts[];
     /** (optional) the workflow concurrency options */
     concurrency: WorkflowConcurrencyOpts | undefined;
+    /** (optional) the timeout for the schedule */
+    scheduleTimeout?: string | undefined;
 }
 export interface WorkflowConcurrencyOpts {
     /** (required) the action id for getting the concurrency group */

package/protoc/workflows/workflows.js

@@ -135,6 +135,7 @@ function createBaseCreateWorkflowVersionOpts() {
         scheduledTriggers: [],
         jobs: [],
         concurrency: undefined,
+        scheduleTimeout: undefined,
     };
 }
 exports.CreateWorkflowVersionOpts = {
@@ -163,6 +164,9 @@ exports.CreateWorkflowVersionOpts = {
         if (message.concurrency !== undefined) {
             exports.WorkflowConcurrencyOpts.encode(message.concurrency, writer.uint32(66).fork()).ldelim();
         }
+        if (message.scheduleTimeout !== undefined) {
+            writer.uint32(74).string(message.scheduleTimeout);
+        }
         return writer;
     },
     decode(input, length) {
@@ -220,6 +224,12 @@ exports.CreateWorkflowVersionOpts = {
                     }
                     message.concurrency = exports.WorkflowConcurrencyOpts.decode(reader, reader.uint32());
                     continue;
+                case 9:
+                    if (tag !== 74) {
+                        break;
+                    }
+                    message.scheduleTimeout = reader.string();
+                    continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -246,6 +256,7 @@ exports.CreateWorkflowVersionOpts = {
                 ? object.jobs.map((e) => exports.CreateWorkflowJobOpts.fromJSON(e))
                 : [],
             concurrency: isSet(object.concurrency) ? exports.WorkflowConcurrencyOpts.fromJSON(object.concurrency) : undefined,
+            scheduleTimeout: isSet(object.scheduleTimeout) ? globalThis.String(object.scheduleTimeout) : undefined,
         };
     },
     toJSON(message) {
@@ -275,13 +286,16 @@ exports.CreateWorkflowVersionOpts = {
         if (message.concurrency !== undefined) {
             obj.concurrency = exports.WorkflowConcurrencyOpts.toJSON(message.concurrency);
         }
+        if (message.scheduleTimeout !== undefined) {
+            obj.scheduleTimeout = message.scheduleTimeout;
+        }
         return obj;
     },
     create(base) {
         return exports.CreateWorkflowVersionOpts.fromPartial(base !== null && base !== void 0 ? base : {});
     },
     fromPartial(object) {
-        var _a, _b, _c, _d, _e, _f, _g;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         const message = createBaseCreateWorkflowVersionOpts();
         message.name = (_a = object.name) !== null && _a !== void 0 ? _a : "";
         message.description = (_b = object.description) !== null && _b !== void 0 ? _b : "";
@@ -293,6 +307,7 @@ exports.CreateWorkflowVersionOpts = {
         message.concurrency = (object.concurrency !== undefined && object.concurrency !== null)
             ? exports.WorkflowConcurrencyOpts.fromPartial(object.concurrency)
             : undefined;
+        message.scheduleTimeout = (_h = object.scheduleTimeout) !== null && _h !== void 0 ? _h : undefined;
         return message;
     },
 };

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;

package/workflow.d.ts

@@ -37,6 +37,7 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
     id: z.ZodString;
     description: z.ZodString;
     version: z.ZodOptional<z.ZodString>;
+    scheduleTimeout: z.ZodOptional<z.ZodString>;
     timeout: z.ZodOptional<z.ZodString>;
     on: z.ZodUnion<[z.ZodObject<{
         cron: z.ZodString;
@@ -90,6 +91,7 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
         cron?: undefined;
     };
     version?: string | undefined;
+    scheduleTimeout?: string | undefined;
     timeout?: string | undefined;
 }, {
     description: string;
@@ -108,6 +110,7 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
         cron?: undefined;
     };
     version?: string | undefined;
+    scheduleTimeout?: string | undefined;
     timeout?: string | undefined;
 }>;
 export interface Workflow extends z.infer<typeof CreateWorkflowSchema> {

package/workflow.js

@@ -48,6 +48,7 @@ exports.CreateWorkflowSchema = z.object({
     id: z.string(),
     description: z.string(),
     version: z.string().optional(),
+    scheduleTimeout: z.string().optional(),
     timeout: exports.HatchetTimeoutSchema.optional(),
     on: OnConfigSchema,
     steps: StepsSchema,