@hatchet-dev/typescript-sdk 1.34.1 → 1.35.1

package/clients/dispatcher/action-listener.js

@@ -225,8 +225,6 @@ class ActionListener {
             }
         });
     }
-    // Leaves the heartbeat running: tasks that are already in flight still need
-    // the engine to see this worker as alive until they finish.
     stopStream() {
         this.done = true;
         // Abort the gRPC stream to immediately cancel the generator

package/package.json

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

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

@@ -1,6 +1,17 @@
 import { BaseWorkflowDeclaration, WorkflowDefinition } from '../..';
 import type { LegacyWorkflow } from '../../../legacy/legacy-transformer';
+import { WorkflowPauseScheduledCronRunQueueBehavior } from '../../../clients/rest/generated/data-contracts';
 import { HatchetClient } from '../client';
+import { Duration } from '../duration';
+export { WorkflowPauseScheduledCronRunQueueBehavior };
+export type PauseWorkflowOpts = {
+    /** How long runs stay queued while the workflow is paused before they are dropped. */
+    queueTTL: Duration;
+    /** The behavior of cron runs triggered while the workflow is paused. Defaults to QUEUE. */
+    pausedWorkflowCronRunQueueBehavior?: WorkflowPauseScheduledCronRunQueueBehavior;
+    /** The behavior of scheduled runs triggered while the workflow is paused. Defaults to QUEUE. */
+    pausedWorkflowScheduledRunQueueBehavior?: WorkflowPauseScheduledCronRunQueueBehavior;
+};
 export declare const workflowNameString: (workflow: string | WorkflowDefinition | BaseWorkflowDeclaration<any, any> | LegacyWorkflow) => string;
 /**
  * The workflows client is a client for managing workflows programmatically within Hatchet.
@@ -39,4 +50,18 @@ export declare class WorkflowsClient {
      * @returns A promise that resolves to the deleted workflow.
      */
     delete(workflow: string | BaseWorkflowDeclaration<any, any> | LegacyWorkflow): Promise<void>;
+    /**
+     * Pause a workflow. While paused, new runs of the workflow are queued but not started.
+     * @param workflow - The workflow name, ID, or object.
+     * @param opts - The options for the pause operation.
+     * @returns A promise that resolves to the updated workflow.
+     */
+    pause(workflow: string | BaseWorkflowDeclaration<any, any> | LegacyWorkflow, opts: PauseWorkflowOpts): Promise<import("../../../clients/rest/generated/data-contracts").Workflow>;
+    /**
+     * Unpause a workflow.
+     * @param workflow - The workflow name, ID, or object.
+     * @returns A promise that resolves to the updated workflow.
+     */
+    unpause(workflow: string | BaseWorkflowDeclaration<any, any> | LegacyWorkflow): Promise<import("../../../clients/rest/generated/data-contracts").Workflow>;
+    private update;
 }

package/v1/client/features/workflows.js

@@ -9,9 +9,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WorkflowsClient = exports.workflowNameString = void 0;
+exports.WorkflowsClient = exports.workflowNameString = exports.WorkflowPauseScheduledCronRunQueueBehavior = void 0;
 const legacy_transformer_1 = require("../../../legacy/legacy-transformer");
 const uuid_1 = require("../../../util/uuid");
+const data_contracts_1 = require("../../../clients/rest/generated/data-contracts");
+Object.defineProperty(exports, "WorkflowPauseScheduledCronRunQueueBehavior", { enumerable: true, get: function () { return data_contracts_1.WorkflowPauseScheduledCronRunQueueBehavior; } });
+const duration_1 = require("../duration");
 const workflowNameString = (workflow) => {
     if (typeof workflow === 'string') {
         return workflow;
@@ -148,5 +151,50 @@ class WorkflowsClient {
             }
         });
     }
