@hatchet-dev/typescript-sdk 0.12.5 → 0.13.0

package/clients/worker/worker.js

@@ -57,8 +57,9 @@ class Worker {
             }
             : {};
         this.action_registry = Object.assign(Object.assign(Object.assign({}, this.action_registry), newActions), onFailureAction);
-        this.action_registry = ((_a = workflow.concurrency) === null || _a === void 0 ? void 0 : _a.name)
-            ? Object.assign(Object.assign({}, this.action_registry), { [`${workflow.id}:${workflow.concurrency.name}`]: workflow.concurrency.key }) : Object.assign({}, this.action_registry);
+        this.action_registry =
+            ((_a = workflow.concurrency) === null || _a === void 0 ? void 0 : _a.name) && workflow.concurrency.key
+                ? Object.assign(Object.assign({}, this.action_registry), { [`${workflow.id}:${workflow.concurrency.name}`]: workflow.concurrency.key }) : Object.assign({}, this.action_registry);
     }
     getHandler(workflows) {
         for (const workflow of workflows) {
@@ -82,13 +83,19 @@ class Worker {
     }
     registerWorkflow(initWorkflow) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
+            var _a, _b, _c, _d;
             const workflow = Object.assign(Object.assign({}, initWorkflow), { id: this.client.config.namespace + initWorkflow.id });
             try {
-                const concurrency = ((_a = workflow.concurrency) === null || _a === void 0 ? void 0 : _a.name)
+                if (((_a = workflow.concurrency) === null || _a === void 0 ? void 0 : _a.key) && workflow.concurrency.expression) {
+                    throw new hatchet_error_1.default('Cannot have both key function and expression in workflow concurrency configuration');
+                }
+                const concurrency = ((_b = workflow.concurrency) === null || _b === void 0 ? void 0 : _b.name) || ((_c = workflow.concurrency) === null || _c === void 0 ? void 0 : _c.expression)
                     ? {
-                        action: `${workflow.id}:${workflow.concurrency.name}`,
+                        action: !workflow.concurrency.expression
+                            ? `${workflow.id}:${workflow.concurrency.name}`
+                            : undefined,
                         maxRuns: workflow.concurrency.maxRuns || 1,
+                        expression: workflow.concurrency.expression,
                         limitStrategy: workflow.concurrency.limitStrategy || workflows_1.ConcurrencyLimitStrategy.CANCEL_IN_PROGRESS,
                     }
                     : undefined;
@@ -105,7 +112,7 @@ class Worker {
                                 parents: [],
                                 userData: '{}',
                                 retries: workflow.onFailure.retries || 0,
-                                rateLimits: (_b = workflow.onFailure.rate_limits) !== null && _b !== void 0 ? _b : [],
+                                rateLimits: (_d = workflow.onFailure.rate_limits) !== null && _d !== void 0 ? _d : [],
                                 workerLabels: {}, // no worker labels for on failure steps
                             },
                         ],

package/examples/concurrency/group-round-robin/{concurrency-worker.js → concurrency-worker-expression.js}

@@ -26,7 +26,7 @@ const workflow = {
     },
     concurrency: {
         name: 'user-concurrency',
-        key: (ctx) => ctx.workflowInput().group,
+        expression: 'input.group',
         maxRuns: 2,
         limitStrategy: workflow_1.ConcurrencyLimitStrategy.GROUP_ROUND_ROBIN,
     },

package/examples/concurrency/group-round-robin/concurrency-worker-key-fn.d.ts

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

package/examples/concurrency/group-round-robin/concurrency-worker-key-fn.js

@@ -0,0 +1,62 @@
+"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 });
+const sdk_1 = __importDefault(require("../../../sdk"));
+const workflow_1 = require("../../../workflow");
+const hatchet = sdk_1.default.init();
+const sleep = (ms) => new Promise((resolve) => {
+    setTimeout(resolve, ms);
+});
+const workflow = {
+    id: 'concurrency-example-rr',
+    description: 'test',
+    on: {
+        event: 'concurrency:create',
+    },
+    concurrency: {
+        name: 'user-concurrency',
+        // NOTE: it is recommended to use expression unless you specifically need to use a custom key function
+        key: (ctx) => ctx.workflowInput().group,
+        maxRuns: 2,
+        limitStrategy: workflow_1.ConcurrencyLimitStrategy.GROUP_ROUND_ROBIN,
+    },
+    steps: [
+        {
+            name: 'step1',
+            run: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+                const { data } = ctx.workflowInput();
+                const { signal } = ctx.controller;
+                if (signal.aborted)
+                    throw new Error('step1 was aborted');
+                console.log('starting step1 and waiting 5 seconds...', data);
+                yield sleep(2000);
+                if (signal.aborted)
+                    throw new Error('step1 was aborted');
+                // NOTE: the AbortController signal can be passed to many http libraries to cancel active requests
+                // fetch(url, { signal })
+                // axios.get(url, { signal })
+                console.log('executed step1!');
+                return { step1: `step1 results for ${data}!` };
+            }),
+        },
+    ],
+};
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker = yield hatchet.worker('example-worker');
+        yield worker.registerWorkflow(workflow);
+        worker.start();
+    });
+}
+main();

package/examples/fanout-worker.js

@@ -29,7 +29,9 @@ const parentWorkflow = {
             timeout: '10s',
             run: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
                 ctx.putStream('spawning children');
-                const promises = Array.from({ length: 7 }, (_, i) => ctx.spawnWorkflow('child-workflow', { input: `child-input-${i}` }, { additionalMetadata: { childKey: "childValue" } }).result());
+                const promises = Array.from({ length: 7 }, (_, i) => ctx
+                    .spawnWorkflow('child-workflow', { input: `child-input-${i}` }, { additionalMetadata: { childKey: 'childValue' } })
+                    .result());
                 const results = yield Promise.all(promises);
                 console.log('spawned workflow results:', results);
                 console.log('number of spawned workflows:', results.length);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "0.12.5",
+  "version": "0.13.0",
   "description": "Background task orchestration & visibility for developers",
   "types": "dist/index.d.ts",
   "files": [
@@ -46,7 +46,7 @@
     "worker:dag": "npm run exec -- ./src/examples/dag-worker.ts",
     "worker:concurrency": "npm run exec -- ./src/examples/concurrency/cancel-in-progress/concurrency-worker.ts",
     "event:concurrency": "npm run exec -- ./src/examples/concurrency/cancel-in-progress/concurrency-event.ts",
-    "worker:concurrency:rr": "npm run exec -- ./src/examples/concurrency/group-round-robin/concurrency-worker.ts",
+    "worker:concurrency:rr": "npm run exec -- ./src/examples/concurrency/group-round-robin/concurrency-worker-expression.ts",
     "event:concurrency:rr": "npm run exec -- ./src/examples/concurrency/group-round-robin/concurrency-event.ts",
     "worker:playground": "npm run exec -- ./src/examples/playground.ts",
     "worker:retries": "npm run exec -- ./src/examples/retries-worker.ts",
@@ -92,6 +92,7 @@
     "typescript": "^5.3.3"
   },
   "dependencies": {
+    "@bufbuild/protobuf": "^2.1.0",
     "@types/qs": "^6.9.11",
     "abort-controller-x": "^0.4.3",
     "axios": "^1.6.7",