@hatchet-dev/typescript-sdk 0.1.9 → 0.1.11

package/clients/admin/admin-client.d.ts

@@ -6,6 +6,7 @@ export declare class AdminClient {
     client: WorkflowServiceClient;
     constructor(config: ClientConfig, channel: Channel, factory: ClientFactory);
     put_workflow(workflow: CreateWorkflowVersionOpts): Promise<void>;
+    run_workflow(workflowName: string, input: object): Promise<string>;
     schedule_workflow(workflowId: string, options?: {
         schedules?: Date[];
     }): void;

package/clients/admin/admin-client.js

@@ -32,6 +32,22 @@ class AdminClient {
             }
         });
     }
+    run_workflow(workflowName, input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const inputStr = JSON.stringify(input);
+                const resp = yield this.client.triggerWorkflow({
+                    name: workflowName,
+                    input: inputStr,
+                });
+                return resp.workflowRunId;
+            }
+            catch (e) {
+                throw new hatchet_error_1.default(e.message);
+            }
+        });
+    }
+    // RunWorkflow(workflowName string, input interface{}) (string, error)
     schedule_workflow(workflowId, options) {
         try {
             this.client.scheduleWorkflow({

package/clients/hatchet-client/hatchet-client.d.ts

@@ -6,6 +6,7 @@ import { Workflow } from '../../workflow';
 import { Worker } from '../worker';
 import Logger from '../../util/logger/logger';
 import { ClientConfig } from './client-config';
+import { ListenerClient } from '../listener/listener-client';
 export interface HatchetClientOptions {
     config_path?: string;
     credentials?: ChannelCredentials;
@@ -17,6 +18,7 @@ export declare class HatchetClient {
     event: EventClient;
     dispatcher: DispatcherClient;
     admin: AdminClient;
+    listener: ListenerClient;
     logger: Logger;
     constructor(config?: Partial<ClientConfig>, options?: HatchetClientOptions);
     static with_host_port(host: string, port: number, config?: Partial<ClientConfig>, options?: HatchetClientOptions): HatchetClient;

package/clients/hatchet-client/hatchet-client.js

@@ -47,6 +47,7 @@ const nice_grpc_1 = require("nice-grpc");
 const worker_1 = require("../worker");
 const logger_1 = __importDefault(require("../../util/logger/logger"));
 const client_config_1 = require("./client-config");
+const listener_client_1 = require("../listener/listener-client");
 const addTokenMiddleware = (token) => function _(call, options) {
     return __asyncGenerator(this, arguments, function* _1() {
         var _a, e_1, _b, _c;
@@ -100,6 +101,7 @@ class HatchetClient {
         this.event = new event_client_1.EventClient(this.config, this.channel, clientFactory);
         this.dispatcher = new dispatcher_client_1.DispatcherClient(this.config, this.channel, clientFactory);
         this.admin = new admin_client_1.AdminClient(this.config, this.channel, clientFactory);
+        this.listener = new listener_client_1.ListenerClient(this.config, this.channel, clientFactory);
         this.logger = new logger_1.default('HatchetClient', this.config.log_level);
         this.logger.info(`Initialized HatchetClient`);
     }

package/clients/listener/listener-client.d.ts

@@ -0,0 +1,23 @@
+import { Channel, ClientFactory } from 'nice-grpc';
+import { DispatcherClient as PbDispatcherClient } from '../../protoc/dispatcher';
+import { ClientConfig } from '../hatchet-client/client-config';
+import { Logger } from '../../util/logger';
+export declare enum StepRunEventType {
+    STEP_RUN_EVENT_TYPE_STARTED = "STEP_RUN_EVENT_TYPE_STARTED",
+    STEP_RUN_EVENT_TYPE_COMPLETED = "STEP_RUN_EVENT_TYPE_COMPLETED",
+    STEP_RUN_EVENT_TYPE_FAILED = "STEP_RUN_EVENT_TYPE_FAILED",
+    STEP_RUN_EVENT_TYPE_CANCELLED = "STEP_RUN_EVENT_TYPE_CANCELLED",
+    STEP_RUN_EVENT_TYPE_TIMED_OUT = "STEP_RUN_EVENT_TYPE_TIMED_OUT"
+}
+export interface StepRunEvent {
+    type: StepRunEventType;
+    payload: string;
+}
+export declare class ListenerClient {
+    config: ClientConfig;
+    client: PbDispatcherClient;
+    logger: Logger;
+    constructor(config: ClientConfig, channel: Channel, factory: ClientFactory);
+    on(workflowRunId: string, handler: (event: StepRunEvent) => Promise<void>): Promise<void>;
+    retrySubscribe(workflowRunId: string): Promise<AsyncIterable<import("../../protoc/dispatcher").WorkflowEvent>>;
+}

package/clients/listener/listener-client.js

@@ -0,0 +1,120 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListenerClient = exports.StepRunEventType = void 0;
+const nice_grpc_1 = require("nice-grpc");
+const dispatcher_1 = require("../../protoc/dispatcher");
+const hatchet_error_1 = __importDefault(require("../../util/errors/hatchet-error"));
+const logger_1 = require("../../util/logger");
+const sleep_1 = __importDefault(require("../../util/sleep"));
+const DEFAULT_ACTION_LISTENER_RETRY_INTERVAL = 5; // seconds
+const DEFAULT_ACTION_LISTENER_RETRY_COUNT = 5;
+// eslint-disable-next-line no-shadow
+var StepRunEventType;
+(function (StepRunEventType) {
+    StepRunEventType["STEP_RUN_EVENT_TYPE_STARTED"] = "STEP_RUN_EVENT_TYPE_STARTED";
+    StepRunEventType["STEP_RUN_EVENT_TYPE_COMPLETED"] = "STEP_RUN_EVENT_TYPE_COMPLETED";
+    StepRunEventType["STEP_RUN_EVENT_TYPE_FAILED"] = "STEP_RUN_EVENT_TYPE_FAILED";
+    StepRunEventType["STEP_RUN_EVENT_TYPE_CANCELLED"] = "STEP_RUN_EVENT_TYPE_CANCELLED";
+    StepRunEventType["STEP_RUN_EVENT_TYPE_TIMED_OUT"] = "STEP_RUN_EVENT_TYPE_TIMED_OUT";
+})(StepRunEventType || (exports.StepRunEventType = StepRunEventType = {}));
+class ListenerClient {
+    constructor(config, channel, factory) {
+        this.config = config;
+        this.client = factory.create(dispatcher_1.DispatcherDefinition, channel);
+        this.logger = new logger_1.Logger(`Dispatcher`, config.log_level);
+    }
+    on(workflowRunId, handler) {
+        var _a, e_1, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            let listener = this.client.subscribeToWorkflowEvents({
+                workflowRunId,
+            });
+            try {
+                try {
+                    for (var _d = true, listener_1 = __asyncValues(listener), listener_1_1; listener_1_1 = yield listener_1.next(), _a = listener_1_1.done, !_a; _d = true) {
+                        _c = listener_1_1.value;
+                        _d = false;
+                        const workflowEvent = _c;
+                        let eventType;
+                        switch (workflowEvent.eventType) {
+                            case dispatcher_1.ResourceEventType.RESOURCE_EVENT_TYPE_STARTED:
+                                eventType = StepRunEventType.STEP_RUN_EVENT_TYPE_STARTED;
+                                break;
+                            case dispatcher_1.ResourceEventType.RESOURCE_EVENT_TYPE_COMPLETED:
+                                eventType = StepRunEventType.STEP_RUN_EVENT_TYPE_COMPLETED;
+                                break;
+                            case dispatcher_1.ResourceEventType.RESOURCE_EVENT_TYPE_FAILED:
+                                eventType = StepRunEventType.STEP_RUN_EVENT_TYPE_FAILED;
+                                break;
+                            case dispatcher_1.ResourceEventType.RESOURCE_EVENT_TYPE_CANCELLED:
+                                eventType = StepRunEventType.STEP_RUN_EVENT_TYPE_CANCELLED;
+                                break;
+                            case dispatcher_1.ResourceEventType.RESOURCE_EVENT_TYPE_TIMED_OUT:
+                                eventType = StepRunEventType.STEP_RUN_EVENT_TYPE_TIMED_OUT;
+                                break;
+                            default:
+                                throw new hatchet_error_1.default(`Unknown event type: ${workflowEvent.eventType}`);
+                        }
+                        yield handler({
+                            type: eventType,
+                            payload: workflowEvent.eventPayload,
+                        });
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = listener_1.return)) yield _b.call(listener_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }
+            catch (e) {
+                if (e.code === nice_grpc_1.Status.CANCELLED) {
+                    return;
+                }
+                if (e.code === nice_grpc_1.Status.UNAVAILABLE) {
+                    listener = yield this.retrySubscribe(workflowRunId);
+                }
+            }
+        });
+    }
+    retrySubscribe(workflowRunId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let retries = 0;
+            while (retries < DEFAULT_ACTION_LISTENER_RETRY_COUNT) {
+                try {
+                    yield (0, sleep_1.default)(DEFAULT_ACTION_LISTENER_RETRY_INTERVAL);
+                    const listener = this.client.subscribeToWorkflowEvents({
+                        workflowRunId,
+                    });
+                    return listener;
+                }
+                catch (e) {
+                    retries += 1;
+                }
+            }
+            throw new hatchet_error_1.default(`Could not subscribe to the worker after ${DEFAULT_ACTION_LISTENER_RETRY_COUNT} retries`);
+        });
+    }
+}
+exports.ListenerClient = ListenerClient;

package/clients/worker/worker.d.ts

@@ -13,7 +13,6 @@ export declare class Worker {
     killing: boolean;
     handle_kill: boolean;
     action_registry: ActionRegistry;
-    concurrency_action_registry: ActionRegistry;
     listener: ActionListener | undefined;
     futures: Record<Action['stepRunId'], HatchetPromise<any>>;
     contexts: Record<Action['stepRunId'], Context<any>>;

package/clients/worker/worker.js

@@ -35,7 +35,6 @@ class Worker {
         this.client = client;
         this.name = options.name;
         this.action_registry = {};
-        this.concurrency_action_registry = {};
         process.on('SIGTERM', () => this.exitGracefully());
         process.on('SIGINT', () => this.exitGracefully());
         this.killing = false;
@@ -46,9 +45,9 @@ class Worker {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const concurrency = ((_a = workflow.concurrency) === null || _a === void 0 ? void 0 : _a.action)
+                const concurrency = ((_a = workflow.concurrency) === null || _a === void 0 ? void 0 : _a.name)
                     ? {
-                        action: `${this.serviceName}:${workflow.concurrency.action}`,
+                        action: `${this.serviceName}:${workflow.concurrency.name}`,
                         maxRuns: workflow.concurrency.maxRuns || 1,
                         limitStrategy: workflow.concurrency.limitStrategy || workflows_1.ConcurrencyLimitStrategy.CANCEL_IN_PROGRESS,
                     }
@@ -87,11 +86,8 @@ class Worker {
                 acc[`${this.serviceName}:${step.name}`] = step.run;
                 return acc;
             }, {});
-            this.concurrency_action_registry = ((_b = workflow.concurrency) === null || _b === void 0 ? void 0 : _b.action)
-                ? {
-                    [`${this.serviceName}:${workflow.concurrency.action}`]: workflow.concurrency.key,
-                }
-                : {};
+            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);
         });
     }
     handleStartStepRun(action) {
@@ -148,6 +144,7 @@ class Worker {
         const context = new step_1.Context(action.actionPayload);
         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}'`);
@@ -218,17 +215,25 @@ class Worker {
         };
     }
     handleCancelStepRun(action) {
-        const { stepRunId } = action;
-        const future = this.futures[stepRunId];
-        const context = this.contexts[stepRunId];
-        //  TODO send cancel signal to context
-        // if (context && context.cancel) {
-        //   context.cancel();
-        //   delete this.contexts[stepRunId];
-        // }
-        if (future) {
-            future.cancel();
-            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];
+            }
+            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() {

package/index.d.ts

@@ -1,4 +1,5 @@
 import { HatchetClient as Hatchet } from './clients/hatchet-client';
 export * from './workflow';
 export * from './step';
+export * from './clients/worker';
 export default Hatchet;

package/index.js

@@ -17,4 +17,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const hatchet_client_1 = require("./clients/hatchet-client");
 __exportStar(require("./workflow"), exports);
 __exportStar(require("./step"), exports);
+__exportStar(require("./clients/worker"), exports);
 exports.default = hatchet_client_1.HatchetClient;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "Background task orchestration & visibility for developers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -29,6 +29,7 @@
     "exec": "npx dotenv -- ts-node -r tsconfig-paths/register --project tsconfig.json",
     "example:event": "npm run exec -- ./examples/example-event.ts",
     "worker:simple": "npm run exec -- ./examples/simple-worker.ts",
+    "manual:trigger": "npm run exec -- ./examples/manual-trigger.ts",
     "worker:dag": "npm run exec -- ./examples/dag-worker.ts",
     "worker:concurrency": "npm run exec -- ./examples/concurrency/concurrency-worker.ts",
     "event:concurrency": "npm run exec -- ./examples/concurrency/concurrency-event.ts",

package/protoc/dispatcher/dispatcher.d.ts

@@ -27,6 +27,25 @@ export declare enum StepActionEventType {
 }
 export declare function stepActionEventTypeFromJSON(object: any): StepActionEventType;
 export declare function stepActionEventTypeToJSON(object: StepActionEventType): string;
+export declare enum ResourceType {
+    RESOURCE_TYPE_UNKNOWN = 0,
+    RESOURCE_TYPE_STEP_RUN = 1,
+    RESOURCE_TYPE_WORKFLOW_RUN = 2,
+    UNRECOGNIZED = -1
+}
+export declare function resourceTypeFromJSON(object: any): ResourceType;
+export declare function resourceTypeToJSON(object: ResourceType): string;
+export declare enum ResourceEventType {
+    RESOURCE_EVENT_TYPE_UNKNOWN = 0,
+    RESOURCE_EVENT_TYPE_STARTED = 1,
+    RESOURCE_EVENT_TYPE_COMPLETED = 2,
+    RESOURCE_EVENT_TYPE_FAILED = 3,
+    RESOURCE_EVENT_TYPE_CANCELLED = 4,
+    RESOURCE_EVENT_TYPE_TIMED_OUT = 5,
+    UNRECOGNIZED = -1
+}
+export declare function resourceEventTypeFromJSON(object: any): ResourceEventType;
+export declare function resourceEventTypeToJSON(object: ResourceEventType): string;
 export interface WorkerRegisterRequest {
     /** the name of the worker */
     workerName: string;
@@ -120,6 +139,20 @@ export interface ActionEventResponse {
     /** the id of the worker */
     workerId: string;
 }
+export interface SubscribeToWorkflowEventsRequest {
+    /** the id of the workflow run */
+    workflowRunId: string;
+}
+export interface WorkflowEvent {
+    /** the id of the workflow run */
+    workflowRunId: string;
+    resourceType: ResourceType;
+    eventType: ResourceEventType;
+    resourceId: string;
+    eventTimestamp: Date | undefined;
+    /** the event payload */
+    eventPayload: string;
+}
 export declare const WorkerRegisterRequest: {
     encode(message: WorkerRegisterRequest, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number): WorkerRegisterRequest;
@@ -192,6 +225,22 @@ export declare const ActionEventResponse: {
     create(base?: DeepPartial<ActionEventResponse>): ActionEventResponse;
     fromPartial(object: DeepPartial<ActionEventResponse>): ActionEventResponse;
 };
+export declare const SubscribeToWorkflowEventsRequest: {
+    encode(message: SubscribeToWorkflowEventsRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): SubscribeToWorkflowEventsRequest;
+    fromJSON(object: any): SubscribeToWorkflowEventsRequest;
+    toJSON(message: SubscribeToWorkflowEventsRequest): unknown;
+    create(base?: DeepPartial<SubscribeToWorkflowEventsRequest>): SubscribeToWorkflowEventsRequest;
+    fromPartial(object: DeepPartial<SubscribeToWorkflowEventsRequest>): SubscribeToWorkflowEventsRequest;
+};
+export declare const WorkflowEvent: {
+    encode(message: WorkflowEvent, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): WorkflowEvent;
+    fromJSON(object: any): WorkflowEvent;
+    toJSON(message: WorkflowEvent): unknown;
+    create(base?: DeepPartial<WorkflowEvent>): WorkflowEvent;
+    fromPartial(object: DeepPartial<WorkflowEvent>): WorkflowEvent;
+};
 export type DispatcherDefinition = typeof DispatcherDefinition;
 export declare const DispatcherDefinition: {
     readonly name: "Dispatcher";
@@ -241,6 +290,28 @@ export declare const DispatcherDefinition: {
             readonly responseStream: true;
             readonly options: {};
         };
+        readonly subscribeToWorkflowEvents: {
+            readonly name: "SubscribeToWorkflowEvents";
+            readonly requestType: {
+                encode(message: SubscribeToWorkflowEventsRequest, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): SubscribeToWorkflowEventsRequest;
+                fromJSON(object: any): SubscribeToWorkflowEventsRequest;
+                toJSON(message: SubscribeToWorkflowEventsRequest): unknown;
+                create(base?: DeepPartial<SubscribeToWorkflowEventsRequest>): SubscribeToWorkflowEventsRequest;
+                fromPartial(object: DeepPartial<SubscribeToWorkflowEventsRequest>): SubscribeToWorkflowEventsRequest;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                encode(message: WorkflowEvent, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): WorkflowEvent;
+                fromJSON(object: any): WorkflowEvent;
+                toJSON(message: WorkflowEvent): unknown;
+                create(base?: DeepPartial<WorkflowEvent>): WorkflowEvent;
+                fromPartial(object: DeepPartial<WorkflowEvent>): WorkflowEvent;
+            };
+            readonly responseStream: true;
+            readonly options: {};
+        };
         readonly sendStepActionEvent: {
             readonly name: "SendStepActionEvent";
             readonly requestType: {
@@ -312,6 +383,7 @@ export declare const DispatcherDefinition: {
 export interface DispatcherServiceImplementation<CallContextExt = {}> {
     register(request: WorkerRegisterRequest, context: CallContext & CallContextExt): Promise<DeepPartial<WorkerRegisterResponse>>;
     listen(request: WorkerListenRequest, context: CallContext & CallContextExt): ServerStreamingMethodResult<DeepPartial<AssignedAction>>;
+    subscribeToWorkflowEvents(request: SubscribeToWorkflowEventsRequest, context: CallContext & CallContextExt): ServerStreamingMethodResult<DeepPartial<WorkflowEvent>>;
     sendStepActionEvent(request: StepActionEvent, context: CallContext & CallContextExt): Promise<DeepPartial<ActionEventResponse>>;
     sendGroupKeyActionEvent(request: GroupKeyActionEvent, context: CallContext & CallContextExt): Promise<DeepPartial<ActionEventResponse>>;
     unsubscribe(request: WorkerUnsubscribeRequest, context: CallContext & CallContextExt): Promise<DeepPartial<WorkerUnsubscribeResponse>>;
@@ -319,6 +391,7 @@ export interface DispatcherServiceImplementation<CallContextExt = {}> {
 export interface DispatcherClient<CallOptionsExt = {}> {
     register(request: DeepPartial<WorkerRegisterRequest>, options?: CallOptions & CallOptionsExt): Promise<WorkerRegisterResponse>;
     listen(request: DeepPartial<WorkerListenRequest>, options?: CallOptions & CallOptionsExt): AsyncIterable<AssignedAction>;
+    subscribeToWorkflowEvents(request: DeepPartial<SubscribeToWorkflowEventsRequest>, options?: CallOptions & CallOptionsExt): AsyncIterable<WorkflowEvent>;
     sendStepActionEvent(request: DeepPartial<StepActionEvent>, options?: CallOptions & CallOptionsExt): Promise<ActionEventResponse>;
     sendGroupKeyActionEvent(request: DeepPartial<GroupKeyActionEvent>, options?: CallOptions & CallOptionsExt): Promise<ActionEventResponse>;
     unsubscribe(request: DeepPartial<WorkerUnsubscribeRequest>, options?: CallOptions & CallOptionsExt): Promise<WorkerUnsubscribeResponse>;

package/protoc/dispatcher/dispatcher.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DispatcherDefinition = exports.ActionEventResponse = exports.StepActionEvent = exports.GroupKeyActionEvent = exports.WorkerUnsubscribeResponse = exports.WorkerUnsubscribeRequest = exports.WorkerListenRequest = exports.AssignedAction = exports.WorkerRegisterResponse = exports.WorkerRegisterRequest = exports.stepActionEventTypeToJSON = exports.stepActionEventTypeFromJSON = exports.StepActionEventType = exports.groupKeyActionEventTypeToJSON = exports.groupKeyActionEventTypeFromJSON = exports.GroupKeyActionEventType = exports.actionTypeToJSON = exports.actionTypeFromJSON = exports.ActionType = exports.protobufPackage = void 0;
+exports.DispatcherDefinition = exports.WorkflowEvent = exports.SubscribeToWorkflowEventsRequest = exports.ActionEventResponse = exports.StepActionEvent = exports.GroupKeyActionEvent = exports.WorkerUnsubscribeResponse = exports.WorkerUnsubscribeRequest = exports.WorkerListenRequest = exports.AssignedAction = exports.WorkerRegisterResponse = exports.WorkerRegisterRequest = exports.resourceEventTypeToJSON = exports.resourceEventTypeFromJSON = exports.ResourceEventType = exports.resourceTypeToJSON = exports.resourceTypeFromJSON = exports.ResourceType = exports.stepActionEventTypeToJSON = exports.stepActionEventTypeFromJSON = exports.StepActionEventType = exports.groupKeyActionEventTypeToJSON = exports.groupKeyActionEventTypeFromJSON = exports.GroupKeyActionEventType = exports.actionTypeToJSON = exports.actionTypeFromJSON = exports.ActionType = exports.protobufPackage = void 0;
 const _m0 = __importStar(require("protobufjs/minimal"));
 const timestamp_1 = require("../google/protobuf/timestamp");
 exports.protobufPackage = "";
@@ -156,6 +156,102 @@ function stepActionEventTypeToJSON(object) {
     }
 }
 exports.stepActionEventTypeToJSON = stepActionEventTypeToJSON;
+var ResourceType;
+(function (ResourceType) {
+    ResourceType[ResourceType["RESOURCE_TYPE_UNKNOWN"] = 0] = "RESOURCE_TYPE_UNKNOWN";
+    ResourceType[ResourceType["RESOURCE_TYPE_STEP_RUN"] = 1] = "RESOURCE_TYPE_STEP_RUN";
+    ResourceType[ResourceType["RESOURCE_TYPE_WORKFLOW_RUN"] = 2] = "RESOURCE_TYPE_WORKFLOW_RUN";
+    ResourceType[ResourceType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(ResourceType || (exports.ResourceType = ResourceType = {}));
+function resourceTypeFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "RESOURCE_TYPE_UNKNOWN":
+            return ResourceType.RESOURCE_TYPE_UNKNOWN;
+        case 1:
+        case "RESOURCE_TYPE_STEP_RUN":
+            return ResourceType.RESOURCE_TYPE_STEP_RUN;
+        case 2:
+        case "RESOURCE_TYPE_WORKFLOW_RUN":
+            return ResourceType.RESOURCE_TYPE_WORKFLOW_RUN;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return ResourceType.UNRECOGNIZED;
+    }
+}
+exports.resourceTypeFromJSON = resourceTypeFromJSON;
+function resourceTypeToJSON(object) {
+    switch (object) {
+        case ResourceType.RESOURCE_TYPE_UNKNOWN:
+            return "RESOURCE_TYPE_UNKNOWN";
+        case ResourceType.RESOURCE_TYPE_STEP_RUN:
+            return "RESOURCE_TYPE_STEP_RUN";
+        case ResourceType.RESOURCE_TYPE_WORKFLOW_RUN:
+            return "RESOURCE_TYPE_WORKFLOW_RUN";
+        case ResourceType.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+exports.resourceTypeToJSON = resourceTypeToJSON;
+var ResourceEventType;
+(function (ResourceEventType) {
+    ResourceEventType[ResourceEventType["RESOURCE_EVENT_TYPE_UNKNOWN"] = 0] = "RESOURCE_EVENT_TYPE_UNKNOWN";
+    ResourceEventType[ResourceEventType["RESOURCE_EVENT_TYPE_STARTED"] = 1] = "RESOURCE_EVENT_TYPE_STARTED";
+    ResourceEventType[ResourceEventType["RESOURCE_EVENT_TYPE_COMPLETED"] = 2] = "RESOURCE_EVENT_TYPE_COMPLETED";
+    ResourceEventType[ResourceEventType["RESOURCE_EVENT_TYPE_FAILED"] = 3] = "RESOURCE_EVENT_TYPE_FAILED";
+    ResourceEventType[ResourceEventType["RESOURCE_EVENT_TYPE_CANCELLED"] = 4] = "RESOURCE_EVENT_TYPE_CANCELLED";
+    ResourceEventType[ResourceEventType["RESOURCE_EVENT_TYPE_TIMED_OUT"] = 5] = "RESOURCE_EVENT_TYPE_TIMED_OUT";
+    ResourceEventType[ResourceEventType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(ResourceEventType || (exports.ResourceEventType = ResourceEventType = {}));
+function resourceEventTypeFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "RESOURCE_EVENT_TYPE_UNKNOWN":
+            return ResourceEventType.RESOURCE_EVENT_TYPE_UNKNOWN;
+        case 1:
+        case "RESOURCE_EVENT_TYPE_STARTED":
+            return ResourceEventType.RESOURCE_EVENT_TYPE_STARTED;
+        case 2:
+        case "RESOURCE_EVENT_TYPE_COMPLETED":
+            return ResourceEventType.RESOURCE_EVENT_TYPE_COMPLETED;
+        case 3:
+        case "RESOURCE_EVENT_TYPE_FAILED":
+            return ResourceEventType.RESOURCE_EVENT_TYPE_FAILED;
+        case 4:
+        case "RESOURCE_EVENT_TYPE_CANCELLED":
+            return ResourceEventType.RESOURCE_EVENT_TYPE_CANCELLED;
+        case 5:
+        case "RESOURCE_EVENT_TYPE_TIMED_OUT":
+            return ResourceEventType.RESOURCE_EVENT_TYPE_TIMED_OUT;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return ResourceEventType.UNRECOGNIZED;
+    }
+}
+exports.resourceEventTypeFromJSON = resourceEventTypeFromJSON;
+function resourceEventTypeToJSON(object) {
+    switch (object) {
+        case ResourceEventType.RESOURCE_EVENT_TYPE_UNKNOWN:
+            return "RESOURCE_EVENT_TYPE_UNKNOWN";
+        case ResourceEventType.RESOURCE_EVENT_TYPE_STARTED:
+            return "RESOURCE_EVENT_TYPE_STARTED";
+        case ResourceEventType.RESOURCE_EVENT_TYPE_COMPLETED:
+            return "RESOURCE_EVENT_TYPE_COMPLETED";
+        case ResourceEventType.RESOURCE_EVENT_TYPE_FAILED:
+            return "RESOURCE_EVENT_TYPE_FAILED";
+        case ResourceEventType.RESOURCE_EVENT_TYPE_CANCELLED:
+            return "RESOURCE_EVENT_TYPE_CANCELLED";
+        case ResourceEventType.RESOURCE_EVENT_TYPE_TIMED_OUT:
+            return "RESOURCE_EVENT_TYPE_TIMED_OUT";
+        case ResourceEventType.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+exports.resourceEventTypeToJSON = resourceEventTypeToJSON;
 function createBaseWorkerRegisterRequest() {
     return { workerName: "", actions: [], services: [] };
 }
@@ -1080,6 +1176,187 @@ exports.ActionEventResponse = {
         return message;
     },
 };
+function createBaseSubscribeToWorkflowEventsRequest() {
+    return { workflowRunId: "" };
+}
+exports.SubscribeToWorkflowEventsRequest = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.workflowRunId !== "") {
+            writer.uint32(10).string(message.workflowRunId);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseSubscribeToWorkflowEventsRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.workflowRunId = reader.string();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return { workflowRunId: isSet(object.workflowRunId) ? globalThis.String(object.workflowRunId) : "" };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.workflowRunId !== "") {
+            obj.workflowRunId = message.workflowRunId;
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.SubscribeToWorkflowEventsRequest.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a;
+        const message = createBaseSubscribeToWorkflowEventsRequest();
+        message.workflowRunId = (_a = object.workflowRunId) !== null && _a !== void 0 ? _a : "";
+        return message;
+    },
+};
+function createBaseWorkflowEvent() {
+    return {
+        workflowRunId: "",
+        resourceType: 0,
+        eventType: 0,
+        resourceId: "",
+        eventTimestamp: undefined,
+        eventPayload: "",
+    };
+}
+exports.WorkflowEvent = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.workflowRunId !== "") {
+            writer.uint32(10).string(message.workflowRunId);
+        }
+        if (message.resourceType !== 0) {
+            writer.uint32(16).int32(message.resourceType);
+        }
+        if (message.eventType !== 0) {
+            writer.uint32(24).int32(message.eventType);
+        }
+        if (message.resourceId !== "") {
+            writer.uint32(34).string(message.resourceId);
+        }
+        if (message.eventTimestamp !== undefined) {
+            timestamp_1.Timestamp.encode(toTimestamp(message.eventTimestamp), writer.uint32(42).fork()).ldelim();
+        }
+        if (message.eventPayload !== "") {
+            writer.uint32(50).string(message.eventPayload);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseWorkflowEvent();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.workflowRunId = reader.string();
+                    continue;
+                case 2:
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.resourceType = reader.int32();
+                    continue;
+                case 3:
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.eventType = reader.int32();
+                    continue;
+                case 4:
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.resourceId = reader.string();
+                    continue;
+                case 5:
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.eventTimestamp = fromTimestamp(timestamp_1.Timestamp.decode(reader, reader.uint32()));
+                    continue;
+                case 6:
+                    if (tag !== 50) {
+                        break;
+                    }
+                    message.eventPayload = reader.string();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            workflowRunId: isSet(object.workflowRunId) ? globalThis.String(object.workflowRunId) : "",
+            resourceType: isSet(object.resourceType) ? resourceTypeFromJSON(object.resourceType) : 0,
+            eventType: isSet(object.eventType) ? resourceEventTypeFromJSON(object.eventType) : 0,
+            resourceId: isSet(object.resourceId) ? globalThis.String(object.resourceId) : "",
+            eventTimestamp: isSet(object.eventTimestamp) ? fromJsonTimestamp(object.eventTimestamp) : undefined,
+            eventPayload: isSet(object.eventPayload) ? globalThis.String(object.eventPayload) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.workflowRunId !== "") {
+            obj.workflowRunId = message.workflowRunId;
+        }
+        if (message.resourceType !== 0) {
+            obj.resourceType = resourceTypeToJSON(message.resourceType);
+        }
+        if (message.eventType !== 0) {
+            obj.eventType = resourceEventTypeToJSON(message.eventType);
+        }
+        if (message.resourceId !== "") {
+            obj.resourceId = message.resourceId;
+        }
+        if (message.eventTimestamp !== undefined) {
+            obj.eventTimestamp = message.eventTimestamp.toISOString();
+        }
+        if (message.eventPayload !== "") {
+            obj.eventPayload = message.eventPayload;
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.WorkflowEvent.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a, _b, _c, _d, _e, _f;
+        const message = createBaseWorkflowEvent();
+        message.workflowRunId = (_a = object.workflowRunId) !== null && _a !== void 0 ? _a : "";
+        message.resourceType = (_b = object.resourceType) !== null && _b !== void 0 ? _b : 0;
+        message.eventType = (_c = object.eventType) !== null && _c !== void 0 ? _c : 0;
+        message.resourceId = (_d = object.resourceId) !== null && _d !== void 0 ? _d : "";
+        message.eventTimestamp = (_e = object.eventTimestamp) !== null && _e !== void 0 ? _e : undefined;
+        message.eventPayload = (_f = object.eventPayload) !== null && _f !== void 0 ? _f : "";
+        return message;
+    },
+};
 exports.DispatcherDefinition = {
     name: "Dispatcher",
     fullName: "Dispatcher",
@@ -1100,6 +1377,14 @@ exports.DispatcherDefinition = {
             responseStream: true,
             options: {},
         },
+        subscribeToWorkflowEvents: {
+            name: "SubscribeToWorkflowEvents",
+            requestType: exports.SubscribeToWorkflowEventsRequest,
+            requestStream: false,
+            responseType: exports.WorkflowEvent,
+            responseStream: true,
+            options: {},
+        },
         sendStepActionEvent: {
             name: "SendStepActionEvent",
             requestType: exports.StepActionEvent,

package/protoc/workflows/workflows.d.ts

@@ -157,6 +157,14 @@ export interface DeleteWorkflowRequest {
 export interface GetWorkflowByNameRequest {
     name: string;
 }
+export interface TriggerWorkflowRequest {
+    name: string;
+    /** (optional) the input data for the workflow */
+    input: string;
+}
+export interface TriggerWorkflowResponse {
+    workflowRunId: string;
+}
 export declare const PutWorkflowRequest: {
     encode(message: PutWorkflowRequest, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number): PutWorkflowRequest;
@@ -301,6 +309,22 @@ export declare const GetWorkflowByNameRequest: {
     create(base?: DeepPartial<GetWorkflowByNameRequest>): GetWorkflowByNameRequest;
     fromPartial(object: DeepPartial<GetWorkflowByNameRequest>): GetWorkflowByNameRequest;
 };
+export declare const TriggerWorkflowRequest: {
+    encode(message: TriggerWorkflowRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): TriggerWorkflowRequest;
+    fromJSON(object: any): TriggerWorkflowRequest;
+    toJSON(message: TriggerWorkflowRequest): unknown;
+    create(base?: DeepPartial<TriggerWorkflowRequest>): TriggerWorkflowRequest;
+    fromPartial(object: DeepPartial<TriggerWorkflowRequest>): TriggerWorkflowRequest;
+};
+export declare const TriggerWorkflowResponse: {
+    encode(message: TriggerWorkflowResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): TriggerWorkflowResponse;
+    fromJSON(object: any): TriggerWorkflowResponse;
+    toJSON(message: TriggerWorkflowResponse): unknown;
+    create(base?: DeepPartial<TriggerWorkflowResponse>): TriggerWorkflowResponse;
+    fromPartial(object: DeepPartial<TriggerWorkflowResponse>): TriggerWorkflowResponse;
+};
 /** WorkflowService represents a set of RPCs for managing workflows. */
 export type WorkflowServiceDefinition = typeof WorkflowServiceDefinition;
 export declare const WorkflowServiceDefinition: {
@@ -373,6 +397,28 @@ export declare const WorkflowServiceDefinition: {
             readonly responseStream: false;
             readonly options: {};
         };
+        readonly triggerWorkflow: {
+            readonly name: "TriggerWorkflow";
+            readonly requestType: {
+                encode(message: TriggerWorkflowRequest, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): TriggerWorkflowRequest;
+                fromJSON(object: any): TriggerWorkflowRequest;
+                toJSON(message: TriggerWorkflowRequest): unknown;
+                create(base?: DeepPartial<TriggerWorkflowRequest>): TriggerWorkflowRequest;
+                fromPartial(object: DeepPartial<TriggerWorkflowRequest>): TriggerWorkflowRequest;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                encode(message: TriggerWorkflowResponse, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): TriggerWorkflowResponse;
+                fromJSON(object: any): TriggerWorkflowResponse;
+                toJSON(message: TriggerWorkflowResponse): unknown;
+                create(base?: DeepPartial<TriggerWorkflowResponse>): TriggerWorkflowResponse;
+                fromPartial(object: DeepPartial<TriggerWorkflowResponse>): TriggerWorkflowResponse;
+            };
+            readonly responseStream: false;
+            readonly options: {};
+        };
         readonly getWorkflowByName: {
             readonly name: "GetWorkflowByName";
             readonly requestType: {
@@ -445,6 +491,7 @@ export interface WorkflowServiceImplementation<CallContextExt = {}> {
     listWorkflows(request: ListWorkflowsRequest, context: CallContext & CallContextExt): Promise<DeepPartial<ListWorkflowsResponse>>;
     putWorkflow(request: PutWorkflowRequest, context: CallContext & CallContextExt): Promise<DeepPartial<WorkflowVersion>>;
     scheduleWorkflow(request: ScheduleWorkflowRequest, context: CallContext & CallContextExt): Promise<DeepPartial<WorkflowVersion>>;
+    triggerWorkflow(request: TriggerWorkflowRequest, context: CallContext & CallContextExt): Promise<DeepPartial<TriggerWorkflowResponse>>;
     getWorkflowByName(request: GetWorkflowByNameRequest, context: CallContext & CallContextExt): Promise<DeepPartial<Workflow>>;
     listWorkflowsForEvent(request: ListWorkflowsForEventRequest, context: CallContext & CallContextExt): Promise<DeepPartial<ListWorkflowsResponse>>;
     deleteWorkflow(request: DeleteWorkflowRequest, context: CallContext & CallContextExt): Promise<DeepPartial<Workflow>>;
@@ -453,6 +500,7 @@ export interface WorkflowServiceClient<CallOptionsExt = {}> {
     listWorkflows(request: DeepPartial<ListWorkflowsRequest>, options?: CallOptions & CallOptionsExt): Promise<ListWorkflowsResponse>;
     putWorkflow(request: DeepPartial<PutWorkflowRequest>, options?: CallOptions & CallOptionsExt): Promise<WorkflowVersion>;
     scheduleWorkflow(request: DeepPartial<ScheduleWorkflowRequest>, options?: CallOptions & CallOptionsExt): Promise<WorkflowVersion>;
+    triggerWorkflow(request: DeepPartial<TriggerWorkflowRequest>, options?: CallOptions & CallOptionsExt): Promise<TriggerWorkflowResponse>;
     getWorkflowByName(request: DeepPartial<GetWorkflowByNameRequest>, options?: CallOptions & CallOptionsExt): Promise<Workflow>;
     listWorkflowsForEvent(request: DeepPartial<ListWorkflowsForEventRequest>, options?: CallOptions & CallOptionsExt): Promise<ListWorkflowsResponse>;
     deleteWorkflow(request: DeepPartial<DeleteWorkflowRequest>, options?: CallOptions & CallOptionsExt): Promise<Workflow>;

package/protoc/workflows/workflows.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WorkflowServiceDefinition = exports.GetWorkflowByNameRequest = exports.DeleteWorkflowRequest = exports.Step = exports.Job = exports.WorkflowTriggerCronRef = exports.WorkflowTriggerEventRef = exports.WorkflowTriggers = exports.WorkflowVersion = exports.Workflow = exports.ListWorkflowsForEventRequest = exports.ListWorkflowsResponse = exports.ScheduleWorkflowRequest = exports.ListWorkflowsRequest = exports.CreateWorkflowStepOpts = exports.CreateWorkflowJobOpts = exports.WorkflowConcurrencyOpts = exports.CreateWorkflowVersionOpts = exports.PutWorkflowRequest = exports.concurrencyLimitStrategyToJSON = exports.concurrencyLimitStrategyFromJSON = exports.ConcurrencyLimitStrategy = exports.protobufPackage = void 0;
+exports.WorkflowServiceDefinition = exports.TriggerWorkflowResponse = exports.TriggerWorkflowRequest = exports.GetWorkflowByNameRequest = exports.DeleteWorkflowRequest = exports.Step = exports.Job = exports.WorkflowTriggerCronRef = exports.WorkflowTriggerEventRef = exports.WorkflowTriggers = exports.WorkflowVersion = exports.Workflow = exports.ListWorkflowsForEventRequest = exports.ListWorkflowsResponse = exports.ScheduleWorkflowRequest = exports.ListWorkflowsRequest = exports.CreateWorkflowStepOpts = exports.CreateWorkflowJobOpts = exports.WorkflowConcurrencyOpts = exports.CreateWorkflowVersionOpts = exports.PutWorkflowRequest = exports.concurrencyLimitStrategyToJSON = exports.concurrencyLimitStrategyFromJSON = exports.ConcurrencyLimitStrategy = exports.protobufPackage = void 0;
 const _m0 = __importStar(require("protobufjs/minimal"));
 const timestamp_1 = require("../google/protobuf/timestamp");
 const wrappers_1 = require("../google/protobuf/wrappers");
@@ -1871,6 +1871,124 @@ exports.GetWorkflowByNameRequest = {
         return message;
     },
 };
+function createBaseTriggerWorkflowRequest() {
+    return { name: "", input: "" };
+}
+exports.TriggerWorkflowRequest = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.name !== "") {
+            writer.uint32(10).string(message.name);
+        }
+        if (message.input !== "") {
+            writer.uint32(18).string(message.input);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseTriggerWorkflowRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.name = reader.string();
+                    continue;
+                case 2:
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.input = reader.string();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            name: isSet(object.name) ? globalThis.String(object.name) : "",
+            input: isSet(object.input) ? globalThis.String(object.input) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.name !== "") {
+            obj.name = message.name;
+        }
+        if (message.input !== "") {
+            obj.input = message.input;
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.TriggerWorkflowRequest.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a, _b;
+        const message = createBaseTriggerWorkflowRequest();
+        message.name = (_a = object.name) !== null && _a !== void 0 ? _a : "";
+        message.input = (_b = object.input) !== null && _b !== void 0 ? _b : "";
+        return message;
+    },
+};
+function createBaseTriggerWorkflowResponse() {
+    return { workflowRunId: "" };
+}
+exports.TriggerWorkflowResponse = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.workflowRunId !== "") {
+            writer.uint32(10).string(message.workflowRunId);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseTriggerWorkflowResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.workflowRunId = reader.string();
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return { workflowRunId: isSet(object.workflowRunId) ? globalThis.String(object.workflowRunId) : "" };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.workflowRunId !== "") {
+            obj.workflowRunId = message.workflowRunId;
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.TriggerWorkflowResponse.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a;
+        const message = createBaseTriggerWorkflowResponse();
+        message.workflowRunId = (_a = object.workflowRunId) !== null && _a !== void 0 ? _a : "";
+        return message;
+    },
+};
 exports.WorkflowServiceDefinition = {
     name: "WorkflowService",
     fullName: "WorkflowService",
@@ -1899,6 +2017,14 @@ exports.WorkflowServiceDefinition = {
             responseStream: false,
             options: {},
         },
+        triggerWorkflow: {
+            name: "TriggerWorkflow",
+            requestType: exports.TriggerWorkflowRequest,
+            requestStream: false,
+            responseType: exports.TriggerWorkflowResponse,
+            responseStream: false,
+            options: {},
+        },
         getWorkflowByName: {
             name: "GetWorkflowByName",
             requestType: exports.GetWorkflowByNameRequest,

package/step.d.ts

@@ -22,6 +22,7 @@ interface ContextData<T = unknown> {
 }
 export declare class Context<T = unknown> {
     data: ContextData<T>;
+    controller: AbortController;
     constructor(payload: string);
     stepOutput(step: string): string;
     triggeredByEvent(): boolean;

package/step.js

@@ -37,6 +37,7 @@ exports.CreateStepSchema = z.object({
 });
 class Context {
     constructor(payload) {
+        this.controller = new AbortController();
         try {
             this.data = JSON.parse(JSON.parse(payload));
         }

package/workflow.d.ts

@@ -17,15 +17,15 @@ declare const StepsSchema: z.ZodArray<z.ZodObject<{
 export type Steps = z.infer<typeof StepsSchema>;
 export declare const ConcurrencyLimitStrategy: typeof PbConcurrencyLimitStrategy;
 export declare const WorkflowConcurrency: z.ZodObject<{
-    action: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
     maxRuns: z.ZodOptional<z.ZodNumber>;
     limitStrategy: z.ZodOptional<z.ZodNativeEnum<typeof PbConcurrencyLimitStrategy>>;
 }, "strip", z.ZodTypeAny, {
-    action?: string | undefined;
+    name: string;
     maxRuns?: number | undefined;
     limitStrategy?: PbConcurrencyLimitStrategy | undefined;
 }, {
-    action?: string | undefined;
+    name: string;
     maxRuns?: number | undefined;
     limitStrategy?: PbConcurrencyLimitStrategy | undefined;
 }>;

package/workflow.js

@@ -39,7 +39,7 @@ const OnConfigSchema = z.union([CronConfigSchema, EventConfigSchema]);
 const StepsSchema = z.array(step_1.CreateStepSchema);
 exports.ConcurrencyLimitStrategy = workflows_1.ConcurrencyLimitStrategy;
 exports.WorkflowConcurrency = z.object({
-    action: z.string().optional(),
+    name: z.string(),
     maxRuns: z.number().optional(),
     limitStrategy: z.nativeEnum(exports.ConcurrencyLimitStrategy).optional(),
 });