@hatchet-dev/typescript-sdk 1.9.4 → 1.9.5

package/clients/dispatcher/action-listener.d.ts

@@ -23,6 +23,7 @@ export declare class ActionListener {
     done: boolean;
     listenStrategy: ListenStrategy;
     heartbeat: Heartbeat;
+    abortController?: AbortController;
     constructor(client: DispatcherClient, workerId: string, retryInterval?: number, retryCount?: number);
     actions: () => AsyncGenerator<Action, void, unknown>;
     setListenStrategy(strategy: ListenStrategy): Promise<void>;

package/clients/dispatcher/action-listener.js

@@ -36,6 +36,7 @@ exports.ActionListener = void 0;
 exports.createActionKey = createActionKey;
 const dispatcher_1 = require("../../protoc/dispatcher");
 const nice_grpc_1 = require("nice-grpc");
+const abort_controller_x_1 = require("abort-controller-x");
 const sleep_1 = __importDefault(require("../../util/sleep"));
 const hatchet_error_1 = __importDefault(require("../../util/errors/hatchet-error"));
 const heartbeat_controller_1 = require("./heartbeat/heartbeat-controller");
@@ -96,6 +97,11 @@ class ActionListener {
                         }
                     }
                     catch (e) {
+                        // If the stream was aborted (e.g., during worker shutdown), exit gracefully
+                        if ((0, abort_controller_x_1.isAbortError)(e)) {
+                            client.logger.info('Listener aborted, exiting generator');
+                            break;
+                        }
                         client.logger.info('Listener error');
                         // if this is a HatchetError, we should throw this error
                         if (e instanceof hatchet_error_1.default) {
@@ -157,15 +163,21 @@ class ActionListener {
                 yield (0, sleep_1.default)(DEFAULT_ACTION_LISTENER_RETRY_INTERVAL);
             }
             try {
+                // Create a new AbortController for this connection
+                this.abortController = new AbortController();
                 if (this.listenStrategy === ListenStrategy.LISTEN_STRATEGY_V1) {
                     const result = this.client.listen({
                         workerId: this.workerId,
+                    }, {
+                        signal: this.abortController.signal,
                     });
                     this.logger.green('Connection established using LISTEN_STRATEGY_V1');
                     return result;
                 }
                 const res = this.client.listenV2({
                     workerId: this.workerId,
+                }, {
+                    signal: this.abortController.signal,
                 });
                 yield this.heartbeat.start();
                 this.logger.green('Connection established using LISTEN_STRATEGY_V2');
@@ -187,6 +199,10 @@ class ActionListener {
         return __awaiter(this, void 0, void 0, function* () {
             this.done = true;
             this.heartbeat.stop();
+            // Abort the gRPC stream to immediately cancel the generator
+            if (this.abortController) {
+                this.abortController.abort('Worker stopping');
+            }
             try {
                 return yield this.client.unsubscribe({
                     workerId: this.workerId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "1.9.4",
+  "version": "1.9.5",
   "description": "Background task orchestration & visibility for developers",
   "types": "dist/index.d.ts",
   "files": [

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

@@ -92,14 +92,18 @@ class V1Worker {
         });
     }
     registerDurableActionsV1(workflow) {
-        const newActions = workflow._durableTasks.reduce((acc, task) => {
+        const newActions = workflow._durableTasks
+            .filter((task) => !!task.fn)
+            .reduce((acc, task) => {
             acc[`${(0, apply_namespace_1.applyNamespace)(workflow.name, this.client.config.namespace).toLowerCase()}:${task.name.toLowerCase()}`] = (ctx) => task.fn(ctx.input, ctx);
             return acc;
         }, {});
         this.action_registry = Object.assign(Object.assign({}, this.action_registry), newActions);
     }
     registerActionsV1(workflow) {
-        const newActions = workflow._tasks.reduce((acc, task) => {
+        const newActions = workflow._tasks
+            .filter((task) => !!task.fn)
+            .reduce((acc, task) => {
             acc[`${workflow.name}:${task.name.toLowerCase()}`] = (ctx) => task.fn(ctx.input, ctx);
             return acc;
         }, {});

package/v1/declaration.d.ts

@@ -295,7 +295,7 @@ export declare class WorkflowDeclaration<I extends InputType = UnknownInputType,
      */
     task<Name extends string, Fn extends Name extends keyof O ? (input: I, ctx: Context<I>) => O[Name] extends OutputType ? O[Name] | Promise<O[Name]> : void : (input: I, ctx: Context<I>) => void, FnReturn = ReturnType<Fn> extends Promise<infer P> ? P : ReturnType<Fn>, TO extends OutputType = Name extends keyof O ? O[Name] extends OutputType ? O[Name] : never : FnReturn extends OutputType ? FnReturn : never>(options: (Omit<CreateWorkflowTaskOpts<I, TO>, 'fn'> & {
         name: Name;
-        fn: Fn;
+        fn?: Fn;
     }) | TaskWorkflowDeclaration<I, TO>): CreateWorkflowTaskOpts<I, TO>;
     /**
      * Adds an onFailure task to the workflow.

package/v1/examples/affinity/affinity-workers.d.ts

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

package/v1/examples/affinity/affinity-workers.js

@@ -0,0 +1,87 @@
+"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 workflows_1 = require("../../../protoc/workflows");
+const hatchet_client_1 = require("../hatchet-client");
+// > AffinityWorkflow
+const workflow = hatchet_client_1.hatchet.workflow({
+    name: 'affinity-workflow',
+    description: 'test',
+});
+workflow.task({
+    name: 'step1',
+    fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const results = [];
+        // eslint-disable-next-line no-plusplus
+        for (let i = 0; i < 50; i++) {
+            const result = yield ctx.spawnWorkflow(childWorkflow.id, {});
+            results.push(result.output);
+        }
+        console.log('Spawned 50 child workflows');
+        console.log('Results:', yield Promise.all(results));
+        return { step1: 'step1 results!' };
+    }),
+});
+// !!
+const childWorkflow = hatchet_client_1.hatchet.workflow({
+    name: 'child-affinity-workflow',
+    description: 'test',
+});
+childWorkflow.task({
+    name: 'child-step1',
+    desiredWorkerLabels: {
+        model: {
+            value: 'xyz',
+            required: true,
+        },
+    },
+    fn: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        return { childStep1: 'childStep1 results!' };
+    }),
+});
+childWorkflow.task({
+    name: 'child-step2',
+    desiredWorkerLabels: {
+        memory: {
+            value: 512,
+            required: true,
+            comparator: workflows_1.WorkerLabelComparator.LESS_THAN,
+        },
+    },
+    fn: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        return { childStep2: 'childStep2 results!' };
+    }),
+});
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // > AffinityWorker
+        const worker1 = yield hatchet_client_1.hatchet.worker('affinity-worker-1', {
+            labels: {
+                model: 'abc',
+                memory: 1024,
+            },
+        });
+        // !!
+        yield worker1.registerWorkflow(workflow);
+        yield worker1.registerWorkflow(childWorkflow);
+        worker1.start();
+        const worker2 = yield hatchet_client_1.hatchet.worker('affinity-worker-2', {
+            labels: {
+                model: 'xyz',
+                memory: 512,
+            },
+        });
+        yield worker2.registerWorkflow(workflow);
+        yield worker2.registerWorkflow(childWorkflow);
+        worker2.start();
+    });
+}
+main();

package/v1/examples/logging/byo-logger.d.ts

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

package/v1/examples/logging/byo-logger.js

@@ -0,0 +1,73 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// eslint-disable-next-line import/no-extraneous-dependencies
+const pino_1 = __importDefault(require("pino"));
+const sdk_1 = __importDefault(require("../../../sdk"));
+// > Create Pino logger
+const logger = (0, pino_1.default)();
+class PinoLogger {
+    constructor(context, logLevel = 'DEBUG') {
+        this.logLevel = logLevel;
+        this.context = context;
+    }
+    debug(message, extra) {
+        logger.debug(extra, message);
+    }
+    info(message, extra) {
+        logger.info(extra, message);
+    }
+    green(message, extra) {
+        logger.info(extra, `%c${message}`);
+    }
+    warn(message, error, extra) {
+        logger.warn(extra, `${message} ${error}`);
+    }
+    error(message, error, extra) {
+        logger.error(extra, `${message} ${error}`);
+    }
+    // optional util method
+    util(key, message, extra) {
+        // for example you may want to expose a trace method
+        if (key === 'trace') {
+            logger.info(extra, 'trace');
+        }
+    }
+}
+const hatchet = sdk_1.default.init({
+    log_level: 'DEBUG',
+    logger: (ctx, level) => new PinoLogger(ctx, level),
+});
+// !!
+// > Use the logger
+const workflow = hatchet.task({
+    name: 'byo-logger-example',
+    fn: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        // eslint-disable-next-line no-plusplus
+        for (let i = 0; i < 5; i++) {
+            logger.info(`log message ${i}`);
+        }
+        return { step1: 'completed step run' };
+    }),
+});
+// !!
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker = yield hatchet.worker('byo-logger-worker', {
+            workflows: [workflow],
+        });
+        worker.start();
+    });
+}
+main();

package/v1/examples/logging/logger.d.ts

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

package/v1/examples/logging/logger.js

@@ -0,0 +1,46 @@
+"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 hatchet_client_1 = require("../hatchet-client");
+const sleep = (ms) => new Promise((resolve) => {
+    setTimeout(resolve, ms);
+});
+// > Logger
+const workflow = hatchet_client_1.hatchet.workflow({
+    name: 'logger-example',
+    description: 'test',
+    on: {
+        event: 'user:create',
+    },
+});
+workflow.task({
+    name: 'logger-step1',
+    fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        // log in a for loop
+        // eslint-disable-next-line no-plusplus
+        for (let i = 0; i < 10; i++) {
+            ctx.logger.info(`log message ${i}`);
+            yield sleep(200);
+        }
+        return { step1: 'completed step run' };
+    }),
+});
+// !!
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker = yield hatchet_client_1.hatchet.worker('logger-worker', {
+            slots: 1,
+            workflows: [workflow],
+        });
+        yield worker.start();
+    });
+}
+main();

package/v1/examples/with_timeouts/workflow.js

@@ -13,7 +13,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.refreshTimeout = exports.withTimeouts = void 0;
-// > Declaring a Task
 const sleep_1 = __importDefault(require("../../../util/sleep"));
 const hatchet_client_1 = require("../hatchet-client");
 // > Execution Timeout

package/v1/task.d.ts

@@ -55,7 +55,7 @@ export type CreateBaseTaskOpts<I extends InputType = UnknownInputType, O extends
      * @param ctx The execution context for the task.
      * @returns The result of the task execution.
      */
-    fn: C;
+    fn?: C;
     /**
      * @deprecated use executionTimeout instead
      */

package/version.d.ts

@@ -1 +1 @@
-export declare const HATCHET_VERSION = "1.9.4";
+export declare const HATCHET_VERSION = "1.9.5";

package/version.js

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