@hatchet-dev/typescript-sdk 1.0.0-alpha1 → 1.0.0

package/v1/examples/on_success/workflow.js

@@ -0,0 +1,59 @@
+"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.onSuccessDag = exports.onSuccess = void 0;
+/* eslint-disable no-console */
+const hatchet_client_1 = require("../hatchet-client");
+// ❓ On Success Task
+exports.onSuccess = hatchet_client_1.hatchet.task({
+    name: 'run-on-success',
+    // 👀 onSuccess handler will run if the fn task succeeds
+    onSuccess: (_, ctx) => {
+        console.log('onSuccess for run:', ctx.workflowRunId());
+        return {
+            'on-success': 'success',
+        };
+    },
+    fn: () => __awaiter(void 0, void 0, void 0, function* () {
+        return {
+            'always-succeed': 'success',
+        };
+    }),
+});
+// !!
+// ❓ On Success DAG
+exports.onSuccessDag = hatchet_client_1.hatchet.workflow({
+    name: 'on-success-dag',
+    // 👀 onSuccess handler will run if all tasks in the workflow succeed
+    onSuccess: (_, ctx) => {
+        console.log('onSuccess for run:', ctx.workflowRunId());
+        return {
+            'on-success': 'success',
+        };
+    },
+});
+exports.onSuccessDag.task({
+    name: 'always-succeed',
+    fn: () => __awaiter(void 0, void 0, void 0, function* () {
+        return {
+            'always-succeed': 'success',
+        };
+    }),
+});
+exports.onSuccessDag.task({
+    name: 'always-succeed2',
+    fn: () => __awaiter(void 0, void 0, void 0, function* () {
+        return {
+            'always-succeed': 'success',
+        };
+    }),
+});
+// !!

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

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

package/v1/examples/retries/run.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 });
+/* eslint-disable no-console */
+const workflow_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const res = yield workflow_1.retries.run({});
+            console.log(res);
+        }
+        catch (e) {
+            console.log('error', e);
+        }
+    });
+}
+if (require.main === module) {
+    main()
+        .catch(console.error)
+        .finally(() => process.exit(0));
+}

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

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

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

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

@@ -0,0 +1,5 @@
+export declare const retries: import("../..").TaskWorkflowDeclaration<import("../../..").JsonObject, never>;
+export declare const retriesWithCount: import("../..").TaskWorkflowDeclaration<import("../../..").JsonObject, {
+    message: string;
+}>;
+export declare const withBackoff: import("../..").TaskWorkflowDeclaration<import("../../..").JsonObject, never>;

package/v1/examples/retries/workflow.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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withBackoff = exports.retriesWithCount = exports.retries = void 0;
+/* eslint-disable no-console */
+const hatchet_client_1 = require("../hatchet-client");
+// ❓ Simple Step Retries
+exports.retries = hatchet_client_1.hatchet.task({
+    name: 'retries',
+    retries: 3,
+    fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        throw new Error('intentional failure');
+    }),
+});
+// !!
+// ❓ Step Retries with Count
+exports.retriesWithCount = hatchet_client_1.hatchet.task({
+    name: 'retriesWithCount',
+    retries: 3,
+    fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        // ❓ Get the current retry count
+        const retryCount = ctx.retryCount();
+        console.log(`Retry count: ${retryCount}`);
+        if (retryCount < 2) {
+            throw new Error('intentional failure');
+        }
+        return {
+            message: 'success',
+        };
+    }),
+});
+// !!
+// ❓ Step Retries with Backoff
+exports.withBackoff = hatchet_client_1.hatchet.task({
+    name: 'withBackoff',
+    retries: 3,
+    backoff: {
+        factor: 2,
+        maxSeconds: 10,
+    },
+    fn: () => __awaiter(void 0, void 0, void 0, function* () {
+        throw new Error('intentional failure');
+    }),
+});
+// !!

package/v1/examples/simple/client-run.d.ts

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

package/v1/examples/simple/client-run.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// ❓ Client Run Methods
+const hatchet_client_1 = require("../hatchet-client");
+hatchet_client_1.hatchet.run('simple', { Message: 'Hello, World!' });
+hatchet_client_1.hatchet.runNoWait('simple', { Message: 'Hello, World!' }, {});
+hatchet_client_1.hatchet.schedule.create('simple', {
+    triggerAt: new Date(Date.now() + 1000 * 60 * 60 * 24),
+    input: { Message: 'Hello, World!' },
+});
+hatchet_client_1.hatchet.cron.create('simple', {
+    name: 'my-cron',
+    expression: '0 0 * * *',
+    input: { Message: 'Hello, World!' },
+});
+// !!

package/v1/examples/simple/cron.js

