@hatchet-dev/typescript-sdk 1.34.0-alpha.1 → 1.34.0

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

@@ -0,0 +1,50 @@
+"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`);
+}

package/v1/examples/durable_callback_ordering/workflow.js

@@ -69,11 +69,15 @@ exports.callbackOrderingMid = hatchet_client_1.hatchet.durableTask({
         };
     }),
 });
+// The root is never evicted. The ordering property under test lives in the
+// mids, and the worker evicts one waiting run per server round trip, oldest
+// wait first: evictable roots register before every mid and would consume the
+// sweep for as long as it takes to ack all of them before any mid is reached.
 exports.callbackOrderingRoot = hatchet_client_1.hatchet.durableTask({
     name: `${WORKFLOW_PREFIX}-root`,
     executionTimeout: '10m',
     retries: 0,
-    evictionPolicy: EVICTION_POLICY,
+    evictionPolicy: { ttl: undefined, allowCapacityEviction: false, priority: 0 },
     fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
         var _a;
         const durables = (_a = input.durables) !== null && _a !== void 0 ? _a : exports.ROOT_DEFAULTS.durables;

package/version.d.ts

@@ -1 +1 @@
-export declare const HATCHET_VERSION = "1.34.0-alpha.1";
+export declare const HATCHET_VERSION = "1.34.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.34.0-alpha.1';
+exports.HATCHET_VERSION = '1.34.0';