@hatchet-dev/typescript-sdk 1.9.4 → 1.9.6

package/clients/worker/worker.d.ts

@@ -39,7 +39,7 @@ export declare class V0Worker {
     });
     private registerActions;
     getHandler(workflows: Workflow[]): WebhookHandler;
-    registerWebhook(webhook: WebhookWorkerCreateRequest): Promise<import("axios").AxiosResponse<import("../rest/generated/data-contracts").WebhookWorkerCreated, any>>;
+    registerWebhook(webhook: WebhookWorkerCreateRequest): Promise<import("axios").AxiosResponse<import("../rest/generated/data-contracts").WebhookWorkerCreated, any, {}>>;
     /**
      * @deprecated use registerWorkflow instead
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "1.9.4",
+  "version": "1.9.6",
   "description": "Background task orchestration & visibility for developers",
   "types": "dist/index.d.ts",
   "files": [

package/v1/client/features/runs.d.ts

@@ -68,8 +68,8 @@ export declare class RunsClient {
     get<T = any>(run: string | WorkflowRunRef<T>): Promise<import("../../../clients/rest/generated/data-contracts").V1WorkflowRunDetails>;
     get_status<T = any>(run: string | WorkflowRunRef<T>): Promise<V1TaskStatus>;
     list(opts?: Partial<ListRunsOpts>): Promise<import("../../../clients/rest/generated/data-contracts").V1TaskSummaryList>;
-    cancel(opts: CancelRunOpts): Promise<import("axios").AxiosResponse<import("../../../clients/rest/generated/data-contracts").V1CancelledTasks, any>>;
-    replay(opts: ReplayRunOpts): Promise<import("axios").AxiosResponse<import("../../../clients/rest/generated/data-contracts").V1ReplayedTasks, any>>;
+    cancel(opts: CancelRunOpts): Promise<import("axios").AxiosResponse<import("../../../clients/rest/generated/data-contracts").V1CancelledTasks, any, {}>>;
+    replay(opts: ReplayRunOpts): Promise<import("axios").AxiosResponse<import("../../../clients/rest/generated/data-contracts").V1ReplayedTasks, any, {}>>;
     private prepareFilter;
     private prepareListFilter;
     runRef<T extends Record<string, any> = any>(id: string): WorkflowRunRef<T>;

package/v1/client/worker/worker-internal.d.ts

@@ -38,7 +38,7 @@ export declare class V1Worker {
     });
     private registerActions;
     getHandler(workflows: Workflow[]): void;
-    registerWebhook(webhook: WebhookWorkerCreateRequest): Promise<import("axios").AxiosResponse<import("../../../clients/rest/generated/data-contracts").WebhookWorkerCreated, any>>;
+    registerWebhook(webhook: WebhookWorkerCreateRequest): Promise<import("axios").AxiosResponse<import("../../../clients/rest/generated/data-contracts").WebhookWorkerCreated, any, {}>>;
     /**
      * @deprecated use registerWorkflow instead
      */

package/v1/client/worker/worker-internal.js

