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

package/v1/client/worker/context.js

@@ -0,0 +1,512 @@
+"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.DurableContext = exports.Context = void 0;
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable max-classes-per-file */
+const declaration_1 = require("../../declaration");
+const hatchet_error_1 = __importDefault(require("../../../util/errors/hatchet-error"));
+const parse_1 = require("../../../util/parse");
+const conditions_1 = require("../../conditions");
+const transformer_1 = require("../../conditions/transformer");
+const condition_1 = require("../../../protoc/v1/shared/condition");
+const step_1 = require("../../../step");
+class Context {
+    constructor(action, v1, worker) {
+        // @deprecated use ctx.abortController instead
+        this.controller = new AbortController();
+        this.overridesData = {};
+        this.spawnIndex = 0;
+        try {
+            const data = (0, parse_1.parseJSON)(action.actionPayload);
+            this.data = data;
+            this.action = action;
+            this.v1 = v1;
+            this.worker = new step_1.ContextWorker(worker);
+            this.logger = v1.config.logger(`Context Logger`, v1.config.log_level);
+            // if this is a getGroupKeyRunId, the data is the workflow input
+            if (action.getGroupKeyRunId !== '') {
+                this.input = data;
+            }
+            else {
+                this.input = data.input;
+            }
+            this.overridesData = data.overrides || {};
+        }
+        catch (e) {
+            throw new hatchet_error_1.default(`Could not parse payload: ${e.message}`);
+        }
+    }
+    get abortController() {
+        return this.controller;
+    }
+    get cancelled() {
+        return this.controller.signal.aborted;
+    }
+    /**
+     * Retrieves the output of a parent task.
+     * @param parentTask - The a CreateTaskOpts or string of the parent task name.
+     * @returns The output of the specified parent task.
+     * @throws An error if the task output is not found.
+     */
+    parentOutput(parentTask) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // NOTE: parentOutput is async since we plan on potentially making this a cacheable server call
+            if (typeof parentTask !== 'string') {
+                return this.parentOutput(parentTask.name);
+            }
+            if (!this.data.parents) {
+                throw new hatchet_error_1.default('Parent task outputs not found');
+            }
+            if (!this.data.parents[parentTask]) {
+                throw new hatchet_error_1.default(`Output for parent task '${parentTask}' not found`);
+            }
+            return this.data.parents[parentTask];
+        });
+    }
+    /**
+     * Returns errors from any task runs in the workflow.
+     * @returns A record mapping task names to error messages.
+     * @throws A warning if no errors are found (this method should be used in on-failure tasks).
+     * @deprecated use ctx.errors() instead
+     */
+    stepRunErrors() {
+        return this.errors();
+    }
+    /**
+     * Returns errors from any task runs in the workflow.
+     * @returns A record mapping task names to error messages.
+     * @throws A warning if no errors are found (this method should be used in on-failure tasks).
+     */
+    errors() {
+        const errors = this.data.step_run_errors || {};
+        if (Object.keys(errors).length === 0) {
+            this.logger.error('No run errors found. `ctx.errors` is intended to be run in an on-failure task, and will only work on engine versions more recent than v0.53.10');
+        }
+        return errors;
+    }
+    /**
+     * Gets the dag conditional triggers for the current workflow run.
+     * @returns The triggers for the current workflow.
+     */
+    triggers() {
+        return this.data.triggers;
+    }
+    /**
+     * Determines if the workflow was triggered by an event.
+     * @returns True if the workflow was triggered by an event, otherwise false.
+     */
+    triggeredByEvent() {
+        var _a;
+        return ((_a = this.data) === null || _a === void 0 ? void 0 : _a.triggered_by) === 'event';
+    }
+    /**
+     * Gets the name of the current workflow.
+     * @returns The name of the workflow.
+     */
+    workflowName() {
+        return this.action.jobName;
+    }
+    /**
+     * Gets the user data associated with the workflow.
+     * @returns The user data.
+     */
+    userData() {
+        var _a;
+        return (_a = this.data) === null || _a === void 0 ? void 0 : _a.user_data;
+    }
+    /**
+     * Gets the name of the current running task.
+     * @returns The name of the task.
+     */
+    taskName() {
+        return this.action.stepName;
+    }
+    /**
+     * Gets the ID of the current workflow run.
+     * @returns The workflow run ID.
+     */
+    workflowRunId() {
+        return this.action.workflowRunId;
+    }
+    /**
+     * Gets the ID of the current task run.
+     * @returns The task run ID.
+     */
+    taskRunId() {
+        return this.action.stepRunId;
+    }
+    /**
+     * Gets the number of times the current task has been retried.
+     * @returns The retry count.
+     */
+    retryCount() {
+        return this.action.retryCount;
+    }
+    /**
+     * Logs a message from the current task.
+     * @param message - The message to log.
+     * @param level - The log level (optional).
+     */
+    log(message, level) {
+        const { stepRunId } = this.action;
+        if (!stepRunId) {
+            // log a warning
+            this.logger.warn('cannot log from context without stepRunId');
+            return;
+        }
+        // FIXME: this is a hack to get around the fact that the log level is not typed
+        this.v1.event.putLog(stepRunId, message, level);
+    }
+    /**
+     * Refreshes the timeout for the current task.
+     * @param incrementBy - The interval by which to increment the timeout.
+     * The interval should be specified in the format of '10s' for 10 seconds, '1m' for 1 minute, or '1d' for 1 day.
+     */
+    refreshTimeout(incrementBy) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { stepRunId } = this.action;
+            if (!stepRunId) {
+                // log a warning
+                this.logger.warn('cannot refresh timeout from context without stepRunId');
+                return;
+            }
+            yield this.v1._v0.dispatcher.refreshTimeout(incrementBy, stepRunId);
+        });
+    }
+    /**
+     * Releases a worker slot for a task run such that the worker can pick up another task.
+     * Note: this is an advanced feature that may lead to unexpected behavior if used incorrectly.
+     * @returns A promise that resolves when the slot has been released.
+     */
+    releaseSlot() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.v1._v0.dispatcher.client.releaseSlot({
+                stepRunId: this.action.stepRunId,
+            });
+        });
+    }
+    /**
+     * Streams data from the current task run.
+     * @param data - The data to stream (string or binary).
+     * @returns A promise that resolves when the data has been streamed.
+     */
+    putStream(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { stepRunId } = this.action;
+            if (!stepRunId) {
+                // log a warning
+                this.logger.warn('cannot log from context without stepRunId');
+                return;
+            }
+            yield this.v1._v0.event.putStream(stepRunId, data);
+        });
+    }
+    spawnOptions(workflow, options) {
+        let workflowName;
+        if (typeof workflow === 'string') {
+            workflowName = workflow;
+        }
+        else {
+            workflowName = workflow.id;
+        }
+        const opts = options || {};
+        const { sticky } = opts;
+        if (sticky && !this.worker.hasWorkflow(workflowName)) {
+            throw new hatchet_error_1.default(`Cannot run with sticky: workflow ${workflowName} is not registered on the worker`);
+        }
+        const { workflowRunId, stepRunId } = this.action;
+        const finalOpts = Object.assign(Object.assign({}, options), { parentId: workflowRunId, parentStepRunId: stepRunId, childIndex: this.spawnIndex, desiredWorkerId: sticky ? this.worker.id() : undefined });
+        this.spawnIndex += 1;
+        return { workflowName, opts: finalOpts };
+    }
+    spawn(workflow, input, options) {
+        const { workflowName, opts } = this.spawnOptions(workflow, options);
+        return this.v1.admin.runWorkflow(workflowName, input, opts);
+    }
+    spawnBulk(children) {
+        const workflows = children.map((child) => {
+            const { workflowName, opts } = this.spawnOptions(child.workflow, child.options);
+            return { workflowName, input: child.input, options: opts };
+        });
+        return this.v1.admin.runWorkflows(workflows);
+    }
+    /**
+     * Runs multiple children workflows in parallel without waiting for their results.
+     * @param children - An array of  objects containing the workflow name, input data, and options for each workflow.
+     * @returns A list of workflow run references to the enqueued runs.
+     */
+    bulkRunNoWaitChildren(children) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.spawnBulk(children);
+        });
+    }
+    /**
+     * Runs multiple children workflows in parallel and waits for all results.
+     * @param children - An array of objects containing the workflow name, input data, and options for each workflow.
+     * @returns A list of results from the children workflows.
+     */
+    bulkRunChildren(children) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const runs = yield this.bulkRunNoWaitChildren(children);
+            return Promise.all(runs.map((run) => run.output));
+        });
+    }
+    /**
+     * Runs a new workflow and waits for its result.
+     *
+     * @param workflow - The workflow to run (name, Workflow instance, or WorkflowV1 instance).
+     * @param input - The input data for the workflow.
+     * @param options - An options object containing key, sticky, priority, and additionalMetadata.
+     * @returns The result of the workflow.
+     */
+    runChild(workflow, input, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const run = yield this.spawn(workflow, input, options);
+            return run.output;
+        });
+    }
+    /**
+     * Enqueues a new workflow without waiting for its result.
+     *
+     * @param workflow - The workflow to enqueue (name, Workflow instance, or WorkflowV1 instance).
+     * @param input - The input data for the workflow.
+     * @param options - An options object containing key, sticky, priority, and additionalMetadata.
+     * @returns A reference to the spawned workflow run.
+     */
+    runNoWaitChild(workflow, input, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.spawn(workflow, input, options);
+        });
+    }
+    /**
+     * Retrieves additional metadata associated with the current workflow run.
+     * @returns A record of metadata key-value pairs.
+     */
+    additionalMetadata() {
+        if (!this.action.additionalMetadata) {
+            return {};
+        }
+        // parse the additional metadata
+        const res = (0, parse_1.parseJSON)(this.action.additionalMetadata);
+        return res;
+    }
+    /**
+     * Gets the index of this workflow if it was spawned as part of a bulk operation.
+     * @returns The child index number, or undefined if not set.
+     */
+    childIndex() {
+        return this.action.childWorkflowIndex;
+    }
+    /**
+     * Gets the key associated with this workflow if it was spawned as a child workflow.
+     * @returns The child key, or undefined if not set.
+     */
+    childKey() {
+        return this.action.childWorkflowKey;
+    }
+    /**
+     * Gets the ID of the parent workflow run if this workflow was spawned as a child.
+     * @returns The parent workflow run ID, or undefined if not a child workflow.
+     */
+    parentWorkflowRunId() {
+        return this.action.parentWorkflowRunId;
+    }
+    priority() {
+        switch (this.action.priority) {
+            case 1:
+                return declaration_1.Priority.LOW;
+            case 2:
+                return declaration_1.Priority.MEDIUM;
+            case 3:
+                return declaration_1.Priority.HIGH;
+            default:
+                return undefined;
+        }
+    }
+    // FIXME: drop these at some point soon
+    /**
+     * Get the output of a task.
+     * @param task - The name of the task to get the output for.
+     * @returns The output of the task.
+     * @throws An error if the task output is not found.
+     * @deprecated use ctx.parentOutput instead
+     */
+    stepOutput(step) {
+        if (!this.data.parents) {
+            throw new hatchet_error_1.default('Parent task outputs not found');
+        }
+        if (!this.data.parents[step]) {
+            throw new hatchet_error_1.default(`Output for parent task '${step}' not found`);
+        }
+        return this.data.parents[step];
+    }
+    /**
+     * Gets the input data for the current workflow.
+     * @returns The input data for the workflow.
+     * @deprecated use task input parameter instead
+     */
+    workflowInput() {
+        return this.input;
+    }
+    /**
+     * Gets the name of the current task.
+     * @returns The name of the task.
+     * @deprecated use ctx.taskName instead
+     */
+    stepName() {
+        return this.taskName();
+    }
+    /**
+     * Spawns multiple workflows.
+     *
+     * @param workflows - An array of objects containing the workflow name, input data, and options for each workflow.
+     * @returns A list of references to the spawned workflow runs.
+     * @deprecated Use bulkRunNoWaitChildren or bulkRunChildren instead.
+     */
+    spawnWorkflows(workflows) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { workflowRunId, stepRunId } = this.action;
+            const workflowRuns = workflows.map(({ workflow, input, options }) => {
+                let workflowName;
+                if (typeof workflow === 'string') {
+                    workflowName = workflow;
+                }
+                else {
+                    workflowName = workflow.id;
+                }
+                const name = this.v1.config.namespace + workflowName;
+                const opts = options || {};
+                const { sticky } = opts;
+                if (sticky && !this.worker.hasWorkflow(name)) {
+                    throw new hatchet_error_1.default(`Cannot run with sticky: workflow ${name} is not registered on the worker`);
+                }
+                const resp = {
+                    workflowName: name,
+                    input,
+                    options: Object.assign(Object.assign({}, opts), { parentId: workflowRunId, parentStepRunId: stepRunId, childIndex: this.spawnIndex, desiredWorkerId: sticky ? this.worker.id() : undefined }),
+                };
+                this.spawnIndex += 1;
+                return resp;
+            });
+            try {
+                const batchSize = 10;
+                let resp = [];
+                for (let i = 0; i < workflowRuns.length; i += batchSize) {
+                    const batch = workflowRuns.slice(i, i + batchSize);
+                    const batchResp = yield this.v1._v0.admin.runWorkflows(batch);
+                    resp = resp.concat(batchResp);
+                }
+                const res = [];
+                resp.forEach((ref, index) => {
+                    const wf = workflows[index].workflow;
+                    if (wf instanceof declaration_1.TaskWorkflowDeclaration) {
+                        // eslint-disable-next-line no-param-reassign
+                        ref._standalone_task_name = wf._standalone_task_name;
+                    }
+                    res.push(ref);
+                });
+                return resp;
+            }
+            catch (e) {
+                throw new hatchet_error_1.default(e.message);
+            }
+        });
+    }
+    /**
+     * Spawns a new workflow.
+     *
+     * @param workflow - The workflow to spawn (name, Workflow instance, or WorkflowV1 instance).
+     * @param input - The input data for the workflow.
+     * @param options - Additional options for spawning the workflow.
+     * @returns A reference to the spawned workflow run.
+     * @deprecated Use runChild or runNoWaitChild instead.
+     */
+    spawnWorkflow(workflow, input, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { workflowRunId, stepRunId } = this.action;
+            let workflowName = '';
+            if (typeof workflow === 'string') {
+                workflowName = workflow;
+            }
+            else {
+                workflowName = workflow.id;
+            }
+            const name = this.v1.config.namespace + workflowName;
+            const opts = options || {};
+            const { sticky } = opts;
+            if (sticky && !this.worker.hasWorkflow(name)) {
+                throw new hatchet_error_1.default(`cannot run with sticky: workflow ${name} is not registered on the worker`);
+            }
+            try {
+                const resp = yield this.v1._v0.admin.runWorkflow(name, input, Object.assign({ parentId: workflowRunId, parentStepRunId: stepRunId, childIndex: this.spawnIndex, desiredWorkerId: sticky ? this.worker.id() : undefined }, opts));
+                this.spawnIndex += 1;
+                if (workflow instanceof declaration_1.TaskWorkflowDeclaration) {
+                    resp._standalone_task_name = workflow._standalone_task_name;
+                }
+                return resp;
+            }
+            catch (e) {
+                throw new hatchet_error_1.default(e.message);
+            }
+        });
+    }
+}
+exports.Context = Context;
+class DurableContext extends Context {
+    constructor() {
+        super(...arguments);
+        this.waitKey = 0;
+    }
+    /**
+     * Pauses execution for the specified duration.
+     * Duration is "global" meaning it will wait in real time regardless of transient failures like worker restarts.
+     * @param duration - The duration to sleep for.
+     * @returns A promise that resolves when the sleep duration has elapsed.
+     */
+    sleepFor(duration, readableDataKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.waitFor({ sleepFor: duration, readableDataKey });
+        });
+    }
+    /**
+     * Pauses execution until the specified conditions are met.
+     * Conditions are "global" meaning they will wait in real time regardless of transient failures like worker restarts.
+     * @param conditions - The conditions to wait for.
+     * @returns A promise that resolves with the event that satisfied the conditions.
+     */
+    waitFor(conditions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pbConditions = (0, transformer_1.conditionsToPb)((0, conditions_1.Render)(condition_1.Action.CREATE, conditions));
+            // eslint-disable-next-line no-plusplus
+            const key = `waitFor-${this.waitKey++}`;
+            yield this.v1._v0.durableListener.registerDurableEvent({
+                taskId: this.action.stepRunId,
+                signalKey: key,
+                sleepConditions: pbConditions.sleepConditions,
+                userEventConditions: pbConditions.userEventConditions,
+            });
+            const listener = this.v1._v0.durableListener.subscribe({
+                taskId: this.action.stepRunId,
+                signalKey: key,
+            });
+            const event = yield listener.get();
+            // Convert event.data from Uint8Array to string if needed
+            const eventData = event.data instanceof Uint8Array ? new TextDecoder().decode(event.data) : event.data;
+            const res = JSON.parse(eventData);
+            return res.CREATE;
+        });
+    }
+}
+exports.DurableContext = DurableContext;

