@hatchet-dev/typescript-sdk 1.5.1 → 1.5.3

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

@@ -24,6 +24,6 @@ export declare class EventClient {
     constructor(config: ClientConfig, channel: Channel, factory: ClientFactory);
     push<T>(type: string, input: T, options?: PushEventOptions): Promise<import("../../protoc/events/events").Event>;
     bulkPush<T>(type: string, inputs: EventWithMetadata<T>[], options?: PushEventOptions): Promise<import("../../protoc/events/events").Events>;
-    putLog(stepRunId: string, log: string, level?: LogLevel): void;
-    putStream(stepRunId: string, data: string | Uint8Array): void;
+    putLog(stepRunId: string, log: string, level?: LogLevel, taskRetryCount?: number, metadata?: Record<string, any>): Promise<void>;
+    putStream(stepRunId: string, data: string | Uint8Array): Promise<void>;
 }

package/clients/event/event-client.js

@@ -82,46 +82,52 @@ class EventClient {
             throw new hatchet_error_1.default(e.message);
         }
     }
-    putLog(stepRunId, log, level) {
-        const createdAt = new Date();
-        if (log.length > 1000) {
-            this.logger.warn(`log is too long, skipping: ${log.length} characters`);
-            return;
-        }
-        //  fire and forget the log
-        this.client
-            .putLog({
-            stepRunId,
-            createdAt,
-            message: log,
-            level: level || LogLevel.INFO,
-        })
-            .catch((e) => {
-            // log a warning, but this is not a fatal error
-            this.logger.warn(`Could not put log: ${e.message}`);
+    putLog(stepRunId, log, level, taskRetryCount, metadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const createdAt = new Date();
+            if (log.length > 1000) {
+                this.logger.warn(`log is too long, skipping: ${log.length} characters`);
+                return;
+            }
+            //  fire and forget the log
+            yield this.client
+                .putLog({
+                stepRunId,
+                createdAt,
+                message: log,
+                level: level || LogLevel.INFO,
+                taskRetryCount,
+                metadata: metadata ? JSON.stringify(metadata) : undefined,
+            })
+                .catch((e) => {
+                // log a warning, but this is not a fatal error
+                this.logger.warn(`Could not put log: ${e.message}`);
+            });
         });
     }
     putStream(stepRunId, data) {
-        const createdAt = new Date();
-        let dataBytes;
-        if (typeof data === 'string') {
-            dataBytes = new TextEncoder().encode(data);
-        }
-        else if (data instanceof Uint8Array) {
-            dataBytes = data;
-        }
-        else {
-            throw new Error('Invalid data type. Expected string or Uint8Array.');
-        }
-        (0, retrier_1.retrier)(() => __awaiter(this, void 0, void 0, function* () {
-            return this.client.putStreamEvent({
-                stepRunId,
-                createdAt,
-                message: dataBytes,
+        return __awaiter(this, void 0, void 0, function* () {
+            const createdAt = new Date();
+            let dataBytes;
+            if (typeof data === 'string') {
+                dataBytes = new TextEncoder().encode(data);
+            }
+            else if (data instanceof Uint8Array) {
+                dataBytes = data;
+            }
+            else {
+                throw new Error('Invalid data type. Expected string or Uint8Array.');
+            }
+            (0, retrier_1.retrier)(() => __awaiter(this, void 0, void 0, function* () {
+                return this.client.putStreamEvent({
+                    stepRunId,
+                    createdAt,
+                    message: dataBytes,
+                });
+            }), this.logger).catch((e) => {
+                // log a warning, but this is not a fatal error
+                this.logger.warn(`Could not put log: ${e.message}`);
             });
-        }), this.logger).catch((e) => {
-            // log a warning, but this is not a fatal error
-            this.logger.warn(`Could not put log: ${e.message}`);
         });
     }
 }

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

@@ -1,13 +1,16 @@
-import { Logger, LogLevel } from '../../util/logger';
+import { LogExtra, Logger, LogLevel } from '../../util/logger';
 export declare const DEFAULT_LOGGER: (context: string, logLevel?: LogLevel) => HatchetLogger;
+type UtilKeys = 'trace';
 export declare class HatchetLogger implements Logger {
     private logLevel;
     private context;
     constructor(context: string, logLevel?: LogLevel);
     private log;
-    debug(message: string): void;
-    info(message: string): void;
-    green(message: string): void;
-    warn(message: string, error?: Error): void;
-    error(message: string, error?: Error): void;
+    debug(message: string): Promise<void>;
+    info(message: string): Promise<void>;
+    green(message: string): Promise<void>;
+    warn(message: string, error?: Error): Promise<void>;
+    error(message: string, error?: Error): Promise<void>;
+    util(key: UtilKeys, message: string, extra?: LogExtra): void | Promise<void>;
 }
+export {};

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

@@ -1,4 +1,13 @@
 "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());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HatchetLogger = exports.DEFAULT_LOGGER = void 0;
 /* eslint-disable no-console */
@@ -39,19 +48,34 @@ class HatchetLogger {
         }
     }
     debug(message) {
-        this.log('DEBUG', message, '35');
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.log('DEBUG', message, '35');
+        });
     }
     info(message) {
-        this.log('INFO', message);
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.log('INFO', message);
+        });
     }
     green(message) {
-        this.log('INFO', message, '32');
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.log('INFO', message, '32');
+        });
     }
     warn(message, error) {
-        this.log('WARN', `${message} ${error}`, '93');
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.log('WARN', `${message} ${error}`, '93');
+        });
     }
     error(message, error) {
-        this.log('ERROR', `${message} ${error}`, '91');
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.log('ERROR', `${message} ${error}`, '91');
+        });
+    }
+    util(key, message, extra) {
+        if (key === 'trace') {
+            this.log('INFO', `trace: ${message}`, '35');
+        }
     }
 }
 exports.HatchetLogger = HatchetLogger;

