@hatchet-dev/typescript-sdk 1.13.0 → 1.14.0

package/v1/examples/cancellation/cancellation-workflow.js

@@ -0,0 +1,69 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abortSignal = exports.cancellationWorkflow = void 0;
+const axios_1 = __importDefault(require("axios"));
+const sleep_1 = __importDefault(require("../../../util/sleep"));
+const hatchet_client_1 = require("../hatchet-client");
+// > Self-cancelling workflow (mirrors Python example)
+exports.cancellationWorkflow = hatchet_client_1.hatchet.workflow({
+    name: 'CancelWorkflow',
+});
+exports.cancellationWorkflow.task({
+    name: 'self-cancel',
+    fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        yield (0, sleep_1.default)(2000, ctx.abortController.signal);
+        // Cancel the current task run (server-side) and optimistically abort local execution.
+        yield ctx.cancel();
+        // If cancellation didn't stop execution yet, keep waiting but cooperatively.
+        yield (0, sleep_1.default)(10000, ctx.abortController.signal);
+        return { error: 'Task should have been cancelled' };
+    }),
+});
+exports.cancellationWorkflow.task({
+    name: 'check-flag',
+    fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        for (let i = 0; i < 3; i += 1) {
+            yield (0, sleep_1.default)(1000, ctx.abortController.signal);
+            if (ctx.cancelled) {
+                throw new Error('Cancelled');
+            }
+        }
+        return { error: 'Task should have been cancelled' };
+    }),
+});
+// !!
+// > Abort Signal
+exports.abortSignal = hatchet_client_1.hatchet.task({
+    name: 'abort-signal',
+    fn: (_1, _a) => __awaiter(void 0, [_1, _a], void 0, function* (_, { abortController }) {
+        try {
+            const response = yield axios_1.default.get('https://api.example.com/data', {
+                signal: abortController.signal,
+            });
+            // Handle the response
+        }
+        catch (error) {
+            if (axios_1.default.isCancel(error)) {
+                // Request was canceled
+                console.log('Request canceled');
+            }
+            else {
+                // Handle other errors
+            }
+        }
+    }),
+});
+// !!
+// see ./worker.ts and ./run.ts for how to run the workflow

package/v1/examples/cancellation/run.js

@@ -0,0 +1,53 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-console */
+// > Running a Task with Results
+const sleep_1 = __importDefault(require("../../../util/sleep"));
+const cancellation_workflow_1 = require("./cancellation-workflow");
+const hatchet_client_1 = require("../hatchet-client");
+// ...
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const run = yield cancellation_workflow_1.cancellationWorkflow.runNoWait({});
+        const run1 = yield cancellation_workflow_1.cancellationWorkflow.runNoWait({});
+        yield (0, sleep_1.default)(1000);
+        yield run.cancel();
+        const res = yield run.output;
+        const res1 = yield run1.output;
+        console.log('canceled', res);
+        console.log('completed', res1);
+        yield (0, sleep_1.default)(1000);
+        yield run.replay();
+        const resReplay = yield run.output;
+        console.log(resReplay);
+        const run2 = yield cancellation_workflow_1.cancellationWorkflow.runNoWait({}, { additionalMetadata: { test: 'abc' } });
+        const run4 = yield cancellation_workflow_1.cancellationWorkflow.runNoWait({}, { additionalMetadata: { test: 'test' } });
+        yield (0, sleep_1.default)(1000);
+        yield hatchet_client_1.hatchet.runs.cancel({
+            filters: {
+                since: new Date(Date.now() - 60 * 60),
+                additionalMetadata: { test: 'test' },
+            },
+        });
+        const res3 = yield Promise.all([run2.output, run4.output]);
+        console.log(res3);
+        // !!
+    });
+}
+if (require.main === module) {
+    main()
+        .catch(console.error)
+        .finally(() => process.exit(0));
+}

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

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

package/v1/examples/cancellation/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 cancellation_workflow_1 = require("./cancellation-workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker = yield hatchet_client_1.hatchet.worker('cancellation-worker', {
+            // 👀 Declare the workflows that the worker can execute
+            workflows: [cancellation_workflow_1.cancellationWorkflow],
+            // 👀 Declare the number of concurrent task runs the worker can accept
+            slots: 100,
+        });
+        yield worker.start();
+    });
+}
+if (require.main === module) {
+    main();
+}
+// !!

