@hatchet-dev/typescript-sdk 1.35.1 → 1.37.0

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.35.1";
+export declare const HATCHET_VERSION = "1.37.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.35.1';
+exports.HATCHET_VERSION = '1.37.0';

package/v1/examples/durable-streams/publish-latency.d.ts

@@ -1,15 +0,0 @@
-import { HatchetClient } from '../..';
-export type PublishLatencyStats = {
-    count: number;
-    avgMs: number;
-    p50Ms: number;
-    p99Ms: number;
-    maxMs: number;
-    throughputPerSec: number;
-};
-/**
- * Times `count` sequential publishes, after `warmupCount` unmeasured ones
- * absorb connection setup and topic creation.
- */
-export declare function measurePublishLatency(hatchet: HatchetClient, topic: string, payload: Uint8Array | string, count: number, warmupCount?: number): Promise<PublishLatencyStats>;
-export declare function formatPublishLatency(stats: PublishLatencyStats): string;

package/v1/examples/durable-streams/publish-latency.js

@@ -1,50 +0,0 @@
-"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.measurePublishLatency = measurePublishLatency;
-exports.formatPublishLatency = formatPublishLatency;
-const perf_hooks_1 = require("perf_hooks");
-function percentile(sorted, p) {
-    return sorted[Math.min(sorted.length - 1, Math.floor(sorted.length * p))];
-}
-/**
- * Times `count` sequential publishes, after `warmupCount` unmeasured ones
- * absorb connection setup and topic creation.
- */
-function measurePublishLatency(hatchet_1, topic_1, payload_1, count_1) {
-    return __awaiter(this, arguments, void 0, function* (hatchet, topic, payload, count, warmupCount = 5) {
-        for (let i = 0; i < warmupCount; i += 1) {
-            yield hatchet.streams.publish(topic, payload);
-        }
-        const durationsMs = [];
-        const start = perf_hooks_1.performance.now();
-        for (let i = 0; i < count; i += 1) {
-            const before = perf_hooks_1.performance.now();
-            yield hatchet.streams.publish(topic, payload);
-            durationsMs.push(perf_hooks_1.performance.now() - before);
-        }
-        const totalMs = perf_hooks_1.performance.now() - start;
-        const sorted = [...durationsMs].sort((a, b) => a - b);
-        return {
-            count,
-            avgMs: durationsMs.reduce((sum, d) => sum + d, 0) / count,
-            p50Ms: percentile(sorted, 0.5),
-            p99Ms: percentile(sorted, 0.99),
-            maxMs: sorted[sorted.length - 1],
-            throughputPerSec: (count / totalMs) * 1000,
-        };
-    });
-}
-function formatPublishLatency(stats) {
-    const fmt = (ms) => ms.toFixed(2);
-    return (`avg=${fmt(stats.avgMs)}ms p50=${fmt(stats.p50Ms)}ms p99=${fmt(stats.p99Ms)}ms ` +
-        `max=${fmt(stats.maxMs)}ms throughput=${fmt(stats.throughputPerSec)}/s`);
-}