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

package/v1/client/client.d.ts

@@ -13,11 +13,6 @@ 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.
@@ -26,8 +21,6 @@ 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
      */
@@ -42,7 +35,7 @@ export declare class HatchetClient implements IHatchetClient {
      * @param options - Optional client options
      * @param axiosConfig - Optional Axios configuration for HTTP requests
      */
-    constructor(config?: Config, options?: HatchetClientOptions, axiosConfig?: AxiosRequestConfig);
+    constructor(config?: Partial<ClientConfig>, options?: HatchetClientOptions, axiosConfig?: AxiosRequestConfig);
     /**
      * Static factory method to create a new Hatchet client instance.
      * @param config - Optional configuration for the client
@@ -50,7 +43,7 @@ export declare class HatchetClient implements IHatchetClient {
      * @param axiosConfig - Optional Axios configuration for HTTP requests
      * @returns A new Hatchet client instance
      */
-    static init(config?: Config, options?: HatchetClientOptions, axiosConfig?: AxiosRequestConfig): HatchetClient;
+    static init(config?: Partial<ClientConfig>, options?: HatchetClientOptions, axiosConfig?: AxiosRequestConfig): HatchetClient;
     /**
      * Creates a new workflow definition.
      * @template I - The input type for the workflow
@@ -105,7 +98,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): Promise<WorkflowRunRef<O>>;
+    runNoWait<I extends InputType = UnknownInputType, O extends OutputType = void>(workflow: BaseWorkflowDeclaration<I, O> | string | V0Workflow, input: I, options: RunOpts): WorkflowRunRef<O>;
     /**
      * @alias run
      * Triggers a workflow run and waits for the result.
@@ -219,4 +212,3 @@ 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,12 +3,10 @@ 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,15 +28,11 @@ 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
      */
@@ -67,9 +63,6 @@ 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) {
@@ -120,29 +113,18 @@ 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_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;
-        });
+    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);
     }
     /**
      * @alias run
@@ -170,11 +152,8 @@ class HatchetClient {
      */
     run(workflow_1, input_1) {
         return __awaiter(this, arguments, void 0, function* (workflow, input, options = {}) {
-            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;
+            const run = this.runNoWait(workflow, input, options);
+            return run.output;
         });
     }
     /**

package/v1/client/worker.js

@@ -11,7 +11,6 @@ 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
@@ -51,14 +50,13 @@ 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(withMiddleware);
+                    const register = this.nonDurable.registerWorkflowV1(wf);
                     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(withMiddleware.definition);
+                        this.durable.registerDurableActionsV1(wf.definition);
                     }
                     return register;
                 }

package/v1/declaration.d.ts

@@ -7,6 +7,11 @@ import { CreateWorkflowTaskOpts, CreateOnFailureTaskOpts, TaskConcurrency, TaskF
 import { Duration } from './client/duration';
 import { MetricsClient } from './client/features/metrics';
 import { InputType, OutputType, UnknownInputType, JsonObject } from './types';
+export declare enum Priority {
+    LOW = 1,
+    MEDIUM = 2,
+    HIGH = 3
+}
 /**
  * Additional metadata that can be attached to a workflow run.
  */
@@ -16,9 +21,15 @@ type AdditionalMetadata = Record<string, string>;
  */
 export type RunOpts = {
     /**
-     * Additional metadata to attach to the workflow run.
+     * (optional) additional metadata to attach to the workflow run.
      */
     additionalMetadata?: AdditionalMetadata;
+    /**
+     * (optional) the priority for the workflow run.
+     *
+     * values: Priority.LOW, Priority.MEDIUM, Priority.HIGH (1, 2, or 3 )
+     */
+    priority?: Priority;
 };
 /**
  * Helper type to safely extract output types from task results
@@ -59,6 +70,11 @@ export type CreateBaseWorkflowOpts = {
      */
     onEvents?: string[];
     concurrency?: TaskConcurrency;
+    /**
+     * (optional) the priority for the workflow.
+     * values: Priority.LOW, Priority.MEDIUM, Priority.HIGH (1, 2, or 3 )
+     */
+    defaultPriority?: Priority;
 };
 export type CreateTaskWorkflowOpts<I extends InputType = UnknownInputType, O extends OutputType = void> = CreateBaseWorkflowOpts & CreateBaseTaskOpts<I, O, TaskFn<I, O>>;
 export type CreateDurableTaskWorkflowOpts<I extends InputType = UnknownInputType, O extends OutputType = void> = CreateBaseWorkflowOpts & CreateBaseTaskOpts<I, O, DurableTaskFn<I, O>>;
