@hatchet-dev/typescript-sdk 1.13.1 → 1.15.0

package/{examples → src/v1/examples/logger}/byo-logger.js

@@ -14,7 +14,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 // eslint-disable-next-line import/no-extraneous-dependencies
 const pino_1 = __importDefault(require("pino"));
-const sdk_1 = __importDefault(require("../sdk"));
+const sdk_1 = __importDefault(require("../../../../sdk"));
 // > Create Pino logger
 const logger = (0, pino_1.default)();
 class PinoLogger {

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

@@ -0,0 +1,2 @@
+import type { HatchetClient } from '../../../../v1';
+export declare function createLoggingWorkflow(client: HatchetClient): import("../../../../v1").WorkflowDeclaration<import("../../../../v1").UnknownInputType, {}, {}>;

package/src/v1/examples/logger/workflow.js

@@ -0,0 +1,38 @@
+"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.createLoggingWorkflow = createLoggingWorkflow;
+function createLoggingWorkflow(client) {
+    const wf = client.workflow({ name: 'logging-workflow' });
+    wf.task({
+        name: 'root_logger',
+        fn: () => __awaiter(this, void 0, void 0, function* () {
+            for (let i = 0; i < 12; i += 1) {
+                console.info(`executed step1 - ${i}`);
+                console.info({ step1: 'step1' });
+                // keep this fast for e2e
+            }
+            return { status: 'success' };
+        }),
+    });
+    wf.task({
+        name: 'context_logger',
+        fn: (_input, ctx) => __awaiter(this, void 0, void 0, function* () {
+            for (let i = 0; i < 12; i += 1) {
+                // Python uses ctx.log; TS has both ctx.log (deprecated) and ctx.logger.*
+                yield ctx.log(`executed step1 - ${i}`);
+                yield ctx.log(JSON.stringify({ step1: 'step1' }));
+            }
+            return { status: 'success' };
+        }),
+    });
+    return wf;
+}

package/src/v1/examples/logging/byo-logger.js

@@ -0,0 +1,73 @@
+"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-next-line import/no-extraneous-dependencies
+const pino_1 = __importDefault(require("pino"));
+const sdk_1 = __importDefault(require("../../../../sdk"));
+// > Create Pino logger
+const logger = (0, pino_1.default)();
+class PinoLogger {
+    constructor(context, logLevel = 'DEBUG') {
+        this.logLevel = logLevel;
+        this.context = context;
+    }
+    debug(message, extra) {
+        logger.debug(extra, message);
+    }
+    info(message, extra) {
+        logger.info(extra, message);
+    }
+    green(message, extra) {
+        logger.info(extra, `%c${message}`);
+    }
+    warn(message, error, extra) {
+        logger.warn(extra, `${message} ${error}`);
+    }
+    error(message, error, extra) {
+        logger.error(extra, `${message} ${error}`);
+    }
+    // optional util method
+    util(key, message, extra) {
+        // for example you may want to expose a trace method
+        if (key === 'trace') {
+            logger.info(extra, 'trace');
+        }
+    }
+}
+const hatchet = sdk_1.default.init({
+    log_level: 'DEBUG',
+    logger: (ctx, level) => new PinoLogger(ctx, level),
+});
+// !!
+// > Use the logger
+const workflow = hatchet.task({
+    name: 'byo-logger-example',
+    fn: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        // eslint-disable-next-line no-plusplus
+        for (let i = 0; i < 5; i++) {
+            logger.info(`log message ${i}`);
+        }
+        return { step1: 'completed step run' };
+    }),
+});
+// !!
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker = yield hatchet.worker('byo-logger-worker', {
+            workflows: [workflow],
+        });
+        worker.start();
+    });
+}
+main();

package/src/v1/examples/logging/logger.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 });
+const hatchet_client_1 = require("../hatchet-client");
+const sleep = (ms) => new Promise((resolve) => {
+    setTimeout(resolve, ms);
+});
+// > Logger
+const workflow = hatchet_client_1.hatchet.workflow({
+    name: 'logger-example',
+    description: 'test',
+    on: {
+        event: 'user:create',
+    },
+});
+workflow.task({
+    name: 'logger-step1',
+    fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        // log in a for loop
+        // eslint-disable-next-line no-plusplus
+        for (let i = 0; i < 10; i++) {
+            ctx.logger.info(`log message ${i}`);
+            yield sleep(200);
+        }
+        return { step1: 'completed step run' };
+    }),
+});
+// !!
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker = yield hatchet_client_1.hatchet.worker('logger-worker', {
+            slots: 1,
+            workflows: [workflow],
+        });
+        yield worker.start();
+    });
+}
+main();

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

