@hatchet-dev/typescript-sdk 1.13.1 → 1.15.0

package/{v1 → src/v1}/declaration.js

@@ -9,10 +9,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TaskWorkflowDeclaration = exports.WorkflowDeclaration = exports.BaseWorkflowDeclaration = exports.Priority = void 0;
+exports.TaskWorkflowDeclaration = exports.WorkflowDeclaration = exports.BaseWorkflowDeclaration = exports.StickyStrategy = exports.Priority = void 0;
 exports.CreateTaskWorkflow = CreateTaskWorkflow;
 exports.CreateWorkflow = CreateWorkflow;
 exports.CreateDurableTaskWorkflow = CreateDurableTaskWorkflow;
+const abort_error_1 = require("../../util/abort-error");
 const parent_run_context_vars_1 = require("./parent-run-context-vars");
 const UNBOUND_ERR = new Error('workflow unbound to hatchet client, hint: use client.run instead');
 // eslint-disable-next-line no-shadow
@@ -22,16 +23,30 @@ var Priority;
     Priority[Priority["MEDIUM"] = 2] = "MEDIUM";
     Priority[Priority["HIGH"] = 3] = "HIGH";
 })(Priority || (exports.Priority = Priority = {}));
+/**
+ * Sticky strategy for workflow scheduling.
+ *
+ * Prefer using `StickyStrategy.SOFT` / `StickyStrategy.HARD` (v1, non-protobuf).
+ * For backwards compatibility, the workflow/task `sticky` field also accepts legacy
+ * protobuf enum values (`0`/`1`) and strings (`'SOFT'`/`'HARD'`).
+ * @internal
+ */
+exports.StickyStrategy = {
+    SOFT: 'soft',
+    HARD: 'hard',
+};
 /**
  * Represents a workflow that can be executed by Hatchet.
  * @template I The input type for the workflow.
  * @template O The return type of the workflow.
+ * @internal
  */
 class BaseWorkflowDeclaration {
     /**
      * Creates a new workflow instance.
      * @param options The options for creating the workflow.
      * @param client Optional Hatchet client instance.
+     * @internal
      */
     constructor(options, client) {
         this.definition = Object.assign(Object.assign({}, options), { _tasks: [], _durableTasks: [] });
@@ -48,7 +63,18 @@ class BaseWorkflowDeclaration {
             if (!parentRunContext && ((options === null || options === void 0 ? void 0 : options.childKey) || (options === null || options === void 0 ? void 0 : options.sticky))) {
                 this.client.admin.logger.warn('ignoring childKey or sticky because run is not being spawned from a parent task');
             }
-            const runOpts = Object.assign(Object.assign({}, options), { parentId: parentRunContext === null || parentRunContext === void 0 ? void 0 : parentRunContext.parentId, parentTaskRunExternalId: parentRunContext === null || parentRunContext === void 0 ? void 0 : parentRunContext.parentTaskRunExternalId, childIndex: parentRunContext === null || parentRunContext === void 0 ? void 0 : parentRunContext.childIndex, sticky: (options === null || options === void 0 ? void 0 : options.sticky) ? parentRunContext === null || parentRunContext === void 0 ? void 0 : parentRunContext.desiredWorkerId : undefined, childKey: options === null || options === void 0 ? void 0 : options.childKey });
+            const inheritedSignal = parentRunContext === null || parentRunContext === void 0 ? void 0 : parentRunContext.signal;
+            // Precheck: if we're being called from a cancelled parent task, do not enqueue more work.
+            // The signal is inherited from the parent task's `ctx.abortController.signal`.
+            (0, abort_error_1.throwIfAborted)(inheritedSignal, {
+                isTrigger: true,
+                context: (parentRunContext === null || parentRunContext === void 0 ? void 0 : parentRunContext.parentTaskRunExternalId)
+                    ? `task run ${parentRunContext.parentTaskRunExternalId}`
+                    : undefined,
+                warn: (message) => this.client.admin.logger.warn(message),
+            });
+            parent_run_context_vars_1.parentRunContextManager.incrementChildIndex(Array.isArray(input) ? input.length : 1);
+            const runOpts = Object.assign(Object.assign({}, (options !== null && options !== void 0 ? options : {})), { parentId: parentRunContext === null || parentRunContext === void 0 ? void 0 : parentRunContext.parentId, parentTaskRunExternalId: parentRunContext === null || parentRunContext === void 0 ? void 0 : parentRunContext.parentTaskRunExternalId, childIndex: parentRunContext === null || parentRunContext === void 0 ? void 0 : parentRunContext.childIndex, sticky: (options === null || options === void 0 ? void 0 : options.sticky) ? parentRunContext === null || parentRunContext === void 0 ? void 0 : parentRunContext.desiredWorkerId : undefined, childKey: options === null || options === void 0 ? void 0 : options.childKey });
             if (Array.isArray(input)) {
                 let resp = [];
                 for (let i = 0; i < input.length; i += 500) {
@@ -74,6 +100,9 @@ class BaseWorkflowDeclaration {
                         // eslint-disable-next-line no-param-reassign
                         ref._standaloneTaskName = _standaloneTaskName;
                     }
+                    // Ensure result subscriptions inherit cancellation if no signal is provided explicitly.
+                    // eslint-disable-next-line no-param-reassign
+                    ref.defaultSignal = inheritedSignal;
                     res.push(ref);
                 });
                 return res;
@@ -82,6 +111,7 @@ class BaseWorkflowDeclaration {
             if (_standaloneTaskName) {
                 res._standaloneTaskName = _standaloneTaskName;
             }
+            res.defaultSignal = inheritedSignal;
             return res;
         });
     }
@@ -103,6 +133,17 @@ class BaseWorkflowDeclaration {
             }
             if (Array.isArray(input)) {
                 const refs = yield this.runNoWait(input, options, _standaloneTaskName);
+                if (options === null || options === void 0 ? void 0 : options.returnExceptions) {
+                    const settled = yield Promise.allSettled(refs.map((ref) => ref.result()));
+                    return settled.map((s) => {
+                        if (s.status === 'fulfilled')
+                            return s.value;
+                        const { reason } = s;
+                        if (reason instanceof Error)
+                            return reason;
+                        return new Error(Array.isArray(reason) ? reason.join('; ') : String(reason));
+                    });
+                }
                 return Promise.all(refs.map((ref) => ref.result()));
             }
             const res = yield this.runNoWait(input, options, _standaloneTaskName);
@@ -119,10 +160,16 @@ class BaseWorkflowDeclaration {
      */
     schedule(enqueueAt, input, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             if (!this.client) {
                 throw UNBOUND_ERR;
             }
-            const scheduled = this.client.scheduled.create(this.definition.name, Object.assign({ triggerAt: enqueueAt, input: input }, options));
+            // If called from within a cancelled parent task, do not enqueue scheduled work.
+            (0, abort_error_1.throwIfAborted)((_a = parent_run_context_vars_1.parentRunContextManager.getContext()) === null || _a === void 0 ? void 0 : _a.signal, {
+                isTrigger: true,
+                warn: (message) => this.client.admin.logger.warn(message),
+            });
+            const scheduled = this.client.scheduled.create(this.definition.name, Object.assign({ triggerAt: enqueueAt, input: input }, (options !== null && options !== void 0 ? options : {})));
             return scheduled;
         });
     }