@@ -9,16 +9,20 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const client_1 = require("../client");
+const hatchet_client_1 = require("../hatchet-client");
 const workflow_1 = require("./workflow");
 function main() {
     return __awaiter(this, void 0, void 0, function* () {
+        // ❓ Create
         const cron = yield workflow_1.simple.cron('simple-daily', '0 0 * * *', {
             Message: 'hello',
         });
+        // it may be useful to save the cron id for later
+        const cronId = cron.metadata.id;
+        // !!
         // eslint-disable-next-line no-console
         console.log(cron.metadata.id);
-        yield client_1.hatchet.cron.delete(cron);
+        yield hatchet_client_1.hatchet.crons.delete(cron);
     });
 }
 if (require.main === module) {

package/v1/examples/simple/delay.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const client_1 = require("../client");
+const hatchet_client_1 = require("../hatchet-client");
 const workflow_1 = require("./workflow");
 function main() {
     return __awaiter(this, void 0, void 0, function* () {
@@ -19,7 +19,7 @@ function main() {
         });
         // eslint-disable-next-line no-console
         console.log(scheduled.metadata.id);
-        yield client_1.hatchet.schedule.delete(scheduled);
+        yield hatchet_client_1.hatchet.schedules.delete(scheduled);
     });
 }
 if (require.main === module) {

package/v1/examples/simple/enqueue.d.ts

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

package/v1/examples/simple/enqueue.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 });
+/* eslint-disable import/no-duplicates */
+/* eslint-disable no-console */
+const hatchet_client_1 = require("../hatchet-client");
+// ❓ Enqueuing a Workflow (Fire and Forget)
+const workflow_1 = require("./workflow");
+// ...
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // 👀 Enqueue the workflow
+        const run = yield workflow_1.simple.runNoWait({
+            Message: 'hello',
+        });
+        // 👀 Get the run ID of the workflow
+        const runId = yield run.getWorkflowRunId();
+        // It may be helpful to store the run ID of the workflow
+        // in a database or other persistent storage for later use
+        console.log(runId);
+        // !!
+        // ❓ Subscribing to results
+        // the return object of the enqueue method is a WorkflowRunRef which includes a listener for the result of the workflow
+        const result = yield run.result();
+        console.log(result);
+        // if you need to subscribe to the result of the workflow at a later time, you can use the runRef method and the stored runId
+        const ref = hatchet_client_1.hatchet.runRef(runId);
+        const result2 = yield ref.result();
+        console.log(result2);
+        // !!
+    });
+}
+if (require.main === module) {
+    main();
+}

package/v1/examples/simple/run.js

@@ -9,14 +9,19 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-console */
+// ❓ Running a Workflow with Results
 const workflow_1 = require("./workflow");
+// ...
 function main() {
     return __awaiter(this, void 0, void 0, function* () {
+        // 👀 Run the workflow with results
         const res = yield workflow_1.simple.run({
-            Message: 'hello',
+            Message: 'HeLlO WoRlD',
         });
-        // eslint-disable-next-line no-console
-        console.log(res.step2);
+        // 👀 Access the results of the workflow
+        console.log(res.TransformedMessage);
+        // !!
     });
 }
 if (require.main === module) {

package/v1/examples/simple/schedule.js

@@ -9,17 +9,23 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const client_1 = require("../client");
+/* 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* () {
-        const runAt = new Date(Date.now() + 1000 * 60 * 60 * 24);
+        // ❓ Create a Scheduled Run
+        const runAt = new Date(new Date().setHours(12, 0, 0, 0) + 24 * 60 * 60 * 1000);
         const scheduled = yield workflow_1.simple.schedule(runAt, {
             Message: 'hello',
         });
-        // eslint-disable-next-line no-console
-        console.log(scheduled.metadata.id);
-        yield client_1.hatchet.schedule.delete(scheduled);
+        // 👀 Get the scheduled run ID of the workflow
+        // it may be helpful to store the scheduled run ID of the workflow
+        // in a database or other persistent storage for later use
+        const scheduledRunId = scheduled.metadata.id;
+        console.log(scheduledRunId);
+        // !!
+        yield hatchet_client_1.hatchet.schedules.delete(scheduled);
     });
 }
 if (require.main === module) {

package/v1/examples/simple/stub-workflow.d.ts

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

package/v1/examples/simple/stub-workflow.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simple = void 0;
+// ❓ Declaring an External Workflow Reference
+const hatchet_client_1 = require("../hatchet-client");
+// declare the workflow with the same name as the
+// workflow name on the worker
+exports.simple = hatchet_client_1.hatchet.workflow({
+    name: 'simple',
+});
+// you can use all the same run methods on the stub
+// with full type-safety
+exports.simple.run({ Message: 'Hello, World!' });
+exports.simple.runNoWait({ Message: 'Hello, World!' });
+exports.simple.schedule(new Date(), { Message: 'Hello, World!' });
+exports.simple.cron('my-cron', '0 0 * * *', { Message: 'Hello, World!' });
+// !!

package/v1/examples/simple/worker.js

@@ -9,12 +9,16 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const client_1 = require("../client");
+// ❓ Declaring a Worker
+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 client_1.hatchet.worker('simple-worker', {
+        const worker = yield hatchet_client_1.hatchet.worker('simple-worker', {
+            // 👀 Declare the workflows that the worker can execute
             workflows: [workflow_1.simple],
+            // 👀 Declare the number of concurrent task runs the worker can accept
+            slots: 100,
         });
         yield worker.start();
     });
@@ -22,3 +26,4 @@ function main() {
 if (require.main === module) {
     main();
 }
+// !!

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

@@ -1,5 +1,6 @@
-type SimpleInput = {
+export type SimpleInput = {
     Message: string;
 };
-export declare const simple: import("../../workflow").WorkflowDeclaration<SimpleInput, any>;
-export {};
+export declare const simple: import("../..").TaskWorkflowDeclaration<SimpleInput, {
+    TransformedMessage: string;
+}>;

package/v1/examples/simple/workflow.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.simple = void 0;
-const client_1 = require("../client");
-exports.simple = client_1.hatchet.workflow({
+// ❓ Declaring a Task
+const hatchet_client_1 = require("../hatchet-client");
+exports.simple = hatchet_client_1.hatchet.task({
     name: 'simple',
-});
-exports.simple.task({
-    name: 'to-lower',
     fn: (input) => {
         return {
             TransformedMessage: input.Message.toLowerCase(),
         };
     },
 });
+// !!
+// see ./worker.ts and ./run.ts for how to run the workflow

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

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

package/v1/examples/sticky/run.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 });
+/* eslint-disable no-console */
+const workflow_1 = require("../retries/workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const res = yield workflow_1.retries.run({});
+            console.log(res);
+        }
+        catch (e) {
+            console.log('error', e);
+        }
+    });
+}
+if (require.main === module) {
+    main()
+        .catch(console.error)
+        .finally(() => process.exit(0));
+}

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

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

