@hatchet-dev/typescript-sdk 0.12.5 → 0.13.1

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"
      */
@@ -383,6 +382,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.
@@ -433,6 +440,9 @@ export interface EventList {
 export interface ReplayEventRequest {
     eventIds: string[];
 }
+export interface CancelEventRequest {
+    eventIds: string[];
+}
 export interface Workflow {
     metadata: APIResourceMeta;
     /** The name of the workflow. */
@@ -442,7 +452,6 @@ export interface Workflow {
     versions?: WorkflowVersionMeta[];
     /** The tags of the workflow. */
     tags?: WorkflowTag[];
-    lastRun?: WorkflowRun;
     /** The jobs of the workflow. */
     jobs?: Job[];
 }
@@ -473,6 +482,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 +548,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 +568,42 @@ export interface WorkflowRun {
     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 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
@@ -563,10 +620,27 @@ export interface WorkflowRun {
     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 +660,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 +683,8 @@ export declare enum StepRunStatus {
     RUNNING = "RUNNING",
     SUCCEEDED = "SUCCEEDED",
     FAILED = "FAILED",
-    CANCELLED = "CANCELLED"
+    CANCELLED = "CANCELLED",
+    CANCELLING = "CANCELLING"
 }
 export interface JobRun {
     metadata: APIResourceMeta;
@@ -629,9 +710,8 @@ export interface JobRun {
 }
 export interface WorkflowRunTriggeredBy {
     metadata: APIResourceMeta;
-    parentId: string;
+    parentWorkflowRunId?: string;
     eventId?: string;
-    event?: Event;
     cronParentId?: string;
     cronSchedule?: string;
 }
@@ -642,7 +722,7 @@ export interface StepRun {
     jobRun?: JobRun;
     stepId: string;
     step?: Step;
-    children?: string[];
+    childWorkflowsCount?: number;
     parents?: string[];
     childWorkflowRuns?: string[];
     workerId?: string;
@@ -682,7 +762,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 +777,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 +797,7 @@ export interface StepRunArchive {
     /** @format date-time */
     startedAt?: string;
     error?: string;
+    retryCount: number;
     /** @format date-time */
     createdAt: string;
     startedAtEpoch?: number;
@@ -737,10 +821,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 +879,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 +897,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 +937,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 +1066,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.EventOrderByDirection = exports.EventOrderByField = exports.TenantResource = exports.TenantMemberRole = void 0;
 var TenantMemberRole;
 (function (TenantMemberRole) {
     TenantMemberRole["OWNER"] = "OWNER";
@@ -34,6 +34,18 @@ var EventOrderByDirection;
     EventOrderByDirection["Asc"] = "asc";
     EventOrderByDirection["Desc"] = "desc";
 })(EventOrderByDirection || (exports.EventOrderByDirection = EventOrderByDirection = {}));
+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 +55,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 +78,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 +96,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 +126,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

@@ -57,8 +57,9 @@ class Worker {
             }
             : {};
         this.action_registry = Object.assign(Object.assign(Object.assign({}, this.action_registry), newActions), onFailureAction);
-        this.action_registry = ((_a = workflow.concurrency) === null || _a === void 0 ? void 0 : _a.name)
-            ? Object.assign(Object.assign({}, this.action_registry), { [`${workflow.id}:${workflow.concurrency.name}`]: workflow.concurrency.key }) : Object.assign({}, this.action_registry);
+        this.action_registry =
+            ((_a = workflow.concurrency) === null || _a === void 0 ? void 0 : _a.name) && workflow.concurrency.key
+                ? Object.assign(Object.assign({}, this.action_registry), { [`${workflow.id}:${workflow.concurrency.name}`]: workflow.concurrency.key }) : Object.assign({}, this.action_registry);
     }
     getHandler(workflows) {
         for (const workflow of workflows) {
@@ -82,13 +83,19 @@ class Worker {
     }
     registerWorkflow(initWorkflow) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
+            var _a, _b, _c, _d;
             const workflow = Object.assign(Object.assign({}, initWorkflow), { id: this.client.config.namespace + initWorkflow.id });
             try {
-                const concurrency = ((_a = workflow.concurrency) === null || _a === void 0 ? void 0 : _a.name)
+                if (((_a = workflow.concurrency) === null || _a === void 0 ? void 0 : _a.key) && workflow.concurrency.expression) {
+                    throw new hatchet_error_1.default('Cannot have both key function and expression in workflow concurrency configuration');
+                }
+                const concurrency = ((_b = workflow.concurrency) === null || _b === void 0 ? void 0 : _b.name) || ((_c = workflow.concurrency) === null || _c === void 0 ? void 0 : _c.expression)
                     ? {
-                        action: `${workflow.id}:${workflow.concurrency.name}`,
+                        action: !workflow.concurrency.expression
+                            ? `${workflow.id}:${workflow.concurrency.name}`
+                            : undefined,
                         maxRuns: workflow.concurrency.maxRuns || 1,
+                        expression: workflow.concurrency.expression,
                         limitStrategy: workflow.concurrency.limitStrategy || workflows_1.ConcurrencyLimitStrategy.CANCEL_IN_PROGRESS,
                     }
                     : undefined;
@@ -105,7 +112,7 @@ class Worker {
                                 parents: [],
                                 userData: '{}',
                                 retries: workflow.onFailure.retries || 0,
-                                rateLimits: (_b = workflow.onFailure.rate_limits) !== null && _b !== void 0 ? _b : [],
+                                rateLimits: (_d = workflow.onFailure.rate_limits) !== null && _d !== void 0 ? _d : [],
                                 workerLabels: {}, // no worker labels for on failure steps
                             },
                         ],

package/examples/concurrency/group-round-robin/{concurrency-worker.js → concurrency-worker-expression.js}

@@ -26,7 +26,7 @@ const workflow = {
     },
     concurrency: {
         name: 'user-concurrency',
-        key: (ctx) => ctx.workflowInput().group,
+        expression: 'input.group',
         maxRuns: 2,
         limitStrategy: workflow_1.ConcurrencyLimitStrategy.GROUP_ROUND_ROBIN,
     },

package/examples/concurrency/group-round-robin/concurrency-worker-key-fn.d.ts

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

package/examples/concurrency/group-round-robin/concurrency-worker-key-fn.js

@@ -0,0 +1,62 @@
+"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 workflow_1 = require("../../../workflow");
+const hatchet = sdk_1.default.init();
+const sleep = (ms) => new Promise((resolve) => {
+    setTimeout(resolve, ms);
+});
+const workflow = {
+    id: 'concurrency-example-rr',
+    description: 'test',
+    on: {
+        event: 'concurrency:create',
+    },
+    concurrency: {
+        name: 'user-concurrency',
+        // NOTE: it is recommended to use expression unless you specifically need to use a custom key function
+        key: (ctx) => ctx.workflowInput().group,
+        maxRuns: 2,
+        limitStrategy: workflow_1.ConcurrencyLimitStrategy.GROUP_ROUND_ROBIN,
+    },
+    steps: [
+        {
+            name: 'step1',
+            run: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+                const { data } = ctx.workflowInput();
+                const { signal } = ctx.controller;
+                if (signal.aborted)
+                    throw new Error('step1 was aborted');
+                console.log('starting step1 and waiting 5 seconds...', data);
+                yield sleep(2000);
+                if (signal.aborted)
+                    throw new Error('step1 was aborted');
+                // NOTE: the AbortController signal can be passed to many http libraries to cancel active requests
+                // fetch(url, { signal })
+                // axios.get(url, { signal })
+                console.log('executed step1!');
+                return { step1: `step1 results for ${data}!` };
+            }),
+        },
+    ],
+};
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker = yield hatchet.worker('example-worker');
+        yield worker.registerWorkflow(workflow);
+        worker.start();
+    });
+}
+main();

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,14 +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.spawnWorkflow('child-workflow', { input: `child-input-${i}` }, { additionalMetadata: { childKey: "childValue" } }).result());
+                const promises = Array.from({ length: 3 }, (_, i) => ctx
+                    .spawnWorkflow('child-workflow', { input: `child-input-${i}` }, { additionalMetadata: { childKey: 'childValue' } })
+                    .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' };
             }),
         },
     ],
@@ -42,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();