@hatchet-dev/typescript-sdk 1.13.1 → 1.15.0

package/src/v1/examples/dag_match_condition/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("../../../../v1/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 → src/v1}/examples/deep/workflow.js

@@ -13,7 +13,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parent = exports.child5 = exports.child4 = exports.child3 = exports.child2 = exports.child1 = void 0;
-const sleep_1 = __importDefault(require("../../../util/sleep"));
+const sleep_1 = __importDefault(require("../../../../util/sleep"));
 const hatchet_client_1 = require("../hatchet-client");
 exports.child1 = hatchet_client_1.hatchet.workflow({
     name: 'child1',

package/src/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/src/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("../../../../v1/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 → src/v1}/examples/durable-event/workflow.js

@@ -10,7 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.durableEventWithFilter = exports.durableEvent = void 0;
-// import sleep from '../../../util/sleep.js';
+// import sleep from '../../../../util/sleep.js';
 const hatchet_client_1 = require("../hatchet-client");
 // > Durable Event
 exports.durableEvent = hatchet_client_1.hatchet.durableTask({

package/src/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 → src/v1}/examples/durable-sleep/workflow.js

@@ -10,7 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.durableSleep = void 0;
-// import sleep from '../../../util/sleep.js';
+// import sleep from '../../../../util/sleep.js';
 const hatchet_client_1 = require("../hatchet-client");
 exports.durableSleep = hatchet_client_1.hatchet.workflow({
     name: 'durable-sleep',

package/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/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/src/v1/examples/durable_sleep/workflow.d.ts

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

package/src/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',
+        };
+    }),
+});
+// !!

package/src/v1/examples/e2e-worker.js

@@ -0,0 +1,82 @@
+"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 });
+/**
+ * Shared e2e worker - registers all v1 example workflows for e2e tests.
+ * Spawned by jest.e2e-global-setup and killed by jest.e2e-global-teardown.
+ * Set HATCHET_CLIENT_WORKER_HEALTHCHECK_ENABLED=true and
+ * HATCHET_CLIENT_WORKER_HEALTHCHECK_PORT before running.
+ */
+const hatchet_client_1 = require("./hatchet-client");
+const workflow_1 = require("./bulk_fanout/workflow");
+const workflow_2 = require("./bulk_operations/workflow");
+const cancellation_workflow_1 = require("./cancellation/cancellation-workflow");
+const complex_workflow_1 = require("./conditions/complex-workflow");
+const workflow_3 = require("./concurrency_cancel_in_progress/workflow");
+const workflow_4 = require("./concurrency_cancel_newest/workflow");
+const workflow_5 = require("./concurrency_multiple_keys/workflow");
+const workflow_6 = require("./concurrency_workflow_level/workflow");
+const workflow_7 = require("./dag/workflow");
+const workflow_8 = require("./durable/workflow");
+const workflow_9 = require("./logger/workflow");
+const workflow_10 = require("./non_retryable/workflow");
+const workflow_11 = require("./on_failure/workflow");
+const workflow_12 = require("./on_event/workflow");
+const workflow_13 = require("./return_exceptions/workflow");
+const workflow_14 = require("./run_details/workflow");
+const e2e_workflows_1 = require("./simple/e2e-workflows");
+const workflow_15 = require("./streaming/workflow");
+const workflow_16 = require("./timeout/workflow");
+const workflow_17 = require("./webhooks/workflow");
+const workflows = [
+    workflow_1.bulkChild,
+    workflow_1.bulkParentWorkflow,
+    workflow_2.bulkReplayTest1,
+    workflow_2.bulkReplayTest2,
+    workflow_2.bulkReplayTest3,
+    cancellation_workflow_1.cancellationWorkflow,
+    complex_workflow_1.taskConditionWorkflow,
+    workflow_3.concurrencyCancelInProgressWorkflow,
+    workflow_4.concurrencyCancelNewestWorkflow,
+    workflow_5.concurrencyMultipleKeysWorkflow,
+    workflow_6.concurrencyWorkflowLevelWorkflow,
+    workflow_7.dag,
+    workflow_8.durableWorkflow,
+    workflow_8.waitForSleepTwice,
+    (0, workflow_9.createLoggingWorkflow)(hatchet_client_1.hatchet),
+    workflow_10.nonRetryableWorkflow,
+    workflow_11.failureWorkflow,
+    workflow_12.lower,
+    workflow_13.returnExceptionsTask,
+    workflow_14.runDetailTestWorkflow,
+    e2e_workflows_1.helloWorld,
+    e2e_workflows_1.helloWorldDurable,
+    workflow_15.streamingTask,
+    workflow_16.timeoutTask,
+    workflow_16.refreshTimeoutTask,
+    workflow_17.webhookWorkflow,
+];
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker = yield hatchet_client_1.hatchet.worker('e2e-test-worker', {
+            workflows,
+            slots: 100,
+        });
+        void worker.start();
+        yield worker.waitUntilReady(30000);
+        console.log('[e2e-worker] Worker registered and ready');
+        yield new Promise(() => { });
+    });
+}
+main().catch((err) => {
+    console.error('e2e-worker failed:', err);
+    process.exit(1);
+});

