@hatchet-dev/typescript-sdk 1.12.0 → 1.12.1

package/v1/client/worker/worker.d.ts

@@ -5,23 +5,16 @@ import { WebhookWorkerCreateRequest } from '../../../clients/rest/generated/data
 import { BaseWorkflowDeclaration } from '../../declaration';
 import { HatchetClient } from '../..';
 import { V1Worker } from './worker-internal';
+import { type WorkerSlotOptions } from './slot-utils';
 /**
  * Options for creating a new hatchet worker
  * @interface CreateWorkerOpts
  */
-export interface CreateWorkerOpts {
-    /** (optional) Maximum number of concurrent runs on this worker, defaults to 100 */
-    slots?: number;
-    /** (optional) Array of workflows to register */
-    workflows?: BaseWorkflowDeclaration<any, any>[] | V0Workflow[];
+export interface CreateWorkerOpts extends WorkerSlotOptions {
     /** (optional) Worker labels for affinity-based assignment */
     labels?: WorkerLabels;
     /** (optional) Whether to handle kill signals */
     handleKill?: boolean;
-    /** @deprecated Use slots instead */
-    maxRuns?: number;
-    /** (optional) Maximum number of concurrent runs on the durable worker, defaults to 1,000 */
-    durableSlots?: number;
 }
 /**
  * HatchetWorker class for workflow execution runtime
@@ -32,8 +25,11 @@ export declare class Worker {
     _v1: HatchetClient;
     _v0: LegacyHatchetClient;
     /** Internal reference to the underlying V0 worker implementation */
-    nonDurable: V1Worker;
-    durable?: V1Worker;
+    _internal: V1Worker;
+    /** Set when connected to a legacy engine that needs dual-worker architecture */
+    private _legacyWorker;
+    /** Tracks all workflows registered after construction (via registerWorkflow/registerWorkflows) */
+    private _registeredWorkflows;
     /**
      * Creates a new HatchetWorker instance
      * @param nonDurable - The V0 worker implementation
@@ -63,12 +59,12 @@ export declare class Worker {
      * Starts the worker
      * @returns Promise that resolves when the worker is stopped or killed
      */
-    start(): Promise<void[]>;
+    start(): Promise<void>;
     /**
      * Stops the worker
      * @returns Promise that resolves when the worker stops
      */
-    stop(): Promise<void[]>;
+    stop(): Promise<void>;
     /**
      * Updates or inserts worker labels
      * @param labels - Worker labels to update
@@ -87,6 +83,7 @@ export declare class Worker {
      */
     registerWebhook(webhook: WebhookWorkerCreateRequest): Promise<import("axios").AxiosResponse<import("../../../clients/rest/generated/data-contracts").WebhookWorkerCreated, any, {}>>;
     isPaused(): Promise<boolean>;
-    pause(): Promise<any[]>;
-    unpause(): Promise<any[]>;
+    pause(): Promise<void> | Promise<import("../../../clients/rest/generated/data-contracts").Worker>;
+    unpause(): Promise<void> | Promise<import("../../../clients/rest/generated/data-contracts").Worker>;
 }
+export { testingExports as __testing } from './slot-utils';

package/v1/client/worker/worker.js

@@ -9,10 +9,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Worker = void 0;
+exports.__testing = exports.Worker = void 0;
 const declaration_1 = require("../../declaration");
 const worker_internal_1 = require("./worker-internal");
-const DEFAULT_DURABLE_SLOTS = 1000;
+const slot_utils_1 = require("./slot-utils");
+const deprecated_1 = require("./deprecated");
 /**
  * HatchetWorker class for workflow execution runtime
  */
