@hatchet-dev/typescript-sdk 1.13.1 → 1.14.0

package/v1/examples/conditions/complex-workflow.js

@@ -0,0 +1,107 @@
+"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.taskConditionWorkflow = void 0;
+// > Create a workflow
+const conditions_1 = require("../../conditions");
+const parent_condition_1 = require("../../conditions/parent-condition");
+const hatchet_client_1 = require("../hatchet-client");
+exports.taskConditionWorkflow = hatchet_client_1.hatchet.workflow({
+    name: 'TaskConditionWorkflow',
+});
+// !!
+// > Add base task
+const start = exports.taskConditionWorkflow.task({
+    name: 'start',
+    fn: () => {
+        return {
+            randomNumber: Math.floor(Math.random() * 100) + 1,
+        };
+    },
+});
+// !!
+// > Add wait for sleep
+const waitForSleep = exports.taskConditionWorkflow.task({
+    name: 'waitForSleep',
+    parents: [start],
+    waitFor: [new conditions_1.SleepCondition('10s')],
+    fn: () => {
+        return {
+            randomNumber: Math.floor(Math.random() * 100) + 1,
+        };
+    },
+});
+// !!
+// > Add skip on event
+const skipOnEvent = exports.taskConditionWorkflow.task({
+    name: 'skipOnEvent',
+    parents: [start],
+    waitFor: [new conditions_1.SleepCondition('10s')],
+    skipIf: [new conditions_1.UserEventCondition('skip_on_event:skip', 'true')],
+    fn: () => {
+        return {
+            randomNumber: Math.floor(Math.random() * 100) + 1,
+        };
+    },
+});
+// !!
+// > Add branching
+const leftBranch = exports.taskConditionWorkflow.task({
+    name: 'leftBranch',
+    parents: [waitForSleep],
+    skipIf: [new parent_condition_1.ParentCondition(waitForSleep, 'output.randomNumber > 50')],
+    fn: () => {
+        return {
+            randomNumber: Math.floor(Math.random() * 100) + 1,
+        };
+    },
+});
+const rightBranch = exports.taskConditionWorkflow.task({
+    name: 'rightBranch',
+    parents: [waitForSleep],
+    skipIf: [new parent_condition_1.ParentCondition(waitForSleep, 'output.randomNumber <= 50')],
+    fn: () => {
+        return {
+            randomNumber: Math.floor(Math.random() * 100) + 1,
+        };
+    },
+});
+// !!
+// > Add wait for event
+const waitForEvent = exports.taskConditionWorkflow.task({
+    name: 'waitForEvent',
+    parents: [start],
+    waitFor: [(0, conditions_1.Or)(new conditions_1.SleepCondition('1m'), new conditions_1.UserEventCondition('wait_for_event:start', 'true'))],
+    fn: () => {
+        return {
+            randomNumber: Math.floor(Math.random() * 100) + 1,
+        };
+    },
+});
+// !!
+// > Add sum
+exports.taskConditionWorkflow.task({
+    name: 'sum',
+    parents: [start, waitForSleep, waitForEvent, skipOnEvent, leftBranch, rightBranch],
+    fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b, _c;
+        const one = (yield ctx.parentOutput(start)).randomNumber;
+        const two = (yield ctx.parentOutput(waitForEvent)).randomNumber;
+        const three = (yield ctx.parentOutput(waitForSleep)).randomNumber;
+        const four = ((_a = (yield ctx.parentOutput(skipOnEvent))) === null || _a === void 0 ? void 0 : _a.randomNumber) || 0;
+        const five = ((_b = (yield ctx.parentOutput(leftBranch))) === null || _b === void 0 ? void 0 : _b.randomNumber) || 0;
+        const six = ((_c = (yield ctx.parentOutput(rightBranch))) === null || _c === void 0 ? void 0 : _c.randomNumber) || 0;
+        return {
+            sum: one + two + three + four + five + six,
+        };
+    }),
+});
+// !!

package/v1/examples/conditions/event.d.ts

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

package/v1/examples/conditions/event.js

