@hatchet-dev/typescript-sdk 0.20.3 → 1.0.0-alpha0

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

@@ -62,7 +62,6 @@ class CronClient {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b, _c;
             const workflowId = typeof workflow === 'string' ? workflow : workflow.id;
-            console.log('workflowId', workflowId);
             // Validate cron input with zod schema
             try {
                 const parsedCron = exports.CreateCronTriggerSchema.parse(cron);

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

@@ -2,10 +2,11 @@ import { EventClient } from '../event/event-client';
 import { DispatcherClient } from '../dispatcher/dispatcher-client';
 import { AdminClient } from '../admin/admin-client';
 import { CallOptions, ChannelCredentials, ClientMiddlewareCall } from 'nice-grpc';
-import { Workflow } from '../../workflow';
-import { Worker, WorkerOpts } from '../worker';
+import { Workflow as V0Workflow } from '../../workflow';
+import { V0Worker, WorkerOpts } from '../worker';
 import { AxiosRequestConfig } from 'axios';
 import { Logger } from '../../util/logger';
+import { Workflow as V1Workflow } from '../../v1/workflow';
 import { ClientConfig } from './client-config';
 import { ListenerClient } from '../listener/listener-client';
 import { Api } from '../rest/generated/Api';
@@ -17,7 +18,7 @@ export interface HatchetClientOptions {
 }
 export declare const channelFactory: (config: ClientConfig, credentials: ChannelCredentials) => import("nice-grpc").Channel;
 export declare const addTokenMiddleware: (token: string) => <Request, Response>(call: ClientMiddlewareCall<Request, Response>, options: CallOptions) => AsyncGenerator<Awaited<Response>, Awaited<Response> | undefined, undefined>;
-export declare class HatchetClient {
+export declare class InternalHatchetClient {
     config: ClientConfig;
     credentials: ChannelCredentials;
     event: EventClient;
@@ -30,8 +31,8 @@ export declare class HatchetClient {
     cron: CronClient;
     schedule: ScheduleClient;
     constructor(config?: Partial<ClientConfig>, options?: HatchetClientOptions, axiosOpts?: AxiosRequestConfig);
-    static init(config?: Partial<ClientConfig>, options?: HatchetClientOptions, axiosConfig?: AxiosRequestConfig): HatchetClient;
-    run(workflow: string | Workflow): Promise<Worker>;
-    worker(workflow: string | Workflow, opts?: Omit<WorkerOpts, 'name'> | number): Promise<Worker>;
-    webhooks(workflows: Workflow[]): import("../worker/handler").WebhookHandler;
+    static init(config?: Partial<ClientConfig>, options?: HatchetClientOptions, axiosConfig?: AxiosRequestConfig): InternalHatchetClient;
+    run(workflow: string | V0Workflow): Promise<V0Worker>;
+    worker(workflow: string | V0Workflow, opts?: Omit<WorkerOpts, 'name'> | number): Promise<V0Worker>;
+    webhooks(workflows: Array<V1Workflow<any, any> | V0Workflow>): import("../worker/handler").WebhookHandler;
 }

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

@@ -37,7 +37,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HatchetClient = exports.addTokenMiddleware = exports.channelFactory = void 0;
+exports.InternalHatchetClient = exports.addTokenMiddleware = exports.channelFactory = void 0;
 const zod_1 = require("zod");
 const config_loader_1 = require("../../util/config-loader");
 const event_client_1 = require("../event/event-client");
@@ -46,6 +46,7 @@ const admin_client_1 = require("../admin/admin-client");
 const nice_grpc_1 = require("nice-grpc");
 const worker_1 = require("../worker");
 const hatchet_logger_1 = require("./hatchet-logger");
+const worker_2 = require("../../v1/client/worker");
 const client_config_1 = require("./client-config");
 const listener_client_1 = require("../listener/listener-client");
 const rest_1 = __importDefault(require("../rest"));
@@ -88,7 +89,7 @@ const addTokenMiddleware = (token) => function _(call, options) {
     });
 };
 exports.addTokenMiddleware = addTokenMiddleware;
-class HatchetClient {
+class InternalHatchetClient {
     constructor(config, options, axiosOpts) {
         // Initializes a new Client instance.
         // Loads config in the following order: config param > yaml file > env vars
@@ -120,13 +121,13 @@ class HatchetClient {
         this.listener = new listener_client_1.ListenerClient(this.config, (0, exports.channelFactory)(this.config, this.credentials), clientFactory, this.api);
         this.admin = new admin_client_1.AdminClient(this.config, (0, exports.channelFactory)(this.config, this.credentials), clientFactory, this.api, this.tenantId, this.listener);
         this.logger = this.config.logger('HatchetClient', this.config.log_level);
-        this.logger.info(`Initialized HatchetClient`);
+        this.logger.debug(`Initialized HatchetClient`);
         // Feature Clients
         this.cron = new cron_client_1.CronClient(this.tenantId, this.config, this.api, this.admin);
         this.schedule = new schedule_client_1.ScheduleClient(this.tenantId, this.config, this.api, this.admin);
     }
     static init(config, options, axiosConfig) {
-        return new HatchetClient(config, options, axiosConfig);
+        return new InternalHatchetClient(config, options, axiosConfig);
     }
     // @deprecated
     run(workflow) {
@@ -150,7 +151,7 @@ class HatchetClient {
             else {
                 options = Object.assign(Object.assign({}, options), opts);
             }
-            const worker = new worker_1.Worker(this, options);
+            const worker = new worker_1.V0Worker(this, options);
             if (typeof workflow !== 'string') {
                 yield worker.registerWorkflow(workflow);
                 return worker;
@@ -159,10 +160,10 @@ class HatchetClient {
         });
     }
     webhooks(workflows) {
-        const worker = new worker_1.Worker(this, {
+        const worker = new worker_1.V0Worker(this, {
             name: 'webhook-worker',
         });
-        return worker.getHandler(workflows);
+        return worker.getHandler(workflows.map(worker_2.toV0Workflow));
     }
 }
-exports.HatchetClient = HatchetClient;
+exports.InternalHatchetClient = InternalHatchetClient;

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

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HatchetLogger = exports.DEFAULT_LOGGER = void 0;
-/* eslint-disable no-console */
 const logger_1 = require("../../util/logger");
 const DEFAULT_LOGGER = (context, logLevel) => new HatchetLogger(context, logLevel);
 exports.DEFAULT_LOGGER = DEFAULT_LOGGER;
@@ -21,22 +20,7 @@ class HatchetLogger {
                 second: '2-digit',
             });
             // eslint-disable-next-line no-console
-            // eslint-disable-next-line prefer-destructuring
-            let print = console.log;
-            if (level === 'ERROR') {
-                print = console.error;
-            }
-            if (level === 'WARN') {
-                print = console.warn;
-            }
-            if (level === 'INFO') {
-                print = console.info;
-            }
-            if (level === 'DEBUG') {
-                print = console.debug;
-            }
-            // eslint-disable-next-line no-console
-            print(`🪓 ${process.pid} | ${time} ${color && `\x1b[${color || ''}m`} [${level}/${this.context}] ${message}\x1b[0m`);
+            console.log(`🪓 ${process.pid} | ${time} ${color && `\x1b[${color || ''}m`} [${level}/${this.context}] ${message}\x1b[0m`);
         }
     }
     debug(message) {

package/clients/worker/handler.d.ts

@@ -1,13 +1,13 @@
 import { IncomingMessage, ServerResponse } from 'http';
 import { Workflow } from '../../workflow';
-import { Worker } from './worker';
+import { V0Worker } from './worker';
 export interface HandlerOpts {
     secret: string;
 }
 export declare class WebhookHandler {
     private worker;
     private workflows;
-    constructor(worker: Worker, workflows: Workflow[]);
+    constructor(worker: V0Worker, workflows: Workflow[]);
     /**
      * Handles a request with a provided body, secret, and signature.
      *

package/clients/worker/worker.d.ts

@@ -1,4 +1,4 @@
-import { HatchetClient } from '../hatchet-client';
+import { InternalHatchetClient } from '../hatchet-client';
 import { Action, ActionListener } from '../dispatcher/action-listener';
 import { StepActionEvent, StepActionEventType, GroupKeyActionEvent, GroupKeyActionEventType } from '../../protoc/dispatcher';
 import HatchetPromise from '../../util/hatchet-promise/hatchet-promise';
@@ -15,8 +15,8 @@ export interface WorkerOpts {
     maxRuns?: number;
     labels?: WorkerLabels;
 }
-export declare class Worker {
-    client: HatchetClient;
+export declare class V0Worker {
+    client: InternalHatchetClient;
     name: string;
     workerId: string | undefined;
     killing: boolean;
@@ -30,7 +30,7 @@ export declare class Worker {
     logger: Logger;
     registeredWorkflowPromises: Array<Promise<any>>;
     labels: WorkerLabels;
-    constructor(client: HatchetClient, options: {
+    constructor(client: InternalHatchetClient, options: {
         name: string;
         handleKill?: boolean;
         maxRuns?: number;

package/clients/worker/worker.js

@@ -19,14 +19,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Worker = void 0;
+exports.V0Worker = void 0;
 const hatchet_error_1 = __importDefault(require("../../util/errors/hatchet-error"));
 const dispatcher_1 = require("../../protoc/dispatcher");
 const hatchet_promise_1 = __importDefault(require("../../util/hatchet-promise/hatchet-promise"));
 const workflows_1 = require("../../protoc/workflows");
 const handler_1 = require("./handler");
 const step_1 = require("../../step");
-class Worker {
+class V0Worker {
     constructor(client, options) {
         this.workflow_registry = [];
         this.futures = {};
@@ -187,6 +187,8 @@ class Worker {
                         // Send the action event to the dispatcher
                         const event = this.getStepActionEvent(action, dispatcher_1.StepActionEventType.STEP_EVENT_TYPE_COMPLETED, result || null);
                         yield this.client.dispatcher.sendStepActionEvent(event);
+                        // delete the run from the futures
+                        delete this.futures[action.stepRunId];
                     }
                     catch (actionEventError) {
                         this.logger.error(`Could not send completed action event: ${actionEventError.message || actionEventError}`);
@@ -200,11 +202,6 @@ class Worker {
                         }
                         this.logger.error(`Could not send action event: ${actionEventError.message || actionEventError}`);
                     }
-                    finally {
-                        // delete the run from the futures
-                        delete this.futures[action.stepRunId];
-                        delete this.contexts[action.stepRunId];
-                    }
                 });
                 const failure = (error) => __awaiter(this, void 0, void 0, function* () {
                     this.logger.error(`Step run ${action.stepRunId} failed: ${error.message}`);
@@ -218,15 +215,12 @@ class Worker {
                             stack: error === null || error === void 0 ? void 0 : error.stack,
                         });
                         yield this.client.dispatcher.sendStepActionEvent(event);
+                        // delete the run from the futures
+                        delete this.futures[action.stepRunId];
                     }
                     catch (e) {
                         this.logger.error(`Could not send action event: ${e.message}`);
                     }
-                    finally {
-                        // delete the run from the futures
-                        delete this.futures[action.stepRunId];
-                        delete this.contexts[action.stepRunId];
-                    }
                 });
                 const future = new hatchet_promise_1.default((() => __awaiter(this, void 0, void 0, function* () {
                     let result;
@@ -285,15 +279,12 @@ class Worker {
                         this.client.dispatcher.sendGroupKeyActionEvent(event).catch((e) => {
                             this.logger.error(`Could not send action event: ${e.message}`);
                         });
+                        // delete the run from the futures
+                        delete this.futures[key];
                     }
                     catch (e) {
                         this.logger.error(`Could not send action event: ${e.message}`);
                     }
-                    finally {
-                        // delete the run from the futures
-                        delete this.futures[key];
-                        delete this.contexts[key];
-                    }
                 };
                 const failure = (error) => {
                     this.logger.error(`Step run ${key} failed: ${error.message}`);
@@ -303,15 +294,12 @@ class Worker {
                         this.client.dispatcher.sendGroupKeyActionEvent(event).catch((e) => {
                             this.logger.error(`Could not send action event: ${e.message}`);
                         });
+                        // delete the run from the futures
+                        delete this.futures[key];
                     }
                     catch (e) {
                         this.logger.error(`Could not send action event: ${e.message}`);
                     }
-                    finally {
-                        // delete the run from the futures
-                        delete this.futures[key];
-                        delete this.contexts[key];
-                    }
                 };
                 const future = new hatchet_promise_1.default(run().then(success).catch(failure));
                 this.futures[key] = future;
@@ -356,13 +344,14 @@ class Worker {
     }
     handleCancelStepRun(action) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { stepRunId } = action;
             try {
                 this.logger.info(`Cancelling step run ${action.stepRunId}`);
+                const { stepRunId } = action;
                 const future = this.futures[stepRunId];
                 const context = this.contexts[stepRunId];
                 if (context && context.controller) {
                     context.controller.abort('Cancelled by worker');
+                    delete this.contexts[stepRunId];
                 }
                 if (future) {
                     future.promise.catch(() => {
@@ -370,15 +359,12 @@ class Worker {
                     });
                     future.cancel('Cancelled by worker');
                     yield future.promise;
+                    delete this.futures[stepRunId];
                 }
             }
             catch (e) {
                 this.logger.error('Could not cancel step run: ', e);
             }
-            finally {
-                delete this.futures[stepRunId];
-                delete this.contexts[stepRunId];
-            }
         });
     }
     stop() {
@@ -482,7 +468,7 @@ class Worker {
         });
     }
 }
-exports.Worker = Worker;
+exports.V0Worker = V0Worker;
 function toPbWorkerLabel(in_) {
     if (!in_) {
         return {};

package/examples/api.js

@@ -49,7 +49,7 @@ function main() {
         const { admin } = hatchet;
         yield admin.putWorkflow(opts);
         const worker = yield hatchet.worker('example-worker');
-        worker.registerAction('slack:example', (ctx) => __awaiter(this, void 0, void 0, function* () {
+        worker.v0.registerAction('slack:example', (ctx) => __awaiter(this, void 0, void 0, function* () {
             const setData = ctx.userData();
             console.log('executed step1!', setData);
             return { step1: 'step1' };

package/examples/example-event-with-results.js

@@ -27,7 +27,7 @@ function main() {
         const ref = yield hatchet.admin.runWorkflow('simple-workflow', {
             test: 'test',
         });
-        const listener = yield hatchet.listener.stream(yield ref.getWorkflowRunId());
+        const listener = yield hatchet.v0.listener.stream(yield ref.getWorkflowRunId());
         console.log('listening for events');
         try {
             for (var _d = true, listener_1 = __asyncValues(listener), listener_1_1; listener_1_1 = yield listener_1.next(), _a = listener_1_1.done, !_a; _d = true) {

package/examples/stream-by-additional-meta.js

@@ -34,7 +34,7 @@ function main() {
         // and can have an arbitrary property name.
         yield hatchet.admin.runWorkflow('parent-workflow', {}, { additionalMetadata: { [streamKey]: streamVal } });
         // Stream all events for the additional meta key value
-        const stream = yield hatchet.listener.streamByAdditionalMeta(streamKey, streamVal);
+        const stream = yield hatchet.v0.listener.streamByAdditionalMeta(streamKey, streamVal);
         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;

package/index.d.ts

@@ -1,9 +1,11 @@
-import { HatchetClient as Hatchet } from './clients/hatchet-client';
+import { HatchetClient as Hatchet } from './v1/client/client';
 export * from './workflow';
 export * from './step';
 export * from './clients/worker';
 export * from './clients/rest';
 export * from './clients/admin';
 export * from './util/workflow-run-ref';
+export * from './v1/client/client';
+export * from './v1/client/worker';
 export default Hatchet;
 export { Hatchet };

package/index.js

@@ -15,12 +15,14 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Hatchet = void 0;
-const hatchet_client_1 = require("./clients/hatchet-client");
-Object.defineProperty(exports, "Hatchet", { enumerable: true, get: function () { return hatchet_client_1.HatchetClient; } });
+const client_1 = require("./v1/client/client");
+Object.defineProperty(exports, "Hatchet", { enumerable: true, get: function () { return client_1.HatchetClient; } });
 __exportStar(require("./workflow"), exports);
 __exportStar(require("./step"), exports);
 __exportStar(require("./clients/worker"), exports);
 __exportStar(require("./clients/rest"), exports);
 __exportStar(require("./clients/admin"), exports);
 __exportStar(require("./util/workflow-run-ref"), exports);
-exports.default = hatchet_client_1.HatchetClient;
+__exportStar(require("./v1/client/client"), exports);
+__exportStar(require("./v1/client/worker"), exports);
+exports.default = client_1.HatchetClient;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "0.20.3",
+  "version": "1.0.0-alpha0",
   "description": "Background task orchestration & visibility for developers",
   "types": "dist/index.d.ts",
   "files": [

package/sdk.d.ts

@@ -1,2 +1,2 @@
-import { HatchetClient as Hatchet } from './clients/hatchet-client';
+import { HatchetClient as Hatchet } from './v1/client/client';
 export default Hatchet;

package/sdk.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const hatchet_client_1 = require("./clients/hatchet-client");
-exports.default = hatchet_client_1.HatchetClient;
+const client_1 = require("./v1/client/client");
+exports.default = client_1.HatchetClient;

package/step.d.ts

@@ -3,11 +3,13 @@ import { Workflow } from './workflow';
 import { Action } from './clients/dispatcher/action-listener';
 import { LogLevel } from './clients/event/event-client';
 import { Logger } from './util/logger';
-import { HatchetClient } from './clients/hatchet-client';
+import { InternalHatchetClient } from './clients/hatchet-client';
 import WorkflowRunRef from './util/workflow-run-ref';
-import { Worker } from './clients/worker';
+import { V0Worker } from './clients/worker';
 import { WorkerLabels } from './clients/dispatcher/dispatcher-client';
 import { CreateStepRateLimit, RateLimitDuration, WorkerLabelComparator } from './protoc/workflows';
+import { CreateTaskOpts } from './v1/task';
+import { Workflow as WorkflowV1 } from './v1/workflow';
 export declare const CreateRateLimitSchema: z.ZodObject<{
     key: z.ZodOptional<z.ZodString>;
     staticKey: z.ZodOptional<z.ZodString>;
@@ -166,7 +168,7 @@ interface ContextData<T, K> {
 }
 export declare class ContextWorker {
     private worker;
-    constructor(worker: Worker);
+    constructor(worker: V0Worker);
     id(): string | undefined;
     hasWorkflow(workflowName: string): boolean;
     labels(): WorkerLabels;
@@ -177,13 +179,14 @@ export declare class Context<T, K = {}> {
     input: T;
     controller: AbortController;
     action: Action;
-    client: HatchetClient;
+    client: InternalHatchetClient;
     worker: ContextWorker;
     overridesData: Record<string, any>;
     logger: Logger;
     spawnIndex: number;
-    constructor(action: Action, client: HatchetClient, worker: Worker);
-    stepOutput(step: string): NextStep;
+    constructor(action: Action, client: InternalHatchetClient, worker: V0Worker);
+    parentData<L = NextStep>(task: CreateTaskOpts<any, L> | string): Promise<L>;
+    stepOutput<L = NextStep>(step: string): L;
     stepRunErrors(): Record<string, string>;
     triggeredByEvent(): boolean;
     workflowInput(): T;
@@ -203,14 +206,43 @@ export declare class Context<T, K = {}> {
     refreshTimeout(incrementBy: string): Promise<void>;
     releaseSlot(): Promise<void>;
     putStream(data: string | Uint8Array): Promise<void>;
+    /**
+     * Enqueues multiple children workflows in parallel.
+     * @param children an array of objects containing the workflow name, input data, and options for each workflow
+     * @returns a list of workflow run references to the enqueued runs
+     */
+    bulkEnqueueChildren<Q extends Record<string, any> = any, P extends Record<string, any> = any>(children: Array<{
+        workflow: string | Workflow | WorkflowV1<Q, P>;
+        input: Q;
+        options?: {
+            key?: string;
+            sticky?: boolean;
+            additionalMetadata?: Record<string, string>;
+        };
+    }>): Promise<WorkflowRunRef<P>[]>;
+    /**
+     * Runs multiple children workflows in parallel.
+     * @param children an array of objects containing the workflow name, input data, and options for each workflow
+     * @returns a list of results from the children workflows
+     */
+    bulkRunChildren<Q extends Record<string, any> = any, P extends Record<string, any> = any>(children: Array<{
+        workflow: string | Workflow | WorkflowV1<Q, P>;
+        input: Q;
+        options?: {
+            key?: string;
+            sticky?: boolean;
+            additionalMetadata?: Record<string, string>;
+        };
+    }>): Promise<P[]>;
     /**
      * 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
+     * @deprecated use bulkEnqueueChildren or bulkRunChildren instead
      */
-    spawnWorkflows<Q = JsonValue, P = JsonValue>(workflows: Array<{
-        workflow: string | Workflow;
+    spawnWorkflows<Q extends Record<string, any> = any, P extends Record<string, any> = any>(workflows: Array<{
+        workflow: string | Workflow | WorkflowV1<Q, P>;
         input: Q;
         options?: {
             key?: string;
@@ -218,6 +250,39 @@ export declare class Context<T, K = {}> {
             additionalMetadata?: Record<string, string>;
         };
     }>): Promise<WorkflowRunRef<P>[]>;
+    /**
+     * Runs a new workflow.
+     *
+     * @param workflow the workflow to run
+     * @param input the input data for the workflow
+     * @param options additional options for spawning the workflow. If a string is provided, it is used as the key.
+     * @param <Q> the type of the input data
+     * @param <P> the type of the output data
+     * @return the result of the workflow
+     */
+    runChild<Q extends Record<string, any>, P extends Record<string, any>>(workflow: string | Workflow | WorkflowV1<Q, P>, input: Q, options?: string | {
+        key?: string;
+        sticky?: boolean;
+        additionalMetadata?: Record<string, string>;
+    }): Promise<P>;
+    /**
+     * Enqueues a new workflow.
+     *
+     * @param workflowName the name of the workflow to spawn
+     * @param input the input data for the workflow
+     * @param options additional options for spawning the workflow. If a string is provided, it is used as the key.
+     *                If an object is provided, it can include:
+     *                - key: a unique identifier for the workflow (deprecated, use options.key instead)
+     *                - sticky: a boolean indicating whether to use sticky execution
+     * @param <Q> the type of the input data
+     * @param <P> the type of the output data
+     * @return a reference to the spawned workflow run
+     */
+    enqueueChild<Q extends Record<string, any>, P extends Record<string, any>>(workflow: string | Workflow | WorkflowV1<Q, P>, input: Q, options?: string | {
+        key?: string;
+        sticky?: boolean;
+        additionalMetadata?: Record<string, string>;
+    }): WorkflowRunRef<P>;
     /**
      * Spawns a new workflow.
      *
@@ -230,8 +295,9 @@ export declare class Context<T, K = {}> {
      * @param <Q> the type of the input data
      * @param <P> the type of the output data
      * @return a reference to the spawned workflow run
+     * @deprecated use runChild or enqueueChild instead
      */
-    spawnWorkflow<Q = JsonValue, P = JsonValue>(workflow: string | Workflow, input: Q, options?: string | {
+    spawnWorkflow<Q extends Record<string, any>, P extends Record<string, any>>(workflow: string | Workflow | WorkflowV1<Q, P>, input: Q, options?: string | {
         key?: string;
         sticky?: boolean;
         additionalMetadata?: Record<string, string>;

package/step.js

@@ -50,7 +50,6 @@ exports.mapRateLimit = mapRateLimit;
 /* eslint-disable max-classes-per-file */
 const hatchet_error_1 = __importDefault(require("./util/errors/hatchet-error"));
 const z = __importStar(require("zod"));
-const workflow_1 = require("./workflow");
 const parse_1 = require("./util/parse");
 const workflows_1 = require("./protoc/workflows");
 exports.CreateRateLimitSchema = z.object({
@@ -79,7 +78,7 @@ exports.DesiredWorkerLabelSchema = z
 exports.CreateStepSchema = z.object({
     name: z.string(),
     parents: z.array(z.string()).optional(),
-    timeout: workflow_1.HatchetTimeoutSchema.optional(),
+    timeout: z.string().optional(),
     retries: z.number().optional(),
     rate_limits: z.array(exports.CreateRateLimitSchema).optional(),
     worker_labels: z.record(z.lazy(() => exports.DesiredWorkerLabelSchema)).optional(),
@@ -133,6 +132,16 @@ class Context {
             throw new hatchet_error_1.default(`Could not parse payload: ${e.message}`);
         }
     }
+    // NOTE: parentData is async since we plan on potentially making this a cacheable server call
+    parentData(task) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeof task === 'string') {
+                return this.stepOutput(task);
+            }
+            return this.stepOutput(task.name);
+        });
+    }
+    // TODO deprecated
     stepOutput(step) {
         if (!this.data.parents) {
             throw new hatchet_error_1.default('Step output not found');
@@ -227,11 +236,32 @@ class Context {
             yield this.client.event.putStream(stepRunId, data);
         });
     }
+    /**
+     * Enqueues multiple children workflows in parallel.
+     * @param children an array of objects containing the workflow name, input data, and options for each workflow
+     * @returns a list of workflow run references to the enqueued runs
+     */
+    bulkEnqueueChildren(children) {
+        return this.spawnWorkflows(children);
+    }
+    /**
+     * Runs multiple children workflows in parallel.
+     * @param children an array of objects containing the workflow name, input data, and options for each workflow
+     * @returns a list of results from the children workflows
+     */
+    bulkRunChildren(children) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const runs = yield this.bulkEnqueueChildren(children);
+            const res = runs.map((run) => run.result());
+            return Promise.all(res);
+        });
+    }
     /**
      * 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
+     * @deprecated use bulkEnqueueChildren or bulkRunChildren instead
      */
     spawnWorkflows(workflows) {
         const { workflowRunId, stepRunId } = this.action;
@@ -278,6 +308,38 @@ class Context {
             throw new hatchet_error_1.default(e.message);
         }
     }
+    /**
+     * Runs a new workflow.
+     *
+     * @param workflow the workflow to run
+     * @param input the input data for the workflow
+     * @param options additional options for spawning the workflow. If a string is provided, it is used as the key.
+     * @param <Q> the type of the input data
+     * @param <P> the type of the output data
+     * @return the result of the workflow
+     */
+    runChild(workflow, input, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const run = yield this.spawnWorkflow(workflow, input, options);
+            return run.result();
+        });
+    }
+    /**
+     * Enqueues a new workflow.
+     *
+     * @param workflowName the name of the workflow to spawn
+     * @param input the input data for the workflow
+     * @param options additional options for spawning the workflow. If a string is provided, it is used as the key.
+     *                If an object is provided, it can include:
+     *                - key: a unique identifier for the workflow (deprecated, use options.key instead)
+     *                - sticky: a boolean indicating whether to use sticky execution
+     * @param <Q> the type of the input data
+     * @param <P> the type of the output data
+     * @return a reference to the spawned workflow run
+     */
+    enqueueChild(workflow, input, options) {
+        return this.spawnWorkflow(workflow, input, options);
+    }
     /**
      * Spawns a new workflow.
      *
@@ -290,6 +352,7 @@ class Context {
      * @param <Q> the type of the input data
      * @param <P> the type of the output data
      * @return a reference to the spawned workflow run
+     * @deprecated use runChild or enqueueChild instead
      */
     spawnWorkflow(workflow, input, options) {
         const { workflowRunId, stepRunId } = this.action;