@@ -152,10 +199,16 @@ class BaseWorkflowDeclaration {
      */
     cron(name, expression, input, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             if (!this.client) {
                 throw UNBOUND_ERR;
             }
-            const cronDef = this.client.crons.create(this.definition.name, Object.assign(Object.assign({ expression, input: input }, options), { additionalMetadata: options === null || options === void 0 ? void 0 : options.additionalMetadata, name }));
+            // If called from within a cancelled parent task, do not enqueue cron work.
+            (0, abort_error_1.throwIfAborted)((_a = parent_run_context_vars_1.parentRunContextManager.getContext()) === null || _a === void 0 ? void 0 : _a.signal, {
+                isTrigger: true,
+                warn: (message) => this.client.admin.logger.warn(message),
+            });
+            const cronDef = this.client.crons.create(this.definition.name, Object.assign(Object.assign({ expression, input: input }, (options !== null && options !== void 0 ? options : {})), { additionalMetadata: options === null || options === void 0 ? void 0 : options.additionalMetadata, name }));
             return cronDef;
         });
     }
@@ -231,6 +284,7 @@ class BaseWorkflowDeclaration {
     // }
     /**
      * @deprecated use definition.name instead
+     * @hidden
      */
     get id() {
         return this.definition.name;
@@ -244,6 +298,44 @@ class BaseWorkflowDeclaration {
     }
 }
 exports.BaseWorkflowDeclaration = BaseWorkflowDeclaration;
+/**
+ * A Hatchet workflow, which lets you define tasks and perform actions on the workflow.
+ *
+ * Workflows in Hatchet represent coordinated units of work that can be triggered,
+ * scheduled, or run on a cron schedule. Each workflow can contain multiple tasks
+ * that can be arranged in dependencies (DAGs), with customized retry behavior,
+ * timeouts, concurrency controls, and more.
+ *
+ * Example:
+ * ```typescript
+ * import { hatchet } from './hatchet-client';
+ *
+ * type MyInput = { name: string };
+ *
+ * const workflow = hatchet.workflow<MyInput>({
+ *   name: 'my-workflow',
+ * });
+ *
+ * workflow.task({
+ *   name: 'greet',
+ *   fn: async (input) => {
+ *     return { message: `Hello, ${input.name}!` };
+ *   },
+ * });
+ *
+ * // Run the workflow
+ * await workflow.run({ name: 'World' });
+ * ```
+ *
+ * Workflows support various execution patterns, including:
+ * - One-time execution with `run()` and `runNoWait()`
+ * - Scheduled execution with `schedule()`
+ * - Cron-based recurring execution with `cron()`
+ * - Bulk execution by passing an array input to `run()` and `runNoWait()`
+ *
+ * Tasks within workflows can be defined with `workflow.task()` or
+ * `workflow.durableTask()` and arranged into complex dependency patterns.
+ */
 class WorkflowDeclaration extends BaseWorkflowDeclaration {
     /**
      * Adds a task to the workflow.
@@ -283,7 +375,7 @@ class WorkflowDeclaration extends BaseWorkflowDeclaration {
             typedOptions = options;
         }
         if (this.definition.onFailure) {
-            (_a = this.client) === null || _a === void 0 ? void 0 : _a._v0.logger.warn(`onFailure task will override existing onFailure task`);
+            (_a = this.client) === null || _a === void 0 ? void 0 : _a.logger.warn(`onFailure task will override existing onFailure task`);
         }
         this.definition.onFailure = typedOptions;
         return typedOptions;
@@ -306,7 +398,7 @@ class WorkflowDeclaration extends BaseWorkflowDeclaration {
             typedOptions = options;
         }
         if (this.definition.onSuccess) {
-            (_a = this.client) === null || _a === void 0 ? void 0 : _a._v0.logger.warn(`onSuccess task will override existing onSuccess task`);
+            (_a = this.client) === null || _a === void 0 ? void 0 : _a.logger.warn(`onSuccess task will override existing onSuccess task`);
         }
         this.definition.onSuccess = typedOptions;
         return typedOptions;
@@ -328,10 +420,26 @@ class WorkflowDeclaration extends BaseWorkflowDeclaration {
 }
 exports.WorkflowDeclaration = WorkflowDeclaration;
 /**
- * A standalone task workflow that can be run, scheduled, or triggered via cron.
+ * A standalone task declaration that can be run like a workflow.
+ *
+ * `TaskWorkflowDeclaration` is returned by `hatchet.task(...)` and wraps a single
+ * task definition while exposing the same execution helpers as workflows, such as
+ * `run()`, `runNoWait()`, `schedule()`, and `cron()` (inherited from
+ * `BaseWorkflowDeclaration`).
+ *
+ * Example:
+ * ```typescript
+ * const greet = hatchet.task<{ name: string }, { message: string }>({
+ *   name: 'greet',
+ *   fn: async (input) => ({ message: `Hello, ${input.name}!` }),
+ * });
+ *
+ * await greet.run({ name: 'World' });
+ * const ref = await greet.runNoWait({ name: 'World' });
+ * ```
  *
- * @template I - The task-specific input type.
- * @template O - The task output type.
+ * @template I The input type for the standalone task.
+ * @template O The output type returned by the standalone task.
  * @template GlobalInput - Global input type from the client, merged into all run/schedule/cron input signatures.
  * @template MiddlewareBefore - Extra fields added to the task fn input by pre-middleware hooks.
  * @template MiddlewareAfter - Extra fields merged into the task output by post-middleware hooks.
@@ -418,7 +526,7 @@ class TaskWorkflowDeclaration extends BaseWorkflowDeclaration {
             return _super.cron.call(this, name, expression, input, options);
         });
     }
-    /** Returns the underlying task definition for this declaration. */
+    // Returns the underlying task definition for this declaration.
     get taskDef() {
         return this.definition._tasks[0];
     }

package/src/v1/examples/__e2e__/harness.d.ts

@@ -0,0 +1,19 @@
+import { HatchetClient } from '../../../../v1';
+import type { BaseWorkflowDeclaration } from '../../../../v1';
+import { Worker } from '../../client/worker/worker';
+export declare function requireEnv(name: string): string;
+export declare function makeE2EClient(): HatchetClient;
+export declare function makeTestScope(prefix?: string): string;
+export declare function startWorker({ client, name, workflows, slots, }: {
+    client: HatchetClient;
+    name: string;
+    workflows: Array<BaseWorkflowDeclaration<any, any>>;
+    slots?: number;
+}): Promise<Worker>;
+export declare function stopWorker(worker: Worker | undefined): Promise<void>;
+export declare function poll<T>(fn: () => Promise<T>, { timeoutMs, intervalMs, shouldStop, label, }: {
+    timeoutMs?: number;
+    intervalMs?: number;
+    shouldStop: (value: T) => boolean;
+    label?: string;
+}): Promise<T>;

package/src/v1/examples/__e2e__/harness.js

@@ -0,0 +1,70 @@
+"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.requireEnv = requireEnv;
+exports.makeE2EClient = makeE2EClient;
+exports.makeTestScope = makeTestScope;
+exports.startWorker = startWorker;
+exports.stopWorker = stopWorker;
+exports.poll = poll;
+const sleep_1 = __importDefault(require("../../../../util/sleep"));
+const crypto_1 = require("crypto");
+const v1_1 = require("../../../../v1");
+function requireEnv(name) {
+    const value = process.env[name];
+    if (!value) {
+        throw new Error(`Missing required environment variable ${name}. ` +
+            `E2E tests require a configured Hatchet instance and credentials.`);
+    }
+    return value;
+}
+function makeE2EClient() {
+    // ConfigLoader requires a token; this makes the failure message obvious.
+    requireEnv('HATCHET_CLIENT_TOKEN');
+    return v1_1.HatchetClient.init();
+}
+function makeTestScope(prefix = 'ts_e2e') {
+    return `${prefix}_${(0, crypto_1.randomUUID)()}`;
+}
+function startWorker(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ client, name, workflows, slots = 50, }) {
+        const worker = yield client.worker(name, { workflows, slots });
+        void worker.start();
+        yield worker.waitUntilReady(10000);
+        return worker;
+    });
+}
+function stopWorker(worker) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!worker)
+            return;
+        yield worker.stop();
+        yield (0, sleep_1.default)(300);
+    });
+}
+function poll(fn_1, _a) {
+    return __awaiter(this, arguments, void 0, function* (fn, { timeoutMs = 30000, intervalMs = 100, shouldStop, label = 'poll', }) {
+        const start = Date.now();
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const value = yield fn();
+            if (shouldStop(value))
+                return value;
+            if (Date.now() - start > timeoutMs) {
+                throw new Error(`Timed out waiting for ${label} after ${timeoutMs}ms`);
+            }
+            yield (0, sleep_1.default)(intervalMs);
+        }
+    });
+}

