@hatchet-dev/typescript-sdk 1.1.8-alpha.2 → 1.2.0-alpha.1

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

@@ -46,8 +46,6 @@ export declare const ClientConfigSchema: z.ZodObject<{
     log_level: z.ZodOptional<z.ZodEnum<["OFF", "DEBUG", "INFO", "WARN", "ERROR"]>>;
     tenant_id: z.ZodString;
     namespace: z.ZodOptional<z.ZodString>;
-    grpc_max_send_message_length: z.ZodOptional<z.ZodNumber>;
-    grpc_max_recv_message_length: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     token: string;
     tls_config: {
@@ -62,8 +60,6 @@ export declare const ClientConfigSchema: z.ZodObject<{
     tenant_id: string;
     log_level?: "OFF" | "DEBUG" | "INFO" | "WARN" | "ERROR" | undefined;
     namespace?: string | undefined;
-    grpc_max_send_message_length?: number | undefined;
-    grpc_max_recv_message_length?: number | undefined;
 }, {
     token: string;
     tls_config: {
@@ -78,8 +74,6 @@ export declare const ClientConfigSchema: z.ZodObject<{
     tenant_id: string;
     log_level?: "OFF" | "DEBUG" | "INFO" | "WARN" | "ERROR" | undefined;
     namespace?: string | undefined;
-    grpc_max_send_message_length?: number | undefined;
-    grpc_max_recv_message_length?: number | undefined;
 }>;
 export type LogConstructor = (context: string, logLevel?: LogLevel) => Logger;
 export type ClientConfig = z.infer<typeof ClientConfigSchema> & {

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

@@ -17,6 +17,4 @@ exports.ClientConfigSchema = zod_1.z.object({
     log_level: zod_1.z.enum(['OFF', 'DEBUG', 'INFO', 'WARN', 'ERROR']).optional(),
     tenant_id: zod_1.z.string(),
     namespace: zod_1.z.string().optional(),
-    grpc_max_send_message_length: zod_1.z.number().optional(),
-    grpc_max_recv_message_length: zod_1.z.number().optional(),
 });

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

@@ -53,15 +53,13 @@ const cron_client_1 = require("./features/cron-client");
 const schedule_client_1 = require("./features/schedule-client");
 const durable_listener_client_1 = require("../listeners/durable-listener/durable-listener-client");
 const channelFactory = (config, credentials) => (0, nice_grpc_1.createChannel)(config.host_port, credentials, {
-    'grpc.max_send_message_length': config.grpc_max_send_message_length,
-    'grpc.max_receive_message_length': config.grpc_max_recv_message_length,
     'grpc.ssl_target_name_override': config.tls_config.server_name,
     'grpc.keepalive_timeout_ms': 60 * 1000,
     'grpc.client_idle_timeout_ms': 60 * 1000,
-    'grpc.http2.max_pings_without_data': 0,
-    'grpc.http2.min_recv_ping_interval_without_data_ms': 60 * 1000,
+    // Send keepalive pings every 10 seconds, default is 2 hours.
+    'grpc.keepalive_time_ms': 10 * 1000,
+    // Allow keepalive pings when there are no gRPC calls.
     'grpc.keepalive_permit_without_calls': 1,
-    'grpc-node.max_session_memory': Number.MAX_SAFE_INTEGER,
 });
 exports.channelFactory = channelFactory;
 const addTokenMiddleware = (token) => function _(call, options) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "1.1.8-alpha.2",
+  "version": "1.2.0-alpha.1",
   "description": "Background task orchestration & visibility for developers",
   "types": "dist/index.d.ts",
   "files": [
@@ -88,5 +88,6 @@
     "qs": "^6.14.0",
     "yaml": "^2.7.1",
     "zod": "^3.24.2"
-  }
+  },
+  "packageManager": "pnpm@9.15.4+sha512.b2dc20e2fc72b3e18848459b37359a32064663e5627a51e4c74b2c29dd8e8e0491483c3abb40789cfd578bf362fb6ba8261b05f0387d76792ed6e23ea3b1b6a0"
 }

package/util/config-loader/config-loader.js

@@ -44,7 +44,7 @@ const token_1 = require("./token");
 const DEFAULT_CONFIG_FILE = '.hatchet.yaml';
 class ConfigLoader {
     static loadClientConfig(override, config) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2, _3, _4, _5, _6;
         const yaml = this.loadYamlConfig(config === null || config === void 0 ? void 0 : config.path);
         const tlsConfig = (_a = override === null || override === void 0 ? void 0 : override.tls_config) !== null && _a !== void 0 ? _a : {
             tls_strategy: (_d = (_c = (_b = yaml === null || yaml === void 0 ? void 0 : yaml.tls_config) === null || _b === void 0 ? void 0 : _b.tls_strategy) !== null && _c !== void 0 ? _c : this.env('HATCHET_CLIENT_TLS_STRATEGY')) !== null && _d !== void 0 ? _d : 'tls',
@@ -76,18 +76,14 @@ class ConfigLoader {
             apiUrl = (_z = (_y = override === null || override === void 0 ? void 0 : override.api_url) !== null && _y !== void 0 ? _y : yaml === null || yaml === void 0 ? void 0 : yaml.api_url) !== null && _z !== void 0 ? _z : this.env('HATCHET_CLIENT_API_URL');
         }
         const namespace = (_1 = (_0 = override === null || override === void 0 ? void 0 : override.namespace) !== null && _0 !== void 0 ? _0 : yaml === null || yaml === void 0 ? void 0 : yaml.namespace) !== null && _1 !== void 0 ? _1 : this.env('HATCHET_CLIENT_NAMESPACE');
-        const grpcMaxSendMessageLength = (_3 = (_2 = override === null || override === void 0 ? void 0 : override.grpc_max_send_message_length) !== null && _2 !== void 0 ? _2 : yaml === null || yaml === void 0 ? void 0 : yaml.grpc_max_send_message_length) !== null && _3 !== void 0 ? _3 : parseInt((_4 = this.env('HATCHET_CLIENT_GRPC_MAX_SEND_MESSAGE_LENGTH')) !== null && _4 !== void 0 ? _4 : '-1', 10);
-        const grpcMaxRecvMessageLength = (_6 = (_5 = override === null || override === void 0 ? void 0 : override.grpc_max_recv_message_length) !== null && _5 !== void 0 ? _5 : yaml === null || yaml === void 0 ? void 0 : yaml.grpc_max_recv_message_length) !== null && _6 !== void 0 ? _6 : parseInt((_7 = this.env('HATCHET_CLIENT_GRPC_MAX_RECV_MESSAGE_LENGTH')) !== null && _7 !== void 0 ? _7 : '-1', 10);
         return {
-            token: (_9 = (_8 = override === null || override === void 0 ? void 0 : override.token) !== null && _8 !== void 0 ? _8 : yaml === null || yaml === void 0 ? void 0 : yaml.token) !== null && _9 !== void 0 ? _9 : this.env('HATCHET_CLIENT_TOKEN'),
+            token: (_3 = (_2 = override === null || override === void 0 ? void 0 : override.token) !== null && _2 !== void 0 ? _2 : yaml === null || yaml === void 0 ? void 0 : yaml.token) !== null && _3 !== void 0 ? _3 : this.env('HATCHET_CLIENT_TOKEN'),
             host_port: grpcBroadcastAddress,
             api_url: apiUrl,
             tls_config: tlsConfig,
-            log_level: (_12 = (_11 = (_10 = override === null || override === void 0 ? void 0 : override.log_level) !== null && _10 !== void 0 ? _10 : yaml === null || yaml === void 0 ? void 0 : yaml.log_level) !== null && _11 !== void 0 ? _11 : this.env('HATCHET_CLIENT_LOG_LEVEL')) !== null && _12 !== void 0 ? _12 : 'INFO',
+            log_level: (_6 = (_5 = (_4 = override === null || override === void 0 ? void 0 : override.log_level) !== null && _4 !== void 0 ? _4 : yaml === null || yaml === void 0 ? void 0 : yaml.log_level) !== null && _5 !== void 0 ? _5 : this.env('HATCHET_CLIENT_LOG_LEVEL')) !== null && _6 !== void 0 ? _6 : 'INFO',
             tenant_id: tenantId,
             namespace: namespace ? `${namespace}_`.toLowerCase() : '',
-            grpc_max_send_message_length: grpcMaxSendMessageLength > 0 ? grpcMaxSendMessageLength : undefined,
-            grpc_max_recv_message_length: grpcMaxRecvMessageLength > 0 ? grpcMaxRecvMessageLength : undefined,
         };
     }
     static get default_yaml_config_path() {

package/v1/client/client.d.ts

@@ -13,6 +13,11 @@ import { WorkflowsClient } from './features/workflows';
 import { RunsClient } from './features/runs';
 import { InputType, OutputType, UnknownInputType, StrictWorkflowOutputType } from '../types';
 import { RatelimitsClient } from './features';
+import { Middleware } from '../next/middleware/middleware';
+export interface RuntimeOpts {
+    middleware?: Middleware[];
+}
+type Config = Partial<ClientConfig> & RuntimeOpts;
 /**
  * HatchetV1 implements the main client interface for interacting with the Hatchet workflow engine.
  * It provides methods for creating and executing workflows, as well as managing workers.
@@ -21,6 +26,8 @@ export declare class HatchetClient implements IHatchetClient {
     /** The underlying v0 client instance */
     _v0: InternalHatchetClient;
     _api: Api;
+    private _middleware?;
+    get middleware(): Middleware[] | undefined;
     /**
      * @deprecated v0 client will be removed in a future release, please upgrade to v1
      */
@@ -35,7 +42,7 @@ export declare class HatchetClient implements IHatchetClient {
      * @param options - Optional client options
      * @param axiosConfig - Optional Axios configuration for HTTP requests
      */
-    constructor(config?: Partial<ClientConfig>, options?: HatchetClientOptions, axiosConfig?: AxiosRequestConfig);
+    constructor(config?: Config, options?: HatchetClientOptions, axiosConfig?: AxiosRequestConfig);
     /**
      * Static factory method to create a new Hatchet client instance.
      * @param config - Optional configuration for the client
@@ -43,7 +50,7 @@ export declare class HatchetClient implements IHatchetClient {
      * @param axiosConfig - Optional Axios configuration for HTTP requests
      * @returns A new Hatchet client instance
      */
-    static init(config?: Partial<ClientConfig>, options?: HatchetClientOptions, axiosConfig?: AxiosRequestConfig): HatchetClient;
+    static init(config?: Config, options?: HatchetClientOptions, axiosConfig?: AxiosRequestConfig): HatchetClient;
     /**
      * Creates a new workflow definition.
      * @template I - The input type for the workflow
@@ -98,7 +105,7 @@ export declare class HatchetClient implements IHatchetClient {
      * @param options - Configuration options for the workflow run
      * @returns A WorkflowRunRef containing the run ID and methods to interact with the run
      */
-    runNoWait<I extends InputType = UnknownInputType, O extends OutputType = void>(workflow: BaseWorkflowDeclaration<I, O> | string | V0Workflow, input: I, options: RunOpts): WorkflowRunRef<O>;
+    runNoWait<I extends InputType = UnknownInputType, O extends OutputType = void>(workflow: BaseWorkflowDeclaration<I, O> | string | V0Workflow, input: I, options?: RunOpts): Promise<WorkflowRunRef<O>>;
     /**
      * @alias run
      * Triggers a workflow run and waits for the result.
@@ -212,3 +219,4 @@ export declare class HatchetClient implements IHatchetClient {
     webhooks(workflows: V0Workflow[]): import("../../clients/worker/handler").WebhookHandler;
     runRef<T extends Record<string, any> = any>(id: string): WorkflowRunRef<T>;
 }
+export {};

package/v1/client/client.interface.d.ts

@@ -3,10 +3,12 @@ import { MetricsClient } from './features/metrics';
 import { RunsClient } from './features/runs';
 import { WorkersClient } from './features/workers';
 import { WorkflowsClient } from './features/workflows';
+import { Middleware } from '../next/middleware/middleware';
 export interface IHatchetClient {
     _v0: InternalHatchetClient;
     metrics: MetricsClient;
     runs: RunsClient;
     workflows: WorkflowsClient;
     workers: WorkersClient;
+    middleware?: Middleware[];
 }

package/v1/client/client.js

@@ -28,11 +28,15 @@ const workers_1 = require("./features/workers");
 const workflows_1 = require("./features/workflows");
 const runs_1 = require("./features/runs");
 const features_1 = require("./features");
+const middleware_1 = require("../next/middleware/middleware");
 /**
  * HatchetV1 implements the main client interface for interacting with the Hatchet workflow engine.
  * It provides methods for creating and executing workflows, as well as managing workers.
  */
 class HatchetClient {
+    get middleware() {
+        return this._middleware;
+    }
     /**
      * @deprecated v0 client will be removed in a future release, please upgrade to v1
      */
@@ -63,6 +67,9 @@ class HatchetClient {
             this.tenantId = clientConfig.tenant_id;
             this._api = (0, rest_1.default)(clientConfig.api_url, clientConfig.token, axiosConfig);
             this._v0 = new hatchet_client_1.InternalHatchetClient(clientConfig, options, axiosConfig, this.runs);
+            if (config === null || config === void 0 ? void 0 : config.middleware) {
+                this._middleware = config.middleware;
+            }
         }
         catch (e) {
             if (e instanceof zod_1.z.ZodError) {
@@ -113,18 +120,29 @@ class HatchetClient {
      * @param options - Configuration options for the workflow run
      * @returns A WorkflowRunRef containing the run ID and methods to interact with the run
      */
-    runNoWait(workflow, input, options) {
-        let name;
-        if (typeof workflow === 'string') {
-            name = workflow;
-        }
-        else if ('id' in workflow) {
-            name = workflow.id;
-        }
-        else {
-            throw new Error('unable to identify workflow');
-        }
-        return this._v0.admin.runWorkflow(name, input, options);
+    runNoWait(workflow_1, input_1) {
+        return __awaiter(this, arguments, void 0, function* (workflow, input, options = {}) {
+            let name;
+            if (typeof workflow === 'string') {
+                name = workflow;
+            }
+            else if ('id' in workflow) {
+                name = workflow.id;
+            }
+            else {
+                throw new Error('unable to identify workflow');
+            }
+            const serializedInput = yield (0, middleware_1.serializeInput)(input, this.middleware);
+            const runRef = this._v0.admin.runWorkflow(name, serializedInput, options);
+            // Wrap the runRef to apply output deserialization
+            const originalResult = runRef.result;
+            runRef.result = () => __awaiter(this, void 0, void 0, function* () {
+                const output = yield originalResult.call(runRef);
+                const deserializedOutput = yield (0, middleware_1.deserializeOutput)(output, this.middleware);
+                return deserializedOutput;
+            });
+            return runRef;
+        });
     }
     /**
      * @alias run
@@ -152,8 +170,11 @@ class HatchetClient {
      */
     run(workflow_1, input_1) {
         return __awaiter(this, arguments, void 0, function* (workflow, input, options = {}) {
-            const run = this.runNoWait(workflow, input, options);
-            return run.output;
+            const serializedInput = yield (0, middleware_1.serializeInput)(input, this.middleware);
+            const runRef = yield this.runNoWait(workflow, serializedInput, options);
+            const output = yield runRef.result();
+            const deserializedOutput = yield (0, middleware_1.deserializeOutput)(output, this.middleware);
+            return deserializedOutput;
         });
     }
     /**

package/v1/client/worker.js

@@ -11,6 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Worker = void 0;
 const declaration_1 = require("../declaration");
+const middleware_1 = require("../next/middleware/middleware");
 const DEFAULT_DURABLE_SLOTS = 1000;
 /**
  * HatchetWorker class for workflow execution runtime
@@ -50,13 +51,14 @@ class Worker {
         return __awaiter(this, void 0, void 0, function* () {
             return Promise.all((workflows === null || workflows === void 0 ? void 0 : workflows.map((wf) => __awaiter(this, void 0, void 0, function* () {
                 if (wf instanceof declaration_1.BaseWorkflowDeclaration) {
+                    const withMiddleware = yield (0, middleware_1.bindMiddleware)(wf, this._v1);
                     // TODO check if tenant is V1
-                    const register = this.nonDurable.registerWorkflowV1(wf);
+                    const register = this.nonDurable.registerWorkflowV1(withMiddleware);
                     if (wf.definition._durableTasks.length > 0) {
                         if (!this.durable) {
                             this.durable = yield this._v0.worker(`${this.name}-durable`, Object.assign(Object.assign({}, this.config), { maxRuns: this.config.durableSlots || DEFAULT_DURABLE_SLOTS }));
                         }
-                        this.durable.registerDurableActionsV1(wf.definition);
+                        this.durable.registerDurableActionsV1(withMiddleware.definition);
                     }
                     return register;
                 }

package/v1/declaration.d.ts

@@ -172,7 +172,7 @@ export declare class BaseWorkflowDeclaration<I extends InputType = UnknownInputT
      * @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: I, options?: RunOpts, _standaloneTaskName?: string): WorkflowRunRef<O>;
+    runNoWait(input: I, options?: RunOpts, _standaloneTaskName?: string): Promise<WorkflowRunRef<O>>;
     /**
      * @alias run
      * Triggers a workflow run and waits for the result.
@@ -301,16 +301,9 @@ export declare class WorkflowDeclaration<I extends InputType = UnknownInputType,
 export declare class TaskWorkflowDeclaration<I extends InputType = UnknownInputType, O extends OutputType = void> extends BaseWorkflowDeclaration<I, O> {
     _standalone_task_name: string;
     constructor(options: CreateTaskWorkflowOpts<I, O>, client?: IHatchetClient);
+    runNoWait(input: I, options?: RunOpts): Promise<WorkflowRunRef<O>>;
     run(input: I, options?: RunOpts): Promise<O>;
     run(input: I[], options?: RunOpts): Promise<O[]>;
-    /**
-     * 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: I, options?: RunOpts): WorkflowRunRef<O>;
     get taskDef(): CreateWorkflowTaskOpts<any, any>;
 }
 /**

package/v1/declaration.js

@@ -13,6 +13,7 @@ exports.TaskWorkflowDeclaration = exports.WorkflowDeclaration = exports.BaseWork
 exports.CreateTaskWorkflow = CreateTaskWorkflow;
 exports.CreateWorkflow = CreateWorkflow;
 exports.CreateDurableTaskWorkflow = CreateDurableTaskWorkflow;
+const middleware_1 = require("./next/middleware/middleware");
 const UNBOUND_ERR = new Error('workflow unbound to hatchet client, hint: use client.run instead');
 /**
  * Represents a workflow that can be executed by Hatchet.
@@ -37,14 +38,25 @@ class BaseWorkflowDeclaration {
      * @throws Error if the workflow is not bound to a Hatchet client.
      */
     runNoWait(input, options, _standaloneTaskName) {
-        if (!this.client) {
-            throw UNBOUND_ERR;
-        }
-        const res = this.client._v0.admin.runWorkflow(this.name, input, options);
-        if (_standaloneTaskName) {
-            res._standalone_task_name = _standaloneTaskName;
-        }
-        return res;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.client) {
+                throw UNBOUND_ERR;
+            }
+            const serializedInput = yield (0, middleware_1.serializeInput)(input, this.client.middleware);
+            const res = this.client._v0.admin.runWorkflow(this.name, serializedInput, options);
+            if (_standaloneTaskName) {
+                res._standalone_task_name = _standaloneTaskName;
+            }
+            // Wrap the result method to apply output deserialization
+            const originalResult = res.result;
+            res.result = () => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                const output = yield originalResult.call(res);
+                const deserializedOutput = yield (0, middleware_1.deserializeOutput)(output, (_a = this.client) === null || _a === void 0 ? void 0 : _a.middleware);
+                return deserializedOutput;
+            });
+            return res;
+        });
     }
     runAndWait(input, options, _standaloneTaskName) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -63,32 +75,16 @@ class BaseWorkflowDeclaration {
                 throw UNBOUND_ERR;
             }
             if (Array.isArray(input)) {
-                let resp = [];
-                for (let i = 0; i < input.length; i += 500) {
-                    const batch = input.slice(i, i + 500);
-                    const batchResp = yield this.client._v0.admin.runWorkflows(batch.map((inp) => ({
-                        workflowName: this.definition.name,
-                        input: inp,
-                        options,
-                    })));
-                    resp = resp.concat(batchResp);
-                }
-                const res = [];
-                resp.forEach((ref, index) => {
-                    const wf = input[index].workflow;
-                    if (wf instanceof TaskWorkflowDeclaration) {
-                        // eslint-disable-next-line no-param-reassign
-                        ref._standalone_task_name = wf._standalone_task_name;
-                    }
-                    res.push(ref.result());
-                });
-                return Promise.all(res);
+                return Promise.all(input.map((i) => this.run(i, options, _standaloneTaskName)));
             }
-            const res = this.client._v0.admin.runWorkflow(this.definition.name, input, options);
+            const serializedInput = yield (0, middleware_1.serializeInput)(input, this.client.middleware);
+            const res = this.client._v0.admin.runWorkflow(this.name, serializedInput, options);
             if (_standaloneTaskName) {
                 res._standalone_task_name = _standaloneTaskName;
             }
-            return res.result();
+            const output = yield res.result();
+            const deserializedOutput = yield (0, middleware_1.deserializeOutput)(output, this.client.middleware);
+            return deserializedOutput;
         });
     }
     /**
@@ -308,26 +304,37 @@ class TaskWorkflowDeclaration extends BaseWorkflowDeclaration {
         this._standalone_task_name = options.name;
         this.definition._tasks.push(Object.assign({}, options));
     }
-    run(input, options) {
+    runNoWait(input, options) {
         const _super = Object.create(null, {
-            run: { get: () => super.run }
+            runNoWait: { get: () => super.runNoWait }
         });
         return __awaiter(this, void 0, void 0, function* () {
-            return (yield _super.run.call(this, input, options, this._standalone_task_name));
+            if (!this.client) {
+                throw UNBOUND_ERR;
+            }
+            const res = yield _super.runNoWait.call(this, input, options, this._standalone_task_name);
+            // Wrap the result method to apply output deserialization
+            const originalResult = res.result;
+            res.result = () => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                const output = yield originalResult.call(res);
+                const deserializedOutput = yield (0, middleware_1.deserializeOutput)(output, (_a = this.client) === null || _a === void 0 ? void 0 : _a.middleware);
+                return deserializedOutput;
+            });
+            return res;
         });
     }
-    /**
-     * 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) {
-        if (!this.client) {
-            throw UNBOUND_ERR;
-        }
-        return super.runNoWait(input, options, this._standalone_task_name);
+    run(input, options) {
+        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.run(i, options)));
+            }
+            const runRef = yield this.runNoWait(input, options);
+            return runRef.result();
+        });
     }
     get taskDef() {
         return this.definition._tasks[0];

package/v1/examples/cancellations/run.js

@@ -20,8 +20,8 @@ const hatchet_client_1 = require("../hatchet-client");
 // ...
 function main() {
     return __awaiter(this, void 0, void 0, function* () {
-        const run = workflow_1.cancellation.runNoWait({});
-        const run1 = workflow_1.cancellation.runNoWait({});
+        const run = yield workflow_1.cancellation.runNoWait({});
+        const run1 = yield workflow_1.cancellation.runNoWait({});
         yield (0, sleep_1.default)(1000);
         yield run.cancel();
         const res = yield run.output;
@@ -32,8 +32,8 @@ function main() {
         yield run.replay();
         const resReplay = yield run.output;
         console.log(resReplay);
-        const run2 = workflow_1.cancellation.runNoWait({}, { additionalMetadata: { test: 'abc' } });
-        const run4 = workflow_1.cancellation.runNoWait({}, { additionalMetadata: { test: 'test' } });
+        const run2 = yield workflow_1.cancellation.runNoWait({}, { additionalMetadata: { test: 'abc' } });
+        const run4 = yield workflow_1.cancellation.runNoWait({}, { additionalMetadata: { test: 'test' } });
         yield (0, sleep_1.default)(1000);
         yield hatchet_client_1.hatchet.runs.cancel({
             filters: {

package/v1/examples/middleware/hatchet-client.d.ts

@@ -0,0 +1,2 @@
+import { HatchetClient } from '../../client/client';
+export declare const hatchet: HatchetClient;

package/v1/examples/middleware/hatchet-client.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hatchet = void 0;
+const client_1 = require("../../client/client");
+class EncodeSerializer {
+    deserialize(input) {
+        console.log('client-encode-deserialize', input);
+        if (input.encoded && typeof input.encoded === 'string') {
+            console.warn('WARNING THIS IS NOT REAL ENCRYPTION');
+            const decoded = Buffer.from(input.encoded, 'base64').toString('utf-8');
+            return JSON.parse(decoded);
+        }
+        return input;
+    }
+    serialize(input) {
+        console.warn('WARNING THIS IS NOT REAL ENCRYPTION');
+        const encoded = Buffer.from(JSON.stringify(input)).toString('base64');
+        console.log('client-encode-serialize', input);
+        return {
+            encoded,
+        };
+    }
+}
+class EncodeMiddleware {
+    constructor() {
+        this.input = new EncodeSerializer();
+        this.output = new EncodeSerializer();
+    }
+}
+exports.hatchet = client_1.HatchetClient.init({
+    middleware: [new EncodeMiddleware()],
+});

package/v1/examples/middleware/run.d.ts

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

package/v1/examples/middleware/run.js

@@ -0,0 +1,34 @@
+"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 });
+/* eslint-disable no-console */
+const workflow_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // ❓ Running a Task
+        const res = yield workflow_1.withMiddleware.run({
+            Message: 'HeLlO WoRlD',
+        });
+        // 👀 Access the results of the Task
+        console.log(res);
+        // !!
+    });
+}
+if (require.main === module) {
+    main()
+        .then(() => {
+        process.exit(0);
+    })
+        .catch((err) => {
+        console.error(err);
+        process.exit(1);
+    });
+}