package/v1/client/worker/worker-internal.d.ts

@@ -0,0 +1,62 @@
+import { Action, ActionListener } from '../../../clients/dispatcher/action-listener';
+import { StepActionEvent, StepActionEventType, GroupKeyActionEvent, GroupKeyActionEventType } from '../../../protoc/dispatcher';
+import HatchetPromise from '../../../util/hatchet-promise/hatchet-promise';
+import { Workflow } from '../../../workflow';
+import { Logger } from '../../../util/logger';
+import { WebhookWorkerCreateRequest } from '../../../clients/rest/generated/data-contracts';
+import { BaseWorkflowDeclaration, WorkflowDefinition } from '../../declaration';
+import { HatchetClient } from '../..';
+import { WorkerLabels } from '../../../clients/dispatcher/dispatcher-client';
+import { StepRunFunction } from '../../../step';
+import { Context } from './context';
+export type ActionRegistry = Record<Action['actionId'], Function>;
+export interface WorkerOpts {
+    name: string;
+    handleKill?: boolean;
+    maxRuns?: number;
+    labels?: WorkerLabels;
+}
+export declare class V1Worker {
+    client: HatchetClient;
+    name: string;
+    workerId: string | undefined;
+    killing: boolean;
+    handle_kill: boolean;
+    action_registry: ActionRegistry;
+    workflow_registry: Array<WorkflowDefinition | Workflow>;
+    listener: ActionListener | undefined;
+    futures: Record<Action['stepRunId'], HatchetPromise<any>>;
+    contexts: Record<Action['stepRunId'], Context<any, any>>;
+    maxRuns?: number;
+    logger: Logger;
+    registeredWorkflowPromises: Array<Promise<any>>;
+    labels: WorkerLabels;
+    constructor(client: HatchetClient, options: {
+        name: string;
+        handleKill?: boolean;
+        maxRuns?: number;
+        labels?: WorkerLabels;
+    });
+    private registerActions;
+    getHandler(workflows: Workflow[]): void;
+    registerWebhook(webhook: WebhookWorkerCreateRequest): Promise<import("axios").AxiosResponse<import("../../../clients/rest/generated/data-contracts").WebhookWorkerCreated, any>>;
+    /**
+     * @deprecated use registerWorkflow instead
+     */
+    register_workflow(initWorkflow: Workflow): Promise<void>;
+    registerDurableActionsV1(workflow: WorkflowDefinition): void;
+    private registerActionsV1;
+    registerWorkflowV1(initWorkflow: BaseWorkflowDeclaration<any, any>): Promise<void>;
+    registerWorkflow(initWorkflow: Workflow): Promise<void>;
+    registerAction<T, K>(actionId: string, action: StepRunFunction<T, K>): void;
+    handleStartStepRun(action: Action): Promise<void>;
+    handleStartGroupKeyRun(action: Action): Promise<void>;
+    getStepActionEvent(action: Action, eventType: StepActionEventType, shouldNotRetry: boolean, payload?: any, retryCount?: number): StepActionEvent;
+    getGroupKeyActionEvent(action: Action, eventType: GroupKeyActionEventType, payload?: any): GroupKeyActionEvent;
+    handleCancelStepRun(action: Action): Promise<void>;
+    stop(): Promise<void>;
+    exitGracefully(handleKill: boolean): Promise<void>;
+    start(): Promise<void>;
+    handleAction(action: Action): Promise<void>;
+    upsertLabels(labels: WorkerLabels): Promise<WorkerLabels>;
+}