@@ -172,7 +188,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): Promise<WorkflowRunRef<O>>;
+    runNoWait(input: I, options?: RunOpts, _standaloneTaskName?: string): WorkflowRunRef<O>;
     /**
      * @alias run
      * Triggers a workflow run and waits for the result.
@@ -301,9 +317,16 @@ 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

@@ -9,12 +9,18 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TaskWorkflowDeclaration = exports.WorkflowDeclaration = exports.BaseWorkflowDeclaration = void 0;
+exports.TaskWorkflowDeclaration = exports.WorkflowDeclaration = exports.BaseWorkflowDeclaration = exports.Priority = void 0;
 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');
+// eslint-disable-next-line no-shadow
+var Priority;
+(function (Priority) {
+    Priority[Priority["LOW"] = 1] = "LOW";
+    Priority[Priority["MEDIUM"] = 2] = "MEDIUM";
+    Priority[Priority["HIGH"] = 3] = "HIGH";
+})(Priority || (exports.Priority = Priority = {}));
 /**
  * Represents a workflow that can be executed by Hatchet.
  * @template I The input type for the workflow.
@@ -38,25 +44,14 @@ class BaseWorkflowDeclaration {
      * @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 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;
-        });
+        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;
     }
     runAndWait(input, options, _standaloneTaskName) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -75,16 +70,32 @@ class BaseWorkflowDeclaration {
                 throw UNBOUND_ERR;
             }
             if (Array.isArray(input)) {
-                return Promise.all(input.map((i) => this.run(i, options, _standaloneTaskName)));
+                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);
             }
-            const serializedInput = yield (0, middleware_1.serializeInput)(input, this.client.middleware);
-            const res = this.client._v0.admin.runWorkflow(this.name, serializedInput, options);
+            const res = this.client._v0.admin.runWorkflow(this.definition.name, input, options);
             if (_standaloneTaskName) {
                 res._standalone_task_name = _standaloneTaskName;
             }
-            const output = yield res.result();
-            const deserializedOutput = yield (0, middleware_1.deserializeOutput)(output, this.client.middleware);
-            return deserializedOutput;
+            return res.result();
         });
     }
     /**
@@ -100,11 +111,7 @@ class BaseWorkflowDeclaration {
             if (!this.client) {
                 throw UNBOUND_ERR;
             }
-            const scheduled = this.client._v0.schedule.create(this.definition.name, {
-                triggerAt: enqueueAt,
-                input: input,
-                additionalMetadata: options === null || options === void 0 ? void 0 : options.additionalMetadata,
-            });
+            const scheduled = this.client._v0.schedule.create(this.definition.name, Object.assign({ triggerAt: enqueueAt, input: input }, options));
             return scheduled;
         });
     }
@@ -137,12 +144,7 @@ class BaseWorkflowDeclaration {
             if (!this.client) {
                 throw UNBOUND_ERR;
             }
-            const cronDef = this.client._v0.cron.create(this.definition.name, {
-                expression,
-                input: input,
-                additionalMetadata: options === null || options === void 0 ? void 0 : options.additionalMetadata,
-                name,
-            });
+            const cronDef = this.client._v0.cron.create(this.definition.name, Object.assign(Object.assign({ expression, input: input }, options), { additionalMetadata: options === null || options === void 0 ? void 0 : options.additionalMetadata, name }));
             return cronDef;
         });
     }
@@ -304,37 +306,26 @@ class TaskWorkflowDeclaration extends BaseWorkflowDeclaration {
         this._standalone_task_name = options.name;
         this.definition._tasks.push(Object.assign({}, options));
     }
-    runNoWait(input, options) {
+    run(input, options) {
         const _super = Object.create(null, {
-            runNoWait: { get: () => super.runNoWait }
+            run: { get: () => super.run }
         });
         return __awaiter(this, void 0, void 0, function* () {
-            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;
+            return (yield _super.run.call(this, 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();
-        });
+    /**
+     * 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);
     }
     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 = yield workflow_1.cancellation.runNoWait({});
-        const run1 = yield workflow_1.cancellation.runNoWait({});
+        const run = workflow_1.cancellation.runNoWait({});
+        const run1 = 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 = yield workflow_1.cancellation.runNoWait({}, { additionalMetadata: { test: 'abc' } });
-        const run4 = yield workflow_1.cancellation.runNoWait({}, { additionalMetadata: { test: 'test' } });
+        const run2 = workflow_1.cancellation.runNoWait({}, { additionalMetadata: { test: 'abc' } });
+        const run4 = workflow_1.cancellation.runNoWait({}, { additionalMetadata: { test: 'test' } });
         yield (0, sleep_1.default)(1000);
         yield hatchet_client_1.hatchet.runs.cancel({
             filters: {

package/v1/examples/priority/run.js

@@ -0,0 +1,41 @@
+"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 v1_1 = require("../..");
+const workflow_1 = require("./workflow");
+/* eslint-disable no-console */
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            console.log('running priority workflow');
+            // ❓ Run a Task with a Priority
+            const run = workflow_1.priority.run(new Date(Date.now() + 60 * 60 * 1000), { priority: v1_1.Priority.HIGH });
+            // !!
+            // ❓ Schedule and cron
+            const scheduled = workflow_1.priority.schedule(new Date(Date.now() + 60 * 60 * 1000), {}, { priority: v1_1.Priority.HIGH });
+            const delayed = workflow_1.priority.delay(60 * 60 * 1000, {}, { priority: v1_1.Priority.HIGH });
+            const cron = workflow_1.priority.cron(`daily-cron-${Math.random()}`, '0 0 * * *', {}, { priority: v1_1.Priority.HIGH });
+            // !!
+            const [scheduledResult, delayedResult] = yield Promise.all([scheduled, delayed]);
+            console.log('scheduledResult', scheduledResult);
+            console.log('delayedResult', delayedResult);
+            // !!
+        }
+        catch (e) {
+            console.log('error', e);
+        }
+    });
+}
+if (require.main === module) {
+    main()
+        .catch(console.error)
+        .finally(() => process.exit(0));
+}

