@hatchet-dev/typescript-sdk 0.8.0-alpha.3 → 0.9.0

package/clients/rest/generated/http-client.js

@@ -49,8 +49,8 @@ class HttpClient {
         this.setSecurityData = (data) => {
             this.securityData = data;
         };
-        this.request = (_b) => __awaiter(this, void 0, void 0, function* () {
-            var { secure, path, type, query, format, body } = _b, params = __rest(_b, ["secure", "path", "type", "query", "format", "body"]);
+        this.request = (_a) => __awaiter(this, void 0, void 0, function* () {
+            var { secure, path, type, query, format, body } = _a, params = __rest(_a, ["secure", "path", "type", "query", "format", "body"]);
             const secureParams = ((typeof secure === 'boolean' ? secure : this.secure) &&
                 this.securityWorker &&
                 (yield this.securityWorker(this.securityData))) ||

package/clients/worker/worker.d.ts

@@ -4,8 +4,6 @@ import { StepActionEvent, StepActionEventType, GroupKeyActionEvent, GroupKeyActi
 import HatchetPromise from '../../util/hatchet-promise/hatchet-promise';
 import { Workflow } from '../../workflow';
 import { Logger } from '../../util/logger';
-import { WebhookHandler } from './handler';
-import { WebhookWorkerCreateRequest } from '../rest/generated/data-contracts';
 import { Context, StepRunFunction } from '../../step';
 export type ActionRegistry = Record<Action['actionId'], Function>;
 export declare class Worker {
@@ -20,28 +18,23 @@ export declare class Worker {
     maxRuns?: number;
     logger: Logger;
     registeredWorkflowPromises: Array<Promise<any>>;
-    registeredWorkflowIds: string[];
     constructor(client: HatchetClient, options: {
         name: string;
         handleKill?: boolean;
         maxRuns?: number;
     });
-    private registerActions;
-    getHandler(workflows: Workflow[]): WebhookHandler;
-    registerWebhook(webhook: WebhookWorkerCreateRequest): Promise<import("axios").AxiosResponse<import("../rest/generated/data-contracts").WebhookWorker, any>>;
     /**
      * @deprecated use registerWorkflow instead
      */
     register_workflow(initWorkflow: Workflow): Promise<void>;
     registerWorkflow(initWorkflow: Workflow): Promise<void>;
     registerAction<T, K>(actionId: string, action: StepRunFunction<T, K>): void;
-    handleStartStepRun(action: Action): Promise<void>;
-    handleStartGroupKeyRun(action: Action): Promise<void>;
+    handleStartStepRun(action: Action): void;
+    handleStartGroupKeyRun(action: Action): void;
     getStepActionEvent(action: Action, eventType: StepActionEventType, payload?: any): StepActionEvent;
     getGroupKeyActionEvent(action: Action, eventType: GroupKeyActionEventType, payload?: any): GroupKeyActionEvent;
-    handleCancelStepRun(action: Action): Promise<void>;
+    handleCancelStepRun(action: Action): void;
     stop(): Promise<void>;
     exitGracefully(handleKill: boolean): Promise<void>;
     start(): Promise<void>;
-    handleAction(action: Action): Promise<void>;
 }

package/clients/worker/worker.js

@@ -25,14 +25,13 @@ const dispatcher_1 = require("../../protoc/dispatcher");
 const hatchet_promise_1 = __importDefault(require("../../util/hatchet-promise/hatchet-promise"));
 const workflows_1 = require("../../protoc/workflows");
 const logger_1 = require("../../util/logger");
-const handler_1 = require("./handler");
+// import sleep from '../../util/sleep.js';
 const step_1 = require("../../step");
 class Worker {
     constructor(client, options) {
         this.futures = {};
         this.contexts = {};
         this.registeredWorkflowPromises = [];
-        this.registeredWorkflowIds = [];
         this.client = client;
         this.name = this.client.config.namespace + options.name;
         this.action_registry = {};
@@ -43,33 +42,6 @@ class Worker {
         this.handle_kill = options.handleKill === undefined ? true : options.handleKill;
         this.logger = new logger_1.Logger(`Worker/${this.name}`, this.client.config.log_level);
     }
-    registerActions(workflow) {
-        var _a;
-        const newActions = workflow.steps.reduce((acc, step) => {
-            acc[`${workflow.id}:${step.name}`] = step.run;
-            return acc;
-        }, {});
-        const onFailureAction = workflow.onFailure
-            ? {
-                [`${workflow.id}-on-failure:${workflow.onFailure.name}`]: workflow.onFailure.run,
-            }
-            : {};
-        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);
-    }
-    getHandler(workflows) {
-        for (const workflow of workflows) {
-            const wf = Object.assign(Object.assign({}, workflow), { id: this.client.config.namespace + workflow.id });
-            this.registerActions(wf);
-        }
-        return new handler_1.WebhookHandler(this, workflows);
-    }
-    registerWebhook(webhook) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.client.admin.webhook_create(Object.assign(Object.assign({}, webhook), { workflows: this.registeredWorkflowIds }));
-        });
-    }
     /**
      * @deprecated use registerWorkflow instead
      */
@@ -80,7 +52,7 @@ class Worker {
     }
     registerWorkflow(initWorkflow) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
+            var _a, _b, _c;
             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)
@@ -108,7 +80,6 @@ class Worker {
                         ],
                     }
                     : undefined;
-                this.registeredWorkflowIds.push(workflow.id);
                 const registeredWorkflow = this.client.admin.putWorkflow({
                     name: workflow.id,
                     description: workflow.description,
@@ -147,154 +118,145 @@ class Worker {
             catch (e) {
                 throw new hatchet_error_1.default(`Could not register workflow: ${e.message}`);
             }
-            this.registerActions(workflow);
+            const newActions = workflow.steps.reduce((acc, step) => {
+                acc[`${workflow.id}:${step.name}`] = step.run;
+                return acc;
+            }, {});
+            const onFailureAction = workflow.onFailure
+                ? {
+                    [`${workflow.id}-on-failure:${workflow.onFailure.name}`]: workflow.onFailure.run,
+                }
+                : {};
+            this.action_registry = Object.assign(Object.assign(Object.assign({}, this.action_registry), newActions), onFailureAction);
+            this.action_registry = ((_c = workflow.concurrency) === null || _c === void 0 ? void 0 : _c.name)
+                ? Object.assign(Object.assign({}, this.action_registry), { [`${workflow.id}:${workflow.concurrency.name}`]: workflow.concurrency.key }) : Object.assign({}, this.action_registry);
         });
     }
     registerAction(actionId, action) {
         this.action_registry[actionId] = action;
     }
     handleStartStepRun(action) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { actionId } = action;
-            try {
-                const context = new step_1.Context(action, this.client);
-                this.contexts[action.stepRunId] = context;
-                const step = this.action_registry[actionId];
-                if (!step) {
-                    this.logger.error(`Could not find step '${actionId}'`);
-                    return;
-                }
-                const run = () => __awaiter(this, void 0, void 0, function* () {
-                    return step(context);
-                });
-                const success = (result) => __awaiter(this, void 0, void 0, function* () {
-                    this.logger.info(`Step run ${action.stepRunId} succeeded`);
-                    try {
-                        // Send the action event to the dispatcher
-                        const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_COMPLETED, result || null);
-                        yield this.client.dispatcher.sendStepActionEvent(event);
-                        // delete the run from the futures
-                        delete this.futures[action.stepRunId];
-                    }
-                    catch (actionEventError) {
-                        this.logger.error(`Could not send completed action event: ${actionEventError.message}`);
+        const { actionId } = action;
+        try {
+            const context = new step_1.Context(action, this.client);
+            this.contexts[action.stepRunId] = context;
+            const step = this.action_registry[actionId];
+            if (!step) {
+                this.logger.error(`Could not find step '${actionId}'`);
+                return;
+            }
+            const run = () => __awaiter(this, void 0, void 0, function* () {
+                return step(context);
+            });
+            const success = (result) => {
+                this.logger.info(`Step run ${action.stepRunId} succeeded`);
+                try {
+                    // Send the action event to the dispatcher
+                    const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_COMPLETED, result || null);
+                    this.client.dispatcher.sendStepActionEvent(event).catch((e) => {
+                        this.logger.error(`Could not send completed action event: ${e.message}`);
                         // send a failure event
-                        const failureEvent = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_FAILED, actionEventError.message);
-                        try {
-                            yield this.client.dispatcher.sendStepActionEvent(failureEvent);
-                        }
-                        catch (failureEventError) {
-                            this.logger.error(`Could not send failed action event: ${failureEventError.message}`);
-                        }
-                        this.logger.error(`Could not send action event: ${actionEventError.message}`);
-                    }
-                });
-                const failure = (error) => __awaiter(this, void 0, void 0, function* () {
-                    this.logger.error(`Step run ${action.stepRunId} failed: ${error.message}`);
-                    if (error.stack) {
-                        this.logger.error(error.stack);
-                    }
-                    try {
-                        // Send the action event to the dispatcher
-                        const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_FAILED, {
-                            message: error === null || error === void 0 ? void 0 : error.message,
-                            stack: error === null || error === void 0 ? void 0 : error.stack,
+                        const failureEvent = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_FAILED, e.message);
+                        this.client.dispatcher.sendStepActionEvent(failureEvent).catch((err2) => {
+                            this.logger.error(`Could not send failed action event: ${err2.message}`);
                         });
-                        yield this.client.dispatcher.sendStepActionEvent(event);
-                        // delete the run from the futures
-                        delete this.futures[action.stepRunId];
-                    }
-                    catch (e) {
+                    });
+                    // delete the run from the futures
+                    delete this.futures[action.stepRunId];
+                }
+                catch (e) {
+                    this.logger.error(`Could not send action event: ${e.message}`);
+                }
+            };
+            const failure = (error) => {
+                this.logger.error(`Step run ${action.stepRunId} failed: ${error.message}`);
+                if (error.stack) {
+                    this.logger.error(error.stack);
+                }
+                try {
+                    // Send the action event to the dispatcher
+                    const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_FAILED, {
+                        message: error === null || error === void 0 ? void 0 : error.message,
+                        stack: error === null || error === void 0 ? void 0 : error.stack,
+                    });
+                    this.client.dispatcher.sendStepActionEvent(event).catch((e) => {
                         this.logger.error(`Could not send action event: ${e.message}`);
-                    }
-                });
-                const future = new hatchet_promise_1.default((() => __awaiter(this, void 0, void 0, function* () {
-                    let result;
-                    try {
-                        result = yield run();
-                    }
-                    catch (e) {
-                        yield failure(e);
-                        return;
-                    }
-                    yield success(result);
-                }))());
-                this.futures[action.stepRunId] = future;
-                // Send the action event to the dispatcher
-                const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_STARTED);
-                this.client.dispatcher.sendStepActionEvent(event).catch((e) => {
+                    });
+                    // delete the run from the futures
+                    delete this.futures[action.stepRunId];
+                }
+                catch (e) {
                     this.logger.error(`Could not send action event: ${e.message}`);
-                });
-                yield future.promise;
-            }
-            catch (e) {
+                }
+            };
+            const future = new hatchet_promise_1.default(run().then(success).catch(failure));
+            this.futures[action.stepRunId] = future;
+            // Send the action event to the dispatcher
+            const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_STARTED);
+            this.client.dispatcher.sendStepActionEvent(event).catch((e) => {
                 this.logger.error(`Could not send action event: ${e.message}`);
-            }
-        });
+            });
+        }
+        catch (e) {
+            this.logger.error(`Could not send action event: ${e.message}`);
+        }
     }
     handleStartGroupKeyRun(action) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { actionId } = action;
