Hatchet Docs

Hatchet TypeScript V1 Migration Guide

This guide will help you migrate Hatchet workflows from the V0 SDK to the V1 SDK.

Introductory Example

First, we’ve exposed a new hatchet.task method in the V1 SDK for single-task workflows.

import { hatchet } from '../hatchet-client';

// (optional) Define the input type for the workflow
export type SimpleInput = {
  Message: string;
};

export const simple = hatchet.task({
  name: 'simple',
  fn: (input: SimpleInput) => {
    return {
      TransformedMessage: input.Message.toLowerCase(),
    };
  },
});

Dags are still defined as workflows, but they can now be declared using the hatchet.workflow method.

src/v1/examples/dag/workflow.ts

// First, we declare the workflow
export const dag = hatchet.workflow<DagInput, DagOutput>({
  name: 'simple',
});

// Next, we declare the tasks bound to the workflow
const toLower = dag.task({
  name: 'to-lower',
  fn: (input) => {
    return {
      TransformedMessage: input.Message.toLowerCase(),
    };
  },
});

// Next, we declare the tasks bound to the workflow
dag.task({
  name: 'reverse',
  parents: [toLower],
  fn: async (input, ctx) => {
    const lower = await ctx.parentOutput(toLower);
    return {
      Original: input.Message,
      Transformed: lower.TransformedMessage.split('').reverse().join(''),
    };
  },
});

You can now run work for tasks and workflows by directly interacting with the returned object.

src/v1/examples/simple/run.ts

🚨 No snippet found for Running a Task with Results 

/* eslint-disable no-console */
import { hatchet } from '../hatchet-client';
import { simple } from './workflow';

async function main() {
  // ❓ Running a Task
  const res = await simple.run({
    Message: 'HeLlO WoRlD',
  });

  // 👀 Access the results of the Task
  console.log(res.TransformedMessage);
  // !!
}

export async function extra() {
  // ❓ Running Multiple Tasks
  const res1 = simple.run({
    Message: 'HeLlO WoRlD',
  });

  const res2 = simple.run({
    Message: 'Hello MoOn',
  });

  const results = await Promise.all([res1, res2]);

  console.log(results[0].TransformedMessage);
  console.log(results[1].TransformedMessage);
  // !!

  // ❓ Spawning Tasks from within a Task
  const parent = hatchet.task({
    name: 'parent',
    fn: async (input, ctx) => {
      // Simply call ctx.runChild with the task you want to run
      const child = await ctx.runChild(simple, {
        Message: 'HeLlO WoRlD',
      });

      return {
        result: child.TransformedMessage,
      };
    },
  });
  // !!
}

if (require.main === module) {
  main();
}

There are a few important things to note when migrating to the new SDK:

The new SDK uses a factory pattern (shown above) for creating workflows and declaring their tasks, which we’ve found to be more ergonomic than the previous SDK.
The old method of defining workflows will still work in the new SDK, but we recommend migrating over to the new method shown above for improved type checking and for access to new features.
New features of the SDK, such as the new durable execution features rolled out in V1, will only be accessible from the new WorkflowDeclaration object in the new SDK.

Since the old pattern for declaring workflows will still work in the new SDK, we recommend migrating existing workflows to the new patterns in V1 gradually.

Fanout Example

The new SDK also provides improved type support for spawning workflows (such as children) from around the codebase. Consider the following example:

First, we declare a child workflow:

src/v1/examples/child_workflows/workflow.ts

import { hatchet } from '../hatchet-client';

type ChildInput = {
  N: number;
};

export const child = hatchet.task({
  name: 'child',
  fn: (input: ChildInput) => {
    return {
      Value: input.N,
    };
  },
});

Next, we spawn that child from a parent workflow:

src/v1/examples/child_workflows/workflow.ts


type ParentInput = {
  N: number;
};

export const parent = hatchet.task({
  name: 'parent',
  fn: async (input: ParentInput, ctx) => {
    const n = input.N;
    const promises = [];

    for (let i = 0; i < n; i++) {
      promises.push(ctx.runChild(child, { N: i }));
    }

    const childRes = await Promise.all(promises);
    const sum = childRes.reduce((acc, curr) => acc + curr.Value, 0);

    return {
      Result: sum,
    };
  },
});

In this example, the compiler knows what to expect for the types of input and ctx for each of the tasks, as well as the type of the input of the child task when spawning it from the parent task.

Python Migration Guide Go Migration Guide

We use cookies

Hatchet TypeScript V1 Migration Guide

Introductory Example

Fanout Example