@hatchet-dev/typescript-sdk 1.16.0 → 1.17.1

package/v1/examples/durable_eviction/workflow.js

@@ -0,0 +1,129 @@
+"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.nonEvictableSleep = exports.capacityEvictableSleep = exports.CAPACITY_SLEEP_SECONDS = exports.evictableChildBulkSpawn = exports.bulkChildTask = exports.multipleEviction = exports.evictableChildSpawn = exports.evictableWaitForEvent = exports.evictableSleepForGracefulTermination = exports.evictableSleep = exports.childTask = exports.EVENT_KEY = exports.LONG_SLEEP_SECONDS = exports.EVICTION_TTL_SECONDS = void 0;
+const sleep_1 = __importDefault(require("../../../util/sleep"));
+const hatchet_client_1 = require("../hatchet-client");
+exports.EVICTION_TTL_SECONDS = 5;
+exports.LONG_SLEEP_SECONDS = 15;
+exports.EVENT_KEY = 'durable-eviction:event';
+const EVICTION_POLICY = {
+    ttl: `${exports.EVICTION_TTL_SECONDS}s`,
+    allowCapacityEviction: true,
+    priority: 0,
+};
+exports.childTask = hatchet_client_1.hatchet.task({
+    name: 'eviction-child-task',
+    fn: () => __awaiter(void 0, void 0, void 0, function* () {
+        yield (0, sleep_1.default)(exports.LONG_SLEEP_SECONDS * 1000);
+        return { child_status: 'completed' };
+    }),
+});
+exports.evictableSleep = hatchet_client_1.hatchet.durableTask({
+    name: 'evictable-sleep',
+    executionTimeout: '5m',
+    evictionPolicy: EVICTION_POLICY,
+    fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        yield ctx.sleepFor(`${exports.LONG_SLEEP_SECONDS}s`);
+        return { status: 'completed' };
+    }),
+});
+// NOTE: DO NOT REGISTER ON E2E TEST WORKER
+exports.evictableSleepForGracefulTermination = hatchet_client_1.hatchet.durableTask({
+    name: 'evictable-sleep-for-graceful-termination',
+    executionTimeout: '5m',
+    evictionPolicy: {
+        ttl: `30m`,
+        allowCapacityEviction: true,
+        priority: 0,
+    },
+    fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        yield ctx.sleepFor(`5m`);
+        return { status: 'completed' };
+    }),
+});
+exports.evictableWaitForEvent = hatchet_client_1.hatchet.durableTask({
+    name: 'evictable-wait-for-event',
+    executionTimeout: '5m',
+    evictionPolicy: EVICTION_POLICY,
+    fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        yield ctx.waitForEvent(exports.EVENT_KEY, 'true');
+        return { status: 'completed' };
+    }),
+});
+exports.evictableChildSpawn = hatchet_client_1.hatchet.durableTask({
+    name: 'evictable-child-spawn',
+    executionTimeout: '5m',
+    evictionPolicy: EVICTION_POLICY,
+    fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const childResult = yield exports.childTask.run({});
+        return { child: childResult, status: 'completed' };
+    }),
+});
+exports.multipleEviction = hatchet_client_1.hatchet.durableTask({
+    name: 'multiple-eviction',
+    executionTimeout: '5m',
+    evictionPolicy: EVICTION_POLICY,
+    fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        yield ctx.sleepFor(`${exports.LONG_SLEEP_SECONDS}s`);
+        yield ctx.sleepFor(`${exports.LONG_SLEEP_SECONDS}s`);
+        return { status: 'completed' };
+    }),
+});
+exports.bulkChildTask = hatchet_client_1.hatchet.task({
+    name: 'eviction-bulk-child-task',
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () {
+        yield (0, sleep_1.default)(input.sleepSeconds * 1000);
+        return { sleepSeconds: input.sleepSeconds, status: 'completed' };
+    }),
+});
+exports.evictableChildBulkSpawn = hatchet_client_1.hatchet.durableTask({
+    name: 'evictable-child-bulk-spawn',
+    executionTimeout: '5m',
+    evictionPolicy: EVICTION_POLICY,
+    fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const inputs = Array.from({ length: 3 }, (_, i) => ({
+            sleepSeconds: (exports.EVICTION_TTL_SECONDS + 5) * (i + 1),
+        }));
+        const childResults = yield exports.bulkChildTask.run(inputs);
+        return { child_results: childResults, status: 'completed' };
+    }),
+});
+exports.CAPACITY_SLEEP_SECONDS = 20;
+exports.capacityEvictableSleep = hatchet_client_1.hatchet.durableTask({
+    name: 'capacity-evictable-sleep',
+    executionTimeout: '5m',
+    evictionPolicy: {
+        ttl: undefined,
+        allowCapacityEviction: true,
+        priority: 0,
+    },
+    fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        yield ctx.sleepFor(`${exports.CAPACITY_SLEEP_SECONDS}s`);
+        return { status: 'completed' };
+    }),
+});
+exports.nonEvictableSleep = hatchet_client_1.hatchet.durableTask({
+    name: 'non-evictable-sleep',
+    executionTimeout: '5m',
+    evictionPolicy: {
+        ttl: undefined,
+        allowCapacityEviction: false,
+        priority: 0,
+    },
+    fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        yield ctx.sleepFor('10s');
+        return { status: 'completed' };
+    }),
+});

