Temporal Developer

import { defineSignal, setHandler, condition } from '@temporalio/workflow';

const approveSignal = defineSignal<[boolean]>('approve');
const addItemSignal = defineSignal<[string]>('addItem');

export async function orderWorkflow(): Promise<string> {
  let approved = false;
  const items: string[] = [];

  setHandler(approveSignal, (value) => {
    approved = value;
  });

  setHandler(addItemSignal, (item) => {
    items.push(item);
  });

  await condition(() => approved);
  return `Processed ${items.length} items`;
}

import { setDefaultSignalHandler, condition } from '@temporalio/workflow';

export async function dynamicSignalWorkflow(): Promise<Record<string, unknown[]>> {
  const signals: Record<string, unknown[]> = {};

  setDefaultSignalHandler((signalName: string, ...args: unknown[]) => {
    if (!signals[signalName]) {
      signals[signalName] = [];
    }
    signals[signalName].push(args);
  });

  await condition(() => signals['done'] !== undefined);
  return signals;
}

import { defineQuery, setHandler } from '@temporalio/workflow';

const statusQuery = defineQuery<string>('status');
const progressQuery = defineQuery<number>('progress');

export async function progressWorkflow(): Promise<void> {
  let status = 'running';
  let progress = 0;

  setHandler(statusQuery, () => status);
  setHandler(progressQuery, () => progress);

  for (let i = 0; i < 100; i++) {
    progress = i;
    await doWork();
  }
  status = 'completed';
}

import { setDefaultQueryHandler } from '@temporalio/workflow';

export async function dynamicQueryWorkflow(): Promise<void> {
  const state: Record<string, unknown> = {
    status: 'running',
    progress: 0,
  };

  setDefaultQueryHandler((queryName: string) => {
    return state[queryName];
  });

  // ... workflow logic
}

import { defineUpdate, setHandler, condition } from '@temporalio/workflow';

// Define the update - specify return type and argument types
export const addItemUpdate = defineUpdate<number, [string]>('addItem');
export const addItemValidatedUpdate = defineUpdate<number, [string]>('addItemValidated');

export async function orderWorkflow(): Promise<string> {
  const items: string[] = [];
  let completed = false;

  // Simple update handler - returns new item count
  setHandler(addItemUpdate, (item: string) => {
    items.push(item);
    return items.length;
  });

  // Update handler with validator - rejects invalid input before execution
  setHandler(
    addItemValidatedUpdate,
    (item: string) => {
      items.push(item);
      return items.length;
    },
    {
      validator: (item: string) => {
        if (!item) throw new Error('Item cannot be empty');
        if (items.length >= 100) throw new Error('Order is full');
      },
    }
  );

  await condition(() => completed);
  return `Order with ${items.length} items completed`;
}

import { executeChild } from '@temporalio/workflow';

export async function parentWorkflow(orders: Order[]): Promise<string[]> {
  const results: string[] = [];

  for (const order of orders) {
    const result = await executeChild(processOrderWorkflow, {
      args: [order],
      workflowId: `order-${order.id}`,
    });
    results.push(result);
  }

  return results;
}

import { executeChild, ParentClosePolicy, ChildWorkflowCancellationType } from '@temporalio/workflow';

const result = await executeChild(childWorkflow, {
  args: [input],
  workflowId: `child-${workflowInfo().workflowId}`,

  // ParentClosePolicy - what happens to child when parent closes
  // TERMINATE (default), ABANDON, REQUEST_CANCEL
  parentClosePolicy: ParentClosePolicy.TERMINATE,

  // ChildWorkflowCancellationType - how cancellation is handled
  // WAIT_CANCELLATION_COMPLETED (default), WAIT_CANCELLATION_REQUESTED, TRY_CANCEL, ABANDON
  cancellationType: ChildWorkflowCancellationType.WAIT_CANCELLATION_COMPLETED,
});

import { getExternalWorkflowHandle } from '@temporalio/workflow';
import { mySignal } from './other-workflows';

export async function coordinatorWorkflow(targetWorkflowId: string): Promise<void> {
  const handle = getExternalWorkflowHandle(targetWorkflowId);

  // Signal the external workflow
  await handle.signal(mySignal, { data: 'payload' });

  // Or cancel it
  await handle.cancel();
}

