@hatchet-dev/typescript-sdk 0.13.0 → 0.14.0

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

@@ -106,8 +106,7 @@ export interface PaginationResponse {
 export interface APIResourceMeta {
     /**
      * the id of this resource, in UUID format
-     * @format uuid
-     * @minLength 36
+     * @minLength 0
      * @maxLength 36
      * @example "bb214807-246e-43a5-a25d-41761d1cff9e"
      */
@@ -315,6 +314,7 @@ export interface TenantQueueMetrics {
     /** The total queue metrics. */
     total?: QueueMetrics;
     workflow?: Record<string, QueueMetrics>;
+    queues?: Record<string, number>;
 }
 export interface AcceptInviteRequest {
     /**
@@ -383,6 +383,14 @@ export interface CreateEventRequest {
     /** Additional metadata for the event. */
     additionalMetadata?: object;
 }
+export interface BulkCreateEventRequest {
+    events: CreateEventRequest[];
+}
+export interface BulkCreateEventResponse {
+    metadata: APIResourceMeta;
+    /** The events. */
+    events: Event[];
+}
 export interface EventWorkflowRunSummary {
     /**
      * The number of pending runs.
@@ -430,22 +438,61 @@ export interface EventList {
     pagination?: PaginationResponse;
     rows?: Event[];
 }
+export interface RateLimit {
+    /** The key for the rate limit. */
+    key: string;
+    /** The ID of the tenant associated with this rate limit. */
+    tenantId: string;
+    /** The maximum number of requests allowed within the window. */
+    limitValue: number;
+    /** The current number of requests made within the window. */
+    value: number;
+    /** The window of time in which the limitValue is enforced. */
+    window: string;
+    /**
+     * The last time the rate limit was refilled.
+     * @format date-time
+     * @example "2022-12-13T20:06:48.888Z"
+     */
+    lastRefill: string;
+}
+export interface RateLimitList {
+    pagination?: PaginationResponse;
+    rows?: RateLimit[];
+}
+export declare enum RateLimitOrderByField {
+    Key = "key",
+    Value = "value",
+    LimitValue = "limitValue"
+}
+export declare enum RateLimitOrderByDirection {
+    Asc = "asc",
+    Desc = "desc"
+}
 export interface ReplayEventRequest {
     eventIds: string[];
 }
+export interface CancelEventRequest {
+    eventIds: string[];
+}
 export interface Workflow {
     metadata: APIResourceMeta;
     /** The name of the workflow. */
     name: string;
     /** The description of the workflow. */
     description?: string;
+    /** Whether the workflow is paused. */
+    isPaused?: boolean;
     versions?: WorkflowVersionMeta[];
     /** The tags of the workflow. */
     tags?: WorkflowTag[];
-    lastRun?: WorkflowRun;
     /** The jobs of the workflow. */
     jobs?: Job[];
 }
+export interface WorkflowUpdateRequest {
+    /** Whether the workflow is paused. */
+    isPaused?: boolean;
+}
 export interface WorkflowConcurrency {
     /**
      * The maximum number of concurrent workflow runs.
@@ -473,6 +520,13 @@ export interface WorkflowVersion {
     /** @format int32 */
     order: number;
     workflowId: string;
+    /** The sticky strategy of the workflow. */
+    sticky?: string;
+    /**
+     * The default priority of the workflow.
+     * @format int32
+     */
+    defaultPriority?: number;
     workflow?: Workflow;
     concurrency?: WorkflowConcurrency;
     triggers?: WorkflowTriggers;
@@ -532,6 +586,11 @@ export interface Step {
     children?: string[];
     parents?: string[];
 }
+export interface WorkflowWorkersCount {
+    freeSlotCount?: number;
+    maxSlotCount?: number;
+    workflowRunId?: string;
+}
 export interface WorkflowRun {
     metadata: APIResourceMeta;
     tenantId: string;
@@ -547,6 +606,8 @@ export interface WorkflowRun {
     startedAt?: string;
     /** @format date-time */
     finishedAt?: string;
+    /** @example 1000 */
+    duration?: number;
     /**
      * @format uuid
      * @minLength 36
@@ -563,10 +624,61 @@ export interface WorkflowRun {
     parentStepRunId?: string;
     additionalMetadata?: Record<string, any>;
 }
+export interface WorkflowRunShape {
+    metadata: APIResourceMeta;
+    tenantId: string;
+    workflowId?: string;
+    workflowVersionId: string;
+    workflowVersion?: WorkflowVersion;
+    status: WorkflowRunStatus;
+    displayName?: string;
+    jobRuns?: JobRun[];
+    triggeredBy: WorkflowRunTriggeredBy;
+    input?: Record<string, any>;
+    error?: string;
+    /** @format date-time */
+    startedAt?: string;
+    /** @format date-time */
+    finishedAt?: string;
+    /** @example 1000 */
+    duration?: number;
+    /**
+     * @format uuid
+     * @minLength 36
+     * @maxLength 36
+     * @example "bb214807-246e-43a5-a25d-41761d1cff9e"
+     */
+    parentId?: string;
+    /**
+     * @format uuid
+     * @minLength 36
+     * @maxLength 36
+     * @example "bb214807-246e-43a5-a25d-41761d1cff9e"
+     */
+    parentStepRunId?: string;
+    additionalMetadata?: Record<string, any>;
+}
+export interface ReplayWorkflowRunsRequest {
+    /** @maxLength 500 */
+    workflowRunIds: string[];
+}
+export interface ReplayWorkflowRunsResponse {
+    workflowRuns: WorkflowRun[];
+}
 export interface WorkflowRunList {
     rows?: WorkflowRun[];
     pagination?: PaginationResponse;
 }
+export declare enum WorkflowRunOrderByField {
+    CreatedAt = "createdAt",
+    StartedAt = "startedAt",
+    FinishedAt = "finishedAt",
+    Duration = "duration"
+}
+export declare enum WorkflowRunOrderByDirection {
+    ASC = "ASC",
+    DESC = "DESC"
+}
 export interface WorkflowRunsMetrics {
     counts?: WorkflowRunsMetricsCounts;
 }
@@ -586,6 +698,12 @@ export declare enum WorkflowRunStatus {
     QUEUED = "QUEUED"
 }
 export type WorkflowRunStatusList = WorkflowRunStatus[];
+export declare enum WorkflowKind {
+    FUNCTION = "FUNCTION",
+    DURABLE = "DURABLE",
+    DAG = "DAG"
+}
+export type WorkflowKindList = WorkflowKind[];
 export interface WorkflowRunsCancelRequest {
     workflowRunIds: string[];
 }
@@ -603,7 +721,8 @@ export declare enum StepRunStatus {
     RUNNING = "RUNNING",
     SUCCEEDED = "SUCCEEDED",
     FAILED = "FAILED",
-    CANCELLED = "CANCELLED"
+    CANCELLED = "CANCELLED",
+    CANCELLING = "CANCELLING"
 }
 export interface JobRun {
     metadata: APIResourceMeta;
@@ -629,9 +748,8 @@ export interface JobRun {
 }
 export interface WorkflowRunTriggeredBy {
     metadata: APIResourceMeta;
-    parentId: string;
+    parentWorkflowRunId?: string;
     eventId?: string;
-    event?: Event;
     cronParentId?: string;
     cronSchedule?: string;
 }
@@ -642,7 +760,7 @@ export interface StepRun {
     jobRun?: JobRun;
     stepId: string;
     step?: Step;
-    children?: string[];
+    childWorkflowsCount?: number;
     parents?: string[];
     childWorkflowRuns?: string[];
     workerId?: string;
@@ -682,7 +800,9 @@ export declare enum StepRunEventReason {
     REASSIGNED = "REASSIGNED",
     TIMED_OUT = "TIMED_OUT",
     SLOT_RELEASED = "SLOT_RELEASED",
-    RETRIED_BY_USER = "RETRIED_BY_USER"
+    RETRIED_BY_USER = "RETRIED_BY_USER",
+    WORKFLOW_RUN_GROUP_KEY_SUCCEEDED = "WORKFLOW_RUN_GROUP_KEY_SUCCEEDED",
+    WORKFLOW_RUN_GROUP_KEY_FAILED = "WORKFLOW_RUN_GROUP_KEY_FAILED"
 }
 export declare enum StepRunEventSeverity {
     INFO = "INFO",
@@ -695,7 +815,8 @@ export interface StepRunEvent {
     timeFirstSeen: string;
     /** @format date-time */
     timeLastSeen: string;
-    stepRunId: string;
+    stepRunId?: string;
+    workflowRunId?: string;
     reason: StepRunEventReason;
     severity: StepRunEventSeverity;
     message: string;
@@ -714,6 +835,7 @@ export interface StepRunArchive {
     /** @format date-time */
     startedAt?: string;
     error?: string;
+    retryCount: number;
     /** @format date-time */
     createdAt: string;
     startedAtEpoch?: number;
@@ -737,10 +859,50 @@ export interface WorkerList {
     pagination?: PaginationResponse;
     rows?: Worker[];
 }
+export interface SemaphoreSlots {
+    /**
+     * The step run id.
+     * @format uuid
+     */
+    stepRunId: string;
+    /** The action id. */
+    actionId: string;
+    /**
+     * The time this slot was started.
+     * @format date-time
+     */
+    startedAt?: string;
+    /**
+     * The time this slot will timeout.
+     * @format date-time
+     */
+    timeoutAt?: string;
+    /**
+     * The workflow run id.
+     * @format uuid
+     */
+    workflowRunId: string;
+    status: StepRunStatus;
+}
+export interface RecentStepRuns {
+    metadata: APIResourceMeta;
+    /** The action id. */
+    actionId: string;
+    status: StepRunStatus;
+    /** @format date-time */
+    startedAt?: string;
+    /** @format date-time */
+    finishedAt?: string;
+    /** @format date-time */
+    cancelledAt?: string;
+    /** @format uuid */
+    workflowRunId: string;
+}
 export interface Worker {
     metadata: APIResourceMeta;
     /** The name of the worker. */
     name: string;
+    type: 'SELFHOSTED' | 'MANAGED' | 'WEBHOOK';
     /**
      * The time this worker last sent a heartbeat.
      * @format date-time
@@ -755,10 +917,12 @@ export interface Worker {
     lastListenerEstablished?: string;
     /** The actions this worker can perform. */
     actions?: string[];
-    /** The recent step runs for this worker. */
-    recentStepRuns?: StepRun[];
+    /** The semaphore slot state for the worker. */
+    slots?: SemaphoreSlots[];
+    /** The recent step runs for the worker. */
+    recentStepRuns?: RecentStepRuns[];
     /** The status of the worker. */
-    status?: 'ACTIVE' | 'INACTIVE';
+    status?: 'ACTIVE' | 'INACTIVE' | 'PAUSED';
     /** The maximum number of runs this worker can execute concurrently. */
     maxRuns?: number;
     /** The number of runs this worker can execute concurrently. */
@@ -771,6 +935,26 @@ export interface Worker {
      * @example "bb214807-246e-43a5-a25d-41761d1cff9e"
      */
     dispatcherId?: string;
+    /** The current label state of the worker. */
+    labels?: WorkerLabel[];
+    /** The webhook URL for the worker. */
+    webhookUrl?: string;
+    /**
+     * The webhook ID for the worker.
+     * @format uuid
+     */
+    webhookId?: string;
+}
+export interface WorkerLabel {
+    metadata: APIResourceMeta;
+    /** The key of the label. */
+    key: string;
+    /** The value of the label. */
+    value?: string;
+}
+export interface UpdateWorkerRequest {
+    /** Whether the worker is paused and cannot accept new runs. */
+    isPaused?: boolean;
 }
 export interface APIToken {
     metadata: APIResourceMeta;
@@ -791,6 +975,8 @@ export interface CreateAPITokenRequest {
      * @maxLength 255
      */
     name: string;
+    /** The duration for which the token is valid. */
+    expiresIn?: string;
 }
 export interface CreateAPITokenResponse {
     /** The API token. */
@@ -918,6 +1104,26 @@ export interface WebhookWorker {
     /** The webhook url. */
     url: string;
 }
+export declare enum WebhookWorkerRequestMethod {
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT"
+}
+export interface WebhookWorkerRequest {
+    /**
+     * The date and time the request was created.
+     * @format date-time
+     */
+    created_at: string;
+    /** The HTTP method used for the request. */
+    method: WebhookWorkerRequestMethod;
+    /** The HTTP status code of the response. */
+    statusCode: number;
+}
+export interface WebhookWorkerRequestListResponse {
+    /** The list of webhook requests. */
+    requests?: WebhookWorkerRequest[];
+}
 export interface WebhookWorkerCreated {
     metadata: APIResourceMeta;
     /** The name of the webhook worker. */

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

@@ -10,7 +10,7 @@
  * ---------------------------------------------------------------
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LogLineOrderByDirection = exports.LogLineOrderByField = exports.LogLineLevel = exports.PullRequestState = exports.StepRunEventSeverity = exports.StepRunEventReason = exports.StepRunStatus = exports.JobRunStatus = exports.WorkflowRunStatus = exports.EventOrderByDirection = exports.EventOrderByField = exports.TenantResource = exports.TenantMemberRole = void 0;
+exports.WebhookWorkerRequestMethod = exports.LogLineOrderByDirection = exports.LogLineOrderByField = exports.LogLineLevel = exports.PullRequestState = exports.StepRunEventSeverity = exports.StepRunEventReason = exports.StepRunStatus = exports.JobRunStatus = exports.WorkflowKind = exports.WorkflowRunStatus = exports.WorkflowRunOrderByDirection = exports.WorkflowRunOrderByField = exports.RateLimitOrderByDirection = exports.RateLimitOrderByField = exports.EventOrderByDirection = exports.EventOrderByField = exports.TenantResource = exports.TenantMemberRole = void 0;
 var TenantMemberRole;
 (function (TenantMemberRole) {
     TenantMemberRole["OWNER"] = "OWNER";
@@ -34,6 +34,29 @@ var EventOrderByDirection;
     EventOrderByDirection["Asc"] = "asc";
     EventOrderByDirection["Desc"] = "desc";
 })(EventOrderByDirection || (exports.EventOrderByDirection = EventOrderByDirection = {}));
+var RateLimitOrderByField;
+(function (RateLimitOrderByField) {
+    RateLimitOrderByField["Key"] = "key";
+    RateLimitOrderByField["Value"] = "value";
+    RateLimitOrderByField["LimitValue"] = "limitValue";
+})(RateLimitOrderByField || (exports.RateLimitOrderByField = RateLimitOrderByField = {}));
+var RateLimitOrderByDirection;
+(function (RateLimitOrderByDirection) {
+    RateLimitOrderByDirection["Asc"] = "asc";
+    RateLimitOrderByDirection["Desc"] = "desc";
+})(RateLimitOrderByDirection || (exports.RateLimitOrderByDirection = RateLimitOrderByDirection = {}));
+var WorkflowRunOrderByField;
+(function (WorkflowRunOrderByField) {
+    WorkflowRunOrderByField["CreatedAt"] = "createdAt";
+    WorkflowRunOrderByField["StartedAt"] = "startedAt";
+    WorkflowRunOrderByField["FinishedAt"] = "finishedAt";
+    WorkflowRunOrderByField["Duration"] = "duration";
+})(WorkflowRunOrderByField || (exports.WorkflowRunOrderByField = WorkflowRunOrderByField = {}));
+var WorkflowRunOrderByDirection;
+(function (WorkflowRunOrderByDirection) {
+    WorkflowRunOrderByDirection["ASC"] = "ASC";
+    WorkflowRunOrderByDirection["DESC"] = "DESC";
+})(WorkflowRunOrderByDirection || (exports.WorkflowRunOrderByDirection = WorkflowRunOrderByDirection = {}));
 var WorkflowRunStatus;
 (function (WorkflowRunStatus) {
     WorkflowRunStatus["PENDING"] = "PENDING";
@@ -43,6 +66,12 @@ var WorkflowRunStatus;
     WorkflowRunStatus["CANCELLED"] = "CANCELLED";
     WorkflowRunStatus["QUEUED"] = "QUEUED";
 })(WorkflowRunStatus || (exports.WorkflowRunStatus = WorkflowRunStatus = {}));
+var WorkflowKind;
+(function (WorkflowKind) {
+    WorkflowKind["FUNCTION"] = "FUNCTION";
+    WorkflowKind["DURABLE"] = "DURABLE";
+    WorkflowKind["DAG"] = "DAG";
+})(WorkflowKind || (exports.WorkflowKind = WorkflowKind = {}));
 var JobRunStatus;
 (function (JobRunStatus) {
     JobRunStatus["PENDING"] = "PENDING";
@@ -60,6 +89,7 @@ var StepRunStatus;
     StepRunStatus["SUCCEEDED"] = "SUCCEEDED";
     StepRunStatus["FAILED"] = "FAILED";
     StepRunStatus["CANCELLED"] = "CANCELLED";
+    StepRunStatus["CANCELLING"] = "CANCELLING";
 })(StepRunStatus || (exports.StepRunStatus = StepRunStatus = {}));
 var StepRunEventReason;
 (function (StepRunEventReason) {
@@ -77,6 +107,8 @@ var StepRunEventReason;
     StepRunEventReason["TIMED_OUT"] = "TIMED_OUT";
     StepRunEventReason["SLOT_RELEASED"] = "SLOT_RELEASED";
     StepRunEventReason["RETRIED_BY_USER"] = "RETRIED_BY_USER";
+    StepRunEventReason["WORKFLOW_RUN_GROUP_KEY_SUCCEEDED"] = "WORKFLOW_RUN_GROUP_KEY_SUCCEEDED";
+    StepRunEventReason["WORKFLOW_RUN_GROUP_KEY_FAILED"] = "WORKFLOW_RUN_GROUP_KEY_FAILED";
 })(StepRunEventReason || (exports.StepRunEventReason = StepRunEventReason = {}));
 var StepRunEventSeverity;
 (function (StepRunEventSeverity) {
@@ -105,3 +137,9 @@ var LogLineOrderByDirection;
     LogLineOrderByDirection["Asc"] = "asc";
     LogLineOrderByDirection["Desc"] = "desc";
 })(LogLineOrderByDirection || (exports.LogLineOrderByDirection = LogLineOrderByDirection = {}));
+var WebhookWorkerRequestMethod;
+(function (WebhookWorkerRequestMethod) {
+    WebhookWorkerRequestMethod["GET"] = "GET";
+    WebhookWorkerRequestMethod["POST"] = "POST";
+    WebhookWorkerRequestMethod["PUT"] = "PUT";
+})(WebhookWorkerRequestMethod || (exports.WebhookWorkerRequestMethod = WebhookWorkerRequestMethod = {}));

package/clients/rest/generated/http-client.js

@@ -63,7 +63,7 @@ class HttpClient {
             if (type === ContentType.Text && body && body !== null && typeof body !== 'string') {
                 body = JSON.stringify(body);
             }
-            return this.instance.request(Object.assign(Object.assign({}, requestParams), { headers: Object.assign(Object.assign({}, (requestParams.headers || {})), (type && type !== ContentType.FormData ? { 'Content-Type': type } : {})), params: query, responseType: responseFormat, data: body, url: path }));
+            return this.instance.request(Object.assign(Object.assign({}, requestParams), { headers: Object.assign(Object.assign({}, (requestParams.headers || {})), (type ? { 'Content-Type': type } : {})), params: query, responseType: responseFormat, data: body, url: path }));
         });
         this.instance = axios_1.default.create(Object.assign(Object.assign({}, axiosConfig), { baseURL: axiosConfig.baseURL || '' }));
         this.secure = secure;
@@ -85,6 +85,9 @@ class HttpClient {
         }
     }
     createFormData(input) {
+        if (input instanceof FormData) {
+            return input;
+        }
         return Object.keys(input || {}).reduce((formData, key) => {
             const property = input[key];
             const propertyContent = property instanceof Array ? property : [property];

package/clients/worker/worker.js

@@ -83,7 +83,7 @@ class Worker {
     }
     registerWorkflow(initWorkflow) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d;
+            var _a, _b, _c;
             const workflow = Object.assign(Object.assign({}, initWorkflow), { id: this.client.config.namespace + initWorkflow.id });
             try {
                 if (((_a = workflow.concurrency) === null || _a === void 0 ? void 0 : _a.key) && workflow.concurrency.expression) {
@@ -112,7 +112,7 @@ class Worker {
                                 parents: [],
                                 userData: '{}',
                                 retries: workflow.onFailure.retries || 0,
-                                rateLimits: (_d = workflow.onFailure.rate_limits) !== null && _d !== void 0 ? _d : [],
+                                rateLimits: (0, step_1.mapRateLimit)(workflow.onFailure.rate_limits),
                                 workerLabels: {}, // no worker labels for on failure steps
                             },
                         ],
@@ -136,7 +136,7 @@ class Worker {
                             name: workflow.id,
                             description: workflow.description,
                             steps: workflow.steps.map((step) => {
-                                var _a, _b;
+                                var _a;
                                 return ({
                                     readableId: step.name,
                                     action: `${workflow.id}:${step.name}`,
@@ -145,7 +145,7 @@ class Worker {
                                     parents: (_a = step.parents) !== null && _a !== void 0 ? _a : [],
                                     userData: '{}',
                                     retries: step.retries || 0,
-                                    rateLimits: (_b = step.rate_limits) !== null && _b !== void 0 ? _b : [], // Add the missing rateLimits property
+                                    rateLimits: (0, step_1.mapRateLimit)(step.rate_limits),
                                     workerLabels: toPbWorkerLabel(step.worker_labels),
                                 });
                             }),

package/examples/example-event.js

@@ -5,6 +5,44 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const sdk_1 = __importDefault(require("../sdk"));
 const hatchet = sdk_1.default.init();
+// Push a single event (example)
 hatchet.event.push('user:create', {
     test: 'test',
 });
+// Example events to be pushed in bulk
+const events = [
+    {
+        payload: { test: 'test1' },
+        additionalMetadata: { user_id: 'user1', source: 'test' },
+    },
+    {
+        payload: { test: 'test2' },
+        additionalMetadata: { user_id: 'user2', source: 'test' },
+    },
+    {
+        payload: { test: 'test3' },
+        additionalMetadata: { user_id: 'user3', source: 'test' },
+    },
+];
+// Bulk push the events and compare the keys
+hatchet.event
+    .bulkPush('user:create:bulk', events)
+    .then((result) => {
+    const returnedEvents = result.events;
+    const keysMatch = returnedEvents.every((returnedEvent) => {
+        const expectedKey = `user:create:bulk`;
+        return returnedEvent.key === expectedKey;
+    });
+    if (keysMatch) {
+        // eslint-disable-next-line no-console
+        console.log('All keys match the original events.');
+    }
+    else {
+        // eslint-disable-next-line no-console
+        console.log('Mismatch found between original events and returned events.');
+    }
+})
+    .catch((error) => {
+    // eslint-disable-next-line no-console
+    console.error('Error during bulk push:', error);
+});

package/examples/fanout-worker.js

@@ -14,9 +14,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const sdk_1 = __importDefault(require("../sdk"));
 const hatchet = sdk_1.default.init();
-const sleep = (ms) => new Promise((resolve) => {
-    setTimeout(resolve, ms);
-});
 const parentWorkflow = {
     id: 'parent-workflow',
     description: 'simple example for spawning child workflows',
@@ -26,16 +23,19 @@ const parentWorkflow = {
     steps: [
         {
             name: 'parent-spawn',
-            timeout: '10s',
+            timeout: '70s',
             run: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
-                ctx.putStream('spawning children');
-                const promises = Array.from({ length: 7 }, (_, i) => ctx
+                const promises = Array.from({ length: 3 }, (_, i) => ctx
                     .spawnWorkflow('child-workflow', { input: `child-input-${i}` }, { additionalMetadata: { childKey: 'childValue' } })
-                    .result());
+                    .result()
+                    .then((result) => {
+                    ctx.log('spawned workflow result:');
+                    return result;
+                }));
                 const results = yield Promise.all(promises);
                 console.log('spawned workflow results:', results);
                 console.log('number of spawned workflows:', results.length);
-                return { spawned: results };
+                return { spawned: 'x' };
             }),
         },
     ],
@@ -44,25 +44,46 @@ const childWorkflow = {
     id: 'child-workflow',
     description: 'simple example for spawning child workflows',
     on: {
-        event: 'fanout:create',
+        event: 'child:create',
     },
     steps: [
         {
             name: 'child-work',
             run: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
                 const { input } = ctx.workflowInput();
-                ctx.putStream('child running...');
-                yield sleep(10);
+                // 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);
-                return { 'child-output': 'results' };
+                // Generate a large amount of garbage data
+                const garbageData = Array.from({ length: 1e6 / 3.5 }, (_, i) => `garbage-${i}`).join(',');
+                console.log('Generated garbage data:', `${garbageData.slice(0, 100)}...`); // 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 = Array.from({ length: 1e6 / 3.5 }, (_, i) => `garbage-${i}`).join(',');
+                console.log('Generated garbage data:', `${garbageData.slice(0, 100)}...`); // Print a snippet of the garbage data
+                return { 'child-output': garbageData };
             }),
         },
     ],
 };
 function main() {
     return __awaiter(this, void 0, void 0, function* () {
-        const worker = yield hatchet.worker('fanout-worker');
+        const worker = yield hatchet.worker('fanout-worker', { maxRuns: 1000 });
         yield worker.registerWorkflow(parentWorkflow);
         yield worker.registerWorkflow(childWorkflow);
         worker.start();

package/examples/rate-limit/worker.js

@@ -23,10 +23,25 @@ const workflow = {
     },
     steps: [
         {
-            name: 'step1',
+            name: 'dynamic',
+            rate_limits: [
+                {
+                    dynamicKey: 'input.group',
+                    units: 1,
+                    limit: 10,
+                    duration: workflows_1.RateLimitDuration.DAY,
+                },
+            ],
+            run: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+                console.log('starting step1 with the following input and a dynamic rate limit', ctx.workflowInput());
+                return { step1: 'step1 results!' };
+            }),
+        },
+        {
+            name: 'static',
             rate_limits: [{ key: 'test-limit', units: 1 }],
             run: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
-                console.log('starting step1 with the following input', ctx.workflowInput());
+                console.log('starting step1 with the following input and a static rate limit', ctx.workflowInput());
                 return { step1: 'step1 results!' };
             }),
         },