package/{v1 → src/v1}/examples/affinity/affinity-workers.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const workflows_1 = require("../../../protoc/workflows");
+const v1_1 = require("../../../../v1");
 const hatchet_client_1 = require("../hatchet-client");
 // > AffinityWorkflow
 const workflow = hatchet_client_1.hatchet.workflow({
@@ -22,8 +22,8 @@ workflow.task({
         const results = [];
         // eslint-disable-next-line no-plusplus
         for (let i = 0; i < 50; i++) {
-            const result = yield ctx.spawnWorkflow(childWorkflow.id, {});
-            results.push(result.output);
+            const result = yield childWorkflow.run({});
+            results.push(result);
         }
         console.log('Spawned 50 child workflows');
         console.log('Results:', yield Promise.all(results));
@@ -55,7 +55,7 @@ childWorkflow.task({
         memory: {
             value: 512,
             required: true,
-            comparator: workflows_1.WorkerLabelComparator.LESS_THAN,
+            comparator: v1_1.WorkerLabelComparator.LESS_THAN,
         },
     },
     fn: (ctx) => __awaiter(void 0, void 0, void 0, function* () {

package/src/v1/examples/bulk_fanout/workflow.d.ts

@@ -0,0 +1,9 @@
+export type ParentInput = {
+    n: number;
+};
+export declare const bulkChild: import("../..").TaskWorkflowDeclaration<{
+    i: number;
+}, {
+    i: number;
+}, {}, {}, {}, {}>;
+export declare const bulkParentWorkflow: import("../..").WorkflowDeclaration<import("../..").UnknownInputType, {}, {}>;

package/src/v1/examples/bulk_fanout/workflow.js

@@ -0,0 +1,34 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bulkParentWorkflow = exports.bulkChild = void 0;
+const hatchet_client_1 = require("../hatchet-client");
+exports.bulkChild = hatchet_client_1.hatchet.task({
+    name: 'bulk-child',
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () {
+        return { i: input.i };
+    }),
+});
+exports.bulkParentWorkflow = hatchet_client_1.hatchet.workflow({
+    name: 'bulk-parent',
+});
+exports.bulkParentWorkflow.task({
+    name: 'spawn',
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const typed = input;
+        const children = Array.from({ length: typed.n }, (_, i) => ({
+            workflow: exports.bulkChild,
+            input: { i },
+        }));
+        const results = yield ctx.bulkRunChildren(children);
+        return { results };
+    }),
+});

package/src/v1/examples/bulk_operations/workflow.d.ts

@@ -0,0 +1,3 @@
+export declare const bulkReplayTest1: import("../..").TaskWorkflowDeclaration<import("../..").UnknownInputType, void, {}, {}, {}, {}>;
+export declare const bulkReplayTest2: import("../..").TaskWorkflowDeclaration<import("../..").UnknownInputType, void, {}, {}, {}, {}>;
+export declare const bulkReplayTest3: import("../..").TaskWorkflowDeclaration<import("../..").UnknownInputType, void, {}, {}, {}, {}>;

package/src/v1/examples/bulk_operations/workflow.js

@@ -0,0 +1,44 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bulkReplayTest3 = exports.bulkReplayTest2 = exports.bulkReplayTest1 = void 0;
+/* eslint-disable no-console */
+const hatchet_client_1 = require("../hatchet-client");
+exports.bulkReplayTest1 = hatchet_client_1.hatchet.task({
+    name: 'bulk-replay-test-1',
+    retries: 1,
+    fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        console.log('retrying bulk replay test task', ctx.retryCount());
+        if (ctx.retryCount() === 0) {
+            throw new Error('This is a test error to trigger a retry.');
+        }
+    }),
+});
+exports.bulkReplayTest2 = hatchet_client_1.hatchet.task({
+    name: 'bulk-replay-test-2',
+    retries: 1,
+    fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        console.log('retrying bulk replay test task', ctx.retryCount());
+        if (ctx.retryCount() === 0) {
+            throw new Error('This is a test error to trigger a retry.');
+        }
+    }),
+});
+exports.bulkReplayTest3 = hatchet_client_1.hatchet.task({
+    name: 'bulk-replay-test-3',
+    retries: 1,
+    fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        console.log('retrying bulk replay test task', ctx.retryCount());
+        if (ctx.retryCount() === 0) {
+            throw new Error('This is a test error to trigger a retry.');
+        }
+    }),
+});