export async function parallelWorkflow(items: string[]): Promise<string[]> {
  return await Promise.all(
    items.map((item) => processItem(item))
  );
}

import { continueAsNew, workflowInfo } from '@temporalio/workflow';

export async function longRunningWorkflow(state: State): Promise<string> {
  while (true) {
    state = await processNextBatch(state);

    if (state.isComplete) {
      return 'done';
    }

    const info = workflowInfo();
    if (info.continueAsNewSuggested || info.historyLength > 10000) {
      await continueAsNew<typeof longRunningWorkflow>(state);
    }
  }
}

import { CancellationScope, log } from '@temporalio/workflow';

export async function sagaWorkflow(order: Order): Promise<string> {
  const compensations: Array<() => Promise<void>> = [];

  try {
    // IMPORTANT: Save compensation BEFORE calling the activity
    // If activity fails after completing but before returning,
    // compensation must still be registered
    compensations.push(() => releaseInventory(order));
    await reserveInventory(order);

    compensations.push(() => refundPayment(order));
    await chargePayment(order);

    await shipOrder(order);
    return 'Order completed';
  } catch (err) {
    // nonCancellable ensures compensations run even if the workflow is cancelled
    await CancellationScope.nonCancellable(async () => {
      for (const compensate of compensations.reverse()) {
        try {
          await compensate();
        } catch (compErr) {
          log.warn('Compensation failed', { error: compErr });
        }
      }
    });
    throw err;
  }
}

import { CancellationScope, sleep } from '@temporalio/workflow';

export async function scopedWorkflow(): Promise<void> {
  // Non-cancellable scope - runs even if workflow cancelled
  await CancellationScope.nonCancellable(async () => {
    await cleanupActivity();
  });

  // Timeout scope
  await CancellationScope.withTimeout('5 minutes', async () => {
    await longRunningActivity();
  });

  // Manual cancellation
  const scope = new CancellationScope();
  const promise = scope.run(() => someActivity());
  scope.cancel();
}

import { Trigger } from '@temporalio/workflow';

export async function triggerWorkflow(): Promise<string> {
  const approvalTrigger = new Trigger<boolean>();

  setHandler(approveSignal, (approved) => {
    approvalTrigger.resolve(approved);
  });

  const approved = await approvalTrigger;
  return approved ? 'Approved' : 'Rejected';
}

import { condition, CancelledFailure } from '@temporalio/workflow';

export async function approvalWorkflow(): Promise<string> {
  let approved = false;

  setHandler(approveSignal, () => {
    approved = true;
  });

  // Wait for approval with 24-hour timeout
  const gotApproval = await condition(() => approved, '24 hours');

  if (gotApproval) {
    return 'approved';
  } else {
    return 'auto-rejected due to timeout';
  }
}

import { condition, allHandlersFinished } from '@temporalio/workflow';

export async function handlerAwareWorkflow(): Promise<string> {
  // ... main workflow logic ...

  // Before exiting, wait for all handlers to finish
  await condition(allHandlersFinished);
  return 'done';
}

import { heartbeat, activityInfo, CancelledFailure } from '@temporalio/activity';

export async function processLargeFile(filePath: string): Promise<string> {
  const info = activityInfo();
  // Get heartbeat details from previous attempt (if any)
  const startLine: number = info.heartbeatDetails ?? 0;

  const lines = await readFileLines(filePath);

  try {
    for (let i = startLine; i < lines.length; i++) {
      await processLine(lines[i]);
      // Heartbeat with progress
      // If activity is cancelled, heartbeat() throws CancelledFailure
      heartbeat(i + 1);
    }
    return 'completed';
  } catch (e) {
    if (e instanceof CancelledFailure) {
      // Perform cleanup on cancellation
      await cleanup();
    }
    throw e;
  }
}

import { sleep } from '@temporalio/workflow';

export async function timerWorkflow(): Promise<string> {
  await sleep('1 hour');
  return 'Timer fired';
}

import { proxyLocalActivities } from '@temporalio/workflow';
import type * as activities from './activities';

const { quickLookup } = proxyLocalActivities<typeof activities>({
  startToCloseTimeout: '5 seconds',
});

export async function localActivityWorkflow(): Promise<string> {
  const result = await quickLookup('key');
  return result;
}