package/v1/examples/sticky/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("../retries/workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker = yield hatchet_client_1.hatchet.worker('always-fail-worker', {
+            workflows: [workflow_1.retries],
+        });
+        yield worker.start();
+    });
+}
+if (require.main === module) {
+    main();
+}

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

@@ -0,0 +1,7 @@
+export declare const sticky: import("../..").TaskWorkflowDeclaration<import("../../..").JsonObject, {
+    result: {
+        value: {
+            Value: number;
+        };
+    };
+}>;

package/v1/examples/sticky/workflow.js

@@ -0,0 +1,32 @@
+"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.sticky = void 0;
+/* eslint-disable no-console */
+const workflows_1 = require("../../../protoc/workflows");
+const hatchet_client_1 = require("../hatchet-client");
+const workflow_1 = require("../child_workflows/workflow");
+// ❓ Sticky Task
+exports.sticky = hatchet_client_1.hatchet.task({
+    name: 'sticky',
+    retries: 3,
+    sticky: workflows_1.StickyStrategy.SOFT,
+    fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        // specify a child workflow to run on the same worker
+        const result = yield ctx.runChild(workflow_1.child, {
+            N: 1,
+        }, { sticky: true });
+        return {
+            result,
+        };
+    }),
+});
+// !!

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

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

package/v1/examples/with_timeouts/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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.refreshTimeout = exports.withTimeouts = void 0;
+// ❓ Declaring a Task
+const sleep_1 = __importDefault(require("../../../util/sleep"));
+const hatchet_client_1 = require("../hatchet-client");
+// ❓ Execution Timeout
+exports.withTimeouts = hatchet_client_1.hatchet.task({
+    name: 'with-timeouts',
+    // time the task can wait in the queue before it is cancelled
+    scheduleTimeout: '10s',
+    // time the task can run before it is cancelled
+    executionTimeout: '10s',
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        // wait 15 seconds
+        yield (0, sleep_1.default)(15000);
+        // get the abort controller
+        const { controller } = ctx;
+        // if the abort controller is aborted, throw an error
+        if (controller.signal.aborted) {
+            throw new Error('cancelled');
+        }
+        return {
+            TransformedMessage: input.Message.toLowerCase(),
+        };
+    }),
+});
+// !!
+// ❓ Refresh Timeout
+exports.refreshTimeout = hatchet_client_1.hatchet.task({
+    name: 'refresh-timeout',
+    executionTimeout: '10s',
+    scheduleTimeout: '10s',
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        // adds 15 seconds to the execution timeout
+        ctx.refreshTimeout('15s');
+        yield (0, sleep_1.default)(15000);
+        // get the abort controller
+        const { controller } = ctx;
+        // now this condition will not be met
+        // if the abort controller is aborted, throw an error
+        if (controller.signal.aborted) {
+            throw new Error('cancelled');
+        }
+        return {
+            TransformedMessage: input.Message.toLowerCase(),
+        };
+    }),
+});
+// !!

package/v1/index.d.ts

@@ -0,0 +1,5 @@
+export * from './client/client';
+export * from './client/features';
+export * from './client/worker';
+export * from './declaration';
+export * from './conditions';

package/v1/index.js

@@ -1 +1,21 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./client/client"), exports);
+__exportStar(require("./client/features"), exports);
+__exportStar(require("./client/worker"), exports);
+__exportStar(require("./declaration"), exports);
+__exportStar(require("./conditions"), exports);