package/src/v1/examples/cancellation/cancellation-workflow.d.ts

@@ -0,0 +1,2 @@
+export declare const cancellationWorkflow: import("../..").WorkflowDeclaration<import("../..").UnknownInputType, {}, {}>;
+export declare const abortSignal: import("../..").TaskWorkflowDeclaration<import("../..").UnknownInputType, void, {}, {}, {}, {}>;

package/src/v1/examples/cancellation/cancellation-workflow.js

@@ -0,0 +1,69 @@
+"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.abortSignal = exports.cancellationWorkflow = void 0;
+const axios_1 = __importDefault(require("axios"));
+const sleep_1 = __importDefault(require("../../../../util/sleep"));
+const hatchet_client_1 = require("../hatchet-client");
+// > Self-cancelling workflow (mirrors Python example)
+exports.cancellationWorkflow = hatchet_client_1.hatchet.workflow({
+    name: 'CancelWorkflow',
+});
+exports.cancellationWorkflow.task({
+    name: 'self-cancel',
+    fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        yield (0, sleep_1.default)(2000, ctx.abortController.signal);
+        // Cancel the current task run (server-side) and optimistically abort local execution.
+        yield ctx.cancel();
+        // If cancellation didn't stop execution yet, keep waiting but cooperatively.
+        yield (0, sleep_1.default)(10000, ctx.abortController.signal);
+        return { error: 'Task should have been cancelled' };
+    }),
+});
+exports.cancellationWorkflow.task({
+    name: 'check-flag',
+    fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        for (let i = 0; i < 3; i += 1) {
+            yield (0, sleep_1.default)(1000, ctx.abortController.signal);
+            if (ctx.cancelled) {
+                throw new Error('Cancelled');
+            }
+        }
+        return { error: 'Task should have been cancelled' };
+    }),
+});
+// !!
+// > Abort Signal
+exports.abortSignal = hatchet_client_1.hatchet.task({
+    name: 'abort-signal',
+    fn: (_1, _a) => __awaiter(void 0, [_1, _a], void 0, function* (_, { abortController }) {
+        try {
+            const response = yield axios_1.default.get('https://api.example.com/data', {
+                signal: abortController.signal,
+            });
+            // Handle the response
+        }
+        catch (error) {
+            if (axios_1.default.isCancel(error)) {
+                // Request was canceled
+                console.log('Request canceled');
+            }
+            else {
+                // Handle other errors
+            }
+        }
+    }),
+});
+// !!
+// see ./worker.ts and ./run.ts for how to run the workflow