@@ -0,0 +1,28 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const hatchet_client_1 = require("../hatchet-client");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const event = yield hatchet_client_1.hatchet.events.push('user:event', {
+            Data: { Hello: 'World' },
+        });
+    });
+}
+if (require.main === module) {
+    main()
+        .then(() => process.exit(0))
+        .catch((error) => {
+        // eslint-disable-next-line no-console
+        console.error('Error:', error);
+        process.exit(1);
+    });
+}

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

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

package/v1/examples/conditions/run.js

@@ -0,0 +1,25 @@
+"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* () {
+        const res = yield workflow_1.dagWithConditions.run({});
+        console.log(res['first-task'].Completed);
+        console.log(res['second-task'].Completed);
+    });
+}
+if (require.main === module) {
+    main()
+        .catch(console.error)
+        .finally(() => process.exit(0));
+}

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

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

package/v1/examples/conditions/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('dag-worker', {
+            workflows: [workflow_1.dagWithConditions],
+        });
+        yield worker.start();
+    });
+}
+if (require.main === module) {
+    main();
+}

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

@@ -0,0 +1,11 @@
+type DagInput = {};
+type DagOutput = {
+    'first-task': {
+        Completed: boolean;
+    };
+    'second-task': {
+        Completed: boolean;
+    };
+};
+export declare const dagWithConditions: import("../..").WorkflowDeclaration<DagInput, DagOutput, {}>;
+export {};

package/v1/examples/conditions/workflow.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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dagWithConditions = void 0;
+const sleep_1 = __importDefault(require("../../../util/sleep"));
+const conditions_1 = require("../../conditions");
+const hatchet_client_1 = require("../hatchet-client");
+exports.dagWithConditions = hatchet_client_1.hatchet.workflow({
+    name: 'simple',
+});
+const firstTask = exports.dagWithConditions.task({
+    name: 'first-task',
+    fn: () => __awaiter(void 0, void 0, void 0, function* () {
+        yield (0, sleep_1.default)(2000);
+        return {
+            Completed: true,
+        };
+    }),
+});
+exports.dagWithConditions.task({
+    name: 'second-task',
+    parents: [firstTask],
+    waitFor: (0, conditions_1.Or)({ eventKey: 'user:event' }, { sleepFor: '10s' }),
+    fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        console.log('triggered by condition', ctx.triggers());
+        return {
+            Completed: true,
+        };
+    }),
+});

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

@@ -0,0 +1,7 @@
+export declare const EVENT_KEY = "durable-example:event";
+export declare const SLEEP_TIME_SECONDS = 2;
+export declare const SLEEP_TIME: "2s";
+export declare const durableWorkflow: import("../..").WorkflowDeclaration<import("../..").UnknownInputType, {}, {}>;
+export declare const waitForSleepTwice: import("../..").TaskWorkflowDeclaration<import("../..").JsonObject, {
+    runtime: number;
+}, {}, {}, {}, {}>;

package/v1/examples/durable/workflow.js