package/v1/examples/middleware/worker.d.ts

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

package/v1/examples/middleware/worker.js

@@ -0,0 +1,29 @@
+"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 });
+// ❓ Declaring a Worker
+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('withMiddleware-worker', {
+            // 👀 Declare the workflows that the worker can execute
+            workflows: [workflow_1.withMiddleware],
+            // 👀 Declare the number of concurrent task runs the worker can accept
+            slots: 100,
+        });
+        yield worker.start();
+    });
+}
+if (require.main === module) {
+    main();
+}
+// !!

package/v1/examples/middleware/workflow.d.ts

@@ -0,0 +1,9 @@
+export type SimpleInput = {
+    Message: string;
+};
+export type SimpleOutput = {
+    TransformedMessage: string;
+};
+export declare const withMiddleware: import("../..").TaskWorkflowDeclaration<SimpleInput, {
+    TransformedMessage: string;
+}>;

package/v1/examples/middleware/workflow.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withMiddleware = void 0;
+const hatchet_client_1 = require("./hatchet-client");
+exports.withMiddleware = hatchet_client_1.hatchet.task({
+    name: 'with-middleware',
+    middleware: [
+        {
+            input: {
+                deserialize: (input) => {
+                    console.log('task-input-deserialize', input);
+                    return input;
+                },
+                serialize: (input) => {
+                    console.log('task-input-serialize', input);
+                    return input;
+                },
+            },
+            output: {
+                deserialize: (input) => {
+                    console.log('task-output-deserialize', input);
+                    return input;
+                },
+                serialize: (input) => {
+                    console.log('task-output-serialize', input);
+                    return input;
+                },
+            },
+        },
+    ],
+    fn: (input) => {
+        return {
+            TransformedMessage: input.Message.toLowerCase(),
+        };
+    },
+});
+// !!

