@hatchet-dev/typescript-sdk 1.36.0 → 1.38.0

package/v1/examples/retry_after/workflow.js

@@ -0,0 +1,40 @@
+"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.retryAfterExponentialBackoff = exports.retryAfterUpstreamDelay = void 0;
+const task_1 = require("../../task");
+const hatchet_client_1 = require("../hatchet-client");
+// > Retry after an upstream-provided delay
+exports.retryAfterUpstreamDelay = hatchet_client_1.hatchet.task({
+    name: 'retry-after-upstream-delay',
+    retries: 5,
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        if (ctx.retryCount() < input.failingAttempts) {
+            throw new task_1.RetryAfterError('upstream rate limited', { after: '2s' });
+        }
+        return { attempt: ctx.retryCount() };
+    }),
+});
+// !!
+// > Exponential backoff with full jitter
+exports.retryAfterExponentialBackoff = hatchet_client_1.hatchet.task({
+    name: 'retry-after-exponential-backoff',
+    retries: 3,
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        if (ctx.retryCount() < input.failingAttempts) {
+            throw new task_1.RetryAfterError('upstream unavailable', {
+                after: Math.random() * Math.min(2 ** ctx.retryCount(), 60) * 1000,
+            });
+        }
+        return { attempt: ctx.retryCount() };
+    }),
+});
+// !!

package/v1/task.d.ts

@@ -96,6 +96,19 @@ export type IdempotencyConfig = TTLBasedIdempotencyConfig | StatusBasedIdempoten
 export declare class NonRetryableError extends Error {
     constructor(message?: string);
 }
+export type RetryAfterOpts = {
+    /**
+     * The delay before the next attempt, e.g. `'90s'`, `{ minutes: 5 }`, or a number of milliseconds.
+     */
+    after: Duration;
+};
+/**
+ * Throw from a task to retry it after a delay of its choosing. The retry counts against the task's `retries`.
+ */
+export declare class RetryAfterError extends Error {
+    readonly afterMs: number;
+    constructor(message: string | undefined, opts: RetryAfterOpts);
+}
 export type TaskFn<I extends InputType = UnknownInputType, O extends OutputType = void, C = Context<I>> = (input: I, ctx: C) => O | Promise<O>;
 export type DurableTaskFn<I extends InputType = UnknownInputType, O extends OutputType = void> = TaskFn<I, O, DurableContext<I>>;
 /**

package/v1/task.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NonRetryableError = exports.WorkerLabelComparator = exports.ConcurrencyLimitStrategy = void 0;
+exports.RetryAfterError = 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; } });
+const duration_1 = require("./client/duration");
 const trigger_1 = require("../protoc/v1/shared/trigger");
 Object.defineProperty(exports, "WorkerLabelComparator", { enumerable: true, get: function () { return trigger_1.WorkerLabelComparator; } });
 class NonRetryableError extends Error {
@@ -13,3 +14,15 @@ class NonRetryableError extends Error {
     }
 }
 exports.NonRetryableError = NonRetryableError;
+/**
+ * Throw from a task to retry it after a delay of its choosing. The retry counts against the task's `retries`.
+ */
+class RetryAfterError extends Error {
+    constructor(message, opts) {
+        super(message);
+        this.name = 'RetryAfterError';
+        this.afterMs = Math.max(Math.round((0, duration_1.durationToMs)(opts.after)), 0);
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.RetryAfterError = RetryAfterError;

package/version.d.ts

@@ -1 +1 @@
-export declare const HATCHET_VERSION = "1.36.0";
+export declare const HATCHET_VERSION = "1.38.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.36.0';
+exports.HATCHET_VERSION = '1.38.0';