@@ -1,4 +1,4 @@
-import { HatchetClient } from '../..';
+import { HatchetClient } from '../../../../v1';
 export type GlobalInputType = {
     first: number;
     second: number;

package/{v1 → src/v1}/examples/middleware/client.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hatchetWithMiddlewareChaining = exports.hatchetWithMiddleware = void 0;
 // > Init a client with middleware
-const v1_1 = require("../..");
+const v1_1 = require("../../../../v1");
 const myMiddleware = {
     before: (input, ctx) => {
         console.log('before', input.first);

package/{v1 → src/v1}/examples/middleware/recipes.js

@@ -14,7 +14,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 // > End-to-end encryption
-const v1_1 = require("../..");
+const v1_1 = require("../../../../v1");
 const crypto_1 = require("crypto");
 // !!
 // > Offloading large payloads to S3

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

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

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

@@ -4,5 +4,5 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hatchet = void 0;
-const sdk_1 = __importDefault(require("../../../sdk"));
+const sdk_1 = __importDefault(require("../../../../sdk"));
 exports.hatchet = sdk_1.default.init();

package/{v1 → src/v1}/examples/multiple_wf_concurrency/workflow.d.ts

@@ -7,5 +7,5 @@ type SimpleOutput = {
         TransformedMessage: string;
     };
 };
-export declare const multiConcurrency: import("../..").WorkflowDeclaration<SimpleInput, SimpleOutput, {}>;
+export declare const multiConcurrency: import("../../../../v1").WorkflowDeclaration<SimpleInput, SimpleOutput, {}>;
 export {};

package/{v1 → src/v1}/examples/multiple_wf_concurrency/workflow.js

@@ -10,7 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.multiConcurrency = void 0;
-const workflow_1 = require("../../../workflow");
+const v1_1 = require("../../../../v1");
 const hatchet_client_1 = require("../hatchet-client");
 const sleep = (ms) => new Promise((resolve) => {
     setTimeout(resolve, ms);
@@ -21,12 +21,12 @@ exports.multiConcurrency = hatchet_client_1.hatchet.workflow({
     concurrency: [
         {
             maxRuns: 1,
-            limitStrategy: workflow_1.ConcurrencyLimitStrategy.GROUP_ROUND_ROBIN,
+            limitStrategy: v1_1.ConcurrencyLimitStrategy.GROUP_ROUND_ROBIN,
             expression: 'input.GroupKey',
         },
         {
             maxRuns: 1,
-            limitStrategy: workflow_1.ConcurrencyLimitStrategy.GROUP_ROUND_ROBIN,
+            limitStrategy: v1_1.ConcurrencyLimitStrategy.GROUP_ROUND_ROBIN,
             expression: 'input.UserId',
         },
     ],

package/{v1 → src/v1}/examples/non_retryable/workflow.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.nonRetryableWorkflow = void 0;
-const task_1 = require("../../task");
+const task_1 = require("../../../../v1/task");
 const hatchet_client_1 = require("../hatchet-client");
 exports.nonRetryableWorkflow = hatchet_client_1.hatchet.workflow({
     name: 'no-retry-workflow',

package/src/v1/examples/on_event/event.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 });
+const hatchet_client_1 = require("../hatchet-client");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // > Pushing an Event
+        const res = yield hatchet_client_1.hatchet.events.push('simple-event:create', {
+            Message: 'hello',
+            ShouldSkip: false,
+        });
+        // !!
+        // > Push an Event with Metadata
+        const withMetadata = yield hatchet_client_1.hatchet.events.push('user:create', {
+            test: 'test',
+        }, {
+            additionalMetadata: {
+                source: 'api', // Arbitrary key-value pair
+            },
+        });
+        // !!
+        // > Bulk push events
+        const events = [
+            {
+                payload: { test: 'test1' },
+                additionalMetadata: { user_id: 'user1', source: 'test' },
+            },
+            {
+                payload: { test: 'test2' },
+                additionalMetadata: { user_id: 'user2', source: 'test' },
+            },
+            {
+                payload: { test: 'test3' },
+                additionalMetadata: { user_id: 'user3', source: 'test' },
+            },
+        ];
+        yield hatchet_client_1.hatchet.events.bulkPush('user:create', events);
+        // !!
+        // eslint-disable-next-line no-console
+        console.log(res.eventId);
+    });
+}
+if (require.main === module) {
+    main();
+}

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

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

@@ -0,0 +1,19 @@
+export type Input = {
+    Message: string;
+    ShouldSkip: boolean;
+};
+export declare const SIMPLE_EVENT = "simple-event:create";
+type LowerOutput = {
+    lower: {
+        TransformedMessage: string;
+    };
+};
+export declare const lower: import("../..").WorkflowDeclaration<Input, LowerOutput, {}>;
+export declare const lowerWithFilter: import("../..").WorkflowDeclaration<Input, LowerOutput, {}>;
+type UpperOutput = {
+    upper: {
+        TransformedMessage: string;
+    };
+};
+export declare const upper: import("../..").WorkflowDeclaration<Input, UpperOutput, {}>;
+export {};

package/src/v1/examples/on_event/workflow.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upper = exports.lowerWithFilter = exports.lower = exports.SIMPLE_EVENT = void 0;
+const hatchet_client_1 = require("../hatchet-client");
+exports.SIMPLE_EVENT = 'simple-event:create';
+// > Run workflow on event
+exports.lower = hatchet_client_1.hatchet.workflow({
+    name: 'lower',
+    // 👀 Declare the event that will trigger the workflow
+    onEvents: ['simple-event:create'],
+});
+// !!
+// > Workflow with filter
+exports.lowerWithFilter = hatchet_client_1.hatchet.workflow({
+    name: 'lower',
+    // 👀 Declare the event that will trigger the workflow
+    onEvents: ['simple-event:create'],
+    defaultFilters: [
+        {
+            expression: 'true',
+            scope: 'example-scope',
+            payload: {
+                mainCharacter: 'Anna',
+                supportingCharacter: 'Stiva',
+                location: 'Moscow',
+            },
+        },
+    ],
+});
+// !!
+exports.lower.task({
+    name: 'lower',
+    fn: (input) => {
+        return {
+            TransformedMessage: input.Message.toLowerCase(),
+        };
+    },
+});
+exports.upper = hatchet_client_1.hatchet.workflow({
+    name: 'upper',
+    on: {
+        event: exports.SIMPLE_EVENT,
+    },
+});
+exports.upper.task({
+    name: 'upper',
+    fn: (input) => {
+        return {
+            TransformedMessage: input.Message.toUpperCase(),
+        };
+    },
+});
+// > Accessing the filter payload
+exports.lowerWithFilter.task({
+    name: 'lowerWithFilter',
+    fn: (input, ctx) => {
+        console.log(ctx.filterPayload());
+    },
+});
+// !!

package/{v1 → src/v1}/examples/on_failure/workflow.d.ts

@@ -1 +1,2 @@
+export declare const ERROR_TEXT = "step1 failed";
 export declare const failureWorkflow: import("../..").WorkflowDeclaration<import("../..").UnknownInputType, {}, {}>;

package/{v1 → src/v1}/examples/on_failure/workflow.js

@@ -9,25 +9,30 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.failureWorkflow = void 0;
+exports.failureWorkflow = exports.ERROR_TEXT = void 0;
 /* eslint-disable no-console */
 const hatchet_client_1 = require("../hatchet-client");
+exports.ERROR_TEXT = 'step1 failed';
 // > On Failure Task
+// This workflow will fail because `step1` throws. We define an `onFailure` handler to run cleanup.
 exports.failureWorkflow = hatchet_client_1.hatchet.workflow({
-    name: 'always-fail',
+    name: 'on-failure-workflow',
 });
 exports.failureWorkflow.task({
-    name: 'always-fail',
+    name: 'step1',
+    executionTimeout: '1s',
     fn: () => __awaiter(void 0, void 0, void 0, function* () {
-        throw new Error('intentional failure');
+        throw new Error(exports.ERROR_TEXT);
     }),
 });
+// 👀 After the workflow fails, this special step will run
 exports.failureWorkflow.onFailure({
-    name: 'on-failure',
-    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+    name: 'on_failure',
+    fn: (_input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
         console.log('onFailure for run:', ctx.workflowRunId());
+        console.log('upstream errors:', ctx.errors());
         return {
-            'on-failure': 'success',
+            status: 'success',
         };
     }),
 });

package/{v1 → src/v1}/examples/priority/run.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const v1_1 = require("../..");
+const v1_1 = require("../../../../v1");
 const workflow_1 = require("./workflow");
 /* eslint-disable no-console */
 function main() {

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

@@ -0,0 +1,8 @@
+import { Priority } from '../../../../v1';
+export declare const priority: import("../../../../v1").TaskWorkflowDeclaration<import("../../../../v1").UnknownInputType, {
+    priority: Priority | undefined;
+}, {}, {}, {}, {}>;
+export declare const priorityWf: import("../../../../v1").WorkflowDeclaration<import("../../../../v1").UnknownInputType, {}, {}>;
+export declare const priorityTasks: (import("../../../../v1").WorkflowDeclaration<import("../../../../v1").UnknownInputType, {}, {}> | import("../../../../v1").TaskWorkflowDeclaration<import("../../../../v1").UnknownInputType, {
+    priority: Priority | undefined;
+}, {}, {}, {}, {}>)[];

package/{v1 → src/v1}/examples/priority/workflow.js

@@ -11,7 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.priorityTasks = exports.priorityWf = exports.priority = void 0;
 /* eslint-disable no-console */
-const v1_1 = require("../..");
+const v1_1 = require("../../../../v1");
 const hatchet_client_1 = require("../hatchet-client");
 // > Simple Task Priority
 exports.priority = hatchet_client_1.hatchet.task({
@@ -26,7 +26,7 @@ exports.priority = hatchet_client_1.hatchet.task({
 // !!
 // > Task Priority in a Workflow
 exports.priorityWf = hatchet_client_1.hatchet.workflow({
-    name: 'priorityWf',
+    name: 'priority-wf',
     defaultPriority: v1_1.Priority.LOW,
 });
 // !!

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

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

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

@@ -4,6 +4,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hatchet = void 0;
-const sdk_1 = __importDefault(require("../../../sdk"));
+const sdk_1 = __importDefault(require("../../../../sdk"));
 // HH-client 1 Client
 exports.hatchet = sdk_1.default.init();

package/src/v1/examples/quickstart/run.d.ts

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

package/src/v1/examples/quickstart/worker.d.ts

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

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

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

package/{v1 → src/v1}/examples/rate_limit/workflow.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const workflows_1 = require("../../../protoc/v1/workflows");
+const workflows_1 = require("../../../../protoc/v1/workflows");
 const hatchet_client_1 = require("../hatchet-client");
 // > Upsert Rate Limit
 hatchet_client_1.hatchet.ratelimits.upsert({

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

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

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

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

package/{v1 → src/v1}/examples/retries/workflow.js

@@ -23,7 +23,7 @@ exports.retries = hatchet_client_1.hatchet.task({
 // !!
 // > Retries with Count
 exports.retriesWithCount = hatchet_client_1.hatchet.task({
-    name: 'retriesWithCount',
+    name: 'retries-with-count',
     retries: 3,
     fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
         // > Get the current retry count
@@ -40,7 +40,7 @@ exports.retriesWithCount = hatchet_client_1.hatchet.task({
 // !!
 // > Retries with Backoff
 exports.withBackoff = hatchet_client_1.hatchet.task({
-    name: 'withBackoff',
+    name: 'with-backoff',
     retries: 10,
     backoff: {
         // 👀 Maximum number of seconds to wait between retries

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

@@ -0,0 +1,6 @@
+export type ReturnExceptionsInput = {
+    index: number;
+};
+export declare const returnExceptionsTask: import("../..").TaskWorkflowDeclaration<ReturnExceptionsInput, {
+    message: string;
+}, {}, {}, {}, {}>;

package/src/v1/examples/return_exceptions/workflow.js

@@ -0,0 +1,22 @@
+"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.returnExceptionsTask = void 0;
+const hatchet_client_1 = require("../hatchet-client");
+exports.returnExceptionsTask = hatchet_client_1.hatchet.task({
+    name: 'return-exceptions-task',
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () {
+        if (input.index % 2 === 0) {
+            throw new Error(`error in task with index ${input.index}`);
+        }
+        return { message: 'this is a successful task.' };
+    }),
+});

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

@@ -0,0 +1,4 @@
+export type MockInput = {
+    foo: string;
+};
+export declare const runDetailTestWorkflow: import("../..").WorkflowDeclaration<MockInput, {}, {}>;