package/src/v1/examples/cancellation/run.js

@@ -0,0 +1,53 @@
+"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 });
+/* eslint-disable no-console */
+// > Running a Task with Results
+const sleep_1 = __importDefault(require("../../../../util/sleep"));
+const cancellation_workflow_1 = require("./cancellation-workflow");
+const hatchet_client_1 = require("../hatchet-client");
+// ...
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const run = yield cancellation_workflow_1.cancellationWorkflow.runNoWait({});
+        const run1 = yield cancellation_workflow_1.cancellationWorkflow.runNoWait({});
+        yield (0, sleep_1.default)(1000);
+        yield run.cancel();
+        const res = yield run.output;
+        const res1 = yield run1.output;
+        console.log('canceled', res);
+        console.log('completed', res1);
+        yield (0, sleep_1.default)(1000);
+        yield run.replay();
+        const resReplay = yield run.output;
+        console.log(resReplay);
+        const run2 = yield cancellation_workflow_1.cancellationWorkflow.runNoWait({}, { additionalMetadata: { test: 'abc' } });
+        const run4 = yield cancellation_workflow_1.cancellationWorkflow.runNoWait({}, { additionalMetadata: { test: 'test' } });
+        yield (0, sleep_1.default)(1000);
+        yield hatchet_client_1.hatchet.runs.cancel({
+            filters: {
+                since: new Date(Date.now() - 60 * 60),
+                additionalMetadata: { test: 'test' },
+            },
+        });
+        const res3 = yield Promise.all([run2.output, run4.output]);
+        console.log(res3);
+        // !!
+    });
+}
+if (require.main === module) {
+    main()
+        .catch(console.error)
+        .finally(() => process.exit(0));
+}

