Temporal

import { condition, defineSignal, proxyActivities, setHandler } from "@temporalio/workflow";
import type * as activities from "./activities";

const { chargeCard, sendReceipt } = proxyActivities<typeof activities>({
  startToCloseTimeout: "1 minute",
  retry: { maximumAttempts: 5, initialInterval: "1s", backoffCoefficient: 2 },
});

export const cancelOrder = defineSignal("cancelOrder");

export async function order(orderId: string) {
  let cancelled = false;
  setHandler(cancelOrder, () => {
    cancelled = true;
  });
  const timedOut = !(await condition(() => cancelled, "30 minutes"));
  if (cancelled) return "cancelled";
  await chargeCard(orderId);
  await sendReceipt(orderId);
  return "charged";
}

Set up the activities charge card and send receipt (each attempt may take up to 1 minute; up to 5 attempts; waiting 1 second before the first retry, growing 2× each time).
Define the signal "cancelOrder" as cancel order.

To order (async), given order ID:
  Let cancelled start as false.
  When the signal "cancelOrder" arrives, set cancelled to true.
  Let timed out mean the wait for cancelled is true timed out after 30 minutes.
  If cancelled is true, give back "cancelled".
  Run the activity charge card with order ID.
  Run the activity send receipt with order ID.
  Give back "charged".

import { NativeConnection, Worker } from "@temporalio/worker";
import * as activities from "./activities";

const connection = await NativeConnection.connect({ address: "localhost:7233" });
const worker = await Worker.create({
  connection,
  taskQueue: "orders",
  workflowsPath: require.resolve("./workflows"),
  activities,
});
await worker.run();

Let connection be a connection to the Temporal server at "localhost:7233".
Set up a Temporal worker as worker for the task queue "orders" (workflows from "./workflows"; activities: activities).
Run worker, taking work from its task queue until it shuts down.

import { Client } from "@temporalio/client";
import { cancelOrder, order } from "./workflows";

const client = new Client({ connection });
const handle = await client.workflow.start(order, {
  taskQueue: "orders",
  args: [orderId],
  workflowId: `order-${orderId}`,
});
await handle.signal(cancelOrder);
const outcome = await handle.result();

Set up a Temporal client as client.
Start the workflow order with order ID, without waiting for it to finish (task queue "orders"; workflow ID "order-{order ID}"), and call the result handle.
Send the signal cancel order to handle.
Let outcome be handle's result once the workflow finishes.