@hatchet-dev/typescript-sdk 0.14.0 → 0.15.1-alpha0

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

@@ -12,6 +12,17 @@ type WorkflowMetricsQuery = {
     status?: WorkflowRunStatus;
     groupKey?: string;
 };
+export type WorkflowRun<T = object> = {
+    workflowName: string;
+    input: T;
+    options?: {
+        parentId?: string | undefined;
+        parentStepRunId?: string | undefined;
+        childIndex?: number | undefined;
+        childKey?: string | undefined;
+        additionalMetadata?: Record<string, string> | undefined;
+    };
+};
 /**
  * AdminClient is a client for interacting with the Hatchet Admin API. This allows you to configure, trigger,
  * and monitor workflows.
@@ -78,6 +89,24 @@ export declare class AdminClient {
         additionalMetadata?: Record<string, string> | undefined;
         desiredWorkerId?: string | undefined;
     }): WorkflowRunRef<P>;
+    /**
+     * Run multiple workflows runs with the given input and options. This will create new workflow runs and return their IDs.
+     * Order is preserved in the response.
+     * @param workflowRuns an array of objects containing the workflow name, input, and options for each workflow run
+     * @returns an array of workflow run references
+     */
+    runWorkflows<Q = object, P = object>(workflowRuns: Array<{
+        workflowName: string;
+        input: Q;
+        options?: {
+            parentId?: string | undefined;
+            parentStepRunId?: string | undefined;
+            childIndex?: number | undefined;
+            childKey?: string | undefined;
+            additionalMetadata?: Record<string, string> | undefined;
+            desiredWorkerId?: string | undefined;
+        };
+    }>): Promise<WorkflowRunRef<P>[]>;
     /**
      * @deprecated use listWorkflows instead
      */

package/clients/admin/admin-client.js

@@ -127,6 +127,40 @@ class AdminClient {
             throw new hatchet_error_1.default(e.message);
         }
     }
+    /**
+     * Run multiple workflows runs with the given input and options. This will create new workflow runs and return their IDs.
+     * Order is preserved in the response.
+     * @param workflowRuns an array of objects containing the workflow name, input, and options for each workflow run
+     * @returns an array of workflow run references
+     */
+    runWorkflows(workflowRuns) {
+        // Prepare workflows to be triggered in bulk
+        const workflowRequests = workflowRuns.map(({ workflowName, input, options }) => {
+            let computedName = workflowName;
+            if (this.config.namespace && !workflowName.startsWith(this.config.namespace)) {
+                computedName = this.config.namespace + workflowName;
+            }
+            const inputStr = JSON.stringify(input);
+            return Object.assign(Object.assign({ name: computedName, input: inputStr }, options), { additionalMetadata: (options === null || options === void 0 ? void 0 : options.additionalMetadata)
+                    ? JSON.stringify(options.additionalMetadata)
+                    : undefined });
+        });
+        try {
+            // Call the bulk trigger workflow method
+            const bulkTriggerWorkflowResponse = this.client.bulkTriggerWorkflow(workflows_1.BulkTriggerWorkflowRequest.create({
+                workflows: workflowRequests,
+            }));
+            return bulkTriggerWorkflowResponse.then((res) => {
+                return res.workflowRunIds.map((resp, index) => {
+                    const { options } = workflowRuns[index];
+                    return new workflow_run_ref_1.default(resp, this.listenerClient, options === null || options === void 0 ? void 0 : options.parentId);
+                });
+            });
+        }
+        catch (e) {
+            throw new hatchet_error_1.default(e.message);
+        }
+    }
     /**
      * @deprecated use listWorkflows instead
      */

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

