@hatchet-dev/typescript-sdk 1.13.0 → 1.14.0

package/v1/examples/run_details/workflow.js

@@ -0,0 +1,65 @@
+"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.runDetailTestWorkflow = void 0;
+const sleep_1 = __importDefault(require("../../../util/sleep"));
+const hatchet_client_1 = require("../hatchet-client");
+exports.runDetailTestWorkflow = hatchet_client_1.hatchet.workflow({
+    name: 'run-detail-test',
+});
+const step1 = exports.runDetailTestWorkflow.task({
+    name: 'step1',
+    fn: () => __awaiter(void 0, void 0, void 0, function* () {
+        return ({
+            random_number: Math.floor(Math.random() * 100) + 1,
+        });
+    }),
+});
+const step2 = exports.runDetailTestWorkflow.task({
+    name: 'step2',
+    fn: () => __awaiter(void 0, void 0, void 0, function* () {
+        yield (0, sleep_1.default)(5000);
+        return {
+            random_number: Math.floor(Math.random() * 100) + 1,
+        };
+    }),
+});
+exports.runDetailTestWorkflow.task({
+    name: 'cancel_step',
+    fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        yield ctx.cancel();
+        yield (0, sleep_1.default)(10000);
+        return {};
+    }),
+});
+exports.runDetailTestWorkflow.task({
+    name: 'fail_step',
+    fn: () => __awaiter(void 0, void 0, void 0, function* () {
+        throw new Error('Intentional Failure');
+    }),
+});
+const step3 = exports.runDetailTestWorkflow.task({
+    name: 'step3',
+    parents: [step1, step2],
+    fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const one = (yield ctx.parentOutput(step1)).random_number;
+        const two = (yield ctx.parentOutput(step2)).random_number;
+        return { sum: one + two };
+    }),
+});
+exports.runDetailTestWorkflow.task({
+    name: 'step4',
+    parents: [step1, step3],
+    fn: () => __awaiter(void 0, void 0, void 0, function* () { return ({ step4: 'step4' }); }),
+});

package/v1/examples/simple/e2e-workflows.d.ts

@@ -0,0 +1,14 @@
+export declare const helloWorld: import("../..").TaskWorkflowDeclaration<{
+    [x: string]: import("../..").JsonValue;
+} & {
+    [x: string]: import("../..").JsonValue;
+}, {
+    result: string;
+}, {}, {}, {}, {}>;
+export declare const helloWorldDurable: import("../..").TaskWorkflowDeclaration<{
+    [x: string]: import("../..").JsonValue;
+} & {
+    [x: string]: import("../..").JsonValue;
+}, {
+    result: string;
+}, {}, {}, {}, {}>;

package/v1/examples/simple/e2e-workflows.js

@@ -0,0 +1,27 @@
+"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.helloWorldDurable = exports.helloWorld = void 0;
+const hatchet_client_1 = require("../hatchet-client");
+// Mirrors `sdks/python/examples/simple/worker.py` outputs for e2e.
+exports.helloWorld = hatchet_client_1.hatchet.task({
+    name: 'hello-world',
+    fn: (_input) => __awaiter(void 0, void 0, void 0, function* () {
+        return { result: 'Hello, world!' };
+    }),
+});
+exports.helloWorldDurable = hatchet_client_1.hatchet.durableTask({
+    name: 'hello-world-durable',
+    executionTimeout: '10m',
+    fn: (_input) => __awaiter(void 0, void 0, void 0, function* () {
+        return { result: 'Hello, world!' };
+    }),
+});

package/v1/examples/simple/enqueue.js

@@ -29,11 +29,11 @@ function main() {
         // !!
         // > Subscribing to results
         // the return object of the enqueue method is a WorkflowRunRef which includes a listener for the result of the workflow
-        const result = yield run.result();
+        const result = yield run.output;
         console.log(result);
         // if you need to subscribe to the result of the workflow at a later time, you can use the runRef method and the stored runId
         const ref = hatchet_client_1.hatchet.runRef(runId);
-        const result2 = yield ref.result();
+        const result2 = yield ref.output;
         console.log(result2);
         // !!
     });

package/v1/examples/sticky/workflow.js

@@ -11,14 +11,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sticky = void 0;
 /* eslint-disable no-console */