package/v1/examples/concurrency-types.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Empty task output - satisfies JsonObject for concurrency workflows
+ * that don't return meaningful data (used for rate-limiting tests).
+ */
+export type EmptyTaskOutput = Record<string, never>;

package/v1/examples/concurrency-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,9 @@
+import type { EmptyTaskOutput } from '../concurrency-types';
+export type WorkflowInput = {
+    group: string;
+};
+export type WorkflowOutput = {
+    step1: EmptyTaskOutput;
+    step2: EmptyTaskOutput;
+};
+export declare const concurrencyCancelInProgressWorkflow: import("../..").WorkflowDeclaration<WorkflowInput, WorkflowOutput, {}>;

package/v1/examples/concurrency_cancel_in_progress/workflow.js

@@ -0,0 +1,45 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.concurrencyCancelInProgressWorkflow = void 0;
+const sleep_1 = __importDefault(require("../../../util/sleep"));
+const v1_1 = require("../..");
+const hatchet_client_1 = require("../hatchet-client");
+exports.concurrencyCancelInProgressWorkflow = hatchet_client_1.hatchet.workflow({
+    name: 'concurrencycancelinprogress',
+    concurrency: {
+        expression: 'input.group',
+        maxRuns: 1,
+        limitStrategy: v1_1.ConcurrencyLimitStrategy.CANCEL_IN_PROGRESS,
+    },
+});
+const step1 = exports.concurrencyCancelInProgressWorkflow.task({
+    name: 'step1',
+    fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        for (let i = 0; i < 50; i += 1) {
+            yield (0, sleep_1.default)(100, ctx.abortController.signal);
+        }
+        return {};
+    }),
+});
+exports.concurrencyCancelInProgressWorkflow.task({
+    name: 'step2',
+    parents: [step1],
+    fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        for (let i = 0; i < 50; i += 1) {
+            yield (0, sleep_1.default)(100, ctx.abortController.signal);
+        }
+        return {};
+    }),
+});

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

@@ -0,0 +1,9 @@
+import type { EmptyTaskOutput } from '../concurrency-types';
+export type WorkflowInput = {
+    group: string;
+};
+export type WorkflowOutput = {
+    step1: EmptyTaskOutput;
+    step2: EmptyTaskOutput;
+};
+export declare const concurrencyCancelNewestWorkflow: import("../..").WorkflowDeclaration<WorkflowInput, WorkflowOutput, {}>;

package/v1/examples/concurrency_cancel_newest/workflow.js

@@ -0,0 +1,45 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.concurrencyCancelNewestWorkflow = void 0;
+const sleep_1 = __importDefault(require("../../../util/sleep"));
+const v1_1 = require("../..");
+const hatchet_client_1 = require("../hatchet-client");
+exports.concurrencyCancelNewestWorkflow = hatchet_client_1.hatchet.workflow({
+    name: 'concurrencycancelnewest',
+    concurrency: {
+        expression: 'input.group',
+        maxRuns: 1,
+        limitStrategy: v1_1.ConcurrencyLimitStrategy.CANCEL_NEWEST,
+    },
+});
+const step1 = exports.concurrencyCancelNewestWorkflow.task({
+    name: 'step1',
+    fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        for (let i = 0; i < 50; i += 1) {
+            yield (0, sleep_1.default)(20, ctx.abortController.signal);
+        }
+        return {};
+    }),
+});
+exports.concurrencyCancelNewestWorkflow.task({
+    name: 'step2',
+    parents: [step1],
+    fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        for (let i = 0; i < 50; i += 1) {
+            yield (0, sleep_1.default)(20, ctx.abortController.signal);
+        }
+        return {};
+    }),
+});

package/v1/examples/concurrency_limit_rr/load.d.ts

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

package/v1/examples/concurrency_limit_rr/load.js