@@ -11,7 +11,6 @@ export declare class Streamable {
 export declare class GrpcPooledListener {
     listener: AsyncIterable<WorkflowRunEvent> | undefined;
     requestEmitter: EventEmitter<[never]>;
-    signal: AbortController;
     client: ListenerClient;
     subscribers: Record<string, Streamable>;
     onFinish: () => void;

package/clients/listener/child-listener-client.js

@@ -38,7 +38,7 @@ const events_1 = require("events");
 const dispatcher_1 = require("../../protoc/dispatcher");
 const abort_controller_x_1 = require("abort-controller-x");
 const sleep_1 = __importDefault(require("../../util/sleep"));
-const DEFAULT_EVENT_LISTENER_RETRY_INTERVAL = 5; // seconds
+const DEFAULT_EVENT_LISTENER_RETRY_INTERVAL = 0.5; // seconds
 const DEFAULT_EVENT_LISTENER_RETRY_COUNT = 20;
 class Streamable {
     constructor(listener, id) {
@@ -61,7 +61,6 @@ exports.Streamable = Streamable;
 class GrpcPooledListener {
     constructor(client, onFinish) {
         this.requestEmitter = new events_1.EventEmitter();
-        this.signal = new AbortController();
         this.subscribers = {};
         this.onFinish = () => { };
         this.client = client;
@@ -79,9 +78,7 @@ class GrpcPooledListener {
             }
             try {
                 this.client.logger.debug('Initializing child-listener');
-                this.listener = this.client.client.subscribeToWorkflowRuns(this.request(), {
-                    signal: this.signal.signal,
-                });
+                this.listener = this.client.client.subscribeToWorkflowRuns(this.request(), {});
                 if (retries > 0)
                     setTimeout(() => this.replayRequests(), 100);
                 try {
@@ -97,8 +94,7 @@ class GrpcPooledListener {
                                 if (Object.keys(this.subscribers).length === 0) {
                                     // FIXME it would be better to cleanup on parent complete
                                     this.client.logger.debug('All subscriptions finished, cleaning up listener');
-                                    this.signal.abort();
-                                    this.onFinish();
+                                    break;
                                 }
                             }
                         }
@@ -113,13 +109,14 @@ class GrpcPooledListener {
                 }
             }
             catch (e) {
-                if ((0, abort_controller_x_1.isAbortError)(e)) {
-                    this.client.logger.debug('Child Listener aborted');
+                if (!(0, abort_controller_x_1.isAbortError)(e)) {
+                    this.client.logger.error(`Error in child-listener: ${e.message}`);
+                    this.init(retries + 1);
                     return;
                 }
-                this.client.logger.error(`Error in child-listener: ${e.message}`);
-                this.init(retries + 1);
+                this.client.logger.debug('Child Listener aborted');
             }
+            this.onFinish();
         });
     }
     subscribe(request) {

package/clients/rest/generated/Api.d.ts

@@ -1,4 +1,4 @@
-import { AcceptInviteRequest, APIErrors, APIMeta, BulkCreateEventRequest, BulkCreateEventResponse, CancelEventRequest, CreateAPITokenRequest, CreateAPITokenResponse, CreateEventRequest, CreateSNSIntegrationRequest, CreateTenantAlertEmailGroupRequest, CreateTenantInviteRequest, CreateTenantRequest, Event, EventData, EventKey, EventKeyList, EventList, EventOrderByDirection, EventOrderByField, EventSearch, ListAPIMetaIntegration, ListAPITokensResponse, ListSlackWebhooks, ListSNSIntegrations, LogLineLevelField, LogLineList, LogLineOrderByDirection, LogLineOrderByField, LogLineSearch, RateLimitList, RateLimitOrderByDirection, RateLimitOrderByField, RejectInviteRequest, ReplayEventRequest, ReplayWorkflowRunsRequest, ReplayWorkflowRunsResponse, RerunStepRunRequest, SNSIntegration, StepRun, StepRunArchiveList, StepRunEventList, Tenant, TenantAlertEmailGroup, TenantAlertEmailGroupList, TenantAlertingSettings, TenantInvite, TenantInviteList, TenantMember, TenantMemberList, TenantQueueMetrics, TenantResourcePolicy, TriggerWorkflowRunRequest, UpdateTenantAlertEmailGroupRequest, UpdateTenantInviteRequest, UpdateTenantRequest, UpdateWorkerRequest, User, UserChangePasswordRequest, UserLoginRequest, UserRegisterRequest, UserTenantMembershipsList, WebhookWorkerCreated, WebhookWorkerCreateRequest, WebhookWorkerListResponse, WebhookWorkerRequestListResponse, Worker, WorkerList, Workflow, WorkflowID, WorkflowKindList, WorkflowList, WorkflowMetrics, WorkflowRun, WorkflowRunList, WorkflowRunOrderByDirection, WorkflowRunOrderByField, WorkflowRunsCancelRequest, WorkflowRunShape, WorkflowRunsMetrics, WorkflowRunStatus, WorkflowRunStatusList, WorkflowUpdateRequest, WorkflowVersion, WorkflowWorkersCount } from './data-contracts';
+import { AcceptInviteRequest, APIErrors, APIMeta, BulkCreateEventRequest, BulkCreateEventResponse, CancelEventRequest, CreateAPITokenRequest, CreateAPITokenResponse, CreateEventRequest, CreateSNSIntegrationRequest, CreateTenantAlertEmailGroupRequest, CreateTenantInviteRequest, CreateTenantRequest, Event, EventData, EventKey, EventKeyList, EventList, EventOrderByDirection, EventOrderByField, EventSearch, ListAPIMetaIntegration, ListAPITokensResponse, ListSlackWebhooks, ListSNSIntegrations, LogLineLevelField, LogLineList, LogLineOrderByDirection, LogLineOrderByField, LogLineSearch, RateLimitList, RateLimitOrderByDirection, RateLimitOrderByField, RejectInviteRequest, ReplayEventRequest, ReplayWorkflowRunsRequest, ReplayWorkflowRunsResponse, RerunStepRunRequest, SNSIntegration, StepRun, StepRunArchiveList, StepRunEventList, Tenant, TenantAlertEmailGroup, TenantAlertEmailGroupList, TenantAlertingSettings, TenantInvite, TenantInviteList, TenantMember, TenantMemberList, TenantQueueMetrics, TenantResourcePolicy, TenantStepRunQueueMetrics, TriggerWorkflowRunRequest, UpdateTenantAlertEmailGroupRequest, UpdateTenantInviteRequest, UpdateTenantRequest, UpdateWorkerRequest, User, UserChangePasswordRequest, UserLoginRequest, UserRegisterRequest, UserTenantMembershipsList, WebhookWorkerCreated, WebhookWorkerCreateRequest, WebhookWorkerListResponse, WebhookWorkerRequestListResponse, Worker, WorkerList, Workflow, WorkflowID, WorkflowKindList, WorkflowList, WorkflowMetrics, WorkflowRun, WorkflowRunList, WorkflowRunOrderByDirection, WorkflowRunOrderByField, WorkflowRunsCancelRequest, WorkflowRunShape, WorkflowRunsMetrics, WorkflowRunStatus, WorkflowRunStatusList, WorkflowUpdateRequest, WorkflowVersion, WorkflowWorkersCount } from './data-contracts';
 import { HttpClient, RequestParams } from './http-client';
 export declare class Api<SecurityDataType = unknown> extends HttpClient<SecurityDataType> {
     /**
@@ -416,6 +416,16 @@ export declare class Api<SecurityDataType = unknown> extends HttpClient<Security
          */
         additionalMetadata?: string[];
     }, params?: RequestParams) => Promise<import("axios").AxiosResponse<TenantQueueMetrics, any>>;
+    /**
+     * @description Get the queue metrics for the tenant
+     *
+     * @tags Tenant
+     * @name TenantGetStepRunQueueMetrics
+     * @summary Get step run metrics
+     * @request GET:/api/v1/tenants/{tenant}/step-run-queue-metrics
+     * @secure
+     */
+    tenantGetStepRunQueueMetrics: (tenant: string, params?: RequestParams) => Promise<import("axios").AxiosResponse<TenantStepRunQueueMetrics, any>>;
     /**
      * @description Lists all events for a tenant.
      *

package/clients/rest/generated/Api.js

@@ -422,6 +422,16 @@ class Api extends http_client_1.HttpClient {
          * @secure
          */
         this.tenantGetQueueMetrics = (tenant, query, params = {}) => this.request(Object.assign({ path: `/api/v1/tenants/${tenant}/queue-metrics`, method: 'GET', query: query, secure: true, format: 'json' }, params));
+        /**
+         * @description Get the queue metrics for the tenant
+         *
+         * @tags Tenant
+         * @name TenantGetStepRunQueueMetrics
+         * @summary Get step run metrics
+         * @request GET:/api/v1/tenants/{tenant}/step-run-queue-metrics
+         * @secure
+         */
+        this.tenantGetStepRunQueueMetrics = (tenant, params = {}) => this.request(Object.assign({ path: `/api/v1/tenants/${tenant}/step-run-queue-metrics`, method: 'GET', secure: true, format: 'json' }, params));
         /**
          * @description Lists all events for a tenant.
          *

package/clients/rest/generated/data-contracts.d.ts

@@ -316,6 +316,9 @@ export interface TenantQueueMetrics {
     workflow?: Record<string, QueueMetrics>;
     queues?: Record<string, number>;
 }
+export interface TenantStepRunQueueMetrics {
+    queues?: Record<string, number>;
+}
 export interface AcceptInviteRequest {
     /**
      * @minLength 36
@@ -792,6 +795,7 @@ export declare enum StepRunEventReason {
     SCHEDULING_TIMED_OUT = "SCHEDULING_TIMED_OUT",
     ASSIGNED = "ASSIGNED",
     STARTED = "STARTED",
+    ACKNOWLEDGED = "ACKNOWLEDGED",
     FINISHED = "FINISHED",
     FAILED = "FAILED",
     RETRYING = "RETRYING",

package/clients/rest/generated/data-contracts.js

@@ -98,6 +98,7 @@ var StepRunEventReason;
     StepRunEventReason["SCHEDULING_TIMED_OUT"] = "SCHEDULING_TIMED_OUT";
     StepRunEventReason["ASSIGNED"] = "ASSIGNED";
     StepRunEventReason["STARTED"] = "STARTED";
+    StepRunEventReason["ACKNOWLEDGED"] = "ACKNOWLEDGED";
     StepRunEventReason["FINISHED"] = "FINISHED";
     StepRunEventReason["FAILED"] = "FAILED";
     StepRunEventReason["RETRYING"] = "RETRYING";

package/examples/bulk-fanout-trigger.d.ts

@@ -0,0 +1 @@
+export {};

package/examples/bulk-fanout-trigger.js

@@ -0,0 +1,74 @@
+"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 });
+const sdk_1 = __importDefault(require("../sdk"));
+const hatchet = sdk_1.default.init();
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const workflowRuns = [];
+        workflowRuns[0] = {
+            workflowName: 'bulk-parent-workflow',
+            input: {},
+            options: {
+                additionalMetadata: {
+                    key: 'value',
+                },
+            },
+        };
+        workflowRuns[1] = {
+            workflowName: 'bulk-parent-workflow',
+            input: { second: 'second' },
+            options: {
+                additionalMetadata: {
+                    key: 'value',
+                },
+            },
+        };
+        try {
+            const workflowRunResponse = hatchet.admin.runWorkflows(workflowRuns);
+            const result = yield workflowRunResponse;
+            console.log('result', result);
+            result.forEach((workflowRun) => __awaiter(this, void 0, void 0, function* () {
+                var _a, e_1, _b, _c;
+                const stream = yield workflowRun.stream();
+                try {
+                    for (var _d = true, stream_1 = __asyncValues(stream), stream_1_1; stream_1_1 = yield stream_1.next(), _a = stream_1_1.done, !_a; _d = true) {
+                        _c = stream_1_1.value;
+                        _d = false;
+                        const event = _c;
+                        console.log('event received', event);
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = stream_1.return)) yield _b.call(stream_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }));
+        }
+        catch (error) {
+            console.log('error', error);
+        }
+    });
+}
+main();

package/examples/bulk-fanout-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/examples/bulk-fanout-worker.js

@@ -0,0 +1,93 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sdk_1 = __importDefault(require("../sdk"));
+const hatchet = sdk_1.default.init();
+const parentWorkflow = {
+    id: 'bulk-parent-workflow',
+    description: 'simple example for spawning child workflows',
+    on: {
+        event: 'bulk:fanout:create',
+    },
+    steps: [
+        {
+            name: 'parent-spawn',
+            timeout: '70s',
+            run: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+                // Prepare the workflows to spawn
+                const workflowRequests = Array.from({ length: 300 }, (_, i) => ({
+                    workflow: 'child-workflow',
+                    input: { input: `child-input-${i}` },
+                    options: { additionalMetadata: { childKey: 'childValue' } },
+                }));
+                const spawnedWorkflows = yield ctx.spawnWorkflows(workflowRequests);
+                const results = yield Promise.all(spawnedWorkflows.map((workflowRef) => workflowRef.result().then((result) => {
+                    ctx.log('spawned workflow result:');
+                    return result;
+                })));
+                console.log('spawned workflow results:', results);
+                console.log('number of spawned workflows:', results.length);
+                return { spawned: results.length };
+            }),
+        },
+    ],
+};
+const childWorkflow = {
+    id: 'child-workflow',
+    description: 'simple example for spawning child workflows',
+    on: {
+        event: 'child:create',
+    },
+    steps: [
+        {
+            name: 'child-work',
+            run: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+                const { input } = ctx.workflowInput();
+                // throw new Error('child error');
+                return { 'child-output': 'sm' };
+            }),
+        },
+        {
+            name: 'child-work2',
+            run: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+                const { input } = ctx.workflowInput();
+                // Perform CPU-bound work
+                // throw new Error('child error');
+                console.log('child workflow input:', input);
+                // Generate a large amount of garbage data
+                const garbageData = 'garbage'; // Print a snippet of the garbage data
+                return { 'child-output': garbageData };
+            }),
+        },
+        {
+            name: 'child-work3',
+            parents: ['child-work'],
+            run: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+                const { input } = ctx.workflowInput();
+                // throw new Error('child error');
+                const garbageData = 'child garbage';
+                return { 'child-output': garbageData };
+            }),
+        },
+    ],
+};
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker = yield hatchet.worker('fanout-worker', { maxRuns: 1000 });
+        yield worker.registerWorkflow(parentWorkflow);
+        yield worker.registerWorkflow(childWorkflow);
+        worker.start();
+    });
+}
+main();

package/examples/bulk-trigger.d.ts

@@ -0,0 +1 @@
+export {};

package/examples/bulk-trigger.js

@@ -0,0 +1,63 @@
+"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 });
+const sdk_1 = __importDefault(require("../sdk"));
+const hatchet = sdk_1.default.init();
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const workflowRuns = [];
+        for (let i = 0; i < 100; i += 1) {
+            workflowRuns.push({
+                workflowName: 'simple-workflow',
+                input: {},
+                options: {
+                    additionalMetadata: {
+                        key: 'value',
+                        dedupe: 'key',
+                    },
+                },
+            });
+        }
+        const workflowRunResponse = hatchet.admin.runWorkflows(workflowRuns);
+        const result = yield workflowRunResponse;
+        console.log('result', result);
+        result.forEach((workflowRun) => __awaiter(this, void 0, void 0, function* () {
+            var _a, e_1, _b, _c;
+            const stream = yield workflowRun.stream();
+            try {
+                for (var _d = true, stream_1 = __asyncValues(stream), stream_1_1; stream_1_1 = yield stream_1.next(), _a = stream_1_1.done, !_a; _d = true) {
+                    _c = stream_1_1.value;
+                    _d = false;
+                    const event = _c;
+                    console.log('event received', event);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = stream_1.return)) yield _b.call(stream_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        }));
+    });
+}
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "0.14.0",
+  "version": "0.15.1-alpha0",
   "description": "Background task orchestration & visibility for developers",
   "types": "dist/index.d.ts",
   "files": [
@@ -43,6 +43,9 @@
     "worker:on-failure": "npm run exec -- ./src/examples/on-failure.ts",
     "manual:trigger": "npm run exec -- ./src/examples/manual-trigger.ts",
     "manual:meta": "npm run exec -- ./src/examples/stream-by-additional-meta.ts",
+    "bulk:trigger": "npm run exec -- ./src/examples/bulk-trigger.ts",
+    "bulk:fanout:worker": "npm run exec -- ./src/examples/bulk-fanout-worker.ts",
+    "bulk:fanout:trigger": "npm run exec -- ./src/examples/bulk-fanout-trigger.ts",
     "worker:dag": "npm run exec -- ./src/examples/dag-worker.ts",
     "worker:concurrency": "npm run exec -- ./src/examples/concurrency/cancel-in-progress/concurrency-worker.ts",
     "event:concurrency": "npm run exec -- ./src/examples/concurrency/cancel-in-progress/concurrency-event.ts",
@@ -55,6 +58,7 @@
     "api": "npm run exec -- ./src/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",
+    "publish:ci:alpha": "rm -rf ./dist && npm run tsc:build && npm run prepublish && cd dist && npm publish --access public --no-git-checks --tag alpha",
     "generate-docs": "typedoc"
   },
   "keywords": [],

package/protoc/dispatcher/dispatcher.d.ts

@@ -23,6 +23,7 @@ export declare enum StepActionEventType {
     STEP_EVENT_TYPE_STARTED = 1,
     STEP_EVENT_TYPE_COMPLETED = 2,
     STEP_EVENT_TYPE_FAILED = 3,
+    STEP_EVENT_TYPE_ACKNOWLEDGED = 4,
     UNRECOGNIZED = -1
 }
 export declare function stepActionEventTypeFromJSON(object: any): StepActionEventType;

package/protoc/dispatcher/dispatcher.js

@@ -108,6 +108,7 @@ var StepActionEventType;
     StepActionEventType[StepActionEventType["STEP_EVENT_TYPE_STARTED"] = 1] = "STEP_EVENT_TYPE_STARTED";
     StepActionEventType[StepActionEventType["STEP_EVENT_TYPE_COMPLETED"] = 2] = "STEP_EVENT_TYPE_COMPLETED";
     StepActionEventType[StepActionEventType["STEP_EVENT_TYPE_FAILED"] = 3] = "STEP_EVENT_TYPE_FAILED";
+    StepActionEventType[StepActionEventType["STEP_EVENT_TYPE_ACKNOWLEDGED"] = 4] = "STEP_EVENT_TYPE_ACKNOWLEDGED";
     StepActionEventType[StepActionEventType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
 })(StepActionEventType || (exports.StepActionEventType = StepActionEventType = {}));
 function stepActionEventTypeFromJSON(object) {
@@ -124,6 +125,9 @@ function stepActionEventTypeFromJSON(object) {
         case 3:
         case 'STEP_EVENT_TYPE_FAILED':
             return StepActionEventType.STEP_EVENT_TYPE_FAILED;
+        case 4:
+        case 'STEP_EVENT_TYPE_ACKNOWLEDGED':
+            return StepActionEventType.STEP_EVENT_TYPE_ACKNOWLEDGED;
         case -1:
         case 'UNRECOGNIZED':
         default:
@@ -140,6 +144,8 @@ function stepActionEventTypeToJSON(object) {
             return 'STEP_EVENT_TYPE_COMPLETED';
         case StepActionEventType.STEP_EVENT_TYPE_FAILED:
             return 'STEP_EVENT_TYPE_FAILED';
+        case StepActionEventType.STEP_EVENT_TYPE_ACKNOWLEDGED:
+            return 'STEP_EVENT_TYPE_ACKNOWLEDGED';
         case StepActionEventType.UNRECOGNIZED:
         default:
             return 'UNRECOGNIZED';

package/protoc/workflows/workflows.d.ts

@@ -206,6 +206,12 @@ export interface WorkflowTriggerCronRef {
     parentId: string;
     cron: string;
 }
+export interface BulkTriggerWorkflowRequest {
+    workflows: TriggerWorkflowRequest[];
+}
+export interface BulkTriggerWorkflowResponse {
+    workflowRunIds: string[];
+}
 export interface TriggerWorkflowRequest {
     name: string;
     /** (optional) the input data for the workflow */
@@ -262,6 +268,8 @@ export declare const ScheduleWorkflowRequest: MessageFns<ScheduleWorkflowRequest
 export declare const WorkflowVersion: MessageFns<WorkflowVersion>;
 export declare const WorkflowTriggerEventRef: MessageFns<WorkflowTriggerEventRef>;
 export declare const WorkflowTriggerCronRef: MessageFns<WorkflowTriggerCronRef>;
+export declare const BulkTriggerWorkflowRequest: MessageFns<BulkTriggerWorkflowRequest>;
+export declare const BulkTriggerWorkflowResponse: MessageFns<BulkTriggerWorkflowResponse>;
 export declare const TriggerWorkflowRequest: MessageFns<TriggerWorkflowRequest>;
 export declare const TriggerWorkflowResponse: MessageFns<TriggerWorkflowResponse>;
 export declare const PutRateLimitRequest: MessageFns<PutRateLimitRequest>;
@@ -296,6 +304,14 @@ export declare const WorkflowServiceDefinition: {
             readonly responseStream: false;
             readonly options: {};
         };
+        readonly bulkTriggerWorkflow: {
+            readonly name: "BulkTriggerWorkflow";
+            readonly requestType: MessageFns<BulkTriggerWorkflowRequest>;
+            readonly requestStream: false;
+            readonly responseType: MessageFns<BulkTriggerWorkflowResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
         readonly putRateLimit: {
             readonly name: "PutRateLimit";
             readonly requestType: MessageFns<PutRateLimitRequest>;
@@ -310,12 +326,14 @@ export interface WorkflowServiceImplementation<CallContextExt = {}> {
     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>>;
+    bulkTriggerWorkflow(request: BulkTriggerWorkflowRequest, context: CallContext & CallContextExt): Promise<DeepPartial<BulkTriggerWorkflowResponse>>;
     putRateLimit(request: PutRateLimitRequest, context: CallContext & CallContextExt): Promise<DeepPartial<PutRateLimitResponse>>;
 }
 export interface WorkflowServiceClient<CallOptionsExt = {}> {
     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>;
+    bulkTriggerWorkflow(request: DeepPartial<BulkTriggerWorkflowRequest>, options?: CallOptions & CallOptionsExt): Promise<BulkTriggerWorkflowResponse>;
     putRateLimit(request: DeepPartial<PutRateLimitRequest>, options?: CallOptions & CallOptionsExt): Promise<PutRateLimitResponse>;
 }
 type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;

package/protoc/workflows/workflows.js

@@ -5,7 +5,7 @@
 //   protoc               v3.19.1
 // source: workflows/workflows.proto
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WorkflowServiceDefinition = exports.PutRateLimitResponse = exports.PutRateLimitRequest = exports.TriggerWorkflowResponse = exports.TriggerWorkflowRequest = exports.WorkflowTriggerCronRef = exports.WorkflowTriggerEventRef = exports.WorkflowVersion = exports.ScheduleWorkflowRequest = exports.ListWorkflowsRequest = exports.CreateStepRateLimit = exports.CreateWorkflowStepOpts_WorkerLabelsEntry = exports.CreateWorkflowStepOpts = exports.DesiredWorkerLabels = exports.CreateWorkflowJobOpts = exports.WorkflowConcurrencyOpts = exports.CreateWorkflowVersionOpts = exports.PutWorkflowRequest = exports.RateLimitDuration = exports.WorkerLabelComparator = exports.ConcurrencyLimitStrategy = exports.WorkflowKind = exports.StickyStrategy = exports.protobufPackage = void 0;
+exports.WorkflowServiceDefinition = exports.PutRateLimitResponse = exports.PutRateLimitRequest = exports.TriggerWorkflowResponse = exports.TriggerWorkflowRequest = exports.BulkTriggerWorkflowResponse = exports.BulkTriggerWorkflowRequest = exports.WorkflowTriggerCronRef = exports.WorkflowTriggerEventRef = exports.WorkflowVersion = exports.ScheduleWorkflowRequest = exports.ListWorkflowsRequest = exports.CreateStepRateLimit = exports.CreateWorkflowStepOpts_WorkerLabelsEntry = exports.CreateWorkflowStepOpts = exports.DesiredWorkerLabels = exports.CreateWorkflowJobOpts = exports.WorkflowConcurrencyOpts = exports.CreateWorkflowVersionOpts = exports.PutWorkflowRequest = exports.RateLimitDuration = exports.WorkerLabelComparator = exports.ConcurrencyLimitStrategy = exports.WorkflowKind = exports.StickyStrategy = exports.protobufPackage = void 0;
 exports.stickyStrategyFromJSON = stickyStrategyFromJSON;
 exports.stickyStrategyToJSON = stickyStrategyToJSON;
 exports.workflowKindFromJSON = workflowKindFromJSON;
@@ -1725,6 +1725,118 @@ exports.WorkflowTriggerCronRef = {
         return message;
     },
 };
+function createBaseBulkTriggerWorkflowRequest() {
+    return { workflows: [] };
+}
+exports.BulkTriggerWorkflowRequest = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        for (const v of message.workflows) {
+            exports.TriggerWorkflowRequest.encode(v, writer.uint32(10).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseBulkTriggerWorkflowRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.workflows.push(exports.TriggerWorkflowRequest.decode(reader, reader.uint32()));
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            workflows: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.workflows)
+                ? object.workflows.map((e) => exports.TriggerWorkflowRequest.fromJSON(e))
+                : [],
+        };
+    },
+    toJSON(message) {
+        var _a;
+        const obj = {};
+        if ((_a = message.workflows) === null || _a === void 0 ? void 0 : _a.length) {
+            obj.workflows = message.workflows.map((e) => exports.TriggerWorkflowRequest.toJSON(e));
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.BulkTriggerWorkflowRequest.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a;
+        const message = createBaseBulkTriggerWorkflowRequest();
+        message.workflows = ((_a = object.workflows) === null || _a === void 0 ? void 0 : _a.map((e) => exports.TriggerWorkflowRequest.fromPartial(e))) || [];
+        return message;
+    },
+};
+function createBaseBulkTriggerWorkflowResponse() {
+    return { workflowRunIds: [] };
+}
+exports.BulkTriggerWorkflowResponse = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        for (const v of message.workflowRunIds) {
+            writer.uint32(10).string(v);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseBulkTriggerWorkflowResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.workflowRunIds.push(reader.string());
+                    continue;
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            workflowRunIds: globalThis.Array.isArray(object === null || object === void 0 ? void 0 : object.workflowRunIds)
+                ? object.workflowRunIds.map((e) => globalThis.String(e))
+                : [],
+        };
+    },
+    toJSON(message) {
+        var _a;
+        const obj = {};
+        if ((_a = message.workflowRunIds) === null || _a === void 0 ? void 0 : _a.length) {
+            obj.workflowRunIds = message.workflowRunIds;
+        }
+        return obj;
+    },
+    create(base) {
+        return exports.BulkTriggerWorkflowResponse.fromPartial(base !== null && base !== void 0 ? base : {});
+    },
+    fromPartial(object) {
+        var _a;
+        const message = createBaseBulkTriggerWorkflowResponse();
+        message.workflowRunIds = ((_a = object.workflowRunIds) === null || _a === void 0 ? void 0 : _a.map((e) => e)) || [];
+        return message;
+    },
+};
 function createBaseTriggerWorkflowRequest() {
     return {
         name: '',
@@ -2105,6 +2217,14 @@ exports.WorkflowServiceDefinition = {
             responseStream: false,
             options: {},
         },
+        bulkTriggerWorkflow: {
+            name: 'BulkTriggerWorkflow',
+            requestType: exports.BulkTriggerWorkflowRequest,
+            requestStream: false,
+            responseType: exports.BulkTriggerWorkflowResponse,
+            responseStream: false,
+            options: {},
+        },
         putRateLimit: {
             name: 'PutRateLimit',
             requestType: exports.PutRateLimitRequest,

package/step.d.ts

@@ -183,6 +183,21 @@ export declare class Context<T, K = {}> {
     refreshTimeout(incrementBy: string): Promise<void>;
     releaseSlot(): Promise<void>;
     putStream(data: string | Uint8Array): Promise<void>;
+    /**
+     * Spawns multiple workflows.
+     *
+     * @param workflows an array of objects containing the workflow name, input data, and options for each workflow
+     * @returns a list of references to the spawned workflow runs
+     */
+    spawnWorkflows<Q = JsonValue, P = JsonValue>(workflows: Array<{
+        workflow: string | Workflow;
+        input: Q;
+        options?: {
+            key?: string;
+            sticky?: boolean;
+            additionalMetadata?: Record<string, string>;
+        };
+    }>): Promise<WorkflowRunRef<P>[]>;
     /**
      * Spawns a new workflow.
      *

package/step.js

@@ -48,7 +48,7 @@ exports.CreateRateLimitSchema = z.object({
     key: z.string().optional(),
     staticKey: z.string().optional(),
     dynamicKey: z.string().optional(),
-    units: z.union([z.number().min(1), z.string()]),
+    units: z.union([z.number().min(0), z.string()]),
     limit: z.union([z.number().min(1), z.string()]).optional(),
     duration: z.nativeEnum(workflows_1.RateLimitDuration).optional(),
 });
@@ -205,6 +205,57 @@ class Context {
             yield this.client.event.putStream(stepRunId, data);
         });
     }
+    /**
+     * Spawns multiple workflows.
+     *
+     * @param workflows an array of objects containing the workflow name, input data, and options for each workflow
+     * @returns a list of references to the spawned workflow runs
+     */
+    spawnWorkflows(workflows) {
+        const { workflowRunId, stepRunId } = this.action;
+        const workflowRuns = workflows.map(({ workflow, input, options }) => {
+            let workflowName;
+            if (typeof workflow === 'string') {
+                workflowName = workflow;
+            }
+            else {
+                workflowName = workflow.id;
+            }
+            const name = this.client.config.namespace + workflowName;
+            let key;
+            let sticky = false;
+            let metadata;
+            if (options) {
+                key = options.key;
+                sticky = options.sticky;
+                metadata = options.additionalMetadata;
+            }
+            if (sticky && !this.worker.hasWorkflow(name)) {
+                throw new hatchet_error_1.default(`Cannot run with sticky: workflow ${name} is not registered on the worker`);
+            }
+            const resp = {
+                workflowName: name,
+                input,
+                options: {
+                    parentId: workflowRunId,
+                    parentStepRunId: stepRunId,
+                    childKey: key,
+                    childIndex: this.spawnIndex,
+                    desiredWorkerId: sticky ? this.worker.id() : undefined,
+                    additionalMetadata: metadata,
+                },
+            };
+            this.spawnIndex += 1;
+            return resp;
+        });
+        try {
+            const resp = this.client.admin.runWorkflows(workflowRuns);
+            return resp;
+        }
+        catch (e) {
+            throw new hatchet_error_1.default(e.message);
+        }
+    }
     /**
      * Spawns a new workflow.
      *