package/src/v1/examples/cancellation/worker.js

@@ -0,0 +1,29 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// > Declaring a Worker
+const hatchet_client_1 = require("../hatchet-client");
+const cancellation_workflow_1 = require("./cancellation-workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker = yield hatchet_client_1.hatchet.worker('cancellation-worker', {
+            // 👀 Declare the workflows that the worker can execute
+            workflows: [cancellation_workflow_1.cancellationWorkflow],
+            // 👀 Declare the number of concurrent task runs the worker can accept
+            slots: 100,
+        });
+        yield worker.start();
+    });
+}
+if (require.main === module) {
+    main();
+}
+// !!

package/{v1 → src/v1}/examples/cancellations/run.js

@@ -14,7 +14,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 /* eslint-disable no-console */
 // > Running a Task with Results
-const sleep_1 = __importDefault(require("../../../util/sleep"));
+const sleep_1 = __importDefault(require("../../../../util/sleep"));
 const workflow_1 = require("./workflow");
 const hatchet_client_1 = require("../hatchet-client");
 // ...

package/{v1 → src/v1}/examples/cancellations/workflow.js

@@ -13,7 +13,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.abortSignal = exports.cancellation = void 0;
-const sleep_1 = __importDefault(require("../../../util/sleep"));
+const sleep_1 = __importDefault(require("../../../../util/sleep"));
 const axios_1 = __importDefault(require("axios"));
 const hatchet_client_1 = require("../hatchet-client");
 // > Declaring a Task

package/{v1 → src/v1}/examples/concurrency-rr/workflow.js

@@ -10,7 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.multipleConcurrencyKeys = exports.simpleConcurrency = void 0;
-const workflow_1 = require("../../../workflow");
+const workflow_1 = require("../../../../workflow");
 const hatchet_client_1 = require("../hatchet-client");
 const sleep = (ms) => new Promise((resolve) => {
     setTimeout(resolve, ms);

package/src/v1/examples/concurrency-types.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Empty task output - satisfies JsonObject for concurrency workflows
+ * that don't return meaningful data (used for rate-limiting tests).
+ */
+export type EmptyTaskOutput = Record<string, never>;