package/src/v1/examples/events/filter.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const hatchet_client_1 = require("../hatchet-client");
+const workflow_1 = require("./workflow");
+// > Create a filter
+hatchet_client_1.hatchet.filters.create({
+    workflowId: workflow_1.lower.name,
+    expression: 'input.ShouldSkip == false',
+    scope: 'foobarbaz',
+    payload: {
+        main_character: 'Anna',
+        supporting_character: 'Stiva',
+        location: 'Moscow',
+    },
+});
+// !!
+// > Skip a run
+hatchet_client_1.hatchet.events.push(workflow_1.SIMPLE_EVENT, {
+    Message: 'hello',
+    ShouldSkip: true,
+}, {
+    scope: 'foobarbaz',
+});
+// !!
+// > Trigger a run
+hatchet_client_1.hatchet.events.push(workflow_1.SIMPLE_EVENT, {
+    Message: 'hello',
+    ShouldSkip: false,
+}, {
+    scope: 'foobarbaz',
+});
+// !!

package/{v1 → src/v1}/examples/hatchet-client.d.ts

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

package/{v1 → src/v1}/examples/hatchet-client.js

@@ -2,6 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hatchet = void 0;
 // > Create client
-const v1_1 = require("./..");
+const v1_1 = require("../../../v1");
 exports.hatchet = v1_1.HatchetClient.init();
 // !!

package/{v1 → src/v1}/examples/high-memory/workflow-with-child.js

@@ -23,7 +23,7 @@ exports.child = hatchet_client_1.hatchet.task({
 });
 exports.parent = hatchet_client_1.hatchet.task({
     name: 'parent',
-    timeout: '10m',
+    executionTimeout: '10m',
     fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
         // lets generate large payload 1 mb
         const largePayload = new Array(1024 * 1024).fill('a').join('');

package/{v1 → src/v1}/examples/landing_page/durable-excution.js

@@ -10,7 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 /* eslint-disable @typescript-eslint/no-unused-vars */
-const conditions_1 = require("../../conditions");
+const conditions_1 = require("../../../../v1/conditions");
 const hatchet_client_1 = require("../hatchet-client");
 function main() {
     return __awaiter(this, void 0, void 0, function* () {

package/{v1 → src/v1}/examples/landing_page/flow-control.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.simple = void 0;
-const workflows_1 = require("../../../protoc/v1/workflows");
+const workflows_1 = require("../../../../protoc/v1/workflows");
 const hatchet_client_1 = require("../hatchet-client");
 // > Process what you can handle
 exports.simple = hatchet_client_1.hatchet.task({

package/src/v1/examples/legacy/workflow.d.ts

@@ -0,0 +1,2 @@
+import { Workflow } from '../../../../workflow';
+export declare const simple: Workflow;