@hatchet-dev/typescript-sdk 1.3.2 → 1.4.0-alpha.2

package/v1/client/worker/worker-internal.js

@@ -0,0 +1,703 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.V1Worker = void 0;
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable no-nested-ternary */
+const hatchet_error_1 = __importDefault(require("../../../util/errors/hatchet-error"));
+const dispatcher_1 = require("../../../protoc/dispatcher");
+const hatchet_promise_1 = __importDefault(require("../../../util/hatchet-promise/hatchet-promise"));
+const workflows_1 = require("../../../protoc/workflows");
+const task_1 = require("../../task");
+const transformer_1 = require("../../conditions/transformer");
+const step_1 = require("../../../step");
+const context_1 = require("./context");
+class V1Worker {
+    constructor(client, options) {
+        this.workflow_registry = [];
+        this.futures = {};
+        this.contexts = {};
+        this.registeredWorkflowPromises = [];
+        this.labels = {};
+        this.client = client;
+        this.name = this.client.config.namespace + options.name;
+        this.action_registry = {};
+        this.maxRuns = options.maxRuns;
+        this.labels = options.labels || {};
+        process.on('SIGTERM', () => this.exitGracefully(true));
+        process.on('SIGINT', () => this.exitGracefully(true));
+        this.killing = false;
+        this.handle_kill = options.handleKill === undefined ? true : options.handleKill;
+        this.logger = client.config.logger(`Worker/${this.name}`, this.client.config.log_level);
+    }
+    registerActions(workflow) {
+        var _a;
+        const newActions = workflow.steps.reduce((acc, step) => {
+            acc[`${workflow.id}:${step.name.toLowerCase()}`] = step.run;
+            return acc;
+        }, {});
+        const onFailureAction = workflow.onFailure
+            ? {
+                [`${workflow.id}-on-failure:${workflow.onFailure.name}`]: workflow.onFailure.run,
+            }
+            : {};
+        this.action_registry = Object.assign(Object.assign(Object.assign({}, this.action_registry), newActions), onFailureAction);
+        this.action_registry =
+            ((_a = workflow.concurrency) === null || _a === void 0 ? void 0 : _a.name) && workflow.concurrency.key
+                ? Object.assign(Object.assign({}, this.action_registry), { [`${workflow.id}:${workflow.concurrency.name.toLowerCase()}`]: workflow.concurrency.key }) : Object.assign({}, this.action_registry);
+    }
+    getHandler(workflows) {
+        throw new Error('Not implemented');
+        // TODO v1
+        // for (const workflow of workflows) {
+        //   const wf: Workflow = {
+        //     ...workflow,
+        //     id: this.client.config.namespace + workflow.id,
+        //   };
+        //   this.registerActions(wf);
+        // }
+        // return new WebhookHandler(this, workflows);
+    }
+    registerWebhook(webhook) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client._v0.admin.registerWebhook(Object.assign({}, webhook));
+        });
+    }
+    /**
+     * @deprecated use registerWorkflow instead
+     */
+    register_workflow(initWorkflow) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.registerWorkflow(initWorkflow);
+        });
+    }
+    registerDurableActionsV1(workflow) {
+        const newActions = workflow._durableTasks.reduce((acc, task) => {
+            acc[`${workflow.name}:${task.name.toLowerCase()}`] = (ctx) => task.fn(ctx.input, ctx);
+            return acc;
+        }, {});
+        this.action_registry = Object.assign(Object.assign({}, this.action_registry), newActions);
+    }
+    registerActionsV1(workflow) {
+        const newActions = workflow._tasks.reduce((acc, task) => {
+            acc[`${workflow.name}:${task.name.toLowerCase()}`] = (ctx) => task.fn(ctx.input, ctx);
+            return acc;
+        }, {});
+        const onFailureFn = workflow.onFailure
+            ? typeof workflow.onFailure === 'function'
+                ? workflow.onFailure
+                : workflow.onFailure.fn
+            : undefined;
+        const onFailureAction = onFailureFn
+            ? {
+                [onFailureTaskName(workflow)]: (ctx) => onFailureFn(ctx.input, ctx),
+            }
+            : {};
+        this.action_registry = Object.assign(Object.assign(Object.assign({}, this.action_registry), newActions), onFailureAction);
+    }
+    registerWorkflowV1(initWorkflow) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v;
+            // patch the namespace
+            const workflow = Object.assign(Object.assign({}, initWorkflow.definition), { name: (this.client.config.namespace + initWorkflow.definition.name).toLowerCase() });
+            try {
+                const { concurrency } = workflow;
+                let onFailureTask;
+                if (workflow.onFailure && typeof workflow.onFailure === 'function') {
+                    onFailureTask = {
+                        readableId: 'on-failure-task',
+                        action: onFailureTaskName(workflow),
+                        timeout: '60s',
+                        inputs: '{}',
+                        parents: [],
+                        retries: 0,
+                        rateLimits: [],
+                        workerLabels: {},
+                        concurrency: [],
+                    };
+                }
+                if (workflow.onFailure && typeof workflow.onFailure === 'object') {
+                    const onFailure = workflow.onFailure;
+                    onFailureTask = {
+                        readableId: 'on-failure-task',
+                        action: onFailureTaskName(workflow),
+                        timeout: onFailure.executionTimeout || ((_a = workflow.taskDefaults) === null || _a === void 0 ? void 0 : _a.executionTimeout) || '60s',
+                        scheduleTimeout: onFailure.scheduleTimeout || ((_b = workflow.taskDefaults) === null || _b === void 0 ? void 0 : _b.scheduleTimeout),
+                        inputs: '{}',
+                        parents: [],
+                        retries: onFailure.retries || ((_c = workflow.taskDefaults) === null || _c === void 0 ? void 0 : _c.retries) || 0,
+                        rateLimits: (0, step_1.mapRateLimit)(onFailure.rateLimits || ((_d = workflow.taskDefaults) === null || _d === void 0 ? void 0 : _d.rateLimits)),
+                        workerLabels: toPbWorkerLabel(onFailure.desiredWorkerLabels || ((_e = workflow.taskDefaults) === null || _e === void 0 ? void 0 : _e.workerLabels)),
+                        concurrency: [],
+                        backoffFactor: ((_f = onFailure.backoff) === null || _f === void 0 ? void 0 : _f.factor) || ((_h = (_g = workflow.taskDefaults) === null || _g === void 0 ? void 0 : _g.backoff) === null || _h === void 0 ? void 0 : _h.factor),
+                        backoffMaxSeconds: ((_j = onFailure.backoff) === null || _j === void 0 ? void 0 : _j.maxSeconds) || ((_l = (_k = workflow.taskDefaults) === null || _k === void 0 ? void 0 : _k.backoff) === null || _l === void 0 ? void 0 : _l.maxSeconds),
+                    };
+                }
+                let onSuccessTask;
+                if (workflow.onSuccess && typeof workflow.onSuccess === 'function') {
+                    const parents = getLeaves(workflow._tasks);
+                    onSuccessTask = {
+                        name: 'on-success-task',
+                        fn: workflow.onSuccess,
+                        timeout: '60s',
+                        parents,
+                        retries: 0,
+                        rateLimits: [],
+                        desiredWorkerLabels: {},
+                        concurrency: [],
+                    };
+                }
+                if (workflow.onSuccess && typeof workflow.onSuccess === 'object') {
+                    const onSuccess = workflow.onSuccess;
+                    const parents = getLeaves(workflow._tasks);
+                    onSuccessTask = {
+                        name: 'on-success-task',
+                        fn: onSuccess.fn,
+                        timeout: onSuccess.executionTimeout || ((_m = workflow.taskDefaults) === null || _m === void 0 ? void 0 : _m.executionTimeout) || '60s',
+                        scheduleTimeout: onSuccess.scheduleTimeout || ((_o = workflow.taskDefaults) === null || _o === void 0 ? void 0 : _o.scheduleTimeout),
+                        parents,
+                        retries: onSuccess.retries || ((_p = workflow.taskDefaults) === null || _p === void 0 ? void 0 : _p.retries) || 0,
+                        rateLimits: onSuccess.rateLimits || ((_q = workflow.taskDefaults) === null || _q === void 0 ? void 0 : _q.rateLimits),
+                        desiredWorkerLabels: onSuccess.desiredWorkerLabels || ((_r = workflow.taskDefaults) === null || _r === void 0 ? void 0 : _r.workerLabels),
+                        concurrency: onSuccess.concurrency || ((_s = workflow.taskDefaults) === null || _s === void 0 ? void 0 : _s.concurrency),
+                        backoff: onSuccess.backoff || ((_t = workflow.taskDefaults) === null || _t === void 0 ? void 0 : _t.backoff),
+                    };
+                }
+                if (onSuccessTask) {
+                    workflow._tasks.push(onSuccessTask);
+                }
+                // cron and event triggers
+                if (workflow.on) {
+                    this.logger.warn(`\`on\` for event and cron triggers is deprecated and will be removed soon, use \`onEvents\` and \`onCrons\` instead for ${workflow.name}`);
+                }
+                const eventTriggers = [
+                    ...(workflow.onEvents || []),
+                    ...(((_u = workflow.on) === null || _u === void 0 ? void 0 : _u.event) ? [workflow.on.event] : []),
+                ];
+                const cronTriggers = [
+                    ...(workflow.onCrons || []),
+                    ...(((_v = workflow.on) === null || _v === void 0 ? void 0 : _v.cron) ? [workflow.on.cron] : []),
+                ];
+                const concurrencyArr = Array.isArray(concurrency) ? concurrency : [];
+                const concurrencySolo = !Array.isArray(concurrency) ? concurrency : undefined;
+                const registeredWorkflow = this.client._v0.admin.putWorkflowV1({
+                    name: workflow.name,
+                    description: workflow.description || '',
+                    version: workflow.version || '',
+                    eventTriggers,
+                    cronTriggers,
+                    sticky: workflow.sticky,
+                    concurrencyArr,
+                    onFailureTask,
+                    defaultPriority: workflow.defaultPriority,
+                    tasks: [...workflow._tasks, ...workflow._durableTasks].map((task) => {
+                        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+                        return ({
+                            readableId: task.name,
+                            action: `${workflow.name}:${task.name}`,
+                            timeout: task.executionTimeout ||
+                                task.timeout ||
+                                ((_a = workflow.taskDefaults) === null || _a === void 0 ? void 0 : _a.executionTimeout) ||
+                                '60s',
+                            scheduleTimeout: task.scheduleTimeout || ((_b = workflow.taskDefaults) === null || _b === void 0 ? void 0 : _b.scheduleTimeout),
+                            inputs: '{}',
+                            parents: (_d = (_c = task.parents) === null || _c === void 0 ? void 0 : _c.map((p) => p.name)) !== null && _d !== void 0 ? _d : [],
+                            userData: '{}',
+                            retries: task.retries || ((_e = workflow.taskDefaults) === null || _e === void 0 ? void 0 : _e.retries) || 0,
+                            rateLimits: (0, step_1.mapRateLimit)(task.rateLimits || ((_f = workflow.taskDefaults) === null || _f === void 0 ? void 0 : _f.rateLimits)),
+                            workerLabels: toPbWorkerLabel(task.desiredWorkerLabels || ((_g = workflow.taskDefaults) === null || _g === void 0 ? void 0 : _g.workerLabels)),
+                            backoffFactor: ((_h = task.backoff) === null || _h === void 0 ? void 0 : _h.factor) || ((_k = (_j = workflow.taskDefaults) === null || _j === void 0 ? void 0 : _j.backoff) === null || _k === void 0 ? void 0 : _k.factor),
+                            backoffMaxSeconds: ((_l = task.backoff) === null || _l === void 0 ? void 0 : _l.maxSeconds) || ((_o = (_m = workflow.taskDefaults) === null || _m === void 0 ? void 0 : _m.backoff) === null || _o === void 0 ? void 0 : _o.maxSeconds),
+                            conditions: (0, transformer_1.taskConditionsToPb)(task),
+                            concurrency: task.concurrency
+                                ? Array.isArray(task.concurrency)
+                                    ? task.concurrency
+                                    : [task.concurrency]
+                                : ((_p = workflow.taskDefaults) === null || _p === void 0 ? void 0 : _p.concurrency)
+                                    ? Array.isArray(workflow.taskDefaults.concurrency)
+                                        ? workflow.taskDefaults.concurrency
+                                        : [workflow.taskDefaults.concurrency]
+                                    : [],
+                        });
+                    }),
+                    concurrency: concurrencySolo,
+                });
+                this.registeredWorkflowPromises.push(registeredWorkflow);
+                yield registeredWorkflow;
+                this.workflow_registry.push(workflow);
+            }
+            catch (e) {
+                throw new hatchet_error_1.default(`Could not register workflow: ${e.message}`);
+            }
+            this.registerActionsV1(workflow);
+        });
+    }
+    registerWorkflow(initWorkflow) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const workflow = Object.assign(Object.assign({}, initWorkflow), { id: (this.client.config.namespace + initWorkflow.id).toLowerCase() });
+            try {
+                if (((_a = workflow.concurrency) === null || _a === void 0 ? void 0 : _a.key) && workflow.concurrency.expression) {
+                    throw new hatchet_error_1.default('Cannot have both key function and expression in workflow concurrency configuration');
+                }
+                const concurrency = ((_b = workflow.concurrency) === null || _b === void 0 ? void 0 : _b.name) || ((_c = workflow.concurrency) === null || _c === void 0 ? void 0 : _c.expression)
+                    ? {
+                        action: !workflow.concurrency.expression
+                            ? `${workflow.id}:${workflow.concurrency.name}`
+                            : undefined,
+                        maxRuns: workflow.concurrency.maxRuns || 1,
+                        expression: workflow.concurrency.expression,
+                        limitStrategy: workflow.concurrency.limitStrategy || workflows_1.ConcurrencyLimitStrategy.CANCEL_IN_PROGRESS,
+                    }
+                    : undefined;
+                const onFailureJob = workflow.onFailure
+                    ? {
+                        name: `${workflow.id}-on-failure`,
+                        description: workflow.description,
+                        steps: [
+                            {
+                                readableId: workflow.onFailure.name,
+                                action: `${workflow.id}-on-failure:${workflow.onFailure.name}`,
+                                timeout: workflow.onFailure.timeout || '60s',
+                                inputs: '{}',
+                                parents: [],
+                                userData: '{}',
+                                retries: workflow.onFailure.retries || 0,
+                                rateLimits: (0, step_1.mapRateLimit)(workflow.onFailure.rate_limits),
+                                workerLabels: {}, // no worker labels for on failure steps
+                            },
+                        ],
+                    }
+                    : undefined;
+                const registeredWorkflow = this.client._v0.admin.putWorkflow({
+                    name: workflow.id,
+                    description: workflow.description,
+                    version: workflow.version || '',
+                    eventTriggers: workflow.on && workflow.on.event
+                        ? [this.client.config.namespace + workflow.on.event]
+                        : [],
+                    cronTriggers: workflow.on && workflow.on.cron ? [workflow.on.cron] : [],
+                    scheduledTriggers: [],
+                    concurrency,
+                    scheduleTimeout: workflow.scheduleTimeout,
+                    onFailureJob,
+                    sticky: workflow.sticky,
+                    jobs: [
+                        {
+                            name: workflow.id,
+                            description: workflow.description,
+                            steps: workflow.steps.map((step) => {
+                                var _a, _b, _c;
+                                return ({
+                                    readableId: step.name,
+                                    action: `${workflow.id}:${step.name}`,
+                                    timeout: step.timeout || '60s',
+                                    inputs: '{}',
+                                    parents: (_a = step.parents) !== null && _a !== void 0 ? _a : [],
+                                    userData: '{}',
+                                    retries: step.retries || 0,
+                                    rateLimits: (0, step_1.mapRateLimit)(step.rate_limits),
+                                    workerLabels: toPbWorkerLabel(step.worker_labels),
+                                    backoffFactor: (_b = step.backoff) === null || _b === void 0 ? void 0 : _b.factor,
+                                    backoffMaxSeconds: (_c = step.backoff) === null || _c === void 0 ? void 0 : _c.maxSeconds,
+                                });
+                            }),
+                        },
+                    ],
+                });
+                this.registeredWorkflowPromises.push(registeredWorkflow);
+                yield registeredWorkflow;
+                this.workflow_registry.push(workflow);
+            }
+            catch (e) {
+                throw new hatchet_error_1.default(`Could not register workflow: ${e.message}`);
+            }
+            this.registerActions(workflow);
+        });
+    }
+    registerAction(actionId, action) {
+        this.action_registry[actionId.toLowerCase()] = action;
+    }
+    handleStartStepRun(action) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { actionId } = action;
+            try {
+                // Note: we always use a DurableContext since its a superset of the Context class
+                const context = new context_1.DurableContext(action, this.client, this);
+                this.contexts[action.stepRunId] = context;
+                const step = this.action_registry[actionId];
+                if (!step) {
+                    this.logger.error(`Registered actions: '${Object.keys(this.action_registry).join(', ')}'`);
+                    this.logger.error(`Could not find step '${actionId}'`);
+                    return;
+                }
+                const run = () => __awaiter(this, void 0, void 0, function* () {
+                    return step(context);
+                });
+                const success = (result) => __awaiter(this, void 0, void 0, function* () {
+                    this.logger.info(`Step run ${action.stepRunId} succeeded`);
+                    try {
+                        // Send the action event to the dispatcher
+                        const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_COMPLETED, false, result || null, action.retryCount);
+                        yield this.client._v0.dispatcher.sendStepActionEvent(event);
+                    }
+                    catch (actionEventError) {
+                        this.logger.error(`Could not send completed action event: ${actionEventError.message || actionEventError}`);
+                        // send a failure event
+                        const failureEvent = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_FAILED, false, actionEventError.message, action.retryCount);
+                        try {
+                            yield this.client._v0.dispatcher.sendStepActionEvent(failureEvent);
+                        }
+                        catch (failureEventError) {
+                            this.logger.error(`Could not send failed action event: ${failureEventError.message || failureEventError}`);
+                        }
+                        this.logger.error(`Could not send action event: ${actionEventError.message || actionEventError}`);
+                    }
+                    finally {
+                        // delete the run from the futures
+                        delete this.futures[action.stepRunId];
+                        delete this.contexts[action.stepRunId];
+                    }
+                });
+                const failure = (error) => __awaiter(this, void 0, void 0, function* () {
+                    this.logger.error(`Step run ${action.stepRunId} failed: ${error.message}`);
+                    if (error.stack) {
+                        this.logger.error(error.stack);
+                    }
+                    const shouldNotRetry = error instanceof task_1.NonRetryableError;
+                    try {
+                        // Send the action event to the dispatcher
+                        const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_FAILED, shouldNotRetry, {
+                            message: error === null || error === void 0 ? void 0 : error.message,
+                            stack: error === null || error === void 0 ? void 0 : error.stack,
+                        }, action.retryCount);
+                        yield this.client._v0.dispatcher.sendStepActionEvent(event);
+                    }
+                    catch (e) {
+                        this.logger.error(`Could not send action event: ${e.message}`);
+                    }
+                    finally {
+                        // delete the run from the futures
+                        delete this.futures[action.stepRunId];
+                        delete this.contexts[action.stepRunId];
+                    }
+                });
+                const future = new hatchet_promise_1.default((() => __awaiter(this, void 0, void 0, function* () {
+                    let result;
+                    try {
+                        result = yield run();
+                    }
+                    catch (e) {
+                        yield failure(e);
+                        return;
+                    }
+                    yield success(result);
+                }))());
+                this.futures[action.stepRunId] = future;
+                // Send the action event to the dispatcher
+                const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_STARTED, false, undefined, action.retryCount);
+                this.client._v0.dispatcher.sendStepActionEvent(event).catch((e) => {
+                    this.logger.error(`Could not send action event: ${e.message}`);
+                });
+                try {
+                    yield future.promise;
+                }
+                catch (e) {
+                    this.logger.error('Could not wait for step run to finish: ', e);
+                }
+            }
+            catch (e) {
+                this.logger.error('Could not send action event (outer): ', e);
+            }
+        });
+    }
+    handleStartGroupKeyRun(action) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { actionId } = action;
+            this.logger.error('Concurrency Key Functions have been deprecated and will be removed in a future release. Use Concurrency Expressions instead.');
+            try {
+                const context = new context_1.Context(action, this.client, this);
+                const key = action.getGroupKeyRunId;
+                if (!key) {
+                    this.logger.error(`No group key run id provided for action ${actionId}`);
+                    return;
+                }
+                this.contexts[key] = context;
+                this.logger.debug(`Starting group key run ${key}`);
+                const step = this.action_registry[actionId];
+                if (!step) {
+                    this.logger.error(`Could not find step '${actionId}'`);
+                    return;
+                }
+                const run = () => __awaiter(this, void 0, void 0, function* () {
+                    return step(context);
+                });
+                const success = (result) => {
+                    this.logger.info(`Step run ${action.stepRunId} succeeded`);
+                    try {
+                        // Send the action event to the dispatcher
+                        const event = this.getGroupKeyActionEvent(action, dispatcher_1.GroupKeyActionEventType.GROUP_KEY_EVENT_TYPE_COMPLETED, result);
+                        this.client._v0.dispatcher.sendGroupKeyActionEvent(event).catch((e) => {
+                            this.logger.error(`Could not send action event: ${e.message}`);
+                        });
+                    }
+                    catch (e) {
+                        this.logger.error(`Could not send action event: ${e.message}`);
+                    }
+                    finally {
+                        // delete the run from the futures
+                        delete this.futures[key];
+                        delete this.contexts[key];
+                    }
+                };
+                const failure = (error) => {
+                    this.logger.error(`Step run ${key} failed: ${error.message}`);
+                    try {
+                        // Send the action event to the dispatcher
+                        const event = this.getGroupKeyActionEvent(action, dispatcher_1.GroupKeyActionEventType.GROUP_KEY_EVENT_TYPE_FAILED, error);
+                        this.client._v0.dispatcher.sendGroupKeyActionEvent(event).catch((e) => {
+                            this.logger.error(`Could not send action event: ${e.message}`);
+                        });
+                    }
+                    catch (e) {
+                        this.logger.error(`Could not send action event: ${e.message}`);
+                    }
+                    finally {
+                        // delete the run from the futures
+                        delete this.futures[key];
+                        delete this.contexts[key];
+                    }
+                };
+                const future = new hatchet_promise_1.default(run().then(success).catch(failure));
+                this.futures[key] = future;
+                // Send the action event to the dispatcher
+                const event = this.getGroupKeyActionEvent(action, dispatcher_1.GroupKeyActionEventType.GROUP_KEY_EVENT_TYPE_STARTED);
+                this.client._v0.dispatcher.sendGroupKeyActionEvent(event).catch((e) => {
+                    this.logger.error(`Could not send action event: ${e.message}`);
+                });
+                yield future.promise;
+            }
+            catch (e) {
+                this.logger.error(`Could not send action event: ${e.message}`);
+            }
+        });
+    }
+    getStepActionEvent(action, eventType, shouldNotRetry, payload = '', retryCount = 0) {
+        return {
+            workerId: this.name,
+            jobId: action.jobId,
+            jobRunId: action.jobRunId,
+            stepId: action.stepId,
+            stepRunId: action.stepRunId,
+            actionId: action.actionId,
+            eventTimestamp: new Date(),
+            eventType,
+            eventPayload: JSON.stringify(payload),
+            shouldNotRetry,
+            retryCount,
+        };
+    }
+    getGroupKeyActionEvent(action, eventType, payload = '') {
+        if (!action.getGroupKeyRunId) {
+            throw new hatchet_error_1.default('No group key run id provided');
+        }
+        return {
+            workerId: this.name,
+            workflowRunId: action.workflowRunId,
+            getGroupKeyRunId: action.getGroupKeyRunId,
+            actionId: action.actionId,
+            eventTimestamp: new Date(),
+            eventType,
+            eventPayload: JSON.stringify(payload),
+        };
+    }
+    handleCancelStepRun(action) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { stepRunId } = action;
+            try {
+                this.logger.info(`Cancelling step run ${action.stepRunId}`);
+                const future = this.futures[stepRunId];
+                const context = this.contexts[stepRunId];
+                if (context && context.abortController) {
+                    context.abortController.abort('Cancelled by worker');
+                }
+                if (future) {
+                    future.promise.catch(() => {
+                        this.logger.info(`Cancelled step run ${action.stepRunId}`);
+                    });
+                    future.cancel('Cancelled by worker');
+                    yield future.promise;
+                }
+            }
+            catch (e) {
+                this.logger.error('Could not cancel step run: ', e);
+            }
+            finally {
+                delete this.futures[stepRunId];
+                delete this.contexts[stepRunId];
+            }
+        });
+    }
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.exitGracefully(false);
+        });
+    }
+    exitGracefully(handleKill) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            this.killing = true;
+            this.logger.info('Starting to exit...');
+            try {
+                yield ((_a = this.listener) === null || _a === void 0 ? void 0 : _a.unregister());
+            }
+            catch (e) {
+                this.logger.error(`Could not unregister listener: ${e.message}`);
+            }
+            this.logger.info('Gracefully exiting hatchet worker, running tasks will attempt to finish...');
+            // attempt to wait for futures to finish
+            yield Promise.all(Object.values(this.futures).map(({ promise }) => promise));
+            this.logger.info('Successfully finished pending tasks.');
+            if (handleKill) {
+                this.logger.info('Exiting hatchet worker...');
+                process.exit(0);
+            }
+        });
+    }
+    start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, e_1, _b, _c;
+            // ensure all workflows are registered
+            yield Promise.all(this.registeredWorkflowPromises);
+            if (Object.keys(this.action_registry).length === 0) {
+                return;
+            }
+            try {
+                this.listener = yield this.client._v0.dispatcher.getActionListener({
+                    workerName: this.name,
+                    services: ['default'],
+                    actions: Object.keys(this.action_registry),
+                    maxRuns: this.maxRuns,
+                    labels: this.labels,
+                });
+                this.workerId = this.listener.workerId;
+                const generator = this.listener.actions();
+                this.logger.info(`Worker ${this.name} listening for actions`);
+                try {
+                    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}`);
+                        void this.handleAction(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);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }
+            catch (e) {
+                if (this.killing) {
+                    this.logger.info(`Exiting worker, ignoring error: ${e.message}`);
+                    return;
+                }
+                this.logger.error(`Could not run worker: ${e.message}`);
+                throw new hatchet_error_1.default(`Could not run worker: ${e.message}`);
+            }
+        });
+    }
+    handleAction(action) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const type = action.actionType
+                ? (0, dispatcher_1.actionTypeFromJSON)(action.actionType)
+                : dispatcher_1.ActionType.START_STEP_RUN;
+            if (type === dispatcher_1.ActionType.START_STEP_RUN) {
+                yield this.handleStartStepRun(action);
+            }
+            else if (type === dispatcher_1.ActionType.CANCEL_STEP_RUN) {
+                yield this.handleCancelStepRun(action);
+            }
+            else if (type === dispatcher_1.ActionType.START_GET_GROUP_KEY) {
+                yield this.handleStartGroupKeyRun(action);
+            }
+            else {
+                this.logger.error(`Worker ${this.name} received unknown action type ${type}`);
+            }
+        });
+    }
+    upsertLabels(labels) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.labels = labels;
+            if (!this.workerId) {
+                this.logger.warn('Worker not registered.');
+                return this.labels;
+            }
+            this.client._v0.dispatcher.upsertWorkerLabels(this.workerId, labels);
+            return this.labels;
+        });
+    }
+}
+exports.V1Worker = V1Worker;
+function toPbWorkerLabel(in_) {
+    if (!in_) {
+        return {};
+    }
+    return Object.entries(in_).reduce((acc, [key, value]) => {
+        if (!value) {
+            return Object.assign(Object.assign({}, acc), { [key]: {
+                    strValue: undefined,
+                    intValue: undefined,
+                } });
+        }
+        if (typeof value === 'string') {
+            return Object.assign(Object.assign({}, acc), { [key]: {
+                    strValue: value,
+                    intValue: undefined,
+                } });
+        }
+        if (typeof value === 'number') {
+            return Object.assign(Object.assign({}, acc), { [key]: {
+                    strValue: undefined,
+                    intValue: value,
+                } });
+        }
+        return Object.assign(Object.assign({}, acc), { [key]: {
+                strValue: typeof value.value === 'string' ? value.value : undefined,
+                intValue: typeof value.value === 'number' ? value.value : undefined,
+                required: value.required,
+                weight: value.weight,
+                comparator: value.comparator,
+            } });
+    }, {});
+}
+function onFailureTaskName(workflow) {
+    return `${workflow.name}:on-failure-task`;
+}
+function getLeaves(tasks) {
+    return tasks.filter((task) => isLeafTask(task, tasks));
+}
+function isLeafTask(task, allTasks) {
+    return !allTasks.some((t) => { var _a; return (_a = t.parents) === null || _a === void 0 ? void 0 : _a.some((p) => p.name === task.name); });
+}