-            try {
-                const context = new step_1.Context(action, this.client);
-                const key = action.getGroupKeyRunId;
-                if (!key) {
-                    this.logger.error(`No group key run id provided for action ${actionId}`);
-                    return;
+        const { actionId } = action;
+        try {
+            const context = new step_1.Context(action, this.client);
+            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}'`);
+                return;
+            }
+            const run = () => __awaiter(this, void 0, void 0, function* () {
+                return step(context);
+            });
+            const success = (result) => {
+                this.logger.info(`Step run ${action.stepRunId} succeeded`);
+                try {
+                    // Send the action event to the dispatcher
+                    const event = this.getGroupKeyActionEvent(action, dispatcher_1.GroupKeyActionEventType.GROUP_KEY_EVENT_TYPE_COMPLETED, result);
+                    this.client.dispatcher.sendGroupKeyActionEvent(event).catch((e) => {
+                        this.logger.error(`Could not send action event: ${e.message}`);
+                    });
+                    // delete the run from the futures
+                    delete this.futures[key];
                 }
-                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}'`);
-                    return;
+                catch (e) {
+                    this.logger.error(`Could not send action event: ${e.message}`);
                 }
-                const run = () => __awaiter(this, void 0, void 0, function* () {
-                    return step(context);
-                });
-                const success = (result) => {
-                    this.logger.info(`Step run ${action.stepRunId} succeeded`);
-                    try {
-                        // Send the action event to the dispatcher
-                        const event = this.getGroupKeyActionEvent(action, dispatcher_1.GroupKeyActionEventType.GROUP_KEY_EVENT_TYPE_COMPLETED, result);
-                        this.client.dispatcher.sendGroupKeyActionEvent(event).catch((e) => {
-                            this.logger.error(`Could not send action event: ${e.message}`);
-                        });
-                        // delete the run from the futures
-                        delete this.futures[key];
-                    }
-                    catch (e) {
-                        this.logger.error(`Could not send action event: ${e.message}`);
-                    }
-                };
-                const failure = (error) => {
-                    this.logger.error(`Step run ${key} failed: ${error.message}`);
-                    try {
-                        // Send the action event to the dispatcher
-                        const event = this.getGroupKeyActionEvent(action, dispatcher_1.GroupKeyActionEventType.GROUP_KEY_EVENT_TYPE_FAILED, error);
-                        this.client.dispatcher.sendGroupKeyActionEvent(event).catch((e) => {
-                            this.logger.error(`Could not send action event: ${e.message}`);
-                        });
-                        // delete the run from the futures
-                        delete this.futures[key];
-                    }
-                    catch (e) {
+            };
+            const failure = (error) => {
+                this.logger.error(`Step run ${key} failed: ${error.message}`);
+                try {
+                    // Send the action event to the dispatcher
+                    const event = this.getGroupKeyActionEvent(action, dispatcher_1.GroupKeyActionEventType.GROUP_KEY_EVENT_TYPE_FAILED, error);
+                    this.client.dispatcher.sendGroupKeyActionEvent(event).catch((e) => {
                         this.logger.error(`Could not send action event: ${e.message}`);
-                    }
-                };
-                const future = new hatchet_promise_1.default(run().then(success).catch(failure));
-                this.futures[key] = future;
-                // Send the action event to the dispatcher
-                const event = this.getGroupKeyActionEvent(action, dispatcher_1.GroupKeyActionEventType.GROUP_KEY_EVENT_TYPE_STARTED);
-                this.client.dispatcher.sendGroupKeyActionEvent(event).catch((e) => {
+                    });
+                    // delete the run from the futures
+                    delete this.futures[key];
+                }
+                catch (e) {
                     this.logger.error(`Could not send action event: ${e.message}`);
-                });
-                yield future.promise;
-            }
-            catch (e) {
+                }
+            };
+            const future = new hatchet_promise_1.default(run().then(success).catch(failure));
+            this.futures[action.getGroupKeyRunId] = future;
+            // Send the action event to the dispatcher
+            const event = this.getGroupKeyActionEvent(action, dispatcher_1.GroupKeyActionEventType.GROUP_KEY_EVENT_TYPE_STARTED);
+            this.client.dispatcher.sendGroupKeyActionEvent(event).catch((e) => {
                 this.logger.error(`Could not send action event: ${e.message}`);
-            }
-        });
+            });
+        }
+        catch (e) {
+            this.logger.error(`Could not send action event: ${e.message}`);
+        }
     }
     getStepActionEvent(action, eventType, payload = '') {
         return {
@@ -310,9 +272,6 @@ class Worker {
         };
     }
     getGroupKeyActionEvent(action, eventType, payload = '') {
-        if (!action.getGroupKeyRunId) {
-            throw new hatchet_error_1.default('No group key run id provided');
-        }
         return {
             workerId: this.name,
             workflowRunId: action.workflowRunId,
@@ -324,29 +283,26 @@ class Worker {
         };
     }
     handleCancelStepRun(action) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                this.logger.info(`Cancelling step run ${action.stepRunId}`);
-                const { stepRunId } = action;
-                const future = this.futures[stepRunId];
-                const context = this.contexts[stepRunId];
-                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');
-                    yield future.promise;
-                    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];
+            if (context && context.controller) {
+                context.controller.abort('Cancelled by worker');
+                delete this.contexts[stepRunId];
             }
-            catch (e) {
-                this.logger.error(`Could not cancel step run: ${e.message}`);
+            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() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -394,7 +350,18 @@ class Worker {
                         _d = false;
                         const action = _c;
                         this.logger.info(`Worker ${this.name} received action ${action.actionId}:${action.actionType}`);
-                        void this.handleAction(action);
+                        if (action.actionType === dispatcher_1.ActionType.START_STEP_RUN) {
+                            this.handleStartStepRun(action);
+                        }
+                        else if (action.actionType === dispatcher_1.ActionType.CANCEL_STEP_RUN) {
+                            this.handleCancelStepRun(action);
+                        }
+                        else if (action.actionType === dispatcher_1.ActionType.START_GET_GROUP_KEY) {
+                            this.handleStartGroupKeyRun(action);
+                        }
+                        else {
+                            this.logger.error(`Worker ${this.name} received unknown action type ${action.actionType}`);
+                        }
                     }
                 }
                 catch (e_1_1) { e_1 = { error: e_1_1 }; }
@@ -416,24 +383,5 @@ class Worker {
             }
         });
     }
