@hatchet-dev/typescript-sdk 0.7.2 → 0.8.0-alpha.0

package/clients/worker/worker.d.ts

@@ -4,6 +4,8 @@ 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 {
@@ -18,20 +20,25 @@ 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(workflow: Workflow): WebhookHandler;
+    registerWebhook(webhook: WebhookWorkerCreateRequest): Promise<import("axios").AxiosResponse<import("../rest/generated/data-contracts").WebhookWorker, any>>;
     registerWorkflow(initWorkflow: Workflow): Promise<void>;
     register_workflow(initWorkflow: Workflow): Promise<void>;
     registerAction<T, K>(actionId: string, action: StepRunFunction<T, K>): void;
-    handleStartStepRun(action: Action): void;
-    handleStartGroupKeyRun(action: Action): void;
+    handleStartStepRun(action: Action): Promise<void>;
+    handleStartGroupKeyRun(action: Action): Promise<void>;
     getStepActionEvent(action: Action, eventType: StepActionEventType, payload?: any): StepActionEvent;
     getGroupKeyActionEvent(action: Action, eventType: GroupKeyActionEventType, payload?: any): GroupKeyActionEvent;
-    handleCancelStepRun(action: Action): void;
+    handleCancelStepRun(action: Action): Promise<void>;
     stop(): Promise<void>;
     exitGracefully(handleKill: boolean): Promise<void>;
     start(): Promise<void>;
+    handleAction(action: Action): Promise<void>;
 }

package/clients/worker/worker.js

@@ -25,13 +25,14 @@ 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");
-// import sleep from '../../util/sleep.js';
+const handler_1 = require("./handler");
 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 = {};
@@ -42,6 +43,31 @@ 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(workflow) {
+        const wf = Object.assign(Object.assign({}, workflow), { id: this.client.config.namespace + workflow.id });
+        this.registerActions(wf);
+        return new handler_1.WebhookHandler(this);
+    }
+    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
     registerWorkflow(initWorkflow) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -50,7 +76,7 @@ class Worker {
     }
     register_workflow(initWorkflow) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c;
+            var _a, _b;
             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)
@@ -78,6 +104,7 @@ class Worker {
                         ],
                     }
                     : undefined;
+                this.registeredWorkflowIds.push(workflow.id);
                 const registeredWorkflow = this.client.admin.put_workflow({
                     name: workflow.id,
                     description: workflow.description,
@@ -114,140 +141,139 @@ class Worker {
             catch (e) {
                 throw new hatchet_error_1.default(`Could not register workflow: ${e.message}`);
             }
-            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);
+            this.registerActions(workflow);
         });
     }
     registerAction(actionId, action) {
         this.action_registry[actionId] = action;
     }
     handleStartStepRun(action) {
-        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);
-                    this.client.dispatcher.sendStepActionEvent(event).catch((e) => {
-                        this.logger.error(`Could not send action event: ${e.message}`);
-                    });
-                    // 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);
+        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;
                 }
-                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) => {
+                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);
+                        this.client.dispatcher.sendStepActionEvent(event).catch((e) => {
+                            this.logger.error(`Could not send action event: ${e.message}`);
+                        });
+                        // delete the run from the futures
+                        delete this.futures[action.stepRunId];
+                    }
+                    catch (e) {
                         this.logger.error(`Could not send action event: ${e.message}`);
-                    });
-                    // delete the run from the futures
-                    delete this.futures[action.stepRunId];
-                }
-                catch (e) {
+                    }
+                };
+                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}`);
+                        });
+                        // delete the run from the futures
+                        delete this.futures[action.stepRunId];
+                    }
+                    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[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}`);
-                }
-            };
-            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) => {
+                });
+                yield future.promise;
+            }
+            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) {
-        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];
+        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;
                 }
-                catch (e) {
-                    this.logger.error(`Could not send action event: ${e.message}`);
+                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 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) => {
+                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}`);
-                    });
-                    // 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}`);
+                        });
+                        // delete the run from the futures
+                        delete this.futures[key];
+                    }
+                    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) => {
                     this.logger.error(`Could not send action event: ${e.message}`);
-                }
-            };
-            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) => {
+                });
+                yield future.promise;
+            }
+            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 {
@@ -263,6 +289,9 @@ 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,
@@ -274,26 +303,29 @@ class Worker {
         };
     }
     handleCancelStepRun(action) {
-        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];
+        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];
+                }
             }
-            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}`);
             }
-        }
-        catch (e) {
-            this.logger.error(`Could not cancel step run: ${e.message}`);
-        }
+        });
     }
     stop() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -341,18 +373,7 @@ class Worker {
                         _d = false;
                         const action = _c;
                         this.logger.info(`Worker ${this.name} received action ${action.actionId}:${action.actionType}`);
-                        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}`);
-                        }
+                        void this.handleAction(action);
                     }
                 }
                 catch (e_1_1) { e_1 = { error: e_1_1 }; }
@@ -374,5 +395,24 @@ 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "0.7.2",
+  "version": "0.8.0-alpha.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'",
+    "test:e2e": "jest --testMatch='**/*.e2e.ts' --runInBand --detectOpenHandles",
     "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",
@@ -100,4 +100,4 @@
     "yaml": "^2.3.4",
     "zod": "^3.22.4"
   }
-}
+}

package/protoc/dispatcher/dispatcher.d.ts