@@ -22,9 +23,11 @@ class Worker {
      * @param nonDurable - The V0 worker implementation
      */
     constructor(v1, v0, nonDurable, config, name) {
+        /** Tracks all workflows registered after construction (via registerWorkflow/registerWorkflows) */
+        this._registeredWorkflows = [];
         this._v1 = v1;
         this._v0 = v0;
-        this.nonDurable = nonDurable;
+        this._internal = nonDurable;
         this.config = config;
         this.name = name;
     }
@@ -36,7 +39,8 @@ class Worker {
      */
     static create(v1, v0, name, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            const opts = Object.assign(Object.assign({ name }, options), { maxRuns: options.slots || options.maxRuns });
+            const resolvedOptions = (0, slot_utils_1.resolveWorkerOptions)(options);
+            const opts = Object.assign({ name }, resolvedOptions);
             const internalWorker = new worker_internal_1.V1Worker(v1, opts);
             const worker = new Worker(v1, v0, internalWorker, options, name);
             yield worker.registerWorkflows(options.workflows);
@@ -51,21 +55,17 @@ class Worker {
     registerWorkflows(workflows) {
         return __awaiter(this, void 0, void 0, function* () {
             for (const wf of workflows || []) {
+                this._registeredWorkflows.push(wf);
                 if (wf instanceof declaration_1.BaseWorkflowDeclaration) {
                     // TODO check if tenant is V1
-                    yield this.nonDurable.registerWorkflowV1(wf);
+                    yield this._internal.registerWorkflowV1(wf);
                     if (wf.definition._durableTasks.length > 0) {
-                        if (!this.durable) {
-                            const opts = Object.assign(Object.assign({ name: `${this.name}-durable` }, this.config), { maxRuns: this.config.durableSlots || DEFAULT_DURABLE_SLOTS });
-                            this.durable = new worker_internal_1.V1Worker(this._v1, opts);
-                            yield this.durable.registerWorkflowV1(wf, true);
-                        }
-                        this.durable.registerDurableActionsV1(wf.definition);
+                        this._internal.registerDurableActionsV1(wf.definition);
                     }
                 }
                 else {
                     // fallback to v0 client for backwards compatibility
-                    yield this.nonDurable.registerWorkflow(wf);
+                    yield this._internal.registerWorkflow(wf);
                 }
             }
         });
@@ -84,22 +84,29 @@ class Worker {
      * @returns Promise that resolves when the worker is stopped or killed
      */
     start() {
-        const workers = [this.nonDurable];
-        if (this.durable) {
-            workers.push(this.durable);
-        }
-        return Promise.all(workers.map((w) => w.start()));
+        return __awaiter(this, void 0, void 0, function* () {
+            // Check engine version and fall back to legacy dual-worker mode if needed
+            if (yield (0, deprecated_1.isLegacyEngine)(this._v1)) {
+                // Include workflows registered after construction (via registerWorkflow/registerWorkflows)
+                // so the legacy worker picks them up.
+                const legacyConfig = Object.assign(Object.assign({}, this.config), { workflows: this._registeredWorkflows.length
+                        ? this._registeredWorkflows
+                        : this.config.workflows });
+                this._legacyWorker = yield deprecated_1.LegacyDualWorker.create(this._v1, this.name, legacyConfig);
+                return this._legacyWorker.start();
+            }
+            return this._internal.start();
+        });
     }
     /**
      * Stops the worker
      * @returns Promise that resolves when the worker stops
      */
     stop() {
-        const workers = [this.nonDurable];
-        if (this.durable) {
-            workers.push(this.durable);
+        if (this._legacyWorker) {
+            return this._legacyWorker.stop();
         }
-        return Promise.all(workers.map((w) => w.stop()));
+        return this._internal.stop();
     }
     /**
      * Updates or inserts worker labels
@@ -107,14 +114,14 @@ class Worker {
      * @returns Promise that resolves when labels are updated
      */
     upsertLabels(labels) {
-        return this.nonDurable.upsertLabels(labels);
+        return this._internal.upsertLabels(labels);
     }
     /**
      * Get the labels for the worker
      * @returns The labels for the worker
      */
     getLabels() {
-        return this.nonDurable.labels;
+        return this._internal.labels;
     }
     /**
      * Register a webhook with the worker
@@ -122,44 +129,33 @@ class Worker {
      * @returns A promise that resolves when the webhook is registered
      */
     registerWebhook(webhook) {
-        return this.nonDurable.registerWebhook(webhook);
+        return this._internal.registerWebhook(webhook);
     }
     isPaused() {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            const promises = [];
-            if ((_a = this.nonDurable) === null || _a === void 0 ? void 0 : _a.workerId) {
-                promises.push(this._v1.workers.isPaused(this.nonDurable.workerId));
+            var _a;
+            if (!((_a = this._internal) === null || _a === void 0 ? void 0 : _a.workerId)) {
+                return false;
             }
-            if ((_b = this.durable) === null || _b === void 0 ? void 0 : _b.workerId) {
-                promises.push(this._v1.workers.isPaused(this.durable.workerId));
-            }
-            const res = yield Promise.all(promises);
-            return !res.includes(false);
+            return this._v1.workers.isPaused(this._internal.workerId);
         });
     }
     // TODO docstrings
     pause() {
-        var _a, _b;
-        const promises = [];
-        if ((_a = this.nonDurable) === null || _a === void 0 ? void 0 : _a.workerId) {
-            promises.push(this._v1.workers.pause(this.nonDurable.workerId));
-        }
-        if ((_b = this.durable) === null || _b === void 0 ? void 0 : _b.workerId) {
-            promises.push(this._v1.workers.pause(this.durable.workerId));
+        var _a;
+        if (!((_a = this._internal) === null || _a === void 0 ? void 0 : _a.workerId)) {
+            return Promise.resolve();
         }
-        return Promise.all(promises);
+        return this._v1.workers.pause(this._internal.workerId);
     }
     unpause() {
-        var _a, _b;
-        const promises = [];
-        if ((_a = this.nonDurable) === null || _a === void 0 ? void 0 : _a.workerId) {
-            promises.push(this._v1.workers.unpause(this.nonDurable.workerId));
-        }
-        if ((_b = this.durable) === null || _b === void 0 ? void 0 : _b.workerId) {
-            promises.push(this._v1.workers.unpause(this.durable.workerId));
+        var _a;
+        if (!((_a = this._internal) === null || _a === void 0 ? void 0 : _a.workerId)) {
+            return Promise.resolve();
         }
-        return Promise.all(promises);
+        return this._v1.workers.unpause(this._internal.workerId);
     }
 }
 exports.Worker = Worker;
+var slot_utils_2 = require("./slot-utils");
+Object.defineProperty(exports, "__testing", { enumerable: true, get: function () { return slot_utils_2.testingExports; } });

package/v1/index.d.ts

@@ -7,3 +7,4 @@ export * from './client/duration';
 export * from './types';
 export * from './task';
 export * from './client/worker/context';
+export * from './slot-types';

package/v1/index.js

@@ -23,3 +23,4 @@ __exportStar(require("./client/duration"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./task"), exports);
 __exportStar(require("./client/worker/context"), exports);
+__exportStar(require("./slot-types"), exports);

package/v1/slot-types.d.ts

@@ -0,0 +1,5 @@
+export declare enum SlotType {
+    Default = "default",
+    Durable = "durable"
+}
+export type SlotConfig = Partial<Record<SlotType, number>>;

package/v1/slot-types.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlotType = void 0;
+// eslint-disable-next-line no-shadow
+var SlotType;
+(function (SlotType) {
+    SlotType["Default"] = "default";
+    SlotType["Durable"] = "durable";
+})(SlotType || (exports.SlotType = SlotType = {}));

package/v1/task.d.ts

@@ -103,6 +103,8 @@ export type CreateBaseTaskOpts<I extends InputType = UnknownInputType, O extends
      * (optional) the concurrency options for the task
      */
     concurrency?: Concurrency | Concurrency[];
+    /** @internal */
+    slotRequests?: Record<string, number>;
 };
 export type CreateWorkflowTaskOpts<I extends InputType = UnknownInputType, O extends OutputType = void, C extends TaskFn<I, O> | DurableTaskFn<I, O> = TaskFn<I, O>> = CreateBaseTaskOpts<I, O, C> & {
     /**

package/version.d.ts

@@ -1 +1 @@
-export declare const HATCHET_VERSION = "1.12.0";
+export declare const HATCHET_VERSION = "1.12.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.12.0';
+exports.HATCHET_VERSION = '1.12.1';

package/workflow.d.ts

@@ -380,6 +380,7 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
         } | undefined;
     }[];
     id: string;
+    version?: string | undefined;
     on?: {
         cron: string;
         event?: undefined;
@@ -388,7 +389,6 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
         cron?: undefined;
     } | undefined;
     timeout?: string | undefined;
-    version?: string | undefined;
     scheduleTimeout?: string | undefined;
     sticky?: PbStickyStrategy | undefined;
     onFailure?: {
@@ -442,6 +442,7 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
         } | undefined;
     }[];
     id: string;
+    version?: string | undefined;
     on?: {
         cron: string;
         event?: undefined;
@@ -450,7 +451,6 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
         cron?: undefined;
     } | undefined;
     timeout?: string | undefined;
-    version?: string | undefined;
     scheduleTimeout?: string | undefined;
     sticky?: PbStickyStrategy | undefined;
     onFailure?: {