@@ -0,0 +1,116 @@
+"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.waitForSleepTwice = exports.durableWorkflow = exports.SLEEP_TIME = exports.SLEEP_TIME_SECONDS = exports.EVENT_KEY = void 0;
+/* eslint-disable no-console */
+const conditions_1 = require("../../conditions");
+const hatchet_client_1 = require("../hatchet-client");
+exports.EVENT_KEY = 'durable-example:event';
+exports.SLEEP_TIME_SECONDS = 2;
+exports.SLEEP_TIME = `${exports.SLEEP_TIME_SECONDS}s`;
+// > Create a durable workflow
+exports.durableWorkflow = hatchet_client_1.hatchet.workflow({
+    name: 'durable-workflow',
+});
+// !!
+exports.durableWorkflow.task({
+    name: 'ephemeral_task',
+    fn: () => __awaiter(void 0, void 0, void 0, function* () {
+        console.log('Running non-durable task');
+    }),
+});
+exports.durableWorkflow.durableTask({
+    name: 'durable_task',
+    executionTimeout: '10m',
+    fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        console.log('Waiting for sleep');
+        yield ctx.sleepFor(exports.SLEEP_TIME);
+        console.log('Sleep finished');
+        console.log('Waiting for event');
+        yield ctx.waitFor({ eventKey: exports.EVENT_KEY });
+        console.log('Event received');
+        return { status: 'success' };
+    }),
+});
+function extractKeyAndEventId(waitResult) {
+    // DurableContext.waitFor currently returns the CREATE payload directly.
+    // The shape is typically `{ [readableDataKey]: { [eventId]: ... } }`.
+    const obj = waitResult;
+    if (obj && typeof obj === 'object') {
+        const key = Object.keys(obj)[0];
+        const inner = obj[key];
+        if (inner && typeof inner === 'object') {
+            const eventId = Object.keys(inner)[0];
+            if (eventId) {
+                return { key: 'CREATE', eventId };
+            }
+        }
+        if (key) {
+            return { key: 'CREATE', eventId: key };
+        }
+    }
+    return { key: 'CREATE', eventId: '' };
+}
+exports.durableWorkflow.durableTask({
+    name: 'wait_for_or_group_1',
+    executionTimeout: '10m',
+    fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const start = Date.now();
+        const waitResult = yield ctx.waitFor((0, conditions_1.Or)(new conditions_1.SleepCondition(exports.SLEEP_TIME, 'sleep'), new conditions_1.UserEventCondition(exports.EVENT_KEY, '', 'event')));
+        const { key, eventId } = extractKeyAndEventId(waitResult);
+        return {
+            runtime: Math.round((Date.now() - start) / 1000),
+            key,
+            eventId,
+        };
+    }),
+});
+exports.durableWorkflow.durableTask({
+    name: 'wait_for_or_group_2',
+    executionTimeout: '10m',
+    fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const start = Date.now();
+        const waitResult = yield ctx.waitFor((0, conditions_1.Or)(new conditions_1.SleepCondition(`${6 * exports.SLEEP_TIME_SECONDS}s`, 'sleep'), new conditions_1.UserEventCondition(exports.EVENT_KEY, '', 'event')));
+        const { key, eventId } = extractKeyAndEventId(waitResult);
+        return {
+            runtime: Math.round((Date.now() - start) / 1000),
+            key,
+            eventId,
+        };
+    }),
+});
+exports.durableWorkflow.durableTask({
+    name: 'wait_for_multi_sleep',
+    executionTimeout: '10m',
+    fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const start = Date.now();
+        // sleep 3 times
+        for (let i = 0; i < 3; i += 1) {
+            yield ctx.sleepFor(exports.SLEEP_TIME);
+        }
+        return { runtime: Math.round((Date.now() - start) / 1000) };
+    }),
+});
+exports.waitForSleepTwice = hatchet_client_1.hatchet.durableTask({
+    name: 'wait-for-sleep-twice',
+    executionTimeout: '10m',
+    fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            const start = Date.now();
+            yield ctx.sleepFor(exports.SLEEP_TIME);
+            return { runtime: Math.round((Date.now() - start) / 1000) };
+        }
+        catch (e) {
+            // treat cancellation as a successful completion for parity with Python sample
+            return { runtime: -1 };
+        }
+    }),
+});

package/v1/examples/durable_event/event.d.ts

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

package/v1/examples/durable_event/event.js

@@ -0,0 +1,28 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const hatchet_client_1 = require("../hatchet-client");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const event = yield hatchet_client_1.hatchet.events.push('user:update', {
+            userId: '1234',
+        });
+    });
+}
+if (require.main === module) {
+    main()
+        .then(() => process.exit(0))
+        .catch((error) => {
+        // eslint-disable-next-line no-console
+        console.error('Error:', error);
+        process.exit(1);
+    });
+}

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

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

package/v1/examples/durable_event/run.js

@@ -0,0 +1,30 @@
+"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 timeStart = Date.now();
+        const res = yield workflow_1.durableEvent.run({});
+        const timeEnd = Date.now();
+        // eslint-disable-next-line no-console
+        console.log(`Time taken: ${timeEnd - timeStart}ms`);
+    });
+}
+if (require.main === module) {
+    main()
+        .then(() => process.exit(0))
+        .catch((error) => {
+        // eslint-disable-next-line no-console
+        console.error('Error:', error);
+        process.exit(1);
+    });
+}

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

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