@@ -92,14 +92,18 @@ class V1Worker {
         });
     }
     registerDurableActionsV1(workflow) {
-        const newActions = workflow._durableTasks.reduce((acc, task) => {
+        const newActions = workflow._durableTasks
+            .filter((task) => !!task.fn)
+            .reduce((acc, task) => {
             acc[`${(0, apply_namespace_1.applyNamespace)(workflow.name, this.client.config.namespace).toLowerCase()}:${task.name.toLowerCase()}`] = (ctx) => task.fn(ctx.input, ctx);
             return acc;
         }, {});
         this.action_registry = Object.assign(Object.assign({}, this.action_registry), newActions);
     }
     registerActionsV1(workflow) {
-        const newActions = workflow._tasks.reduce((acc, task) => {
+        const newActions = workflow._tasks
+            .filter((task) => !!task.fn)
+            .reduce((acc, task) => {
             acc[`${workflow.name}:${task.name.toLowerCase()}`] = (ctx) => task.fn(ctx.input, ctx);
             return acc;
         }, {});

package/v1/client/worker/worker.d.ts

@@ -85,7 +85,7 @@ export declare class Worker {
      * @param webhook - The webhook to register
      * @returns A promise that resolves when the webhook is registered
      */
-    registerWebhook(webhook: WebhookWorkerCreateRequest): Promise<import("axios").AxiosResponse<import("../../../clients/rest/generated/data-contracts").WebhookWorkerCreated, any>>;
+    registerWebhook(webhook: WebhookWorkerCreateRequest): Promise<import("axios").AxiosResponse<import("../../../clients/rest/generated/data-contracts").WebhookWorkerCreated, any, {}>>;
     isPaused(): Promise<boolean>;
     pause(): Promise<any[]>;
     unpause(): Promise<any[]>;

package/v1/declaration.d.ts

@@ -295,7 +295,7 @@ export declare class WorkflowDeclaration<I extends InputType = UnknownInputType,
      */
     task<Name extends string, Fn extends Name extends keyof O ? (input: I, ctx: Context<I>) => O[Name] extends OutputType ? O[Name] | Promise<O[Name]> : void : (input: I, ctx: Context<I>) => void, FnReturn = ReturnType<Fn> extends Promise<infer P> ? P : ReturnType<Fn>, TO extends OutputType = Name extends keyof O ? O[Name] extends OutputType ? O[Name] : never : FnReturn extends OutputType ? FnReturn : never>(options: (Omit<CreateWorkflowTaskOpts<I, TO>, 'fn'> & {
         name: Name;
-        fn: Fn;
+        fn?: Fn;
     }) | TaskWorkflowDeclaration<I, TO>): CreateWorkflowTaskOpts<I, TO>;
     /**
      * Adds an onFailure task to the workflow.

package/v1/examples/affinity/affinity-workers.d.ts

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

package/v1/examples/affinity/affinity-workers.js

@@ -0,0 +1,89 @@
+"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 workflows_1 = require("../../../protoc/workflows");
+const hatchet_client_1 = require("../hatchet-client");
+// > AffinityWorkflow
+const workflow = hatchet_client_1.hatchet.workflow({
+    name: 'affinity-workflow',
+    description: 'test',
+});
+workflow.task({
+    name: 'step1',
+    fn: (_, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const results = [];
+        // eslint-disable-next-line no-plusplus
+        for (let i = 0; i < 50; i++) {
+            const result = yield ctx.spawnWorkflow(childWorkflow.id, {});
+            results.push(result.output);
+        }
+        console.log('Spawned 50 child workflows');
+        console.log('Results:', yield Promise.all(results));
+        return { step1: 'step1 results!' };
+    }),
+});
+// !!
+// > Task with labels
+const childWorkflow = hatchet_client_1.hatchet.workflow({
+    name: 'child-affinity-workflow',
+    description: 'test',
+});
+childWorkflow.task({
+    name: 'child-step1',
+    desiredWorkerLabels: {
+        model: {
+            value: 'xyz',
+            required: true,
+        },
+    },
+    fn: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        return { childStep1: 'childStep1 results!' };
+    }),
+});
+// !!
+childWorkflow.task({
+    name: 'child-step2',
+    desiredWorkerLabels: {
+        memory: {
+            value: 512,
+            required: true,
+            comparator: workflows_1.WorkerLabelComparator.LESS_THAN,
+        },
+    },
+    fn: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        return { childStep2: 'childStep2 results!' };
+    }),
+});
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // > AffinityWorker
+        const worker1 = yield hatchet_client_1.hatchet.worker('affinity-worker-1', {
+            labels: {
+                model: 'abc',
+                memory: 1024,
+            },
+        });
+        // !!
+        yield worker1.registerWorkflow(workflow);
+        yield worker1.registerWorkflow(childWorkflow);
+        worker1.start();
+        const worker2 = yield hatchet_client_1.hatchet.worker('affinity-worker-2', {
+            labels: {
+                model: 'xyz',
+                memory: 512,
+            },
+        });
+        yield worker2.registerWorkflow(workflow);
+        yield worker2.registerWorkflow(childWorkflow);
+        worker2.start();
+    });
+}
+main();

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

@@ -10,4 +10,10 @@ type ParentInput = {
 export declare const parent: import("../..").TaskWorkflowDeclaration<ParentInput, {
     Result: number;
 }>;
+export declare const parentSingleChild: import("../..").TaskWorkflowDeclaration<import("../..").UnknownInputType, {
+    Result: number;
+}>;
+export declare const withErrorHandling: import("../..").TaskWorkflowDeclaration<import("../..").UnknownInputType, {
+    Result: number;
+}>;
 export {};

package/v1/examples/child_workflows/workflow.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parent = exports.child = void 0;
+exports.withErrorHandling = exports.parentSingleChild = exports.parent = exports.child = void 0;
 /* eslint-disable no-plusplus */
 // > Declaring a Child
 const hatchet_client_1 = require("../hatchet-client");
@@ -37,3 +37,33 @@ exports.parent = hatchet_client_1.hatchet.task({
     }),
 });
 // !!
+// > Parent with Single Child
+exports.parentSingleChild = hatchet_client_1.hatchet.task({
+    name: 'parent-single-child',
+    fn: () => __awaiter(void 0, void 0, void 0, function* () {
+        const childRes = yield exports.child.run({ N: 1 });
+        return {
+            Result: childRes.Value,
+        };
+    }),
+});
+// !!
+// > Parent with Error Handling
+exports.withErrorHandling = hatchet_client_1.hatchet.task({
+    name: 'parent-error-handling',
+    fn: () => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            const childRes = yield exports.child.run({ N: 1 });
+            return {
+                Result: childRes.Value,
+            };
+        }
+        catch (error) {
+            // decide how to proceed here
+            return {
+                Result: -1,
+            };
+        }
+    }),
+});
+// !!

package/v1/examples/dag/run.js

@@ -12,9 +12,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const workflow_1 = require("./workflow");
 function main() {
     return __awaiter(this, void 0, void 0, function* () {
+        // > Run the workflow
         const res = yield workflow_1.dag.run({
             Message: 'hello world',
         });
+        // !!
         // eslint-disable-next-line no-console
         console.log(res.reverse.Transformed);
     });

package/v1/examples/dag/workflow.js

@@ -11,11 +11,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dag = void 0;
 const hatchet_client_1 = require("../hatchet-client");
+// !!
 // > Declaring a DAG Workflow
 // First, we declare the workflow
 exports.dag = hatchet_client_1.hatchet.workflow({
     name: 'simple',
 });
+// !!
+// > First task
 // Next, we declare the tasks bound to the workflow
 const toLower = exports.dag.task({
     name: 'to-lower',
@@ -25,7 +28,8 @@ const toLower = exports.dag.task({
         };
     },
 });
-// Next, we declare the tasks bound to the workflow
+// !!
+// > Second task with parent
 exports.dag.task({
     name: 'reverse',
     parents: [toLower],
@@ -38,3 +42,16 @@ exports.dag.task({
     }),
 });
 // !!
+// > Accessing Parent Outputs
+exports.dag.task({
+    name: 'task-with-parent-output',
+    parents: [toLower],
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const lower = yield ctx.parentOutput(toLower);
+        return {
+            Original: input.Message,
+            Transformed: lower.TransformedMessage.split('').reverse().join(''),
+        };
+    }),
+});
+// !!