@@ -1,4 +1,4 @@
-import type { CallContext, CallOptions } from 'nice-grpc-common';
+import { type CallContext, type CallOptions } from 'nice-grpc-common';
 import * as _m0 from 'protobufjs/minimal';
 export declare const protobufPackage = "";
 export declare enum ActionType {
@@ -96,6 +96,8 @@ export interface AssignedAction {
     actionPayload: string;
     /** the step name */
     stepName: string;
+    /** the count number of the retry attempt */
+    retryCount: number;
 }
 export interface WorkerListenRequest {
     /** the id of the worker */

package/protoc/dispatcher/dispatcher.js

@@ -1,4 +1,9 @@
 "use strict";
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v1.178.0
+//   protoc               v3.19.1
+// source: dispatcher/dispatcher.proto
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -480,6 +485,7 @@ function createBaseAssignedAction() {
         actionType: 0,
         actionPayload: '',
         stepName: '',
+        retryCount: 0,
     };
 }
 exports.AssignedAction = {
@@ -520,6 +526,9 @@ exports.AssignedAction = {
         if (message.stepName !== '') {
             writer.uint32(98).string(message.stepName);
         }
+        if (message.retryCount !== 0) {
+            writer.uint32(104).int32(message.retryCount);
+        }
         return writer;
     },
     decode(input, length) {
@@ -601,6 +610,12 @@ exports.AssignedAction = {
                     }
                     message.stepName = reader.string();
                     continue;
+                case 13:
+                    if (tag !== 104) {
+                        break;
+                    }
+                    message.retryCount = reader.int32();
+                    continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -625,6 +640,7 @@ exports.AssignedAction = {
             actionType: isSet(object.actionType) ? actionTypeFromJSON(object.actionType) : 0,
             actionPayload: isSet(object.actionPayload) ? globalThis.String(object.actionPayload) : '',
             stepName: isSet(object.stepName) ? globalThis.String(object.stepName) : '',
+            retryCount: isSet(object.retryCount) ? globalThis.Number(object.retryCount) : 0,
         };
     },
     toJSON(message) {
@@ -665,13 +681,16 @@ exports.AssignedAction = {
         if (message.stepName !== '') {
             obj.stepName = message.stepName;
         }
+        if (message.retryCount !== 0) {
+            obj.retryCount = Math.round(message.retryCount);
+        }
         return obj;
     },
     create(base) {
         return exports.AssignedAction.fromPartial(base !== null && base !== void 0 ? base : {});
     },
     fromPartial(object) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
         const message = createBaseAssignedAction();
         message.tenantId = (_a = object.tenantId) !== null && _a !== void 0 ? _a : '';
         message.workflowRunId = (_b = object.workflowRunId) !== null && _b !== void 0 ? _b : '';
@@ -685,6 +704,7 @@ exports.AssignedAction = {
         message.actionType = (_k = object.actionType) !== null && _k !== void 0 ? _k : 0;
         message.actionPayload = (_l = object.actionPayload) !== null && _l !== void 0 ? _l : '';
         message.stepName = (_m = object.stepName) !== null && _m !== void 0 ? _m : '';
+        message.retryCount = (_o = object.retryCount) !== null && _o !== void 0 ? _o : 0;
         return message;
     },
 };
@@ -1389,7 +1409,7 @@ exports.WorkflowEvent = {
         if (message.eventPayload !== '') {
             writer.uint32(50).string(message.eventPayload);
         }
-        if (message.hangup === true) {
+        if (message.hangup !== false) {
             writer.uint32(56).bool(message.hangup);
         }
         if (message.stepRetries !== undefined) {
@@ -1504,7 +1524,7 @@ exports.WorkflowEvent = {
         if (message.eventPayload !== '') {
             obj.eventPayload = message.eventPayload;
         }
-        if (message.hangup === true) {
+        if (message.hangup !== false) {
             obj.hangup = message.hangup;
         }
         if (message.stepRetries !== undefined) {

package/protoc/events/events.d.ts

@@ -1,4 +1,4 @@
-import type { CallContext, CallOptions } from 'nice-grpc-common';
+import { type CallContext, type CallOptions } from 'nice-grpc-common';
 import * as _m0 from 'protobufjs/minimal';
 export declare const protobufPackage = "";
 export interface Event {

package/protoc/events/events.js

@@ -1,4 +1,9 @@
 "use strict";
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v1.178.0
+//   protoc               v3.19.1
+// source: events/events.proto
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);

package/protoc/google/protobuf/timestamp.js

@@ -1,4 +1,9 @@
 "use strict";
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v1.178.0
+//   protoc               v3.19.1
+// source: google/protobuf/timestamp.proto
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -99,6 +104,9 @@ function longToNumber(long) {
     if (long.gt(globalThis.Number.MAX_SAFE_INTEGER)) {
         throw new globalThis.Error('Value is larger than Number.MAX_SAFE_INTEGER');
     }
+    if (long.lt(globalThis.Number.MIN_SAFE_INTEGER)) {
+        throw new globalThis.Error('Value is smaller than Number.MIN_SAFE_INTEGER');
+    }
     return long.toNumber();
 }
 if (_m0.util.Long !== Long) {

package/protoc/workflows/workflows.d.ts

@@ -1,4 +1,4 @@
-import type { CallContext, CallOptions } from 'nice-grpc-common';
+import { type CallContext, type CallOptions } from 'nice-grpc-common';
 import * as _m0 from 'protobufjs/minimal';
 export declare const protobufPackage = "";
 export declare enum ConcurrencyLimitStrategy {

package/protoc/workflows/workflows.js

@@ -1,4 +1,9 @@
 "use strict";
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v1.178.0
+//   protoc               v3.19.1
+// source: workflows/workflows.proto
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);