package/v1/examples/durable_event/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('durable-event-worker', {
+            workflows: [workflow_1.durableEvent],
+        });
+        yield worker.start();
+    });
+}
+if (require.main === module) {
+    main();
+}

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

@@ -0,0 +1,6 @@
+export declare const durableEvent: import("../..").TaskWorkflowDeclaration<import("../..").JsonObject, {
+    Value: string;
+}, {}, {}, {}, {}>;
+export declare const durableEventWithFilter: import("../..").TaskWorkflowDeclaration<import("../..").JsonObject, {
+    Value: string;
+}, {}, {}, {}, {}>;

package/v1/examples/durable_event/workflow.js

@@ -0,0 +1,46 @@
+"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.durableEventWithFilter = exports.durableEvent = void 0;
+// import sleep from '../../../util/sleep.js';
+const hatchet_client_1 = require("../hatchet-client");
+// > Durable Event
+exports.durableEvent = hatchet_client_1.hatchet.durableTask({
+    name: 'durable-event',
+    executionTimeout: '10m',
+    fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const res = ctx.waitFor({
+            eventKey: 'user:update',
+        });
+        console.log('res', res);
+        return {
+            Value: 'done',
+        };
+    }),
+});
+// !!
+exports.durableEventWithFilter = hatchet_client_1.hatchet.durableTask({
+    name: 'durable-event-with-filter',
+    executionTimeout: '10m',
+    fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        // > Durable Event With Filter
+        const res = ctx.waitFor({
+            eventKey: 'user:update',
+            expression: "input.userId == '1234'",
+        });
+        // !!
+        console.log('res', res);
+        return {
+            Value: 'done',
+        };
+    }),
+});
+// !!

package/v1/examples/durable_sleep/event.d.ts

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

package/v1/examples/durable_sleep/event.js

@@ -0,0 +1,28 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const hatchet_client_1 = require("../hatchet-client");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const event = yield hatchet_client_1.hatchet.events.push('user:event', {
+            Data: { Hello: 'World' },
+        });
+    });
+}
+if (require.main === module) {
+    main()
+        .then(() => process.exit(0))
+        .catch((error) => {
+        // eslint-disable-next-line no-console
+        console.error('Error:', error);
+        process.exit(1);
+    });
+}

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

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

package/v1/examples/durable_sleep/run.js

@@ -0,0 +1,30 @@
+"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 timeStart = Date.now();
+        const res = yield workflow_1.durableSleep.run({});
+        const timeEnd = Date.now();
+        // eslint-disable-next-line no-console
+        console.log(`Time taken: ${timeEnd - timeStart}ms`);
+    });
+}
+if (require.main === module) {
+    main()
+        .then(() => process.exit(0))
+        .catch((error) => {
+        // eslint-disable-next-line no-console
+        console.error('Error:', error);
+        process.exit(1);
+    });
+}

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

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

package/v1/examples/durable_sleep/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('sleep-worker', {
+            workflows: [workflow_1.durableSleep],
+        });
+        yield worker.start();
+    });
+}
+if (require.main === module) {
+    main();
+}

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

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

package/v1/examples/durable_sleep/workflow.js

@@ -0,0 +1,31 @@
+"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.durableSleep = void 0;
+// import sleep from '../../../util/sleep.js';
+const hatchet_client_1 = require("../hatchet-client");
+exports.durableSleep = hatchet_client_1.hatchet.workflow({
+    name: 'durable-sleep',
+});
+// > Durable Sleep
+exports.durableSleep.durableTask({
+    name: 'durable-sleep',
+    executionTimeout: '10m',
+    fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        console.log('sleeping for 5s');
+        const sleepRes = yield ctx.sleepFor('5s');
+        console.log('done sleeping for 5s', sleepRes);
+        return {
+            Value: 'done',
+        };
+    }),
+});
+// !!