package/examples/bulk-fanout-worker.js

@@ -33,7 +33,7 @@ const parentWorkflow = {
                 }));
                 const spawnedWorkflows = yield ctx.spawnWorkflows(workflowRequests);
                 const results = yield Promise.all(spawnedWorkflows.map((workflowRef) => workflowRef.output.then((result) => {
-                    ctx.log('spawned workflow result:');
+                    ctx.logger.info('spawned workflow result:');
                     return result;
                 })));
                 console.log('spawned workflow results:', results);

package/examples/byo-logger.js

@@ -22,20 +22,27 @@ class PinoLogger {
         this.logLevel = logLevel;
         this.context = context;
     }
-    debug(message) {
-        logger.debug(message);
+    debug(message, extra) {
+        logger.debug(message, extra);
     }
-    info(message) {
-        logger.info(message);
+    info(message, extra) {
+        logger.info(message, extra);
     }
-    green(message) {
-        logger.info(`%c${message}`);
+    green(message, extra) {
+        logger.info(`%c${message}`, extra);
     }
-    warn(message, error) {
-        logger.warn(`${message} ${error}`);
+    warn(message, error, extra) {
+        logger.warn(`${message} ${error}`, extra);
     }
-    error(message, error) {
-        logger.error(`${message} ${error}`);
+    error(message, error, extra) {
+        logger.error(`${message} ${error}`, extra);
+    }
+    // optional util method
+    util(key, message, extra) {
+        // for example you may want to expose a trace method
+        if (key === 'trace') {
+            logger.info('trace', extra);
+        }
     }
 }
 const hatchet = sdk_1.default.init({
@@ -44,34 +51,22 @@ const hatchet = sdk_1.default.init({
 });
 // !!
 // > Use the logger
-const sleep = (ms) => new Promise((resolve) => {
-    setTimeout(resolve, ms);
+const workflow = hatchet.task({
+    name: 'byo-logger-example',
+    fn: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        // eslint-disable-next-line no-plusplus
+        for (let i = 0; i < 5; i++) {
+            logger.info(`log message ${i}`);
+        }
+        return { step1: 'completed step run' };
+    }),
 });
-const workflow = {
-    id: 'byo-logger-example',
-    description: 'An example showing how to pass a custom logger to Hatchet',
-    on: {
-        event: 'byo-logger:spawn',
-    },
-    steps: [
-        {
-            name: 'logger-step1',
-            run: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
-                // eslint-disable-next-line no-plusplus
-                for (let i = 0; i < 5; i++) {
-                    logger.info(`log message ${i}`);
-                    yield sleep(500);
-                }
-                return { step1: 'completed step run' };
-            }),
-        },
-    ],
-};
 // !!
 function main() {
     return __awaiter(this, void 0, void 0, function* () {
-        const worker = yield hatchet.worker('byo-logger-worker', 1);
-        yield worker.registerWorkflow(workflow);
+        const worker = yield hatchet.worker('byo-logger-worker', {
+            workflows: [workflow],
+        });
         worker.start();
     });
 }

package/examples/fanout-worker.js

@@ -28,7 +28,7 @@ const parentWorkflow = {
                 const promises = Array.from({ length: 3 }, (_, i) => ctx
                     .spawnWorkflow('child-workflow', { input: `child-input-${i}` }, { additionalMetadata: { childKey: 'childValue' } })
                     .then((result) => {
-                    ctx.log('spawned workflow result:');
+                    ctx.logger.info('spawned workflow result:');
                     return result.output;
                 }));
                 const results = yield Promise.all(promises);

package/examples/logger.js

@@ -33,7 +33,7 @@ const workflow = {
                 // log in a for loop
                 // eslint-disable-next-line no-plusplus
                 for (let i = 0; i < 10; i++) {
-                    ctx.log(`log message ${i}`);
+                    ctx.logger.info(`log message ${i}`);
                     yield sleep(200);
                 }
                 return { step1: 'completed step run' };

package/package.json

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

package/protoc/events/events.d.ts

@@ -29,6 +29,8 @@ export interface PutLogRequest {
     level?: string | undefined;
     /** associated log line metadata */
     metadata: string;
+    /** the retry count of the task run */
+    taskRetryCount?: number | undefined;
 }
 export interface PutLogResponse {
 }

package/protoc/events/events.js

@@ -208,7 +208,14 @@ exports.Events = {
     },
 };
 function createBasePutLogRequest() {
-    return { stepRunId: '', createdAt: undefined, message: '', level: undefined, metadata: '' };
+    return {
+        stepRunId: '',
+        createdAt: undefined,
+        message: '',
+        level: undefined,
+        metadata: '',
+        taskRetryCount: undefined,
+    };
 }
 exports.PutLogRequest = {
     encode(message, writer = new wire_1.BinaryWriter()) {
@@ -227,6 +234,9 @@ exports.PutLogRequest = {
         if (message.metadata !== '') {
             writer.uint32(42).string(message.metadata);
         }
+        if (message.taskRetryCount !== undefined) {
+            writer.uint32(48).int32(message.taskRetryCount);
+        }
         return writer;
     },
     decode(input, length) {
@@ -271,6 +281,13 @@ exports.PutLogRequest = {
                     message.metadata = reader.string();
                     continue;
                 }
+                case 6: {
+                    if (tag !== 48) {
+                        break;
+                    }
+                    message.taskRetryCount = reader.int32();
+                    continue;
+                }
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -286,6 +303,9 @@ exports.PutLogRequest = {
             message: isSet(object.message) ? globalThis.String(object.message) : '',
             level: isSet(object.level) ? globalThis.String(object.level) : undefined,
             metadata: isSet(object.metadata) ? globalThis.String(object.metadata) : '',
+            taskRetryCount: isSet(object.taskRetryCount)
+                ? globalThis.Number(object.taskRetryCount)
+                : undefined,
         };
     },
     toJSON(message) {
@@ -305,19 +325,23 @@ exports.PutLogRequest = {
         if (message.metadata !== '') {
             obj.metadata = message.metadata;
         }
+        if (message.taskRetryCount !== undefined) {
+            obj.taskRetryCount = Math.round(message.taskRetryCount);
+        }
         return obj;
     },
     create(base) {
         return exports.PutLogRequest.fromPartial(base !== null && base !== void 0 ? base : {});
     },
     fromPartial(object) {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d, _e, _f;
         const message = createBasePutLogRequest();
         message.stepRunId = (_a = object.stepRunId) !== null && _a !== void 0 ? _a : '';
         message.createdAt = (_b = object.createdAt) !== null && _b !== void 0 ? _b : undefined;
         message.message = (_c = object.message) !== null && _c !== void 0 ? _c : '';
         message.level = (_d = object.level) !== null && _d !== void 0 ? _d : undefined;
         message.metadata = (_e = object.metadata) !== null && _e !== void 0 ? _e : '';
+        message.taskRetryCount = (_f = object.taskRetryCount) !== null && _f !== void 0 ? _f : undefined;
         return message;
     },
 };

package/step.js

@@ -301,7 +301,7 @@ class V0Context {
             this.logger.warn('cannot log from context without stepRunId');
             return;
         }
-        this.v0.event.putLog(stepRunId, message, level);
+        this.v0.event.putLog(stepRunId, message, level, this.retryCount());
     }
     /**
      * Refreshes the timeout for the current task.

package/util/logger/logger.d.ts

@@ -1,9 +1,12 @@
+import { JsonObject } from '../../v1';
+export type LogExtra = JsonObject;
 export declare abstract class Logger {
-    abstract debug(message: string): void;
-    abstract info(message: string): void;
-    abstract green(message: string): void;
-    abstract warn(message: string, error?: Error): void;
-    abstract error(message: string, error?: Error): void;
+    abstract debug(message: string, extra?: LogExtra): void | Promise<void>;
+    abstract info(message: string, extra?: LogExtra): void | Promise<void>;
+    abstract green(message: string, extra?: LogExtra): void | Promise<void>;
+    abstract warn(message: string, error?: Error, extra?: LogExtra): void | Promise<void>;
+    abstract error(message: string, error?: Error, extra?: LogExtra): void | Promise<void>;
+    abstract util?(key: string, message: string, extra?: LogExtra): void | Promise<void>;
 }
 export type LogLevel = 'OFF' | 'DEBUG' | 'INFO' | 'WARN' | 'ERROR';
 export declare enum LogLevelEnum {

package/v1/client/worker/context.d.ts

@@ -16,6 +16,10 @@ type ChildRunOpts = RunOpts & {
     key?: string;
     sticky?: boolean;
 };
+type LogExtra = {
+    extra?: any;
+    error?: Error;
+};
 interface ContextData<T, K> {
     input: T;
     triggers: TriggerData;
@@ -32,7 +36,7 @@ export declare class Context<T, K = {}> {
     v1: HatchetClient;
     worker: ContextWorker;
     overridesData: Record<string, any>;
-    logger: Logger;
+    _logger: Logger;
     spawnIndex: number;
     constructor(action: Action, v1: HatchetClient, worker: V1Worker);
     get abortController(): AbortController;
@@ -101,8 +105,16 @@ export declare class Context<T, K = {}> {
      * Logs a message from the current task.
      * @param message - The message to log.
      * @param level - The log level (optional).
+     * @deprecated use ctx.logger.infoger.info, ctx.logger.infoger.debug, ctx.logger.infoger.warn, ctx.logger.infoger.error, ctx.logger.infoger.trace instead
      */
-    log(message: string, level?: LogLevel): void;
+    log(message: string, level?: LogLevel, extra?: LogExtra): Promise<void> | Promise<void[]>;
+    get logger(): {
+        info: (message: string, extra?: any) => Promise<void> | Promise<void[]>;
+        debug: (message: string, extra?: any) => Promise<void> | Promise<void[]>;
+        warn: (message: string, extra?: LogExtra) => Promise<void> | Promise<void[]>;
+        error: (message: string, extra?: LogExtra) => Promise<void> | Promise<void[]>;
+        util: (key: string, message: string, extra?: LogExtra) => void | Promise<void>;
+    };
     /**
      * Refreshes the timeout for the current task.
      * @param incrementBy - The interval by which to increment the timeout.

package/v1/client/worker/context.js

@@ -34,7 +34,7 @@ class Context {
             this.action = action;
             this.v1 = v1;
             this.worker = new step_1.ContextWorker(worker);
-            this.logger = v1.config.logger(`Context Logger`, v1.config.log_level);
+            this._logger = v1.config.logger(`Context Logger`, v1.config.log_level);
             // if this is a getGroupKeyRunId, the data is the workflow input
             if (action.getGroupKeyRunId !== '') {
                 this.input = data;
@@ -92,7 +92,7 @@ class Context {
     errors() {
         const errors = this.data.step_run_errors || {};
         if (Object.keys(errors).length === 0) {
-            this.logger.error('No run errors found. `ctx.errors` is intended to be run in an on-failure task, and will only work on engine versions more recent than v0.53.10');
+            this._logger.error('No run errors found. `ctx.errors` is intended to be run in an on-failure task, and will only work on engine versions more recent than v0.53.10');
         }
         return errors;
     }
@@ -158,29 +158,56 @@ class Context {
      * Logs a message from the current task.
      * @param message - The message to log.
      * @param level - The log level (optional).
+     * @deprecated use ctx.logger.infoger.info, ctx.logger.infoger.debug, ctx.logger.infoger.warn, ctx.logger.infoger.error, ctx.logger.infoger.trace instead
      */
-    log(message, level) {
+    log(message, level, extra) {
         const { stepRunId } = this.action;
         if (!stepRunId) {
             // log a warning
-            this.logger.warn('cannot log from context without stepRunId');
-            return;
+            this._logger.warn('cannot log from context without stepRunId');
+            return Promise.resolve();
         }
         const logger = this.v1.config.logger('ctx', this.v1.config.log_level);
+        const contextExtra = Object.assign({ workflowRunId: this.action.workflowRunId, taskRunId: this.action.stepRunId, retryCount: this.action.retryCount, workflowName: this.action.jobName }, extra === null || extra === void 0 ? void 0 : extra.extra);
+        const promises = [];
         if (!level || level === 'INFO') {
-            logger.info(message);
+            promises.push(logger.info(message, contextExtra));
         }
         else if (level === 'DEBUG') {
-            logger.debug(message);
+            promises.push(logger.debug(message, contextExtra));
         }
         else if (level === 'WARN') {
-            logger.warn(message);
+            promises.push(logger.warn(message, extra === null || extra === void 0 ? void 0 : extra.error, contextExtra));
         }
         else if (level === 'ERROR') {
-            logger.error(message);
+            promises.push(logger.error(message, extra === null || extra === void 0 ? void 0 : extra.error, contextExtra));
         }
         // FIXME: this is a hack to get around the fact that the log level is not typed
-        this.v1.event.putLog(stepRunId, message, level);
+        promises.push(this.v1.event.putLog(stepRunId, message, level, this.retryCount(), extra === null || extra === void 0 ? void 0 : extra.extra));
+        return Promise.all(promises);
+    }
+    get logger() {
+        return {
+            info: (message, extra) => {
+                return this.log(message, 'INFO', { extra });
+            },
+            debug: (message, extra) => {
+                return this.log(message, 'DEBUG', { extra });
+            },
+            warn: (message, extra) => {
+                return this.log(message, 'WARN', extra);
+            },
+            error: (message, extra) => {
+                return this.log(message, 'ERROR', extra);
+            },
+            util: (key, message, extra) => {
+                const logger = this.v1.config.logger('ctx', this.v1.config.log_level);
+                if (!logger.util) {
+                    return Promise.resolve();
+                }
+                return logger.util(key, message, extra === null || extra === void 0 ? void 0 : extra.extra);
+            },
+        };
     }
     /**
      * Refreshes the timeout for the current task.
@@ -192,7 +219,7 @@ class Context {
             const { stepRunId } = this.action;
             if (!stepRunId) {
                 // log a warning
-                this.logger.warn('cannot refresh timeout from context without stepRunId');
+                this._logger.warn('cannot refresh timeout from context without stepRunId');
                 return;
             }
             yield this.v1._v0.dispatcher.refreshTimeout(incrementBy, stepRunId);
@@ -220,7 +247,7 @@ class Context {
             const { stepRunId } = this.action;
             if (!stepRunId) {
                 // log a warning
-                this.logger.warn('cannot log from context without stepRunId');
+                this._logger.warn('cannot log from context without stepRunId');
                 return;
             }
             yield this.v1._v0.event.putStream(stepRunId, data);
@@ -240,7 +267,7 @@ class Context {
             throw new hatchet_error_1.default(`Cannot run with sticky: workflow ${workflowName} is not registered on the worker`);
         }
         const { workflowRunId, stepRunId } = this.action;
-        const finalOpts = Object.assign(Object.assign({}, options), { parentId: workflowRunId, parentStepRunId: stepRunId, childIndex: this.spawnIndex, desiredWorkerId: sticky ? this.worker.id() : undefined, _standaloneTaskName: workflow instanceof declaration_1.TaskWorkflowDeclaration ? workflow._standalone_task_name : undefined });
+        const finalOpts = Object.assign(Object.assign({}, options), { parentId: workflowRunId, parentStepRunId: stepRunId, childIndex: this.spawnIndex, childKey: options === null || options === void 0 ? void 0 : options.key, desiredWorkerId: sticky ? this.worker.id() : undefined, _standaloneTaskName: workflow instanceof declaration_1.TaskWorkflowDeclaration ? workflow._standalone_task_name : undefined });
         this.spawnIndex += 1;
         return { workflowName, opts: finalOpts };
     }

package/v1/declaration.d.ts

@@ -192,6 +192,7 @@ export declare class BaseWorkflowDeclaration<I extends InputType = UnknownInputT
      * @throws Error if the workflow is not bound to a Hatchet client.
      */
     runNoWait(input: I, options?: RunOpts, _standaloneTaskName?: string): Promise<WorkflowRunRef<O>>;
+    runNoWait(input: I[], options?: RunOpts, _standaloneTaskName?: string): Promise<WorkflowRunRef<O>[]>;
     /**
      * @alias run
      * Triggers a workflow run and waits for the result.
@@ -330,6 +331,7 @@ export declare class TaskWorkflowDeclaration<I extends InputType = UnknownInputT
      * @throws Error if the workflow is not bound to a Hatchet client.
      */
     runNoWait(input: I, options?: RunOpts): Promise<WorkflowRunRef<O>>;
+    runNoWait(input: I[], options?: RunOpts): Promise<WorkflowRunRef<O>[]>;
     get taskDef(): CreateWorkflowTaskOpts<any, any>;
 }
 /**

package/v1/declaration.js

@@ -36,37 +36,7 @@ class BaseWorkflowDeclaration {
         this.definition = Object.assign(Object.assign({}, options), { _tasks: [], _durableTasks: [] });
         this.client = client;
     }
-    /**
-     * Triggers a workflow run without waiting for completion.
-     * @param input The input data for the workflow.
-     * @param options Optional configuration for this workflow run.
-     * @returns A WorkflowRunRef containing the run ID and methods to get results and interact with the run.
-     * @throws Error if the workflow is not bound to a Hatchet client.
-     */
     runNoWait(input, options, _standaloneTaskName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.client) {
-                throw UNBOUND_ERR;
-            }
-            const res = yield this.client.admin.runWorkflow(this.name, input, options);
-            if (_standaloneTaskName) {
-                res._standaloneTaskName = _standaloneTaskName;
-            }
-            return res;
-        });
-    }
-    runAndWait(input, options, _standaloneTaskName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.client) {
-                throw UNBOUND_ERR;
-            }
-            if (Array.isArray(input)) {
-                return Promise.all(input.map((i) => this.runAndWait(i, options, _standaloneTaskName)));
-            }
-            return this.run(input, options, _standaloneTaskName);
-        });
-    }
-    run(input, options, _standaloneTaskName) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.client) {
                 throw UNBOUND_ERR;
@@ -89,14 +59,42 @@ class BaseWorkflowDeclaration {
                         // eslint-disable-next-line no-param-reassign
                         ref._standaloneTaskName = wf._standalone_task_name;
                     }
-                    res.push(ref.result());
+                    if (_standaloneTaskName) {
+                        // eslint-disable-next-line no-param-reassign
+                        ref._standaloneTaskName = _standaloneTaskName;
+                    }
+                    res.push(ref);
                 });