-const workflows_1 = require("../../../protoc/workflows");
+const v1_1 = require("../..");
 const hatchet_client_1 = require("../hatchet-client");
 const workflow_1 = require("../child_workflows/workflow");
 // > Sticky Task
 exports.sticky = hatchet_client_1.hatchet.task({
     name: 'sticky',
     retries: 3,
-    sticky: workflows_1.StickyStrategy.SOFT,
+    sticky: v1_1.StickyStrategy.SOFT,
     fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
         // specify a child workflow to run on the same worker
         const result = yield workflow_1.child.run({

package/v1/examples/timeout/run.d.ts

@@ -0,0 +1 @@
+export {};

package/v1/examples/timeout/run.js

@@ -0,0 +1,30 @@
+"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 });
+/* eslint-disable no-console */
+const workflow_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield workflow_1.timeoutTask.run({ Message: 'hello' });
+        }
+        catch (e) {
+            console.log('timeoutTask failed as expected', e);
+        }
+        const res = yield workflow_1.refreshTimeoutTask.run({ Message: 'hello' });
+        console.log(res);
+    });
+}
+if (require.main === module) {
+    main()
+        .catch(console.error)
+        .finally(() => process.exit(0));
+}

package/v1/examples/timeout/worker.d.ts

@@ -0,0 +1 @@
+export {};

package/v1/examples/timeout/worker.js

@@ -0,0 +1,25 @@
+"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 });
+const hatchet_client_1 = require("../hatchet-client");
+const workflow_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker = yield hatchet_client_1.hatchet.worker('timeout-worker', {
+            workflows: [workflow_1.timeoutTask, workflow_1.refreshTimeoutTask],
+            slots: 50,
+        });
+        yield worker.start();
+    });
+}
+if (require.main === module) {
+    main();
+}

package/v1/examples/timeout/workflow.d.ts

@@ -0,0 +1,10 @@
+export type SimpleInput = {
+    Message: string;
+};
+export declare const timeoutTask: import("../..").TaskWorkflowDeclaration<SimpleInput, {
+    status: string;
+}, {}, {}, {}, {}>;
+export declare const refreshTimeoutTask: import("../..").TaskWorkflowDeclaration<SimpleInput, {
+    status: string;
+    message: string;
+}, {}, {}, {}, {}>;

package/v1/examples/timeout/workflow.js

@@ -0,0 +1,56 @@
+"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.refreshTimeoutTask = exports.timeoutTask = void 0;
+const sleep_1 = __importDefault(require("../../../util/sleep"));
+const hatchet_client_1 = require("../hatchet-client");
+// > Execution Timeout
+// Mirrors Python `examples/timeout/test_timeout.py::test_execution_timeout`
+exports.timeoutTask = hatchet_client_1.hatchet.task({
+    name: 'timeout',
+    executionTimeout: '3s',
+    fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            yield (0, sleep_1.default)(10 * 1000, ctx.abortController.signal);
+        }
+        catch (_a) {
+            throw new Error('Task was cancelled');
+        }
+        return {
+            status: 'success',
+        };
+    }),
+});
+// !!
+// > Refresh Timeout
+// Mirrors Python `examples/timeout/test_timeout.py::test_run_refresh_timeout`
+exports.refreshTimeoutTask = hatchet_client_1.hatchet.task({
+    name: 'refresh-timeout',
+    executionTimeout: '3s',
+    scheduleTimeout: '5s',
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        ctx.refreshTimeout('5s');
+        try {
+            yield (0, sleep_1.default)(4000, ctx.abortController.signal);
+        }
+        catch (_a) {
+            throw new Error('cancelled');
+        }
+        return {
+            status: 'success',
+            message: input.Message.toLowerCase(),
+        };
+    }),
+});
+// !!

package/v1/examples/webhooks/workflow.d.ts

@@ -0,0 +1,5 @@
+export type WebhookInput = {
+    type: string;
+    message: string;
+};
+export declare const webhookWorkflow: import("../..").WorkflowDeclaration<WebhookInput, {}, {}>;

package/v1/examples/webhooks/workflow.js

@@ -0,0 +1,23 @@
+"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.webhookWorkflow = void 0;
+const hatchet_client_1 = require("../hatchet-client");
+exports.webhookWorkflow = hatchet_client_1.hatchet.workflow({
+    name: 'webhook-workflow',
+    onEvents: ['webhook:test'],
+});
+exports.webhookWorkflow.task({
+    name: 'webhook-task',
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () {
+        return input;
+    }),
+});

package/v1/index.d.ts