@@ -0,0 +1,54 @@
+"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-plusplus */
+const hatchet_client_1 = require("../hatchet-client");
+const workflow_1 = require("./workflow");
+function generateRandomString(length) {
+    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let result = '';
+    for (let i = 0; i < length; i++) {
+        result += characters.charAt(Math.floor(Math.random() * characters.length));
+    }
+    return result;
+}
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const groupCount = 2;
+        const runsPerGroup = 20000;
+        const BATCH_SIZE = 400;
+        const workflowRuns = [];
+        for (let i = 0; i < groupCount; i++) {
+            for (let j = 0; j < runsPerGroup; j++) {
+                workflowRuns.push({
+                    workflowName: workflow_1.simpleConcurrency.definition.name,
+                    input: {
+                        Message: generateRandomString(10),
+                        GroupKey: `group-${i}`,
+                    },
+                });
+            }
+        }
+        // Shuffle the workflow runs array
+        for (let i = workflowRuns.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [workflowRuns[i], workflowRuns[j]] = [workflowRuns[j], workflowRuns[i]];
+        }
+        // Process workflows in batches
+        for (let i = 0; i < workflowRuns.length; i += BATCH_SIZE) {
+            const batch = workflowRuns.slice(i, i + BATCH_SIZE);
+            yield hatchet_client_1.hatchet.admin.runWorkflows(batch);
+        }
+    });
+}
+if (require.main === module) {
+    main().then(() => process.exit(0));
+}

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

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

package/v1/examples/concurrency_limit_rr/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.simpleConcurrency.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/concurrency_limit_rr/worker.d.ts

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

package/v1/examples/concurrency_limit_rr/worker.js

@@ -0,0 +1,24 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const hatchet_client_1 = require("../hatchet-client");
+const workflow_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker = yield hatchet_client_1.hatchet.worker('simple-concurrency-worker', {
+            workflows: [workflow_1.simpleConcurrency],
+        });
+        yield worker.start();
+    });
+}
+if (require.main === module) {
+    main();
+}

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

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

package/v1/examples/concurrency_limit_rr/workflow.js

@@ -0,0 +1,62 @@
+"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.multipleConcurrencyKeys = exports.simpleConcurrency = void 0;
+const v1_1 = require("../..");
+const hatchet_client_1 = require("../hatchet-client");
+const sleep = (ms) => new Promise((resolve) => {
+    setTimeout(resolve, ms);
+});
+// > Concurrency Strategy With Key
+exports.simpleConcurrency = hatchet_client_1.hatchet.workflow({
+    name: 'simple-concurrency',
+    concurrency: {
+        maxRuns: 1,
+        limitStrategy: v1_1.ConcurrencyLimitStrategy.GROUP_ROUND_ROBIN,
+        expression: 'input.GroupKey',
+    },
+});
+// !!
+exports.simpleConcurrency.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(),
+        };
+    }),
+});
+// > Multiple Concurrency Keys
+exports.multipleConcurrencyKeys = hatchet_client_1.hatchet.workflow({
+    name: 'simple-concurrency',
+    concurrency: [
+        {
+            maxRuns: 1,
+            limitStrategy: v1_1.ConcurrencyLimitStrategy.GROUP_ROUND_ROBIN,
+            expression: 'input.Tier',
+        },
+        {
+            maxRuns: 1,
+            limitStrategy: v1_1.ConcurrencyLimitStrategy.GROUP_ROUND_ROBIN,
+            expression: 'input.Account',
+        },
+    ],
+});
+// !!
+exports.multipleConcurrencyKeys.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/concurrency_multiple_keys/workflow.d.ts

@@ -0,0 +1,12 @@
+import type { EmptyTaskOutput } from '../concurrency-types';
+export declare const SLEEP_TIME_MS = 500;
+export declare const DIGIT_MAX_RUNS = 8;
+export declare const NAME_MAX_RUNS = 3;
+export type WorkflowInput = {
+    name: string;
+    digit: string;
+};
+export type WorkflowOutput = {
+    concurrency_task: EmptyTaskOutput;
+};
+export declare const concurrencyMultipleKeysWorkflow: import("../..").WorkflowDeclaration<WorkflowInput, WorkflowOutput, {}>;

package/v1/examples/concurrency_multiple_keys/workflow.js