+    /**
+     * Pause a workflow. While paused, new runs of the workflow are queued but not started.
+     * @param workflow - The workflow name, ID, or object.
+     * @param opts - The options for the pause operation.
+     * @returns A promise that resolves to the updated workflow.
+     */
+    pause(workflow, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            return this.update(workflow, {
+                pause: {
+                    action: 'pause',
+                    pausedWorkflowQueueTTL: (0, duration_1.durationToString)(opts.queueTTL),
+                    pausedWorkflowCronRunQueueBehavior: (_a = opts.pausedWorkflowCronRunQueueBehavior) !== null && _a !== void 0 ? _a : data_contracts_1.WorkflowPauseScheduledCronRunQueueBehavior.QUEUE,
+                    pausedWorkflowScheduledRunQueueBehavior: (_b = opts.pausedWorkflowScheduledRunQueueBehavior) !== null && _b !== void 0 ? _b : data_contracts_1.WorkflowPauseScheduledCronRunQueueBehavior.QUEUE,
+                },
+            });
+        });
+    }
+    /**
+     * Unpause a workflow.
+     * @param workflow - The workflow name, ID, or object.
+     * @returns A promise that resolves to the updated workflow.
+     */
+    unpause(workflow) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.update(workflow, { pause: { action: 'unpause' } });
+        });
+    }
+    update(workflow, request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const name = (0, exports.workflowNameString)(workflow);
+            const workflowId = yield this.getWorkflowIdFromName(name);
+            try {
+                const { data } = yield this.api.workflowUpdate(workflowId, request);
+                this.workflowCache.delete(name);
+                this.workflowCache.delete(data.name);
+                return data;
+            }
+            catch (error) {
+                this.workflowCache.delete(name);
+                throw error;
+            }
+        });
+    }
 }
 exports.WorkflowsClient = WorkflowsClient;

package/v1/client/worker/worker-internal.js

