@hatchet-dev/typescript-sdk 0.13.1 → 0.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "0.13.1",
+  "version": "0.15.0",
   "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",

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

@@ -153,8 +153,16 @@ export interface CreateWorkflowStepOpts_WorkerLabelsEntry {
 export interface CreateStepRateLimit {
     /** (required) the key for the rate limit */
     key: string;
-    /** (required) the number of units this step consumes */
-    units: number;
+    /** (optional) the number of units this step consumes */
+    units?: number | undefined;
+    /** (optional) a CEL expression for determining the rate limit key */
+    keyExpr?: string | undefined;
+    /** (optional) a CEL expression for determining the number of units consumed */
+    unitsExpr?: string | undefined;
+    /** (optional) a CEL expression for determining the total amount of rate limit units */
+    limitValuesExpr?: string | undefined;
+    /** (optional) the default rate limit window to use for dynamic rate limits */
+    duration?: RateLimitDuration | undefined;
 }
 /** ListWorkflowsRequest is the request for ListWorkflows. */
 export interface ListWorkflowsRequest {
@@ -198,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 */
@@ -254,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>;
@@ -288,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>;
@@ -302,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;
@@ -1143,16 +1143,35 @@ exports.CreateWorkflowStepOpts_WorkerLabelsEntry = {
     },
 };
 function createBaseCreateStepRateLimit() {
-    return { key: '', units: 0 };
+    return {
+        key: '',
+        units: undefined,
+        keyExpr: undefined,
+        unitsExpr: undefined,
+        limitValuesExpr: undefined,
+        duration: undefined,
+    };
 }
 exports.CreateStepRateLimit = {
     encode(message, writer = new wire_1.BinaryWriter()) {
         if (message.key !== '') {
             writer.uint32(10).string(message.key);
         }
-        if (message.units !== 0) {
+        if (message.units !== undefined) {
             writer.uint32(16).int32(message.units);
         }
+        if (message.keyExpr !== undefined) {
+            writer.uint32(26).string(message.keyExpr);
+        }
+        if (message.unitsExpr !== undefined) {
+            writer.uint32(34).string(message.unitsExpr);
+        }
+        if (message.limitValuesExpr !== undefined) {
+            writer.uint32(42).string(message.limitValuesExpr);
+        }
+        if (message.duration !== undefined) {
+            writer.uint32(48).int32(message.duration);
+        }
         return writer;
     },
     decode(input, length) {
@@ -1174,6 +1193,30 @@ exports.CreateStepRateLimit = {
                     }
                     message.units = reader.int32();
                     continue;
+                case 3:
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.keyExpr = reader.string();
+                    continue;
+                case 4:
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.unitsExpr = reader.string();
+                    continue;
+                case 5:
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.limitValuesExpr = reader.string();
+                    continue;
+                case 6:
+                    if (tag !== 48) {
+                        break;
+                    }
+                    message.duration = reader.int32();
+                    continue;
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -1185,7 +1228,13 @@ exports.CreateStepRateLimit = {
     fromJSON(object) {
         return {
             key: isSet(object.key) ? globalThis.String(object.key) : '',
-            units: isSet(object.units) ? globalThis.Number(object.units) : 0,
+            units: isSet(object.units) ? globalThis.Number(object.units) : undefined,
+            keyExpr: isSet(object.keyExpr) ? globalThis.String(object.keyExpr) : undefined,
+            unitsExpr: isSet(object.unitsExpr) ? globalThis.String(object.unitsExpr) : undefined,
+            limitValuesExpr: isSet(object.limitValuesExpr)
+                ? globalThis.String(object.limitValuesExpr)
+                : undefined,
+            duration: isSet(object.duration) ? rateLimitDurationFromJSON(object.duration) : undefined,
         };
     },
     toJSON(message) {
@@ -1193,19 +1242,35 @@ exports.CreateStepRateLimit = {
         if (message.key !== '') {
             obj.key = message.key;
         }
-        if (message.units !== 0) {
+        if (message.units !== undefined) {
             obj.units = Math.round(message.units);
         }
+        if (message.keyExpr !== undefined) {
+            obj.keyExpr = message.keyExpr;
+        }
+        if (message.unitsExpr !== undefined) {
+            obj.unitsExpr = message.unitsExpr;
+        }
+        if (message.limitValuesExpr !== undefined) {
+            obj.limitValuesExpr = message.limitValuesExpr;
+        }
+        if (message.duration !== undefined) {
+            obj.duration = rateLimitDurationToJSON(message.duration);
+        }
         return obj;
     },
     create(base) {
         return exports.CreateStepRateLimit.fromPartial(base !== null && base !== void 0 ? base : {});
     },
     fromPartial(object) {
-        var _a, _b;
+        var _a, _b, _c, _d, _e, _f;
         const message = createBaseCreateStepRateLimit();
         message.key = (_a = object.key) !== null && _a !== void 0 ? _a : '';
-        message.units = (_b = object.units) !== null && _b !== void 0 ? _b : 0;
+        message.units = (_b = object.units) !== null && _b !== void 0 ? _b : undefined;
+        message.keyExpr = (_c = object.keyExpr) !== null && _c !== void 0 ? _c : undefined;
+        message.unitsExpr = (_d = object.unitsExpr) !== null && _d !== void 0 ? _d : undefined;
+        message.limitValuesExpr = (_e = object.limitValuesExpr) !== null && _e !== void 0 ? _e : undefined;
+        message.duration = (_f = object.duration) !== null && _f !== void 0 ? _f : undefined;
         return message;
     },
 };
@@ -1660,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: '',
@@ -2040,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

@@ -7,16 +7,28 @@ import { HatchetClient } from './clients/hatchet-client';
 import WorkflowRunRef from './util/workflow-run-ref';
 import { Worker } from './clients/worker';
 import { WorkerLabels } from './clients/dispatcher/dispatcher-client';
-import { WorkerLabelComparator } from './protoc/workflows';
+import { CreateStepRateLimit, RateLimitDuration, WorkerLabelComparator } from './protoc/workflows';
 export declare const CreateRateLimitSchema: z.ZodObject<{
-    key: z.ZodString;
-    units: z.ZodNumber;
+    key: z.ZodOptional<z.ZodString>;
+    staticKey: z.ZodOptional<z.ZodString>;
+    dynamicKey: z.ZodOptional<z.ZodString>;
+    units: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
+    limit: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodString]>>;
+    duration: z.ZodOptional<z.ZodNativeEnum<typeof RateLimitDuration>>;
 }, "strip", z.ZodTypeAny, {
-    key: string;
-    units: number;
+    units: string | number;
+    key?: string | undefined;
+    duration?: RateLimitDuration | undefined;
+    limit?: string | number | undefined;
+    staticKey?: string | undefined;
+    dynamicKey?: string | undefined;
 }, {
-    key: string;
-    units: number;
+    units: string | number;
+    key?: string | undefined;
+    duration?: RateLimitDuration | undefined;
+    limit?: string | number | undefined;
+    staticKey?: string | undefined;
+    dynamicKey?: string | undefined;
 }>;
 export declare const DesiredWorkerLabelSchema: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodObject<{
     value: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
@@ -40,14 +52,26 @@ export declare const CreateStepSchema: z.ZodObject<{
     timeout: z.ZodOptional<z.ZodString>;
     retries: z.ZodOptional<z.ZodNumber>;
     rate_limits: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        key: z.ZodString;
-        units: z.ZodNumber;
+        key: z.ZodOptional<z.ZodString>;
+        staticKey: z.ZodOptional<z.ZodString>;
+        dynamicKey: z.ZodOptional<z.ZodString>;
+        units: z.ZodUnion<[z.ZodNumber, z.ZodString]>;
+        limit: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodString]>>;
+        duration: z.ZodOptional<z.ZodNativeEnum<typeof RateLimitDuration>>;
     }, "strip", z.ZodTypeAny, {
-        key: string;
-        units: number;
+        units: string | number;
+        key?: string | undefined;
+        duration?: RateLimitDuration | undefined;
+        limit?: string | number | undefined;
+        staticKey?: string | undefined;
+        dynamicKey?: string | undefined;
     }, {
-        key: string;
-        units: number;
+        units: string | number;
+        key?: string | undefined;
+        duration?: RateLimitDuration | undefined;
+        limit?: string | number | undefined;
+        staticKey?: string | undefined;
+        dynamicKey?: string | undefined;
     }>, "many">>;
     worker_labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodLazy<z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodObject<{
         value: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
@@ -71,8 +95,12 @@ export declare const CreateStepSchema: z.ZodObject<{
     parents?: string[] | undefined;
     retries?: number | undefined;
     rate_limits?: {
-        key: string;
-        units: number;
+        units: string | number;
+        key?: string | undefined;
+        duration?: RateLimitDuration | undefined;
+        limit?: string | number | undefined;
+        staticKey?: string | undefined;
+        dynamicKey?: string | undefined;
     }[] | undefined;
     worker_labels?: Record<string, string | number | {
         value: string | number;
@@ -86,8 +114,12 @@ export declare const CreateStepSchema: z.ZodObject<{
     parents?: string[] | undefined;
     retries?: number | undefined;
     rate_limits?: {
-        key: string;
-        units: number;
+        units: string | number;
+        key?: string | undefined;
+        duration?: RateLimitDuration | undefined;
+        limit?: string | number | undefined;
+        staticKey?: string | undefined;
+        dynamicKey?: string | undefined;
     }[] | undefined;
     worker_labels?: Record<string, string | number | {
         value: string | number;
@@ -151,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.
      *
@@ -178,4 +225,5 @@ export type StepRunFunction<T, K> = (ctx: Context<T, K>) => Promise<NextStep | v
 export interface CreateStep<T, K> extends z.infer<typeof CreateStepSchema> {
     run: StepRunFunction<T, K>;
 }
+export declare function mapRateLimit(limits: CreateStep<any, any>['rate_limits']): CreateStepRateLimit[];
 export {};

package/step.js

@@ -36,6 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Context = exports.ContextWorker = exports.CreateStepSchema = exports.DesiredWorkerLabelSchema = exports.CreateRateLimitSchema = void 0;
+exports.mapRateLimit = mapRateLimit;
 /* eslint-disable max-classes-per-file */
 const hatchet_error_1 = __importDefault(require("./util/errors/hatchet-error"));
 const z = __importStar(require("zod"));
@@ -44,8 +45,12 @@ const logger_1 = require("./util/logger");
 const parse_1 = require("./util/parse");
 const workflows_1 = require("./protoc/workflows");
 exports.CreateRateLimitSchema = z.object({
-    key: z.string(),
-    units: z.number().min(1),
+    key: z.string().optional(),
+    staticKey: z.string().optional(),
+    dynamicKey: z.string().optional(),
+    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(),
 });
 exports.DesiredWorkerLabelSchema = z
     .union([
@@ -200,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.
      *
@@ -273,3 +329,68 @@ class Context {
     }
 }
 exports.Context = Context;
+function mapRateLimit(limits) {
+    if (!limits)
+        return [];
+    return limits.map((l) => {
+        let key = l.staticKey;
+        const keyExpression = l.dynamicKey;
+        if (l.key !== undefined) {
+            // eslint-disable-next-line no-console
+            console.warn('key is deprecated and will be removed in a future release, please use staticKey instead');
+            key = l.key;
+        }
+        if (keyExpression !== undefined) {
+            if (key !== undefined) {
+                throw new Error('Cannot have both static key and dynamic key set');
+            }
+            key = keyExpression;
+            if (!validateCelExpression(keyExpression)) {
+                throw new Error(`Invalid CEL expression: ${keyExpression}`);
+            }
+        }
+        if (key === undefined) {
+            throw new Error(`Invalid key`);
+        }
+        let units;
+        let unitsExpression;
+        if (typeof l.units === 'number') {
+            units = l.units;
+        }
+        else {
+            if (!validateCelExpression(l.units)) {
+                throw new Error(`Invalid CEL expression: ${l.units}`);
+            }
+            unitsExpression = l.units;
+        }
+        let limitExpression;
+        if (l.limit !== undefined) {
+            if (typeof l.limit === 'number') {
+                limitExpression = `${l.limit}`;
+            }
+            else {
+                if (!validateCelExpression(l.limit)) {
+                    throw new Error(`Invalid CEL expression: ${l.limit}`);
+                }
+                limitExpression = l.limit;
+            }
+        }
+        if (keyExpression !== undefined && limitExpression === undefined) {
+            throw new Error('CEL based keys requires limit to be set');
+        }
+        return {
+            key,
+            keyExpr: keyExpression,
+            units,
+            unitsExpr: unitsExpression,
+            limitValuesExpr: limitExpression,
+            duration: l.duration,
+        };
+    });
+}
+// Helper function to validate CEL expressions
+function validateCelExpression(expr) {
+    // This is a placeholder. In a real implementation, you'd need to use a CEL parser or validator.
+    // For now, we'll just return true to mimic the behavior.
+    return true;
+}