package/v1/examples/e2e-worker.js

@@ -26,16 +26,19 @@ const workflow_5 = require("./concurrency_multiple_keys/workflow");
 const workflow_6 = require("./concurrency_workflow_level/workflow");
 const workflow_7 = require("./dag/workflow");
 const workflow_8 = require("./durable/workflow");
-const workflow_9 = require("./logger/workflow");
-const workflow_10 = require("./non_retryable/workflow");
-const workflow_11 = require("./on_failure/workflow");
-const workflow_12 = require("./on_event/workflow");
-const workflow_13 = require("./return_exceptions/workflow");
-const workflow_14 = require("./run_details/workflow");
+const workflow_9 = require("./durable_event/workflow");
+const workflow_10 = require("./durable_eviction/workflow");
+const workflow_11 = require("./durable_sleep/workflow");
+const workflow_12 = require("./logger/workflow");
+const workflow_13 = require("./non_retryable/workflow");
+const workflow_14 = require("./on_failure/workflow");
+const workflow_15 = require("./on_event/workflow");
+const workflow_16 = require("./return_exceptions/workflow");
+const workflow_17 = require("./run_details/workflow");
 const e2e_workflows_1 = require("./simple/e2e-workflows");
-const workflow_15 = require("./streaming/workflow");
-const workflow_16 = require("./timeout/workflow");
-const workflow_17 = require("./webhooks/workflow");
+const workflow_18 = require("./streaming/workflow");
+const workflow_19 = require("./timeout/workflow");
+const workflow_20 = require("./webhooks/workflow");
 const workflows = [
     workflow_1.bulkChild,
     workflow_1.bulkParentWorkflow,
@@ -51,18 +54,38 @@ const workflows = [
     workflow_7.dag,
     workflow_8.durableWorkflow,
     workflow_8.waitForSleepTwice,
-    (0, workflow_9.createLoggingWorkflow)(hatchet_client_1.hatchet),
-    workflow_10.nonRetryableWorkflow,
-    workflow_11.failureWorkflow,
-    workflow_12.lower,
-    workflow_13.returnExceptionsTask,
-    workflow_14.runDetailTestWorkflow,
+    workflow_8.spawnChildTask,
+    workflow_8.durableWithSpawn,
+    workflow_8.durableWithBulkSpawn,
+    workflow_8.durableSleepEventSpawn,
+    workflow_8.durableWithExplicitSpawn,
+    workflow_8.durableNonDeterminism,
+    workflow_8.durableReplayReset,
+    workflow_8.dagChildWorkflow,
+    workflow_8.durableSpawnDag,
+    workflow_9.durableEvent,
+    workflow_9.durableEventWithFilter,
+    workflow_11.durableSleep,
+    workflow_10.evictableSleep,
+    workflow_10.evictableWaitForEvent,
+    workflow_10.evictableChildSpawn,
+    workflow_10.multipleEviction,
+    workflow_10.nonEvictableSleep,
+    workflow_10.childTask,
+    workflow_10.bulkChildTask,
+    workflow_10.evictableChildBulkSpawn,
+    (0, workflow_12.createLoggingWorkflow)(hatchet_client_1.hatchet),
+    workflow_13.nonRetryableWorkflow,
+    workflow_14.failureWorkflow,
+    workflow_15.lower,
+    workflow_16.returnExceptionsTask,
+    workflow_17.runDetailTestWorkflow,
     e2e_workflows_1.helloWorld,
     e2e_workflows_1.helloWorldDurable,
-    workflow_15.streamingTask,
-    workflow_16.timeoutTask,
-    workflow_16.refreshTimeoutTask,
-    workflow_17.webhookWorkflow,
+    workflow_18.streamingTask,
+    workflow_19.timeoutTask,
+    workflow_19.refreshTimeoutTask,
+    workflow_20.webhookWorkflow,
 ];
 function main() {
     return __awaiter(this, void 0, void 0, function* () {

package/v1/index.d.ts

@@ -9,3 +9,8 @@ export * from './task';
 export * from './client/worker/context';
 export * from './slot-types';
 export * from '../legacy/legacy-transformer';
+export { NonDeterminismError } from '../util/errors/non-determinism-error';
+export { EvictionNotSupportedError } from '../util/errors/eviction-not-supported-error';
+export { EvictionPolicy, DEFAULT_DURABLE_TASK_EVICTION_POLICY, } from './client/worker/eviction/eviction-policy';
+export { DurableEvictionConfig } from './client/worker/eviction/eviction-manager';
+export { MinEngineVersion, supportsEviction } from './client/worker/engine-version';

package/v1/index.js

@@ -14,6 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.supportsEviction = exports.MinEngineVersion = exports.DEFAULT_DURABLE_TASK_EVICTION_POLICY = exports.EvictionNotSupportedError = exports.NonDeterminismError = void 0;
 __exportStar(require("./client/client"), exports);
 __exportStar(require("./client/features"), exports);
 __exportStar(require("./client/worker/worker"), exports);
@@ -25,3 +26,12 @@ __exportStar(require("./task"), exports);
 __exportStar(require("./client/worker/context"), exports);
 __exportStar(require("./slot-types"), exports);
 __exportStar(require("../legacy/legacy-transformer"), exports);
+var non_determinism_error_1 = require("../util/errors/non-determinism-error");
+Object.defineProperty(exports, "NonDeterminismError", { enumerable: true, get: function () { return non_determinism_error_1.NonDeterminismError; } });
+var eviction_not_supported_error_1 = require("../util/errors/eviction-not-supported-error");
+Object.defineProperty(exports, "EvictionNotSupportedError", { enumerable: true, get: function () { return eviction_not_supported_error_1.EvictionNotSupportedError; } });
+var eviction_policy_1 = require("./client/worker/eviction/eviction-policy");
+Object.defineProperty(exports, "DEFAULT_DURABLE_TASK_EVICTION_POLICY", { enumerable: true, get: function () { return eviction_policy_1.DEFAULT_DURABLE_TASK_EVICTION_POLICY; } });
+var engine_version_1 = require("./client/worker/engine-version");
+Object.defineProperty(exports, "MinEngineVersion", { enumerable: true, get: function () { return engine_version_1.MinEngineVersion; } });
+Object.defineProperty(exports, "supportsEviction", { enumerable: true, get: function () { return engine_version_1.supportsEviction; } });

package/v1/parent-run-context-vars.d.ts

@@ -1,3 +1,4 @@
+import { DurableContext } from './client/worker/context';
 export interface ParentRunContext {
     parentId: string;
     /**
@@ -11,6 +12,11 @@ export interface ParentRunContext {
      * Used to cancel local "wait for result" subscriptions when the parent task is cancelled.
      */
     signal?: AbortSignal;
+    /**
+     * Present when the current task is running in durable mode.
+     * Used by child `run()` calls to route through `spawnChild` instead of a fresh trigger.
+     */
+    durableContext?: DurableContext<unknown, unknown>;
 }
 export declare class ParentRunContextManager {
     private storage;

package/v1/task.d.ts

@@ -1,8 +1,10 @@
-import { ConcurrencyLimitStrategy, RateLimitDuration, WorkerLabelComparator } from '../protoc/v1/workflows';
+import { ConcurrencyLimitStrategy, RateLimitDuration } from '../protoc/v1/workflows';
 import { Conditions } from './conditions';
 import { Duration } from './client/duration';
 import { InputType, OutputType, UnknownInputType } from './types';
 import { Context, DurableContext } from './client/worker/context';
+import { EvictionPolicy } from './client/worker/eviction/eviction-policy';
+import { WorkerLabelComparator } from '../protoc/v1/shared/trigger';
 export { ConcurrencyLimitStrategy, WorkerLabelComparator };
 /**
  * Options for configuring the concurrency for a task.
@@ -185,7 +187,13 @@ export type CreateWorkflowTaskOpts<I extends InputType = UnknownInputType, O ext
  * @template I The input type for the task function.
  * @template O The return type of the task function (can be inferred from the return value of fn).
  */
-export type CreateWorkflowDurableTaskOpts<I extends InputType = UnknownInputType, O extends OutputType = void, C extends DurableTaskFn<I, O> = DurableTaskFn<I, O>> = CreateWorkflowTaskOpts<I, O, C>;
+export type CreateWorkflowDurableTaskOpts<I extends InputType = UnknownInputType, O extends OutputType = void, C extends DurableTaskFn<I, O> = DurableTaskFn<I, O>> = CreateWorkflowTaskOpts<I, O, C> & {
+    /**
+     * Eviction policy for the durable task. Controls TTL-based eviction and capacity-based eviction.
+     * Defaults to the built-in eviction policy when omitted or `undefined`.
+     */
+    evictionPolicy?: EvictionPolicy;
+};
 /**
  * Options for configuring the onSuccess task that is invoked when a task succeeds.
  * @template I The input type for the task function.

package/v1/task.js

@@ -3,7 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.NonRetryableError = exports.WorkerLabelComparator = exports.ConcurrencyLimitStrategy = void 0;
 const workflows_1 = require("../protoc/v1/workflows");
 Object.defineProperty(exports, "ConcurrencyLimitStrategy", { enumerable: true, get: function () { return workflows_1.ConcurrencyLimitStrategy; } });
-Object.defineProperty(exports, "WorkerLabelComparator", { enumerable: true, get: function () { return workflows_1.WorkerLabelComparator; } });
+const trigger_1 = require("../protoc/v1/shared/trigger");
+Object.defineProperty(exports, "WorkerLabelComparator", { enumerable: true, get: function () { return trigger_1.WorkerLabelComparator; } });
 class NonRetryableError extends Error {
     constructor(message) {
         super(message);

package/version.d.ts

@@ -1 +1 @@
-export declare const HATCHET_VERSION = "1.16.0";
+export declare const HATCHET_VERSION = "1.17.1";

package/version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HATCHET_VERSION = void 0;
-exports.HATCHET_VERSION = '1.16.0';
+exports.HATCHET_VERSION = '1.17.1';