@@ -639,7 +639,7 @@ class InternalWorker {
     }
     shutdown() {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
+            var _a;
             this.killing = true;
             this.setStatus(health_server_1.workerStatus.UNHEALTHY);
             this.logger.info('Starting to exit...');
@@ -670,15 +670,17 @@ class InternalWorker {
             catch (e) {
                 this.logger.error(`Could not stop durable listener: ${e.message}`);
             }
-            (_a = this.listener) === null || _a === void 0 ? void 0 : _a.stopStream();
             this.logger.info('Gracefully exiting hatchet worker, running tasks will attempt to finish...');
-            // attempt to wait for futures to finish
-            yield Promise.all(Object.values(this.futures).map(({ promise }) => promise));
+            // Awaits the underlying work rather than the cancelable wrapper, which rejects as soon as a
+            // cancellation arrives while the task is still winding down.
+            yield Promise.allSettled(Object.values(this.futures).map(({ inner }) => inner));
             this.logger.info('Successfully finished pending tasks.');
-            // Unregistering stops the heartbeat, so it has to wait until the running tasks are done:
-            // otherwise the engine sees a dead worker and reassigns tasks that are about to complete.
+            // Unregistering closes the action stream and stops the heartbeat, so it has to wait until
+            // the running tasks are done. Stopping the heartbeat earlier lets the engine treat the worker
+            // as dead and reassign tasks that are about to complete, and closing the stream earlier makes
+            // the engine reject every heartbeat sent while those tasks finish.
             try {
-                yield ((_b = this.listener) === null || _b === void 0 ? void 0 : _b.unregister());
+                yield ((_a = this.listener) === null || _a === void 0 ? void 0 : _a.unregister());
             }
             catch (e) {
                 this.logger.error(`Could not unregister listener: ${e.message}`);

package/v1/declaration.d.ts

@@ -12,6 +12,7 @@ import { IHatchetClient } from './client/client.interface';
 import { CreateWorkflowTaskOpts, CreateOnFailureTaskOpts, TaskFn, CreateWorkflowDurableTaskOpts, CreateBaseTaskOpts, CreateOnSuccessTaskOpts, Concurrency, DurableTaskFn, WorkerLabelComparator, IdempotencyConfig, BatchTaskConfig, BatchTaskFn } from './task';
 import { Duration } from './client/duration';
 import { MetricsClient } from './client/features/metrics';
+import type { PauseWorkflowOpts } from './client/features/workflows';
 import { InputType, OutputType, UnknownInputType, JsonObject, Resolved } from './types';
 import { Context, DurableContext } from './client/worker/context';
 import { EvictionPolicy } from './client/worker/eviction/eviction-policy';
@@ -374,6 +375,19 @@ export declare class BaseWorkflowDeclaration<I extends InputType = UnknownInputT
      * @throws Error if the workflow is not bound to a Hatchet client.
      */
     get(): Promise<import("../clients/rest/generated/data-contracts").Workflow>;
+    /**
+     * Pause the workflow. While paused, new runs of the workflow are queued but not started.
+     * @param opts - The options for the pause operation.
+     * @returns A promise that resolves to the updated workflow.
+     * @throws Error if the workflow is not bound to a Hatchet client.
+     */
+    pause(opts: PauseWorkflowOpts): Promise<import("../clients/rest/generated/data-contracts").Workflow>;
+    /**
+     * Unpause the workflow.
+     * @returns A promise that resolves to the updated workflow.
+     * @throws Error if the workflow is not bound to a Hatchet client.
+     */
+    unpause(): Promise<import("../clients/rest/generated/data-contracts").Workflow>;
     /**
      * @deprecated use definition.name instead
      * @hidden

package/v1/declaration.js

@@ -379,27 +379,29 @@ class BaseWorkflowDeclaration {
         }
         return this.client.workflows.get(this);
     }
-    // // gets the pause state of the workflow
-    // isPaused() {
-    //   if (!this.client) {
-    //     throw UNBOUND_ERR;
-    //   }
-    //   return this.client.workflows.isPaused(this);
-    // }
-    // // pause assignment of workflow
-    // pause() {
-    //   if (!this.client) {
-    //     throw UNBOUND_ERR;
-    //   }
-    //   return this.client.workflows.pause(this);
-    // }
-    // // unpause assignment of workflow
-    // unpause() {
-    //   if (!this.client) {
-    //     throw UNBOUND_ERR;
-    //   }
-    //   return this.client.workflows.unpause(this);
-    // }
+    /**
+     * Pause the workflow. While paused, new runs of the workflow are queued but not started.
+     * @param opts - The options for the pause operation.
+     * @returns A promise that resolves to the updated workflow.
+     * @throws Error if the workflow is not bound to a Hatchet client.
+     */
+    pause(opts) {
+        if (!this.client) {
+            throw UNBOUND_ERR;
+        }
+        return this.client.workflows.pause(this, opts);
+    }
+    /**
+     * Unpause the workflow.
+     * @returns A promise that resolves to the updated workflow.
+     * @throws Error if the workflow is not bound to a Hatchet client.
+     */
+    unpause() {
+        if (!this.client) {
+            throw UNBOUND_ERR;
+        }
+        return this.client.workflows.unpause(this);
+    }
     /**
      * @deprecated use definition.name instead
      * @hidden

package/v1/examples/workflow_pause/pause.d.ts

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

package/v1/examples/workflow_pause/pause.js

@@ -0,0 +1,35 @@
+"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 v1_1 = require("../..");
+const hatchet_client_1 = require("../hatchet-client");
+const pausableWorkflow = hatchet_client_1.hatchet.workflow({
+    name: 'pausable-workflow',
+});
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // > Pause a workflow
+        yield pausableWorkflow.pause({
+            queueTTL: '24h',
+            pausedWorkflowCronRunQueueBehavior: v1_1.WorkflowPauseScheduledCronRunQueueBehavior.DROP,
+            pausedWorkflowScheduledRunQueueBehavior: v1_1.WorkflowPauseScheduledCronRunQueueBehavior.QUEUE,
+        });
+        // !!
+        // > Unpause a workflow
+        yield pausableWorkflow.unpause();
+        // !!
+    });
+}
+if (require.main === module) {
+    main()
+        .catch(console.error)
+        .finally(() => process.exit(0));
+}

package/version.d.ts

@@ -1 +1 @@
-export declare const HATCHET_VERSION = "1.34.1";
+export declare const HATCHET_VERSION = "1.35.1";

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.1';
+exports.HATCHET_VERSION = '1.35.1';