Duty

Durable TypeScript tasks for everyone

Durability platform that makes code run to completion.
With automated retries, backoff and observability built-in.
No external dependencies - use your existing storage layer & infra.

Get started immediately

$npm i --save @duty/core

import { worker } from "@duty/core"

const db = new PrismaClient() 

const duty = await worker({ storage: prismaAdapter(db) })

const activities = {
    "generateTextEmbedding": async (params: { documentId: string }) => {
        const document = await db.documents.findOne(params.documentId)
        const embedding = await openai.embed(document.text)
        await db.embeddings.create({ data: { documentId: document.id, embedding } })
    }
}

const embedDocumentsTask = duty.task({
      name: 'embed-documents',
      activities,
      run: async (context, params: { documentIds: string[] }) => {
          for (let documentId of params.documentIds) {
              await context.activities.generateTextEmbedding({ documentId })
          }
      }
})

await embedDocumentsTask.run({ documentIds: ['document-1', 'document-2', '...'] })

embed-documents

generateTextEmbedding

This example shows a durable way to fetch embeddings in bulk from OpenAI.
Duty uses your existing Prisma database setup as backing storage (other adapters available).
Should the task error due to e.g. API rate limiting, the task retries automatically.
Activities are cached by default, so each activity runs at most once for a given set of params.

import { worker } from "@duty/core"

const plunk = new Plunk("api-key")
const db = new Kysely<Database>({ dialect: new PostgresDialect() })

const duty = await worker({ storage: kyselyAdapter(db) })

const activities = {
    "sendTrialReminderEmail": async (params: { email: string; days: number }) => {
        const body = params.days > 0
            ? "Hi, you have " + params.days + " days left on your trial. Love, Duty"
            : "Hi, your free trial has expired. Love, Duty."
        await plunk.emails.send({ subject: "Your trial", to: params.email, body })
    },
    "expireTrial": async (params: { email: string }) => db
        .updateTable("accounts")
        .set({ trialExpired: true })
        .where("email", "=", params.email)
        .executeTakeFirst(),
}

const appTrialTask = duty.task({
    name: 'app-trial-task',
    activities,
    run: async (context, params: { email: string; trialExpiryDate: Date }) => {
        const { email, trialExpiryDate } = params
        while (true) {
            const days = calculateDaysLeftUntil(params.trialExpiryDate)
            await context.activities.sendTrialReminderEmail({ email, days })
            if (days <= 0) {
                await context.activities.expireTrial({ email: params.email })
                return
            }
            await context.sleep("1 day")
        }
    },
})

await appTrialTask.run({ 
    email: '[email protected]', 
    trialExpiryDate: new Date('2025-01-07') 
})

This example shows how you can use Duty together with your existing Kysely setup to send trial reminder emails using Plunk.
The task sleeps for a day between each email.
The expireTrial activity showcases calling the database in a durable way.

Uses your Database

No external dependencies - Duty works with your existing database (Postgres, Redis, ...) and ORM (Prisma, Kysely, ...) as backing storage.

Powerful Dashboard

Your durability command center, Duty Admin gives a historical view of tasks, activities and event states.

Fully Open Source

Duty is built in public by people who use it daily. We welcome your feedback and contributions.

View our Repo

Unleashes Productivity

Write code without headaches. Duty does what's needed to make it run to completion.

Duty Cloud for extreme reliability

Large scale with maximum reliability.
Duty Cloud runks your tasks for you so you can focus on writing code.

Coming Soon

Start building durable tasks today!

$npm i --save @duty/core