@@ -0,0 +1,42 @@
+"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.concurrencyMultipleKeysWorkflow = exports.NAME_MAX_RUNS = exports.DIGIT_MAX_RUNS = exports.SLEEP_TIME_MS = void 0;
+const v1_1 = require("../..");
+const hatchet_client_1 = require("../hatchet-client");
+const sleep = (ms) => new Promise((resolve) => {
+    setTimeout(resolve, ms);
+});
+exports.SLEEP_TIME_MS = 500;
+exports.DIGIT_MAX_RUNS = 8;
+exports.NAME_MAX_RUNS = 3;
+exports.concurrencyMultipleKeysWorkflow = hatchet_client_1.hatchet.workflow({
+    name: 'concurrency-workflow-many-keys',
+    concurrency: [
+        {
+            expression: 'input.digit',
+            maxRuns: exports.DIGIT_MAX_RUNS,
+            limitStrategy: v1_1.ConcurrencyLimitStrategy.GROUP_ROUND_ROBIN,
+        },
+        {
+            expression: 'input.name',
+            maxRuns: exports.NAME_MAX_RUNS,
+            limitStrategy: v1_1.ConcurrencyLimitStrategy.GROUP_ROUND_ROBIN,
+        },
+    ],
+});
+exports.concurrencyMultipleKeysWorkflow.task({
+    name: 'concurrency_task',
+    fn: () => __awaiter(void 0, void 0, void 0, function* () {
+        yield sleep(exports.SLEEP_TIME_MS);
+        return {};
+    }),
+});

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

@@ -0,0 +1,13 @@
+import type { EmptyTaskOutput } from '../concurrency-types';
+export declare const SLEEP_TIME_MS = 500;
+export declare const DIGIT_MAX_RUNS = 8;
+export declare const NAME_MAX_RUNS = 3;
+export type WorkflowInput = {
+    name: string;
+    digit: string;
+};
+export type WorkflowOutput = {
+    task_1: EmptyTaskOutput;
+    task_2: EmptyTaskOutput;
+};
+export declare const concurrencyWorkflowLevelWorkflow: import("../..").WorkflowDeclaration<WorkflowInput, WorkflowOutput, {}>;

package/v1/examples/concurrency_workflow_level/workflow.js

@@ -0,0 +1,49 @@
+"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.concurrencyWorkflowLevelWorkflow = exports.NAME_MAX_RUNS = exports.DIGIT_MAX_RUNS = exports.SLEEP_TIME_MS = void 0;
+const v1_1 = require("../..");
+const hatchet_client_1 = require("../hatchet-client");
+const sleep = (ms) => new Promise((resolve) => {
+    setTimeout(resolve, ms);
+});
+exports.SLEEP_TIME_MS = 500;
+exports.DIGIT_MAX_RUNS = 8;
+exports.NAME_MAX_RUNS = 3;
+exports.concurrencyWorkflowLevelWorkflow = hatchet_client_1.hatchet.workflow({
+    name: 'concurrency-workflow-level',
+    concurrency: [
+        {
+            expression: 'input.digit',
+            maxRuns: exports.DIGIT_MAX_RUNS,
+            limitStrategy: v1_1.ConcurrencyLimitStrategy.GROUP_ROUND_ROBIN,
+        },
+        {
+            expression: 'input.name',
+            maxRuns: exports.NAME_MAX_RUNS,
+            limitStrategy: v1_1.ConcurrencyLimitStrategy.GROUP_ROUND_ROBIN,
+        },
+    ],
+});
+exports.concurrencyWorkflowLevelWorkflow.task({
+    name: 'task_1',
+    fn: () => __awaiter(void 0, void 0, void 0, function* () {
+        yield sleep(exports.SLEEP_TIME_MS);
+        return {};
+    }),
+});
+exports.concurrencyWorkflowLevelWorkflow.task({
+    name: 'task_2',
+    fn: () => __awaiter(void 0, void 0, void 0, function* () {
+        yield sleep(exports.SLEEP_TIME_MS);
+        return {};
+    }),
+});

package/v1/examples/conditions/complex-workflow.d.ts

@@ -0,0 +1 @@
+export declare const taskConditionWorkflow: import("../..").WorkflowDeclaration<import("../..").UnknownInputType, {}, {}>;