-    handleAction(action) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const type = action.actionType
-                ? (0, dispatcher_1.actionTypeFromJSON)(action.actionType)
-                : dispatcher_1.ActionType.START_STEP_RUN;
-            if (type === dispatcher_1.ActionType.START_STEP_RUN) {
-                yield this.handleStartStepRun(action);
-            }
-            else if (type === dispatcher_1.ActionType.CANCEL_STEP_RUN) {
-                yield this.handleCancelStepRun(action);
-            }
-            else if (type === dispatcher_1.ActionType.START_GET_GROUP_KEY) {
-                yield this.handleStartGroupKeyRun(action);
-            }
-            else {
-                this.logger.error(`Worker ${this.name} received unknown action type ${type}`);
-            }
-        });
-    }
 }
 exports.Worker = Worker;

package/index.d.ts

@@ -4,4 +4,5 @@ export * from './step';
 export * from './clients/worker';
 export * from './clients/rest';
 export * from './clients/admin';
+export * from './util/workflow-run-ref';
 export default Hatchet;

package/index.js

@@ -20,4 +20,5 @@ __exportStar(require("./step"), exports);
 __exportStar(require("./clients/worker"), exports);
 __exportStar(require("./clients/rest"), exports);
 __exportStar(require("./clients/admin"), exports);