package/v1/examples/{middleware → priority}/worker.js

@@ -9,16 +9,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-// ❓ Declaring a Worker
-const hatchet_client_1 = require("./hatchet-client");
+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,
+        const worker = yield hatchet_client_1.hatchet.worker('priority-worker', {
+            workflows: [...workflow_1.priorityTasks],
         });
         yield worker.start();
     });
@@ -26,4 +22,3 @@ function main() {
 if (require.main === module) {
     main();
 }
-// !!

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

@@ -0,0 +1,8 @@
+import { Priority } from '../..';
+export declare const priority: import("../..").TaskWorkflowDeclaration<import("../..").UnknownInputType, {
+    priority: Priority | undefined;
+}>;
+export declare const priorityWf: import("../..").WorkflowDeclaration<import("../..").UnknownInputType, {}>;
+export declare const priorityTasks: (import("../..").WorkflowDeclaration<import("../..").UnknownInputType, {}> | import("../..").TaskWorkflowDeclaration<import("../..").UnknownInputType, {
+    priority: Priority | undefined;
+}>)[];

package/v1/examples/priority/workflow.js

@@ -0,0 +1,50 @@
+"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.priorityTasks = exports.priorityWf = exports.priority = void 0;
+/* eslint-disable no-console */
+const v1_1 = require("../..");
+const hatchet_client_1 = require("../hatchet-client");
+// ❓ Simple Task Priority
+exports.priority = hatchet_client_1.hatchet.task({
+    name: 'priority',
+    defaultPriority: v1_1.Priority.MEDIUM,
+    fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        return {
+            priority: ctx.priority(),
+        };
+    }),
+});
+// !!
+// ❓ Task Priority in a Workflow
+exports.priorityWf = hatchet_client_1.hatchet.workflow({
+    name: 'priorityWf',
+    defaultPriority: v1_1.Priority.LOW,
+});
+// !!
+exports.priorityWf.task({
+    name: 'child-medium',
+    fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        return {
+            priority: ctx.priority(),
+        };
+    }),
+});
+exports.priorityWf.task({
+    name: 'child-high',
+    // will inherit the default priority from the workflow
+    fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        return {
+            priority: ctx.priority(),
+        };
+    }),
+});
+exports.priorityTasks = [exports.priority, exports.priorityWf];

package/v1/index.d.ts

@@ -5,3 +5,4 @@ export * from './declaration';
 export * from './conditions';
 export * from './client/duration';
 export * from './types';
+export * from './task';

package/v1/index.js

@@ -21,3 +21,4 @@ __exportStar(require("./declaration"), exports);
 __exportStar(require("./conditions"), exports);
 __exportStar(require("./client/duration"), exports);
 __exportStar(require("./types"), exports);
+__exportStar(require("./task"), exports);

package/v1/task.d.ts

@@ -3,7 +3,6 @@ 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.
  */
@@ -99,10 +98,6 @@ 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.2.0-alpha.1";
+export declare const HATCHET_VERSION = "1.2.0";

package/version.js

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

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

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

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

@@ -1,32 +0,0 @@
-"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()],
-});