-                return Promise.all(res);
+                return res;
             }
             const res = yield this.client.admin.runWorkflow(this.definition.name, input, options);
             if (_standaloneTaskName) {
                 res._standaloneTaskName = _standaloneTaskName;
             }
+            return res;
+        });
+    }
+    runAndWait(input, options, _standaloneTaskName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.client) {
+                throw UNBOUND_ERR;
+            }
+            // note: typescript is not smart enough to infer that input is an array
+            return Array.isArray(input)
+                ? this.run(input, options, _standaloneTaskName)
+                : this.run(input, options, _standaloneTaskName);
+        });
+    }
+    run(input, options, _standaloneTaskName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.client) {
+                throw UNBOUND_ERR;
+            }
+            if (Array.isArray(input)) {
+                const refs = yield this.runNoWait(input, options, _standaloneTaskName);
+                return Promise.all(refs.map((ref) => ref.result()));
+            }
+            const res = yield this.runNoWait(input, options, _standaloneTaskName);
             return res.result();
         });
     }
@@ -313,25 +311,21 @@ class TaskWorkflowDeclaration extends BaseWorkflowDeclaration {
             run: { get: () => super.run }
         });
         return __awaiter(this, void 0, void 0, function* () {
-            return (yield _super.run.call(this, input, options, this._standalone_task_name));
+            // note: typescript is not smart enough to infer that input is an array
+            return Array.isArray(input)
+                ? _super.run.call(this, input, options, this._standalone_task_name)
+                : _super.run.call(this, input, options, this._standalone_task_name);
         });
     }