@@ -8,3 +8,4 @@ export * from './types';
 export * from './task';
 export * from './client/worker/context';
 export * from './slot-types';
+export * from '../legacy/legacy-transformer';

package/v1/index.js

@@ -24,3 +24,4 @@ __exportStar(require("./types"), exports);
 __exportStar(require("./task"), exports);
 __exportStar(require("./client/worker/context"), exports);
 __exportStar(require("./slot-types"), exports);
+__exportStar(require("../legacy/legacy-transformer"), exports);

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

@@ -6,10 +6,16 @@ export interface ParentRunContext {
     parentTaskRunExternalId: string;
     desiredWorkerId: string;
     childIndex?: number;
+    /**
+     * (optional) AbortSignal inherited by nested `run()` calls.
+     * Used to cancel local "wait for result" subscriptions when the parent task is cancelled.
+     */
+    signal?: AbortSignal;
 }
 export declare class ParentRunContextManager {
     private storage;
     constructor();
+    runWithContext<T>(opts: ParentRunContext, fn: () => T): T;
     setContext(opts: ParentRunContext): void;
     setParentRunIdAndIncrementChildIndex(opts: ParentRunContext): void;
     incrementChildIndex(n: number): void;

package/v1/parent-run-context-vars.js

@@ -6,6 +6,9 @@ class ParentRunContextManager {
     constructor() {
         this.storage = new async_hooks_1.AsyncLocalStorage();
     }
+    runWithContext(opts, fn) {
+        return this.storage.run(Object.assign({}, opts), fn);
+    }
     setContext(opts) {
         this.storage.enterWith(Object.assign({}, opts));
     }

package/v1/task.d.ts

@@ -1,9 +1,9 @@
-import { ConcurrencyLimitStrategy } from '../protoc/v1/workflows';
-import { CreateStep } from '../step';
+import { ConcurrencyLimitStrategy, RateLimitDuration, WorkerLabelComparator } 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';
+export { ConcurrencyLimitStrategy, WorkerLabelComparator };
 /**
  * Options for configuring the concurrency for a task.
  */
@@ -59,7 +59,7 @@ export type CreateBaseTaskOpts<I extends InputType = UnknownInputType, O extends
     /**
      * @deprecated use executionTimeout instead
      */
-    timeout?: CreateStep<I, O>['timeout'];
+    timeout?: Duration;
     /**
      * (optional) execution timeout duration for the task after it starts running
      * go duration format (e.g., "1s", "5m", "1h").
@@ -79,17 +79,27 @@ export type CreateBaseTaskOpts<I extends InputType = UnknownInputType, O extends
      *
      * default: 0
      */
-    retries?: CreateStep<I, O>['retries'];
+    retries?: number;
     /**
      * (optional) backoff strategy configuration for retries.
      * - factor: Base of the exponential backoff (base ^ retry count)
      * - maxSeconds: Maximum backoff duration in seconds
      */
-    backoff?: CreateStep<I, O>['backoff'];
+    backoff?: {
+        factor?: number | undefined;
+        maxSeconds?: number | undefined;
+    };
     /**
      * (optional) rate limits for the task.
      */
-    rateLimits?: CreateStep<I, O>['rate_limits'];
+    rateLimits?: {
+        units: string | number;
+        key?: string;
+        staticKey?: string;
+        dynamicKey?: string;
+        limit?: string | number;
+        duration?: RateLimitDuration;
+    }[];
     /**
      * (optional) worker labels for task routing and scheduling.
      * Each label can be a simple string/number value or an object with additional configuration:
@@ -98,7 +108,12 @@ export type CreateBaseTaskOpts<I extends InputType = UnknownInputType, O extends
      * - weight: Priority weight for worker selection
      * - comparator: Custom comparison logic for label matching
      */
-    desiredWorkerLabels?: CreateStep<I, O>['worker_labels'];
+    desiredWorkerLabels?: Record<string, {
+        value: string | number;
+        required?: boolean;
+        weight?: number;
+        comparator?: WorkerLabelComparator;
+    }>;
     /**
      * (optional) the concurrency options for the task
      */

package/v1/task.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NonRetryableError = void 0;
+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; } });
 class NonRetryableError extends Error {
     constructor(message) {
         super(message);

package/version.d.ts

@@ -1 +1 @@
-export declare const HATCHET_VERSION = "1.13.0";
+export declare const HATCHET_VERSION = "1.14.0";

package/version.js

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