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

package/v1/declaration.d.ts

@@ -3,10 +3,15 @@ import { Context, DurableContext } from '../step';
 import { CronWorkflows, ScheduledWorkflows } from '../clients/rest/generated/data-contracts';
 import { Workflow as WorkflowV0 } from '../workflow';
 import { IHatchetClient } from './client/client.interface';
-import { CreateWorkflowTaskOpts, CreateOnFailureTaskOpts, TaskConcurrency, TaskFn, CreateWorkflowDurableTaskOpts, CreateBaseTaskOpts, CreateOnSuccessTaskOpts, DurableTaskFn } from './task';
+import { CreateWorkflowTaskOpts, CreateOnFailureTaskOpts, TaskFn, CreateWorkflowDurableTaskOpts, CreateBaseTaskOpts, CreateOnSuccessTaskOpts, Concurrency, DurableTaskFn } from './task';
 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
@@ -58,7 +69,15 @@ export type CreateBaseWorkflowOpts = {
      * (optional) event config for the workflow.
      */
     onEvents?: string[];
-    concurrency?: TaskConcurrency;
+    /**
+     * (optional) concurrency config for the workflow.
+     */
+    concurrency?: Concurrency | Concurrency[];
+    /**
+     * (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>>;
@@ -118,7 +137,7 @@ export type TaskDefaults = {
     /**
      * (optional) the concurrency options for the task.
      */
-    concurrency?: TaskConcurrency | TaskConcurrency[];
+    concurrency?: Concurrency | Concurrency[];
 };
 /**
  * Internal definition of a workflow and its tasks.
@@ -172,7 +191,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 +320,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/multiple_wf_concurrency/run.js

@@ -0,0 +1,39 @@
+"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 workflow_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const res = yield workflow_1.multiConcurrency.run([
+            {
+                Message: 'Hello World',
+                GroupKey: 'A',
+            },
+            {
+                Message: 'Goodbye Moon',
+                GroupKey: 'A',
+            },
+            {
+                Message: 'Hello World B',
+                GroupKey: 'B',
+            },
+        ]);
+        // eslint-disable-next-line no-console
+        console.log(res[0]['to-lower'].TransformedMessage);
+        // eslint-disable-next-line no-console
+        console.log(res[1]['to-lower'].TransformedMessage);
+        // eslint-disable-next-line no-console
+        console.log(res[2]['to-lower'].TransformedMessage);
+    });
+}
+if (require.main === module) {
+    main().then(() => process.exit(0));
+}

package/v1/examples/{middleware → multiple_wf_concurrency}/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('simple-concurrency-worker', {
+            workflows: [workflow_1.multiConcurrency],
         });
         yield worker.start();
     });
@@ -26,4 +22,3 @@ function main() {
 if (require.main === module) {
     main();
 }
-// !!

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

@@ -0,0 +1,11 @@
+type SimpleInput = {
+    Message: string;
+    GroupKey: string;
+};
+type SimpleOutput = {
+    'to-lower': {
+        TransformedMessage: string;
+    };
+};
+export declare const multiConcurrency: import("../..").WorkflowDeclaration<SimpleInput, SimpleOutput>;
+export {};

package/v1/examples/multiple_wf_concurrency/workflow.js

@@ -0,0 +1,43 @@
+"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.multiConcurrency = void 0;
+const workflow_1 = require("../../../workflow");
+const hatchet_client_1 = require("../hatchet-client");
+const sleep = (ms) => new Promise((resolve) => {
+    setTimeout(resolve, ms);
+});
+// ❓ Concurrency Strategy With Key
+exports.multiConcurrency = hatchet_client_1.hatchet.workflow({
+    name: 'simple-concurrency',
+    concurrency: [
+        {
+            maxRuns: 1,
+            limitStrategy: workflow_1.ConcurrencyLimitStrategy.GROUP_ROUND_ROBIN,
+            expression: 'input.GroupKey',
+        },
+        {
+            maxRuns: 1,
+            limitStrategy: workflow_1.ConcurrencyLimitStrategy.GROUP_ROUND_ROBIN,
+            expression: 'input.UserId',
+        },
+    ],
+});
+// !!
+exports.multiConcurrency.task({
+    name: 'to-lower',
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () {
+        yield sleep(Math.floor(Math.random() * (1000 - 200 + 1)) + 200);
+        return {
+            TransformedMessage: input.Message.toLowerCase(),
+        };
+    }),
+});

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

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

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/priority/worker.d.ts

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

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

@@ -9,26 +9,16 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable no-console */
+const hatchet_client_1 = require("../hatchet-client");
 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',
+        const worker = yield hatchet_client_1.hatchet.worker('priority-worker', {
+            workflows: [...workflow_1.priorityTasks],
         });
-        // 👀 Access the results of the Task
-        console.log(res);
-        // !!
+        yield worker.start();
     });
 }
 if (require.main === module) {
-    main()
-        .then(() => {
-        process.exit(0);
-    })
-        .catch((err) => {
-        console.error(err);
-        process.exit(1);
-    });
+    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,11 +3,10 @@ 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.
  */
-export type TaskConcurrency = {
+export type Concurrency = {
     /**
      * required the CEL expression to use for concurrency
      *
@@ -30,6 +29,10 @@ export type TaskConcurrency = {
      */
     limitStrategy?: ConcurrencyLimitStrategy;
 };
+/**
+ * @deprecated use Concurrency instead
+ */
+export type TaskConcurrency = Concurrency;
 export declare class NonRetryableError extends Error {
     constructor(message?: string);
 }
@@ -98,11 +101,7 @@ 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[];
+    concurrency?: Concurrency | Concurrency[];
 };
 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.3.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.3.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()],
-});

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

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