+__exportStar(require("./util/workflow-run-ref"), exports);
 exports.default = hatchet_client_1.HatchetClient;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "0.8.0-alpha.3",
+  "version": "0.9.0",
   "description": "Background task orchestration & visibility for developers",
   "types": "dist/index.d.ts",
   "files": [
@@ -19,7 +19,7 @@
     "prepare": "npm run build",
     "tsc:build": "tsc && resolve-tspaths",
     "test:unit": "jest --testMatch='**/*.test.ts'",
-    "test:e2e": "jest --testMatch='**/*.e2e.ts' --runInBand --detectOpenHandles",
+    "test:e2e": "jest --testMatch='**/*.e2e.ts'",
     "test:unit:watch": "jest --testMatch='**/*.test.ts' --watch",
     "generate": "pnpm run '/generate-.*/'",
     "generate-api": "npx --yes swagger-cli bundle ./hatchet/api-contracts/openapi/openapi.yaml --outfile openapi.yaml --type yaml && npx swagger-typescript-api -p openapi.yaml -o src/clients/rest/generated -n hatchet.ts --modular --axios",
@@ -51,7 +51,7 @@
     "worker:logger": "npm run exec -- ./examples/logger.ts",
     "api": "npm run exec -- ./examples/api.ts",
     "prepublish": "cp package.json dist/package.json;",
-    "publish:ci": "rm -rf ./dist && npm run tsc:build && npm run prepublish && cd dist && npm publish --access public --no-git-checks --tag=alpha",
+    "publish:ci": "rm -rf ./dist && npm run tsc:build && npm run prepublish && cd dist && npm publish --access public --no-git-checks",
     "generate-docs": "typedoc"
   },
   "keywords": [],
@@ -84,7 +84,7 @@
     "ts-jest": "^29.1.1",
     "ts-node": "^10.9.2",
     "ts-proto": "^1.167.0",
-    "typedoc": "^0.25.7",
+    "typedoc": "^0.26.2",
     "typedoc-plugin-markdown": "^4.0.2",
     "typescript": "^5.3.3"
   },