@hatchet-dev/typescript-sdk 0.1.16 → 0.1.19

package/clients/worker/worker.d.ts

@@ -7,7 +7,6 @@ import { Logger } from '../../util/logger';
 import { Context, StepRunFunction } from '../../step';
 export type ActionRegistry = Record<Action['actionId'], Function>;
 export declare class Worker {
-    serviceName: string;
     client: HatchetClient;
     name: string;
     killing: boolean;

package/clients/worker/worker.js

@@ -29,7 +29,6 @@ const logger_1 = require("../../util/logger");
 const step_1 = require("../../step");
 class Worker {
     constructor(client, options) {
-        this.serviceName = 'default';
         this.futures = {};
         this.contexts = {};
         this.client = client;
@@ -48,7 +47,7 @@ class Worker {
             try {
                 const concurrency = ((_a = workflow.concurrency) === null || _a === void 0 ? void 0 : _a.name)
                     ? {
-                        action: `${this.serviceName}:${workflow.concurrency.name}`,
+                        action: `${workflow.id}:${workflow.concurrency.name}`,
                         maxRuns: workflow.concurrency.maxRuns || 1,
                         limitStrategy: workflow.concurrency.limitStrategy || workflows_1.ConcurrencyLimitStrategy.CANCEL_IN_PROGRESS,
                     }
@@ -61,6 +60,7 @@ class Worker {
                     cronTriggers: workflow.on.cron ? [workflow.on.cron] : [],
                     scheduledTriggers: [],
                     concurrency,
+                    scheduleTimeout: workflow.scheduleTimeout,
                     jobs: [
                         {
                             name: workflow.id,
@@ -70,7 +70,7 @@ class Worker {
                                 var _a;
                                 return ({
                                     readableId: step.name,
-                                    action: `${this.serviceName}:${step.name}`,
+                                    action: `${workflow.id}:${step.name}`,
                                     timeout: step.timeout || '60s',
                                     inputs: '{}',
                                     parents: (_a = step.parents) !== null && _a !== void 0 ? _a : [],
@@ -85,12 +85,13 @@ class Worker {
             catch (e) {
                 throw new hatchet_error_1.default(`Could not register workflow: ${e.message}`);
             }
-            this.action_registry = workflow.steps.reduce((acc, step) => {
-                acc[`${this.serviceName}:${step.name}`] = step.run;
+            const newActions = workflow.steps.reduce((acc, step) => {
+                acc[`${workflow.id}:${step.name}`] = step.run;
                 return acc;
             }, {});
+            this.action_registry = Object.assign(Object.assign({}, this.action_registry), newActions);
             this.action_registry = ((_b = workflow.concurrency) === null || _b === void 0 ? void 0 : _b.name)
-                ? Object.assign(Object.assign({}, this.action_registry), { [`${this.serviceName}:${workflow.concurrency.name}`]: workflow.concurrency.key }) : Object.assign({}, this.action_registry);
+                ? Object.assign(Object.assign({}, this.action_registry), { [`${workflow.id}:${workflow.concurrency.name}`]: workflow.concurrency.key }) : Object.assign({}, this.action_registry);
         });
     }
     registerAction(actionId, action) {
@@ -98,45 +99,45 @@ class Worker {
     }
     handleStartStepRun(action) {
         const { actionId } = action;
-        const context = new step_1.Context(action);
-        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);
-                // 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}`);
-            try {
-                // Send the action event to the dispatcher
-                const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_FAILED, error);
-                this.client.dispatcher.sendStepActionEvent(event);
-                // 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;
         try {
+            const context = new step_1.Context(action);
+            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);
+                    // 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}`);
+                try {
+                    // Send the action event to the dispatcher
+                    const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_FAILED, error);
+                    this.client.dispatcher.sendStepActionEvent(event);
+                    // 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);
@@ -147,47 +148,47 @@ class Worker {
     }
     handleStartGroupKeyRun(action) {
         const { actionId } = action;
-        const context = new step_1.Context(action);
-        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);
-                // 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);
-                // 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[action.getGroupKeyRunId] = future;
         try {
+            const context = new step_1.Context(action);
+            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);
+                    // 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);
+                    // 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[action.getGroupKeyRunId] = 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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "0.1.16",
+  "version": "0.1.19",
   "description": "Background task orchestration & visibility for developers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -36,6 +36,7 @@
     "worker:concurrency:rr": "npm run exec -- ./examples/concurrency/group-round-robin/concurrency-worker.ts",
     "event:concurrency:rr": "npm run exec -- ./examples/concurrency/group-round-robin/concurrency-event.ts",
     "worker:retries": "npm run exec -- ./examples/retries-worker.ts",
+    "worker:multi-workflow": "npm run exec -- ./examples/multi-workflow.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",

package/protoc/workflows/workflows.d.ts

@@ -31,6 +31,8 @@ export interface CreateWorkflowVersionOpts {
     jobs: CreateWorkflowJobOpts[];
     /** (optional) the workflow concurrency options */
     concurrency: WorkflowConcurrencyOpts | undefined;
+    /** (optional) the timeout for the schedule */
+    scheduleTimeout?: string | undefined;
 }
 export interface WorkflowConcurrencyOpts {
     /** (required) the action id for getting the concurrency group */

package/protoc/workflows/workflows.js

@@ -135,6 +135,7 @@ function createBaseCreateWorkflowVersionOpts() {
         scheduledTriggers: [],
         jobs: [],
         concurrency: undefined,
+        scheduleTimeout: undefined,
     };
 }
 exports.CreateWorkflowVersionOpts = {
@@ -163,6 +164,9 @@ exports.CreateWorkflowVersionOpts = {
         if (message.concurrency !== undefined) {
             exports.WorkflowConcurrencyOpts.encode(message.concurrency, writer.uint32(66).fork()).ldelim();
         }
+        if (message.scheduleTimeout !== undefined) {
+            writer.uint32(74).string(message.scheduleTimeout);
+        }
         return writer;
     },
     decode(input, length) {
@@ -220,6 +224,12 @@ exports.CreateWorkflowVersionOpts = {
                     }
                     message.concurrency = exports.WorkflowConcurrencyOpts.decode(reader, reader.uint32());
                     continue;
+                case 9:
+                    if (tag !== 74) {
+                        break;
+                    }
+                    message.scheduleTimeout = reader.string();
+                    continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -246,6 +256,7 @@ exports.CreateWorkflowVersionOpts = {
                 ? object.jobs.map((e) => exports.CreateWorkflowJobOpts.fromJSON(e))
                 : [],
             concurrency: isSet(object.concurrency) ? exports.WorkflowConcurrencyOpts.fromJSON(object.concurrency) : undefined,
+            scheduleTimeout: isSet(object.scheduleTimeout) ? globalThis.String(object.scheduleTimeout) : undefined,
         };
     },
     toJSON(message) {
@@ -275,13 +286,16 @@ exports.CreateWorkflowVersionOpts = {
         if (message.concurrency !== undefined) {
             obj.concurrency = exports.WorkflowConcurrencyOpts.toJSON(message.concurrency);
         }
+        if (message.scheduleTimeout !== undefined) {
+            obj.scheduleTimeout = message.scheduleTimeout;
+        }
         return obj;
     },
     create(base) {
         return exports.CreateWorkflowVersionOpts.fromPartial(base !== null && base !== void 0 ? base : {});
     },
     fromPartial(object) {
-        var _a, _b, _c, _d, _e, _f, _g;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         const message = createBaseCreateWorkflowVersionOpts();
         message.name = (_a = object.name) !== null && _a !== void 0 ? _a : "";
         message.description = (_b = object.description) !== null && _b !== void 0 ? _b : "";
@@ -293,6 +307,7 @@ exports.CreateWorkflowVersionOpts = {
         message.concurrency = (object.concurrency !== undefined && object.concurrency !== null)
             ? exports.WorkflowConcurrencyOpts.fromPartial(object.concurrency)
             : undefined;
+        message.scheduleTimeout = (_h = object.scheduleTimeout) !== null && _h !== void 0 ? _h : undefined;
         return message;
     },
 };

package/workflow.d.ts

@@ -37,6 +37,7 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
     id: z.ZodString;
     description: z.ZodString;
     version: z.ZodOptional<z.ZodString>;
+    scheduleTimeout: z.ZodOptional<z.ZodString>;
     timeout: z.ZodOptional<z.ZodString>;
     on: z.ZodUnion<[z.ZodObject<{
         cron: z.ZodString;
@@ -90,6 +91,7 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
         cron?: undefined;
     };
     version?: string | undefined;
+    scheduleTimeout?: string | undefined;
     timeout?: string | undefined;
 }, {
     description: string;
@@ -108,6 +110,7 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
         cron?: undefined;
     };
     version?: string | undefined;
+    scheduleTimeout?: string | undefined;
     timeout?: string | undefined;
 }>;
 export interface Workflow extends z.infer<typeof CreateWorkflowSchema> {

package/workflow.js

@@ -48,6 +48,7 @@ exports.CreateWorkflowSchema = z.object({
     id: z.string(),
     description: z.string(),
     version: z.string().optional(),
+    scheduleTimeout: z.string().optional(),
     timeout: exports.HatchetTimeoutSchema.optional(),
     on: OnConfigSchema,
     steps: StepsSchema,