@hatchet-dev/typescript-sdk 0.1.8 → 0.1.10

package/clients/worker/worker.d.ts

@@ -13,7 +13,6 @@ export declare class Worker {
     killing: boolean;
     handle_kill: boolean;
     action_registry: ActionRegistry;
-    concurrency_action_registry: ActionRegistry;
     listener: ActionListener | undefined;
     futures: Record<Action['stepRunId'], HatchetPromise<any>>;
     contexts: Record<Action['stepRunId'], Context<any>>;

package/clients/worker/worker.js

@@ -35,7 +35,6 @@ class Worker {
         this.client = client;
         this.name = options.name;
         this.action_registry = {};
-        this.concurrency_action_registry = {};
         process.on('SIGTERM', () => this.exitGracefully());
         process.on('SIGINT', () => this.exitGracefully());
         this.killing = false;
@@ -46,9 +45,9 @@ class Worker {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const concurrency = ((_a = workflow.concurrency) === null || _a === void 0 ? void 0 : _a.action)
+                const concurrency = ((_a = workflow.concurrency) === null || _a === void 0 ? void 0 : _a.name)
                     ? {
-                        action: `${this.serviceName}:${workflow.concurrency.action}`,
+                        action: `${this.serviceName}:${workflow.concurrency.name}`,
                         maxRuns: workflow.concurrency.maxRuns || 1,
                         limitStrategy: workflow.concurrency.limitStrategy || workflows_1.ConcurrencyLimitStrategy.CANCEL_IN_PROGRESS,
                     }
@@ -87,11 +86,8 @@ class Worker {
                 acc[`${this.serviceName}:${step.name}`] = step.run;
                 return acc;
             }, {});
-            this.concurrency_action_registry = ((_b = workflow.concurrency) === null || _b === void 0 ? void 0 : _b.action)
-                ? {
-                    [`${this.serviceName}:${workflow.concurrency.action}`]: workflow.concurrency.key,
-                }
-                : {};
+            this.action_registry = ((_b = workflow.concurrency) === null || _b === void 0 ? void 0 : _b.name)
+                ? Object.assign(Object.assign({}, this.action_registry), { [`${this.serviceName}:${workflow.concurrency.name}`]: workflow.concurrency.key }) : Object.assign({}, this.action_registry);
         });
     }
     handleStartStepRun(action) {
@@ -148,6 +144,7 @@ class Worker {
         const context = new step_1.Context(action.actionPayload);
         const key = action.getGroupKeyRunId;
         this.contexts[key] = context;
+        this.logger.debug(`Starting group key run ${key}`);
         const step = this.action_registry[actionId];
         if (!step) {
             this.logger.error(`Could not find step '${actionId}'`);
@@ -218,17 +215,26 @@ class Worker {
         };
     }
     handleCancelStepRun(action) {
-        const { stepRunId } = action;
-        const future = this.futures[stepRunId];
-        const context = this.contexts[stepRunId];
-        //  TODO send cancel signal to context
-        // if (context && context.cancel) {
-        //   context.cancel();
-        //   delete this.contexts[stepRunId];
-        // }
-        if (future) {
-            future.cancel();
-            delete this.futures[stepRunId];
+        try {
+            this.logger.info(`Cancelling step run ${action.stepRunId}`);
+            const { stepRunId } = action;
+            const future = this.futures[stepRunId];
+            const context = this.contexts[stepRunId];
+            //  TODO send cancel signal to context
+            if (context && context.controller) {
+                context.controller.abort('Cancelled by worker');
+                delete this.contexts[stepRunId];
+            }
+            if (future) {
+                future.promise.catch(() => {
+                    this.logger.info(`Cancelled step run ${action.stepRunId}`);
+                });
+                future.cancel('Cancelled by worker');
+                delete this.futures[stepRunId];
+            }
+        }
+        catch (e) {
+            this.logger.error(`Could not cancel step run: ${e.message}`);
         }
     }
     stop() {

package/index.d.ts

@@ -1,2 +1,5 @@
 import { HatchetClient as Hatchet } from './clients/hatchet-client';
+export * from './workflow';
+export * from './step';
+export * from './clients/worker';
 export default Hatchet;

package/index.js

@@ -1,4 +1,21 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 hatchet_client_1 = require("./clients/hatchet-client");
+__exportStar(require("./workflow"), exports);
+__exportStar(require("./step"), exports);
+__exportStar(require("./clients/worker"), exports);
 exports.default = hatchet_client_1.HatchetClient;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Background task orchestration & visibility for developers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/step.d.ts

@@ -22,6 +22,7 @@ interface ContextData<T = unknown> {
 }
 export declare class Context<T = unknown> {
     data: ContextData<T>;
+    controller: AbortController;
     constructor(payload: string);
     stepOutput(step: string): string;
     triggeredByEvent(): boolean;

package/step.js

@@ -37,6 +37,7 @@ exports.CreateStepSchema = z.object({
 });
 class Context {
     constructor(payload) {
+        this.controller = new AbortController();
         try {
             this.data = JSON.parse(JSON.parse(payload));
         }

package/workflow.d.ts

@@ -17,15 +17,15 @@ declare const StepsSchema: z.ZodArray<z.ZodObject<{
 export type Steps = z.infer<typeof StepsSchema>;
 export declare const ConcurrencyLimitStrategy: typeof PbConcurrencyLimitStrategy;
 export declare const WorkflowConcurrency: z.ZodObject<{
-    action: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
     maxRuns: z.ZodOptional<z.ZodNumber>;
     limitStrategy: z.ZodOptional<z.ZodNativeEnum<typeof PbConcurrencyLimitStrategy>>;
 }, "strip", z.ZodTypeAny, {
-    action?: string | undefined;
+    name: string;
     maxRuns?: number | undefined;
     limitStrategy?: PbConcurrencyLimitStrategy | undefined;
 }, {
-    action?: string | undefined;
+    name: string;
     maxRuns?: number | undefined;
     limitStrategy?: PbConcurrencyLimitStrategy | undefined;
 }>;

package/workflow.js

@@ -39,7 +39,7 @@ const OnConfigSchema = z.union([CronConfigSchema, EventConfigSchema]);
 const StepsSchema = z.array(step_1.CreateStepSchema);
 exports.ConcurrencyLimitStrategy = workflows_1.ConcurrencyLimitStrategy;
 exports.WorkflowConcurrency = z.object({
-    action: z.string().optional(),
+    name: z.string(),
     maxRuns: z.number().optional(),
     limitStrategy: z.nativeEnum(exports.ConcurrencyLimitStrategy).optional(),
 });