@hatchet-dev/typescript-sdk 0.8.0-alpha.1 → 0.8.1

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,40 +42,17 @@ 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) {
+    /**
+     * @deprecated use registerWorkflow instead
+     */
+    register_workflow(initWorkflow) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.client.admin.webhook_create(Object.assign(Object.assign({}, webhook), { workflows: this.registeredWorkflowIds }));
+            return this.registerWorkflow(initWorkflow);
         });
     }
-    // @deprecated
     registerWorkflow(initWorkflow) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.register_workflow(initWorkflow);
-        });
-    }
-    register_workflow(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)
@@ -104,13 +80,14 @@ class Worker {
                         ],
                     }
                     : undefined;
-                this.registeredWorkflowIds.push(workflow.id);
-                const registeredWorkflow = this.client.admin.put_workflow({
+                const registeredWorkflow = this.client.admin.putWorkflow({
                     name: workflow.id,
                     description: workflow.description,
                     version: workflow.version || '',
-                    eventTriggers: workflow.on.event ? [this.client.config.namespace + workflow.on.event] : [],
-                    cronTriggers: workflow.on.cron ? [workflow.on.cron] : [],
+                    eventTriggers: workflow.on && workflow.on.event
+                        ? [this.client.config.namespace + workflow.on.event]
+                        : [],
+                    cronTriggers: workflow.on && workflow.on.cron ? [workflow.on.cron] : [],
                     scheduledTriggers: [],
                     concurrency,
                     scheduleTimeout: workflow.scheduleTimeout,
@@ -141,153 +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* () {
-                    try {
-                        yield run();
-                    }
-                    catch (e) {
-                        yield failure(e);
-                        return;
-                    }
-                    yield success(null);
-                }))());
-                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 {
@@ -303,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,
@@ -317,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* () {
@@ -387,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 }; }
@@ -409,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "0.8.0-alpha.1",
+  "version": "0.8.1",
   "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",

package/protoc/dispatcher/dispatcher.js

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

package/protoc/events/events.js

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

package/protoc/google/protobuf/timestamp.js

@@ -1,7 +1,7 @@
 "use strict";
 // Code generated by protoc-gen-ts_proto. DO NOT EDIT.
 // versions:
-//   protoc-gen-ts_proto  v1.178.0
+//   protoc-gen-ts_proto  v1.180.0
 //   protoc               v3.19.1
 // source: google/protobuf/timestamp.proto
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {

package/protoc/workflows/workflows.js

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

package/step.d.ts

@@ -67,7 +67,7 @@ declare class ChildWorkflowRef<T> {
     result(): Promise<T>;
     toJSON(): Promise<string>;
 }
-export declare class Context<T, K> {
+export declare class Context<T, K = {}> {
     data: ContextData<T, K>;
     input: T;
     controller: AbortController;

package/step.js

@@ -229,7 +229,7 @@ class Context {
     spawnWorkflow(workflowName, input, key) {
         const { workflowRunId, stepRunId } = this.action;
         const name = this.client.config.namespace + workflowName;
-        const childWorkflowRunIdPromise = this.client.admin.run_workflow(name, input, {
+        const childWorkflowRunIdPromise = this.client.admin.runWorkflow(name, input, {
             parentId: workflowRunId,
             parentStepRunId: stepRunId,
             childKey: key,

package/util/parse.js

@@ -2,11 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseJSON = void 0;
 function parseJSON(json) {
-    // TODO why is this needed?
-    if (json.startsWith('ey')) {
-        const decoded = Buffer.from(json, 'base64').toString('utf8');
-        return JSON.parse(decoded);
-    }
     try {
         const firstParse = JSON.parse(json);
         // Hatchet engine versions <=0.14.0 return JSON as a quoted string which needs to be parsed again.

package/workflow.d.ts

@@ -60,7 +60,7 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
      * @deprecated Workflow timeout is deprecated. Use step timeouts instead.
      */
     timeout: z.ZodOptional<z.ZodString>;
-    on: z.ZodUnion<[z.ZodObject<{
+    on: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
         cron: z.ZodString;
         event: z.ZodUndefined;
     }, "strip", z.ZodTypeAny, {
@@ -78,7 +78,7 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
     }, {
         event: string;
         cron?: undefined;
-    }>]>;
+    }>]>>;
     steps: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         parents: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
@@ -160,16 +160,16 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
         }[] | undefined;
     }[];
     id: string;
-    on: {
+    version?: string | undefined;
+    scheduleTimeout?: string | undefined;
+    timeout?: string | undefined;
+    on?: {
         cron: string;
         event?: undefined;
     } | {
         event: string;
         cron?: undefined;
-    };
-    version?: string | undefined;
-    scheduleTimeout?: string | undefined;
-    timeout?: string | undefined;
+    } | undefined;
     onFailure?: {
         name: string;
         timeout?: string | undefined;
@@ -193,16 +193,16 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
         }[] | undefined;
     }[];
     id: string;
-    on: {
+    version?: string | undefined;
+    scheduleTimeout?: string | undefined;
+    timeout?: string | undefined;
+    on?: {
         cron: string;
         event?: undefined;
     } | {
         event: string;
         cron?: undefined;
-    };
-    version?: string | undefined;
-    scheduleTimeout?: string | undefined;
-    timeout?: string | undefined;
+    } | undefined;
     onFailure?: {
         name: string;
         timeout?: string | undefined;

package/workflow.js

@@ -35,7 +35,7 @@ const EventConfigSchema = z.object({
     cron: z.undefined(),
     event: z.string(),
 });
-const OnConfigSchema = z.union([CronConfigSchema, EventConfigSchema]);
+const OnConfigSchema = z.union([CronConfigSchema, EventConfigSchema]).optional();
 const StepsSchema = z.array(step_1.CreateStepSchema);
 exports.ConcurrencyLimitStrategy = workflows_1.ConcurrencyLimitStrategy;
 exports.WorkflowConcurrency = z.object({