@hatchet-dev/typescript-sdk 1.33.0 → 1.33.2

package/clients/admin/admin-client.js

@@ -26,6 +26,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AdminClient = void 0;
 const workflows_1 = require("../../protoc/workflows");
 const hatchet_error_1 = require("../../util/errors/hatchet-error");
+const v0_deprecation_warning_1 = require("../../util/v0-deprecation-warning");
 const retrier_1 = require("../../util/retrier");
 const workflow_run_ref_1 = __importDefault(require("../../util/workflow-run-ref"));
 const workflows_2 = require("../../protoc/v1/workflows");
@@ -68,6 +69,9 @@ class AdminClient {
      */
     putWorkflow(workflow) {
         return __awaiter(this, void 0, void 0, function* () {
+            // a v0 workflow definition sent straight to the engine, the one v0 use that never
+            // reaches the legacy transformer
+            (0, v0_deprecation_warning_1.emitV0RemovedWarning)('workflow');
             try {
                 return yield (0, retrier_1.retrier)(() => __awaiter(this, void 0, void 0, function* () { return this.client.putWorkflow({ opts: workflow }); }), this.logger);
             }

package/legacy/legacy-transformer.d.ts

@@ -6,7 +6,8 @@ export type { Workflow as LegacyWorkflow } from './workflow';
  */
 export declare function isLegacyWorkflow(workflow: unknown): workflow is Workflow;
 /**
- * Emits a deprecation warning for legacy workflow usage.
+ * Warns once per process that a v0 workflow is in use: the banner for the terminal and a
+ * DeprecationWarning with a stable code that Node's warning flags and handlers can filter.
  */
 export declare function warnLegacyWorkflow(): void;
 /**

package/legacy/legacy-transformer.js

@@ -6,6 +6,7 @@ exports.transformLegacyWorkflow = transformLegacyWorkflow;
 exports.normalizeWorkflow = normalizeWorkflow;
 exports.normalizeWorkflows = normalizeWorkflows;
 exports.getWorkflowName = getWorkflowName;
+const v0_deprecation_warning_1 = require("../util/v0-deprecation-warning");
 const step_1 = require("./step");
 const declaration_1 = require("../v1/declaration");
 const LEGACY_WORKFLOW_WARNING = [
@@ -34,8 +35,18 @@ function isLegacyWorkflow(workflow) {
 /**
  * Emits a deprecation warning for legacy workflow usage.
  */
+let warnedLegacyWorkflow = false;
+/**
+ * Warns once per process that a v0 workflow is in use: the banner for the terminal and a
+ * DeprecationWarning with a stable code that Node's warning flags and handlers can filter.
+ */
 function warnLegacyWorkflow() {
+    if (warnedLegacyWorkflow) {
+        return;
+    }
+    warnedLegacyWorkflow = true;
     console.warn(LEGACY_WORKFLOW_WARNING);
+    (0, v0_deprecation_warning_1.emitV0RemovedWarning)('workflow');
 }
 /**
  * Transforms a legacy v0 Workflow into a v1 WorkflowDeclaration.

package/legacy/workflow.d.ts

@@ -1,5 +1,5 @@
 import * as z from 'zod/v4';
-import { CreateStep } from '../step';
+import { CreateStep } from './step';
 import { ConcurrencyLimitStrategy as PbConcurrencyLimitStrategy, StickyStrategy as PbStickyStrategy } from '../protoc/v1/workflows';
 declare const StepsSchema: z.ZodArray<z.ZodObject<{
     name: z.ZodString;

package/legacy/workflow.js

@@ -35,7 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CreateWorkflowSchema = exports.StickyStrategy = exports.HatchetTimeoutSchema = exports.WorkflowConcurrency = exports.ConcurrencyLimitStrategy = void 0;
 const z = __importStar(require("zod/v4"));
-const step_1 = require("../step");
+const step_1 = require("./step");
 const workflows_1 = require("../protoc/v1/workflows");
 const CronConfigSchema = z.object({
     cron: z.string(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "1.33.0",
+  "version": "1.33.2",
   "engines": {
     "node": ">=20"
   },

package/protoc/dispatcher/dispatcher.d.ts

@@ -194,6 +194,8 @@ export interface AssignedAction {
     batchStartPayload?: BatchStartPayload | undefined;
     /** (optional) the partition key used for batching */
     batchKey?: string | undefined;
+    /** (optional) inserted_at of the assigned task. The DAG operator uses this to prune durable log partitions. */
+    taskInsertedAt?: Date | undefined;
 }
 export interface BatchStartPayload {
     triggerReason: string;

package/protoc/dispatcher/dispatcher.js

@@ -1281,6 +1281,7 @@ function createBaseAssignedAction() {
         batchIndex: undefined,
         batchStartPayload: undefined,
         batchKey: undefined,
+        taskInsertedAt: undefined,
     };
 }
 exports.AssignedAction = {
@@ -1369,6 +1370,9 @@ exports.AssignedAction = {
         if (message.batchKey !== undefined) {
             writer.uint32(226).string(message.batchKey);
         }
+        if (message.taskInsertedAt !== undefined) {
+            timestamp_1.Timestamp.encode(toTimestamp(message.taskInsertedAt), writer.uint32(234).fork()).join();
+        }
         return writer;
     },
     decode(input, length) {
@@ -1574,6 +1578,13 @@ exports.AssignedAction = {
                     message.batchKey = reader.string();
                     continue;
                 }
+                case 29: {
+                    if (tag !== 234) {
+                        break;
+                    }
+                    message.taskInsertedAt = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
+                    continue;
+                }
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -1702,6 +1713,11 @@ exports.AssignedAction = {
                 ? exports.BatchStartPayload.fromJSON(object.batchStartPayload)
                 : undefined,
             batchKey: isSet(object.batchKey) ? globalThis.String(object.batchKey) : undefined,
+            taskInsertedAt: isSet(object.taskInsertedAt)
+                ? fromJsonTimestamp(object.taskInsertedAt)
+                : isSet(object.task_inserted_at)
+                    ? fromJsonTimestamp(object.task_inserted_at)
+                    : undefined,
         };
     },
     toJSON(message) {
@@ -1790,13 +1806,16 @@ exports.AssignedAction = {
         if (message.batchKey !== undefined) {
             obj.batchKey = message.batchKey;
         }
+        if (message.taskInsertedAt !== undefined) {
+            obj.taskInsertedAt = message.taskInsertedAt.toISOString();
+        }
         return obj;
     },
     create(base) {
         return exports.AssignedAction.fromPartial(base !== null && base !== void 0 ? base : {});
     },
     fromPartial(object) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3;
         const message = createBaseAssignedAction();
         message.tenantId = (_a = object.tenantId) !== null && _a !== void 0 ? _a : '';
         message.workflowRunId = (_b = object.workflowRunId) !== null && _b !== void 0 ? _b : '';
@@ -1829,6 +1848,7 @@ exports.AssignedAction = {
                 ? exports.BatchStartPayload.fromPartial(object.batchStartPayload)
                 : undefined;
         message.batchKey = (_2 = object.batchKey) !== null && _2 !== void 0 ? _2 : undefined;
+        message.taskInsertedAt = (_3 = object.taskInsertedAt) !== null && _3 !== void 0 ? _3 : undefined;
         return message;
     },
 };

package/step.js

@@ -14,6 +14,4 @@ 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 });
-const v0_deprecation_warning_1 = require("./util/v0-deprecation-warning");
 __exportStar(require("./legacy/step"), exports);
-(0, v0_deprecation_warning_1.emitV0RemovedWarning)('step');

package/util/v0-deprecation-warning.d.ts

@@ -1,18 +1,11 @@
 /**
- * v0 SDK root-import deprecation warnings.
+ * The v0 SDK deprecation warning, emitted when a v0 workflow is actually used (registered on a
+ * worker or put to the engine), never when a module is merely imported: the root entry still
+ * re-exports the v0 `workflow` and `step` modules for consumers that only use v1 APIs, and
+ * loading them must stay silent.
  *
- * The legacy `workflow` and `step` re-exports under the root specifier need
- * to keep nagging consumers to migrate to v1, but the original implementation
- * used `console.warn` at module evaluation time, which:
- *   - cannot be silenced by Node's standard `--no-deprecation`,
- *     `--no-warnings`, or `--no-warnings=DeprecationWarning` flags;
- *   - has no stable `code` for `process.on('warning', ...)` handlers; and
- *   - is duplicated when both submodules are loaded (which happens for
- *     anyone importing from the root, since `index.ts` re-exports both).
- *
- * Switching to `process.emitWarning` with a fixed code makes the warnings
- * filterable, dedupable, and consistent with the rest of Node's deprecation
- * surface, while still being visible by default.
+ * `process.emitWarning` with a fixed code keeps the warning filterable with Node's standard
+ * `--no-deprecation` and `--no-warnings` flags and addressable from `process.on('warning')`.
  */
 export declare const V0_DEPRECATION_CODE = "HATCHET_V0_REMOVED";
 /** Reset hook for tests. Not part of the public API. */

package/util/v0-deprecation-warning.js

@@ -1,19 +1,12 @@
 "use strict";
 /**
- * v0 SDK root-import deprecation warnings.
+ * The v0 SDK deprecation warning, emitted when a v0 workflow is actually used (registered on a
+ * worker or put to the engine), never when a module is merely imported: the root entry still
+ * re-exports the v0 `workflow` and `step` modules for consumers that only use v1 APIs, and
+ * loading them must stay silent.
  *
- * The legacy `workflow` and `step` re-exports under the root specifier need
- * to keep nagging consumers to migrate to v1, but the original implementation
- * used `console.warn` at module evaluation time, which:
- *   - cannot be silenced by Node's standard `--no-deprecation`,
- *     `--no-warnings`, or `--no-warnings=DeprecationWarning` flags;
- *   - has no stable `code` for `process.on('warning', ...)` handlers; and
- *   - is duplicated when both submodules are loaded (which happens for
- *     anyone importing from the root, since `index.ts` re-exports both).
- *
- * Switching to `process.emitWarning` with a fixed code makes the warnings
- * filterable, dedupable, and consistent with the rest of Node's deprecation
- * surface, while still being visible by default.
+ * `process.emitWarning` with a fixed code keeps the warning filterable with Node's standard
+ * `--no-deprecation` and `--no-warnings` flags and addressable from `process.on('warning')`.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.V0_DEPRECATION_CODE = void 0;

package/v1/client/features/schedules.d.ts

@@ -1,6 +1,6 @@
 import { ScheduledWorkflows, ScheduledWorkflowsBulkDeleteFilter, ScheduledWorkflowsBulkDeleteResponse, ScheduledWorkflowsBulkUpdateResponse, ScheduledWorkflowsList } from '../../../clients/rest/generated/data-contracts';
 import { z } from 'zod/v4';
-import { Workflow } from '../../../workflow';
+import type { Workflow } from '../../../legacy/workflow';
 import { BaseWorkflowDeclaration, WorkflowDefinition } from '../..';
 import { HatchetClient } from '../client';
 import { WorkflowsClient } from './workflows';

package/v1/embedded.js

@@ -83,6 +83,46 @@ const net_1 = require("net");
 const promises_1 = require("stream/promises");
 const REPO_URL = 'https://github.com/hatchet-dev/hatchet-embedded';
 const DEFAULT_READY_TIMEOUT_MS = 300000;
+const SLOW_NOTICE_DELAY_MS = 2000;
+const HEARTBEAT_INTERVAL_MS = 30000;
+// first-contact progress goes to stderr (like the engine's own output) so it
+// never corrupts program output; warm starts print at most one line
+function logProgress(message) {
+    process.stderr.write(`hatchet embedded: ${message}\n`);
+}
+// prints startMsg only if fn is still running after SLOW_NOTICE_DELAY_MS (and
+// doneMsg once it finishes), so fast warm-start network calls stay quiet while
+// a blocked one explains what the process is waiting on
+function withSlowNotice(startMsg, doneMsg, fn) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        let noticed = false;
+        let finished = false;
+        const timer = setTimeout(() => {
+            // guards a callback already queued when fn settles, so a stale start
+            // message can never print after completion
+            if (finished) {
+                return;
+            }
+            noticed = true;
+            logProgress(startMsg);
+        }, SLOW_NOTICE_DELAY_MS);
+        (_a = timer.unref) === null || _a === void 0 ? void 0 : _a.call(timer);
+        let result;
+        try {
+            result = yield fn();
+        }
+        finally {
+            finished = true;
+            clearTimeout(timer);
+        }
+        // only reached when fn succeeded
+        if (noticed) {
+            logProgress(doneMsg);
+        }
+        return result;
+    });
+}
 function sidecarAssetName() {
     const platform = { darwin: 'darwin', linux: 'linux' }[process.platform];
     const arch = { x64: 'amd64', arm64: 'arm64' }[process.arch];
@@ -168,17 +208,18 @@ function resolveExpectedChecksum(tag, asset, binPath) {
 }
 function ensureSidecarBinary(version, checksum) {
     return __awaiter(this, void 0, void 0, function* () {
-        const tag = yield resolveVersion(version);
+        const tag = yield withSlowNotice(`resolving the latest hatchet-embedded release from ${REPO_URL}`, 'resolved the latest hatchet-embedded release', () => resolveVersion(version));
         const asset = sidecarAssetName();
         const binPath = path.join(os.homedir(), '.hatchet', 'embedded', tag, asset);
         yield fs.mkdir(path.dirname(binPath), { recursive: true });
         // verified on every start, not just at download; a cached binary that no
         // longer matches the expected checksum is re-downloaded
-        const expected = checksum !== null && checksum !== void 0 ? checksum : (yield resolveExpectedChecksum(tag, asset, binPath));
+        const expected = checksum !== null && checksum !== void 0 ? checksum : (yield withSlowNotice(`resolving the expected checksum for ${tag} (the cached checksum is used if the release cannot be reached)`, 'expected checksum resolved', () => resolveExpectedChecksum(tag, asset, binPath)));
         const cached = yield fs.access(binPath).then(() => true, () => false);
         if (cached && (yield sha256File(binPath)) === expected) {
             return binPath;
         }
+        logProgress(`downloading the embedded engine sidecar ${tag} to ${binPath} (tens of MB, cached for later runs)`);
         const url = `${REPO_URL}/releases/download/${tag}/${asset}`;
         const res = yield fetch(url);
         if (!res.ok || !res.body) {
@@ -199,12 +240,15 @@ function ensureSidecarBinary(version, checksum) {
         finally {
             yield fs.rm(tmpPath, { force: true });
         }
+        logProgress(`sidecar ${tag} downloaded`);
         return binPath;
     });
 }
 function waitForHandshake(child, handshakePath, timeoutMs) {
     return __awaiter(this, void 0, void 0, function* () {
-        const deadline = Date.now() + timeoutMs;
+        const start = Date.now();
+        const deadline = start + timeoutMs;
+        let nextHeartbeat = start + HEARTBEAT_INTERVAL_MS;
         let exited;
         child.once('exit', (code) => {
             exited = new Error(`hatchet embedded sidecar exited with code ${code} before becoming ready`);
@@ -213,6 +257,11 @@ function waitForHandshake(child, handshakePath, timeoutMs) {
             if (exited) {
                 throw exited;
             }
+            if (Date.now() >= nextHeartbeat) {
+                const elapsed = Math.round((Date.now() - start) / 1000);
+                logProgress(`still waiting for the embedded engine (${elapsed}s elapsed)`);
+                nextHeartbeat += HEARTBEAT_INTERVAL_MS;
+            }
             try {
                 const handshake = JSON.parse(yield fs.readFile(handshakePath, 'utf8'));
                 if (handshake.token) {
@@ -232,6 +281,8 @@ function waitForHandshake(child, handshakePath, timeoutMs) {
 }
 // sidecars started in this process that have not been stopped yet
 const activeSidecars = new Set();
+// the ambient-token warning is printed at most once per process
+let warnedAmbientToken = false;
 /**
  * Gracefully stops every sidecar started in this process by
  * `HatchetEmbeddedClient.init()` (or `startEmbeddedSidecar`) and resolves once
@@ -254,6 +305,10 @@ function stopEmbeddedSidecar() {
 function startEmbeddedSidecar() {
     return __awaiter(this, arguments, void 0, function* (opts = {}) {
         var _a, _b;
+        if (process.env.HATCHET_CLIENT_TOKEN && !warnedAmbientToken) {
+            warnedAmbientToken = true;
+            logProgress('warning: HATCHET_CLIENT_TOKEN is set in the environment. Hatchet clients created with the standard constructor in this process will NOT use the embedded engine; unset HATCHET_CLIENT_TOKEN for embedded runs.');
+        }
         const suppliedPath = (_a = opts.binaryPath) !== null && _a !== void 0 ? _a : process.env.HATCHET_CLIENT_EMBEDDED_BINARY_PATH;
         let binPath;
         if (suppliedPath) {
@@ -299,6 +354,9 @@ function startEmbeddedSidecar() {
         const child = (0, child_process_1.spawn)(binPath, args, { stdio: ['pipe', 'ignore', 'inherit'] });
         const killChild = () => child.kill();
         process.once('exit', killChild);
+        logProgress(opts.databaseUrl
+            ? 'starting the embedded engine'
+            : 'starting the embedded engine (first run initializes a bundled Postgres and can take a minute)');
         let handshake;
         try {
             handshake = yield waitForHandshake(child, handshakePath, (_b = opts.readyTimeoutMs) !== null && _b !== void 0 ? _b : DEFAULT_READY_TIMEOUT_MS);

package/v1/examples/concurrency-rr/workflow.js

@@ -10,7 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.multipleConcurrencyKeys = exports.simpleConcurrency = void 0;
-const workflow_1 = require("../../../workflow");
+const v1_1 = require("../..");
 const hatchet_client_1 = require("../hatchet-client");
 const sleep = (ms) => new Promise((resolve) => {
     setTimeout(resolve, ms);
@@ -20,7 +20,7 @@ exports.simpleConcurrency = hatchet_client_1.hatchet.workflow({
     name: 'simple-concurrency',
     concurrency: {
         maxRuns: 1,
-        limitStrategy: workflow_1.ConcurrencyLimitStrategy.GROUP_ROUND_ROBIN,
+        limitStrategy: v1_1.ConcurrencyLimitStrategy.GROUP_ROUND_ROBIN,
         expression: 'input.GroupKey',
     },
 });
@@ -40,12 +40,12 @@ exports.multipleConcurrencyKeys = hatchet_client_1.hatchet.workflow({
     concurrency: [
         {
             maxRuns: 1,
-            limitStrategy: workflow_1.ConcurrencyLimitStrategy.GROUP_ROUND_ROBIN,
+            limitStrategy: v1_1.ConcurrencyLimitStrategy.GROUP_ROUND_ROBIN,
             expression: 'input.Tier',
         },
         {
             maxRuns: 1,
-            limitStrategy: workflow_1.ConcurrencyLimitStrategy.GROUP_ROUND_ROBIN,
+            limitStrategy: v1_1.ConcurrencyLimitStrategy.GROUP_ROUND_ROBIN,
             expression: 'input.Account',
         },
     ],

package/version.d.ts

@@ -1 +1 @@
-export declare const HATCHET_VERSION = "1.33.0";
+export declare const HATCHET_VERSION = "1.33.2";

package/version.js

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

package/workflow.js

@@ -18,6 +18,4 @@ exports.StickyStrategy = exports.ConcurrencyLimitStrategy = void 0;
 const v1_1 = require("./v1");
 Object.defineProperty(exports, "ConcurrencyLimitStrategy", { enumerable: true, get: function () { return v1_1.ConcurrencyLimitStrategy; } });
 Object.defineProperty(exports, "StickyStrategy", { enumerable: true, get: function () { return v1_1.StickyStrategy; } });
-const v0_deprecation_warning_1 = require("./util/v0-deprecation-warning");
 __exportStar(require("./legacy/workflow"), exports);
-(0, v0_deprecation_warning_1.emitV0RemovedWarning)('workflow', 'ConcurrencyLimitStrategy and StickyStrategy have been moved to @hatchet-dev/typescript-sdk/v1.');