package/v1/next/index.d.ts

@@ -0,0 +1 @@
+export * from './middleware/middleware';

package/v1/next/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./middleware/middleware"), exports);

package/v1/next/middleware/middleware.d.ts

@@ -0,0 +1,27 @@
+import { JsonObject } from '../../types';
+import { BaseWorkflowDeclaration } from '../../declaration';
+import { HatchetClient } from '../../client/client';
+type SingleMiddleware<T> = (input: JsonObject) => T | Promise<T>;
+type SingleSerialize<T> = (input: T) => JsonObject | Promise<JsonObject>;
+export interface Serializable<T = any> {
+    deserialize: SingleMiddleware<T>;
+    serialize: SingleSerialize<T>;
+}
+export interface Middleware {
+    input: Serializable;
+    output: Serializable;
+}
+export interface MiddlewareChain {
+    middlewares: Middleware[];
+}
+export type MiddlewareFn<T = any> = (input: any) => T | Promise<T>;
+/**
+ * Binds middleware to a workflow's tasks
+ * @param wf - The workflow declaration to bind middleware to
+ * @param client - The HatchetClient instance
+ * @returns The workflow with middleware bound to its tasks
+ */
+export declare function bindMiddleware(wf: BaseWorkflowDeclaration<any, any>, client: HatchetClient): Promise<BaseWorkflowDeclaration<any, any>>;
+export declare function serializeInput(input: JsonObject, middleware?: Middleware[]): Promise<JsonObject>;
+export declare function deserializeOutput(output: JsonObject, middleware?: Middleware[]): Promise<JsonObject>;
+export {};