package/v1/examples/hatchet-client.js

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

package/v1/examples/logging/byo-logger.d.ts

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

package/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/v1/examples/logging/logger.d.ts

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

package/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/examples/on_event/event.js

@@ -18,6 +18,32 @@ function main() {
             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);
     });

package/v1/examples/simple/replay-cancel.d.ts

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

package/v1/examples/simple/replay-cancel.js

@@ -0,0 +1,34 @@
+"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 data_contracts_1 = require("../../../clients/rest/generated/data-contracts");
+const hatchet_client_1 = require("../hatchet-client");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const { runs } = hatchet_client_1.hatchet;
+        // > API operations
+        // list all failed runs
+        const allFailedRuns = yield runs.list({
+            statuses: [data_contracts_1.V1TaskStatus.FAILED],
+        });
+        // replay by ids
+        yield runs.replay({ ids: (_a = allFailedRuns.rows) === null || _a === void 0 ? void 0 : _a.map((r) => r.metadata.id) });
+        // or you can run bulk operations with filters directly
+        yield runs.cancel({
+            filters: {
+                since: new Date('2025-03-27'),
+                additionalMetadata: { user: '123' },
+            },
+        });
+        // !!
+    });
+}

package/v1/examples/simple/run.js

@@ -56,6 +56,15 @@ function extra() {
             }),
         });
         // !!
+        // > Run with metadata
+        const withMetadata = workflow_1.simple.run({
+            Message: 'HeLlO WoRlD',
+        }, {
+            additionalMetadata: {
+                source: 'api', // Arbitrary key-value pair
+            },
+        });
+        // !!
     });
 }
 if (require.main === module) {

package/v1/examples/simple/typed-run-methods.d.ts

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

package/v1/examples/simple/typed-run-methods.js

@@ -0,0 +1,37 @@
+"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* () {
+        // > Run methods
+        const input = { Message: 'Hello, World!' };
+        // run now
+        const result = yield workflow_1.simple.run(input);
+        const runReference = yield workflow_1.simple.runNoWait(input);
+        // or in the future
+        const runAt = new Date(new Date().setHours(12, 0, 0, 0) + 24 * 60 * 60 * 1000);
+        const scheduled = yield workflow_1.simple.schedule(runAt, input);
+        const cron = yield workflow_1.simple.cron('simple-daily', '0 0 * * *', input);
+        // !!
+    });
+}
+function runFlavors() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // > Run method flavors
+        const input = { Message: 'Hello, World!' };
+        // Run workflow and wait for the result
+        const result = yield workflow_1.simple.run(input);
+        // Enqueue workflow to be executed asynchronously
+        const runReference = yield workflow_1.simple.runNoWait(input);
+        // !!
+    });
+}

package/v1/examples/with_timeouts/workflow.js

@@ -13,7 +13,6 @@ var __importDefault = (this && this.__importDefault) || function (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

package/v1/task.d.ts

@@ -55,7 +55,7 @@ export type CreateBaseTaskOpts<I extends InputType = UnknownInputType, O extends
      * @param ctx The execution context for the task.
      * @returns The result of the task execution.
      */
-    fn: C;
+    fn?: C;
     /**
      * @deprecated use executionTimeout instead
      */

package/version.d.ts

@@ -1 +1 @@
-export declare const HATCHET_VERSION = "1.9.4";
+export declare const HATCHET_VERSION = "1.9.6";

package/version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HATCHET_VERSION = void 0;
-exports.HATCHET_VERSION = '1.9.4';
+exports.HATCHET_VERSION = '1.9.6';