-    /**
-     * Triggers a workflow run without waiting for completion.
-     * @param input The input data for the workflow.
-     * @param options Optional configuration for this workflow run.
-     * @returns A WorkflowRunRef containing the run ID and methods to get results and interact with the run.
-     * @throws Error if the workflow is not bound to a Hatchet client.
-     */
     runNoWait(input, options) {
         const _super = Object.create(null, {
             runNoWait: { get: () => super.runNoWait }
         });
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.client) {
-                throw UNBOUND_ERR;
-            }
-            return _super.runNoWait.call(this, input, options, this._standalone_task_name);
+            // note: typescript is not smart enough to infer that input is an array
+            return Array.isArray(input)
+                ? _super.runNoWait.call(this, input, options, this._standalone_task_name)
+                : _super.runNoWait.call(this, input, options, this._standalone_task_name);
         });
     }
     get taskDef() {

package/v1/examples/simple/workflow-with-child.d.ts

@@ -11,6 +11,9 @@ export declare const child1: import("../..").CreateWorkflowTaskOpts<ChildInput,
 export declare const child2: import("../..").CreateWorkflowTaskOpts<ChildInput, {
     TransformedMessage: string;
 }>;
+export declare const child3: import("../..").CreateWorkflowTaskOpts<ChildInput, {
+    TransformedMessage: string;
+}>;
 export declare const parent: import("../..").TaskWorkflowDeclaration<ParentInput, {
     TransformedMessage: string;
 }>;

package/v1/examples/simple/workflow-with-child.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parent = exports.child2 = exports.child1 = exports.child = void 0;
+exports.parent = exports.child3 = exports.child2 = exports.child1 = exports.child = void 0;
 // > Declaring a Task
 const hatchet_client_1 = require("../hatchet-client");
 exports.child = hatchet_client_1.hatchet.workflow({
@@ -18,7 +18,7 @@ exports.child = hatchet_client_1.hatchet.workflow({
 exports.child1 = exports.child.task({
     name: 'child1',
     fn: (input, ctx) => {
-        ctx.log('hello from the child1');
+        ctx.logger.info('hello from the child1', { hello: 'moon' });
         return {
             TransformedMessage: input.Message.toLowerCase(),
         };
@@ -27,7 +27,17 @@ exports.child1 = exports.child.task({
 exports.child2 = exports.child.task({
     name: 'child2',
     fn: (input, ctx) => {
-        ctx.log('hello from the child2');
+        ctx.logger.info('hello from the child2');
+        return {
+            TransformedMessage: input.Message.toLowerCase(),
+        };
+    },
+});
+exports.child3 = exports.child.task({
+    name: 'child3',
+    parents: [exports.child1, exports.child2],
+    fn: (input, ctx) => {
+        ctx.logger.info('hello from the child3');
         return {
             TransformedMessage: input.Message.toLowerCase(),
         };

package/v1/examples/simple/workflow.js

@@ -8,25 +8,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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 });
 exports.simple = void 0;
 // > Declaring a Task
-const sleep_1 = __importDefault(require("../../../util/sleep"));
 const hatchet_client_1 = require("../hatchet-client");
 exports.simple = hatchet_client_1.hatchet.task({
     name: 'simple',
     retries: 3,
-    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
-        ctx.log('hello from the workflow');
-        yield (0, sleep_1.default)(100);
-        ctx.log('goodbye from the workflow');
-        yield (0, sleep_1.default)(100);
-        if (ctx.retryCount() < 2) {
-            throw new Error('test error');
-        }
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () {
         return {
             TransformedMessage: input.Message.toLowerCase(),
         };

package/version.d.ts

@@ -1 +1 @@
-export declare const HATCHET_VERSION = "1.5.1";
+export declare const HATCHET_VERSION = "1.5.3";

package/version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HATCHET_VERSION = void 0;
-exports.HATCHET_VERSION = '1.5.1';
+exports.HATCHET_VERSION = '1.5.3';

package/workflow.d.ts

@@ -387,10 +387,10 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
         event: string;
         cron?: undefined;
     } | undefined;
+    timeout?: string | undefined;
     version?: string | undefined;
     scheduleTimeout?: string | undefined;
     sticky?: PbStickyStrategy | undefined;
-    timeout?: string | undefined;
     onFailure?: {
         name: string;
         timeout?: string | undefined;
@@ -449,10 +449,10 @@ export declare const CreateWorkflowSchema: z.ZodObject<{
         event: string;
         cron?: undefined;
     } | undefined;
+    timeout?: string | undefined;
     version?: string | undefined;
     scheduleTimeout?: string | undefined;
     sticky?: PbStickyStrategy | undefined;
-    timeout?: string | undefined;
     onFailure?: {
         name: string;
         timeout?: string | undefined;

package/v1/examples/on_event copy/event.d.ts

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

package/v1/examples/on_event copy/event.js

@@ -1,26 +0,0 @@
-"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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const hatchet_client_1 = require("../hatchet-client");
-function main() {
-    return __awaiter(this, void 0, void 0, function* () {
-        // ❓ Pushing an Event
-        const res = yield hatchet_client_1.hatchet.event.push('simple-event:create', {
-            Message: 'hello',
-        });
-        // !!
-        // eslint-disable-next-line no-console
-        console.log(res.eventId);
-    });
-}
-if (require.main === module) {
-    main();
-}

package/v1/examples/on_event copy/worker.d.ts

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

package/v1/examples/on_event copy/worker.js

@@ -1,24 +0,0 @@
-"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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const hatchet_client_1 = require("../hatchet-client");
-const workflow_1 = require("./workflow");
-function main() {
-    return __awaiter(this, void 0, void 0, function* () {
-        const worker = yield hatchet_client_1.hatchet.worker('on-event-worker', {
-            workflows: [workflow_1.lower, workflow_1.upper],
-        });
-        yield worker.start();
-    });
-}
-if (require.main === module) {
-    main();
-}

package/v1/examples/on_event copy/workflow.d.ts

@@ -1,16 +0,0 @@
-export type Input = {
-    Message: string;
-};
-type LowerOutput = {
-    lower: {
-        TransformedMessage: string;
-    };
-};
-export declare const lower: import("../..").WorkflowDeclaration<Input, LowerOutput>;
-type UpperOutput = {
-    upper: {
-        TransformedMessage: string;
-    };
-};
-export declare const upper: import("../..").WorkflowDeclaration<Input, UpperOutput>;
-export {};

package/v1/examples/on_event copy/workflow.js

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.upper = exports.lower = void 0;
-const hatchet_client_1 = require("../hatchet-client");
-// ❓ Run workflow on event
-exports.lower = hatchet_client_1.hatchet.workflow({
-    name: 'lower',
-    on: {
-        // 👀 Declare the event that will trigger the workflow
-        event: 'simple-event:create',
-    },
-});
-// !!
-exports.lower.task({
-    name: 'lower',
-    fn: (input) => {
-        return {
-            TransformedMessage: input.Message.toLowerCase(),
-        };
-    },
-});
-exports.upper = hatchet_client_1.hatchet.workflow({
-    name: 'upper',
-    on: {
-        event: 'simple-event:create',
-    },
-});
-exports.upper.task({
-    name: 'upper',
-    fn: (input) => {
-        return {
-            TransformedMessage: input.Message.toUpperCase(),
-        };
-    },
-});