package/v1/next/middleware/middleware.js

@@ -0,0 +1,121 @@
+"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.bindMiddleware = bindMiddleware;
+exports.serializeInput = serializeInput;
+exports.deserializeOutput = deserializeOutput;
+// Helper to compose middleware functions
+const composeMiddleware = (fns) => {
+    return (input) => __awaiter(void 0, void 0, void 0, function* () {
+        let result = input;
+        for (const fn of fns) {
+            result = yield fn(result);
+        }
+        return result;
+    });
+};
+// Get all deserialize functions in the correct order
+const getDeserializeChain = (middleware) => {
+    return middleware.map((m) => m.input.deserialize);
+};
+// Get all serialize functions in the correct order
+const getSerializeChain = (middleware) => {
+    return middleware.map((m) => m.input.serialize);
+};
+/**
+ * Binds middleware to a workflow's tasks
+ * @param wf - The workflow declaration to bind middleware to
+ * @param client - The HatchetClient instance
+ * @returns The workflow with middleware bound to its tasks
+ */
+function bindMiddleware(wf, client) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const tasks = wf.definition._tasks.map((task) => {
+            if (!task.middleware) {
+                // eslint-disable-next-line no-param-reassign
+                task.middleware = [
+                    {
+                        input: {
+                            deserialize: (input) => input,
+                            serialize: (input) => input,
+                        },
+                        output: {
+                            deserialize: (input) => input,
+                            serialize: (input) => input,
+                        },
+                    },
+                ];
+            }
+            const originalFn = task.fn;
+            // Build input middleware chain
+            let inputDeserializeChain = [];
+            let inputSerializeChain = [];
+            if (task.middleware) {
+                inputDeserializeChain = getDeserializeChain(task.middleware);
+                inputSerializeChain = getSerializeChain(task.middleware);
+            }
+            // Build output middleware chain
+            let outputDeserializeChain = [];
+            let outputSerializeChain = [];
+            if (task.middleware) {
+                outputDeserializeChain = getDeserializeChain(task.middleware);
+                outputSerializeChain = getSerializeChain(task.middleware);
+            }
+            // Add client middleware if present
+            if (client.middleware) {
+                inputDeserializeChain = [...getDeserializeChain(client.middleware), ...inputDeserializeChain];
+                inputSerializeChain = [...inputSerializeChain, ...getSerializeChain(client.middleware)];
+                outputDeserializeChain = [
+                    ...getDeserializeChain(client.middleware),
+                    ...outputDeserializeChain,
+                ];
+                outputSerializeChain = [...outputSerializeChain, ...getSerializeChain(client.middleware)];
+            }
+            // Compose the middleware with the original function
+            // eslint-disable-next-line no-param-reassign
+            task.fn = (input, ctx) => __awaiter(this, void 0, void 0, function* () {
+                console.log('fn input', input);
+                // Apply input deserialize chain
+                const deserializedInput = yield composeMiddleware(inputDeserializeChain)(input);
+                // Run the original function
+                const result = yield originalFn(deserializedInput, ctx);
+                // Apply output serialize chain
+                return composeMiddleware(outputSerializeChain)(result);
+            });
+            return task;
+        });
+        // eslint-disable-next-line no-param-reassign
+        wf.definition._tasks = tasks;
+        return wf;
+    });
+}
+function serializeInput(input, middleware) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let serialized = input;
+        if (middleware) {
+            for (const m of middleware) {
+                serialized = yield m.input.serialize(serialized);
+            }
+        }
+        return serialized;
+    });
+}
+function deserializeOutput(output, middleware) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let deserialized = output;
+        if (middleware) {
+            for (const m of middleware) {
+                deserialized = yield m.output.deserialize(deserialized);
+            }
+        }
+        return deserialized;
+    });
+}

package/v1/task.d.ts

@@ -3,6 +3,7 @@ import { Context, CreateStep, DurableContext } from '../step';
 import { Conditions } from './conditions';
 import { Duration } from './client/duration';
 import { InputType, OutputType, UnknownInputType } from './types';
+import { Middleware } from './next/middleware/middleware';
 /**
  * Options for configuring the concurrency for a task.
  */
@@ -98,6 +99,10 @@ export type CreateBaseTaskOpts<I extends InputType = UnknownInputType, O extends
      * (optional) the concurrency options for the task
      */
     concurrency?: TaskConcurrency | TaskConcurrency[];
+    /**
+     * (optional) the middleware for the task
+     */
+    middleware?: Middleware[];
 };
 export type CreateWorkflowTaskOpts<I extends InputType = UnknownInputType, O extends OutputType = void, C extends TaskFn<I, O> | DurableTaskFn<I, O> = TaskFn<I, O>> = CreateBaseTaskOpts<I, O, C> & {
     /**

package/version.d.ts

@@ -1 +1 @@
-export declare const HATCHET_VERSION = "1.1.8-alpha.2";
+export declare const HATCHET_VERSION = "1.2.0-alpha.1";

package/version.js

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