A durable execution platform that lets you write the code you want

async function transfer(
  fromAccount: string,
  toAccount: string,
  amount: number,
) {
  // These are activities, not regular functions.
  // Activities may run elsewhere, and their return value
  // is automatically persisted by Temporal.
  await myActivities.withdraw(fromAccount, amount);
  try {
    await myActivities.deposit(toAccount, amount);
  } catch {
    await myActivities.deposit(fromAccount, amount);
  }
}

@activity.defn
async def compose_greeting(input: ComposeGreetingInput) -> str:
    print(f"Invoking activity, attempt number {activity.info().attempt}")
    # Fail the first 3 attempts, succeed the 4th
    if activity.info().attempt < 4:
        raise RuntimeError("Intentional failure" )
    return f"{input.greeting}, {input.name}!"


@workflow.defn
class GreetingWorkflow:
    @workflow.run
    async def run(self, name: str) -> str:
        # By default activities will retry, backing off an initial interval and
        # then using a coefficient of 2 to increase the backoff each time after
        # for an unlimited amount of time and an unlimited number of attempts.
        # We'll keep those defaults except we'll set the maximum interval to
        # just 2 seconds.
        return await workflow.execute_activity(
            compose_greeting,
            ComposeGreetingInput("Hello", name),
            start_to_close_timeout =timedelta(seconds=10),
            retry_policy=RetryPolicy(maximum_interval=timedelta(seconds=2)),
        )

import { proxyActivities, sleep } from "@temporalio/workflow";
import type { Activities } from "./activities";
const { hasUpgraded, sendReminderEmail } = proxyActivities<Activities>({
  startToCloseTimeout: "10 seconds",
});

async function startTrial(user: string) {
  while (!(await hasUpgraded(user))) {
    await sendReminderEmail(user);
    await sleep("30 days");
  }
}

await new Client().schedule.create({
  action: {
    type: "startWorkflow",
    workflowType: reminderWorkflow,
    args: [
      "♻️ Dear future self, please take out the recycling tonight. Sincerely, past you ❤️",
    ],
    taskQueue: "schedules",
  },
  scheduleId: "sample-schedule",
  spec: {
    calendars: [
      {
        comment: "every wednesday at 8:30pm",
        dayOfWeek: "WEDNESDAY",
        hour: 20,
        minute: 30,
      },
    ],
  },
});

const activities = proxyActivities<Activities>({
  scheduleToCloseTimeout: "30 seconds",
});

interface GreetingParam {
  name: string;
}

export async function greet(param: GreetingParam): Promise<string> {
  return await activities.greet(param);
}

func Accept(ctx workflow.Context, input *AcceptWorkflowInput) (*AcceptWorkflowResult, error) {
	err := emailCandidate(ctx, input)
	if err != nil {
		return nil, err
	}
	submission, err := waitForSubmission(ctx)
	if err != nil {
		return nil, err
	}
	return &AcceptWorkflowResult{Submission: submission},
		nil
}