@hatchet-dev/typescript-sdk 1.3.3 → 1.3.4

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

@@ -9,6 +9,8 @@ declare enum ListenStrategy {
 }
 export interface Action extends AssignedAction {
 }
+export type ActionKey = string;
+export declare function createActionKey(action: Action): ActionKey;
 export declare class ActionListener {
     config: ClientConfig;
     client: PbDispatcherClient;

package/clients/dispatcher/action-listener.js

@@ -33,6 +33,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ActionListener = void 0;
+exports.createActionKey = createActionKey;
+const dispatcher_1 = require("../../protoc/dispatcher");
 const nice_grpc_1 = require("nice-grpc");
 const sleep_1 = __importDefault(require("../../util/sleep"));
 const hatchet_error_1 = __importDefault(require("../../util/errors/hatchet-error"));
@@ -45,6 +47,20 @@ var ListenStrategy;
     ListenStrategy[ListenStrategy["LISTEN_STRATEGY_V1"] = 1] = "LISTEN_STRATEGY_V1";
     ListenStrategy[ListenStrategy["LISTEN_STRATEGY_V2"] = 2] = "LISTEN_STRATEGY_V2";
 })(ListenStrategy || (ListenStrategy = {}));
+function createActionKey(action) {
+    switch (action.actionType) {
+        case dispatcher_1.ActionType.START_GET_GROUP_KEY:
+            return `${action.getGroupKeyRunId}/${action.retryCount}`;
+        case dispatcher_1.ActionType.CANCEL_STEP_RUN:
+        case dispatcher_1.ActionType.START_STEP_RUN:
+        case dispatcher_1.ActionType.UNRECOGNIZED:
+            return `${action.stepRunId}/${action.retryCount}`;
+        default:
+            // eslint-disable-next-line no-case-declarations
+            const exhaustivenessCheck = action.actionType;
+            throw new Error(`Unhandled action type: ${exhaustivenessCheck}`);
+    }
+}
 class ActionListener {
     constructor(client, workerId, retryInterval = DEFAULT_ACTION_LISTENER_RETRY_INTERVAL, retryCount = DEFAULT_ACTION_LISTENER_RETRY_COUNT) {
         this.lastConnectionAttempt = 0;

package/clients/worker/worker.d.ts

@@ -1,5 +1,5 @@
 import { InternalHatchetClient } from '../hatchet-client';
-import { Action, ActionListener } from '../dispatcher/action-listener';
+import { Action, ActionKey, ActionListener } from '../dispatcher/action-listener';
 import { StepActionEvent, StepActionEventType, GroupKeyActionEvent, GroupKeyActionEventType } from '../../protoc/dispatcher';
 import HatchetPromise from '../../util/hatchet-promise/hatchet-promise';
 import { Workflow } from '../../workflow';
@@ -25,8 +25,8 @@ export declare class V0Worker {
     action_registry: ActionRegistry;
     workflow_registry: Array<WorkflowDefinition | Workflow>;
     listener: ActionListener | undefined;
-    futures: Record<Action['stepRunId'], HatchetPromise<any>>;
-    contexts: Record<Action['stepRunId'], Context<any, any>>;
+    futures: Record<ActionKey, HatchetPromise<any>>;
+    contexts: Record<ActionKey, Context<any, any>>;
     maxRuns?: number;
     logger: Logger;
     registeredWorkflowPromises: Array<Promise<any>>;

package/clients/worker/worker.js

@@ -21,6 +21,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.V0Worker = void 0;
 const hatchet_error_1 = __importDefault(require("../../util/errors/hatchet-error"));
+const action_listener_1 = require("../dispatcher/action-listener");
 const dispatcher_1 = require("../../protoc/dispatcher");
 const hatchet_promise_1 = __importDefault(require("../../util/hatchet-promise/hatchet-promise"));
 const workflows_1 = require("../../protoc/workflows");
@@ -336,7 +337,7 @@ class V0Worker {
             try {
                 // Note: we always use a DurableContext since its a superset of the Context class
                 const context = new step_1.DurableContext(action, this.client, this);
-                this.contexts[action.stepRunId] = context;
+                this.contexts[(0, action_listener_1.createActionKey)(action)] = context;
                 const step = this.action_registry[actionId];
                 if (!step) {
                     this.logger.error(`Registered actions: '${Object.keys(this.action_registry).join(', ')}'`);
@@ -367,8 +368,8 @@ class V0Worker {
                     }
                     finally {
                         // delete the run from the futures
-                        delete this.futures[action.stepRunId];
-                        delete this.contexts[action.stepRunId];
+                        delete this.futures[(0, action_listener_1.createActionKey)(action)];
+                        delete this.contexts[(0, action_listener_1.createActionKey)(action)];
                     }
                 });
                 const failure = (error) => __awaiter(this, void 0, void 0, function* () {
@@ -390,8 +391,8 @@ class V0Worker {
                     }
                     finally {
                         // delete the run from the futures
-                        delete this.futures[action.stepRunId];
-                        delete this.contexts[action.stepRunId];
+                        delete this.futures[(0, action_listener_1.createActionKey)(action)];
+                        delete this.contexts[(0, action_listener_1.createActionKey)(action)];
                     }
                 });
                 const future = new hatchet_promise_1.default((() => __awaiter(this, void 0, void 0, function* () {
@@ -405,7 +406,7 @@ class V0Worker {
                     }
                     yield success(result);
                 }))());
-                this.futures[action.stepRunId] = future;
+                this.futures[(0, action_listener_1.createActionKey)(action)] = future;
                 // Send the action event to the dispatcher
                 const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_STARTED, false, undefined, action.retryCount);
                 this.client.dispatcher.sendStepActionEvent(event).catch((e) => {
@@ -428,7 +429,7 @@ class V0Worker {
             const { actionId } = action;
             try {
                 const context = new step_1.Context(action, this.client, this);
-                const key = action.getGroupKeyRunId;
+                const key = (0, action_listener_1.createActionKey)(action);
                 if (!key) {
                     this.logger.error(`No group key run id provided for action ${actionId}`);
                     return;
@@ -527,8 +528,8 @@ class V0Worker {
             const { stepRunId } = action;
             try {
                 this.logger.info(`Cancelling step run ${action.stepRunId}`);
-                const future = this.futures[stepRunId];
-                const context = this.contexts[stepRunId];
+                const future = this.futures[(0, action_listener_1.createActionKey)(action)];
+                const context = this.contexts[(0, action_listener_1.createActionKey)(action)];
                 if (context && context.controller) {
                     context.controller.abort('Cancelled by worker');
                 }
@@ -544,8 +545,8 @@ class V0Worker {
                 this.logger.error('Could not cancel step run: ', e);
             }
             finally {
-                delete this.futures[stepRunId];
-                delete this.contexts[stepRunId];
+                delete this.futures[(0, action_listener_1.createActionKey)(action)];
+                delete this.contexts[(0, action_listener_1.createActionKey)(action)];
             }
         });
     }

package/package.json

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

package/v1/examples/migration-guides/hatchet-client.d.ts

@@ -0,0 +1,2 @@
+import HatchetClient from '../../../sdk';
+export declare const hatchet: HatchetClient;

package/v1/examples/migration-guides/hatchet-client.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hatchet = void 0;
+const sdk_1 = __importDefault(require("../../../sdk"));
+exports.hatchet = sdk_1.default.init();

package/v1/examples/migration-guides/mergent.d.ts

@@ -0,0 +1,23 @@
+export declare function processImageTask(req: {
+    body: {
+        imageUrl: string;
+        filters: string[];
+    };
+}): Promise<{
+    success: boolean;
+    processedUrl: string;
+}>;
+type ImageProcessInput = {
+    imageUrl: string;
+    filters: string[];
+};
+type ImageProcessOutput = {
+    processedUrl: string;
+    metadata: {
+        size: number;
+        format: string;
+        appliedFilters: string[];
+    };
+};
+export declare const imageProcessor: import("../..").TaskWorkflowDeclaration<ImageProcessInput, ImageProcessOutput>;
+export {};

package/v1/examples/migration-guides/mergent.js

@@ -0,0 +1,109 @@
+"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 });
+exports.imageProcessor = void 0;
+exports.processImageTask = processImageTask;
+const hatchet_client_1 = require("./hatchet-client");
+function processImage(imageUrl, filters) {
+    // Do some image processing
+    return Promise.resolve({ url: imageUrl, size: 100, format: 'png' });
+}
+// ❓ Before (Mergent)
+function processImageTask(req) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { imageUrl, filters } = req.body;
+        try {
+            const result = yield processImage(imageUrl, filters);
+            return { success: true, processedUrl: result.url };
+        }
+        catch (error) {
+            console.error('Image processing failed:', error);
+            throw error;
+        }
+    });
+}
+exports.imageProcessor = hatchet_client_1.hatchet.task({
+    name: 'image-processor',
+    retries: 3,
+    executionTimeout: '10m',
+    fn: (_a) => __awaiter(void 0, [_a], void 0, function* ({ imageUrl, filters }) {
+        // Do some image processing
+        const result = yield processImage(imageUrl, filters);
+        if (!result.url)
+            throw new Error('Processing failed to generate URL');
+        return {
+            processedUrl: result.url,
+            metadata: {
+                size: result.size,
+                format: result.format,
+                appliedFilters: filters,
+            },
+        };
+    }),
+});
+// !!
+function run() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // ❓ Running a task (Mergent)
+        const options = {
+            method: 'POST',
+            headers: { Authorization: 'Bearer <token>', 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                name: '4cf95241-fa19-47ef-8a67-71e483747649',
+                queue: 'default',
+                request: {
+                    url: 'https://example.com',
+                    headers: { Authorization: 'fake-secret-token', 'Content-Type': 'application/json' },
+                    body: 'Hello, world!',
+                },
+            }),
+        };
+        fetch('https://api.mergent.co/v2/tasks', options)
+            .then((response) => response.json())
+            .then((response) => console.log(response))
+            .catch((err) => console.error(err));
+        // !!
+        // ❓ Running a task (Hatchet)
+        const result = yield exports.imageProcessor.run({
+            imageUrl: 'https://example.com/image.png',
+            filters: ['blur'],
+        });
+        // you can await fully typed results
+        console.log(result);
+        // !!
+    });
+}
+function schedule() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // ❓ Scheduling tasks (Mergent)
+        const options = {
+            // same options as before
+            body: JSON.stringify({
+                // same body as before
+                delay: '5m',
+            }),
+        };
+        // !!
+        // ❓ Scheduling tasks (Hatchet)
+        // Schedule the task to run at a specific time
+        const runAt = new Date(Date.now() + 1000 * 60 * 60 * 24);
+        exports.imageProcessor.schedule(runAt, {
+            imageUrl: 'https://example.com/image.png',
+            filters: ['blur'],
+        });
+        // Schedule the task to run every hour
+        exports.imageProcessor.cron('run-hourly', '0 * * * *', {
+            imageUrl: 'https://example.com/image.png',
+            filters: ['blur'],
+        });
+        // !!
+    });
+}

package/version.d.ts

@@ -1 +1 @@
-export declare const HATCHET_VERSION = "1.3.3";
+export declare const HATCHET_VERSION = "1.3.4";

package/version.js

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