### Run Hello World Sample

Source: https://github.com/temporalio/samples-typescript/blob/main/README.md

Clones the samples repository, navigates to the 'hello-world' directory, installs dependencies, and starts the sample. Requires Node.js v18+.

```sh
git clone https://github.com/temporalio/samples-typescript.git
cd samples-typescript/hello-world
npm install  # or `pnpm` or `yarn`
npm run start
```

```sh
npm run workflow
```

--------------------------------

### Schedule Output Example

Source: https://github.com/temporalio/samples-typescript/blob/main/schedules/README.md

This is an example of the output you can expect after starting a schedule. It confirms the schedule has started and indicates where to find Workflow logs.

```bash
Started schedule 'sample-schedule'.

The reminder Workflow will run and log from the Worker every 10 seconds.

You can now run:

  npm run schedule.go-faster
  npm run schedule.pause
  npm run schedule.unpause
  npm run schedule.delete
  npm run schedule.describe
  npm run schedule.backfill
  npm run schedule.list
  npm run schedule.trigger
  npm run schedule.update
```

--------------------------------

### Install and Run Next.js + Temporal Project

Source: https://github.com/temporalio/samples-typescript/blob/main/nextjs-ecommerce-oneclick/README.md

Navigate to the project directory, install dependencies, and start the development server. The dev script also launches the Temporal worker and compiles workflow code.

```bash
cd nextjs-ecommerce-oneclick
npm install
npm run dev
```

--------------------------------

### Start Temporal Server (Dev Mode)

Source: https://github.com/temporalio/samples-typescript/blob/main/README.md

Installs and starts the Temporal Server in development mode using Homebrew. Ensure Node.js v18+ is installed.

```sh
brew install temporal
temporal server start-dev
```

--------------------------------

### Start Temporal Server with Workflow Updates Enabled

Source: https://github.com/temporalio/samples-typescript/blob/main/message-passing/introduction/README.md

To run this sample, start the Temporal Server with Workflow Updates enabled using this command. Ensure you have the Temporal CLI installed.

```bash
temporal server start-dev --dynamic-config-value frontend.enableUpdateWorkflowExecution=true
```

--------------------------------

### Running the DSL Interpreter Workflow Sample

Source: https://github.com/temporalio/samples-typescript/blob/main/dsl-interpreter/README.md

Instructions for starting the Temporal Server, installing dependencies, and running the worker and workflows. Use 'npm run workflow1' or 'npm run workflow2' to execute the respective workflows.

```bash
temporal server start-dev
```

```bash
npm install
```

```bash
npm run start.watch
```

```bash
npm run workflow1
```

```bash
npm run workflow2
```

--------------------------------

### Start Temporal Dev Server

Source: https://github.com/temporalio/samples-typescript/blob/main/ai-sdk/README.md

Starts the Temporal development server. Ensure Temporal Server is running before starting the worker.

```bash
temporal server start-dev
```

--------------------------------

### Workflow Client Output Example

Source: https://github.com/temporalio/samples-typescript/blob/main/protobufs/README.md

This output shows the expected logs when running the workflow client, including the started workflow ID and the result returned by the workflow.

```bash
Started workflow my-business-id-b6155489-920f-41a8-9e88-c17c24d47ee9
{ sentence: 'Proto is 2 years old.' }
```

--------------------------------

### Install Dependencies and Prepare Project

Source: https://github.com/temporalio/samples-typescript/blob/main/README.md

Commands to clone the repository, install dependencies, and prepare the project for development. Includes optional reset commands.

```bash
git clone https://github.com/temporalio/samples-typescript.git
cd samples-typescript
pnpm install
pnpm run prepare
```

```bash
git clean -xfd && rm pnpm-lock.yaml
```

--------------------------------

### Install Dependencies

Source: https://github.com/temporalio/samples-typescript/blob/main/ai-sdk/README.md

Installs project dependencies using npm. This command should be run after cloning the repository.

```bash
npm install
```

--------------------------------

### Start Temporal Server and Watch Changes

Source: https://github.com/temporalio/samples-typescript/blob/main/scratchpad/README.md

Instructions for starting a local Temporal development server and running the scratchpad file with watch mode enabled for automatic reloads.

```sh
temporal server start-dev
npm install
npm run start.watch
```

--------------------------------

### Start Local Temporal Server

Source: https://github.com/temporalio/samples-typescript/blob/main/nexus-hello/README.md

Starts a local Temporal server for development. Ensure version 1.4.1 or higher is used.

```bash
temporal server start-dev --port 7233
```

--------------------------------

### Install Dependencies with PNPM

Source: https://github.com/temporalio/samples-typescript/blob/main/food-delivery/README.md

Installs project dependencies using PNPM, which is the recommended package manager for this sample. If PNPM is not installed, it can be installed globally via npm.

```bash
pnpm install
```

--------------------------------

### Enable Eager Workflow Start

Source: https://github.com/temporalio/samples-typescript/blob/main/README.md

Shows how to configure and run a workflow that utilizes Eager Workflow Start. This feature allows a workflow to start executing immediately upon creation, reducing latency.

```typescript
import {
  Workflow,
  eager,
  WorkflowInfo,
} from "@temporalio/workflow";

@eager
@Workflow.defn
export class EagerWorkflow {
  async execute(name: string): Promise<string> {
    console.log(`Eager workflow started for ${name}`);
    return `Hello, ${name}!`;
  }
}

// To enable eager start, the Worker needs to be configured with:
// const worker = new Worker(connection, {
//   taskQueue: "my-task-queue",
//   workflows: [EagerWorkflow],
//   // ... other options
// });

// When executing, the client doesn't need special configuration for eager start,
// it's determined by the workflow definition.
// await client.execute(EagerWorkflow, {
//   args: ["World"],
//   taskQueue: "my-task-queue",
// });

```

--------------------------------

### Start Workflows with Client API

Source: https://context7.com/temporalio/samples-typescript/llms.txt

Demonstrates starting workflows using the Temporal Client. Use `client.workflow.start` for fire-and-forget execution or `client.workflow.execute` to wait for completion.

```typescript
import { Connection, Client } from '@temporalio/client';
import { example } from './workflows';
import { nanoid } from 'nanoid';

async function run() {
  const connection = await Connection.connect();
  const client = new Client({ connection });

  const handle = await client.workflow.start(example, {
    taskQueue: 'hello-world',
    args: ['Temporal'],
    workflowId: 'workflow-' + nanoid(),
  });
  console.log(`Started workflow ${handle.workflowId}`);
  console.log(await handle.result()); // Hello, Temporal!
}

run().catch((err) => {
  console.error(err);
  process.exit(1);
});
```

--------------------------------

### Installing NPM Dependencies

Source: https://github.com/temporalio/samples-typescript/blob/main/interceptors-opentelemetry/README.md

Installs the necessary Node.js packages for the project. Use `pnpm` or `yarn` if preferred.

```sh
npm install   # or `pnpm` or `yarn`
```

--------------------------------

### Start NestJS Server

Source: https://github.com/temporalio/samples-typescript/blob/main/nestjs-exchange-rates/README.md

Starts the main NestJS application server, which handles incoming HTTP requests.

```bash
npm run start:server
```

--------------------------------

### Start Production Server

Source: https://github.com/temporalio/samples-typescript/blob/main/nestjs-exchange-rates/README.md

Runs the NestJS server application from its production build.

```bash
npm run start:server:prod
```

--------------------------------

### Install Dependencies and Run Scratchpad

Source: https://github.com/temporalio/samples-typescript/blob/main/scratchpad/README.md

Installs necessary Temporal TypeScript packages and runs the scratchpad file using ts-node. Ensure Temporal Server is running separately.

```sh
npm install --save ts-node @temporalio/worker @temporalio/workflow @temporalio/client @temporalio/common
curl -sOL https://raw.githubusercontent.com/temporalio/samples-typescript/main/scratchpad/scratchpad.ts
ts-node scratchpad.ts
```

--------------------------------

### Nexus Hello World Example

Source: https://github.com/temporalio/samples-typescript/blob/main/README.md

This sample demonstrates defining a Nexus Service, implementing its operation handlers, and invoking these operations from a Temporal Workflow. It showcases inter-service communication via Nexus.

```typescript
import { Server } from '@temporalio/nexus';

const server = new Server({
  // Configuration for the Nexus server
});

server.addOperation({
  id: 'greet',
  handler: async (name: string) => `Hello, ${name}!`, // Operation handler
});

// Start the Nexus server
server.start().catch(err => {
  console.error('Nexus server failed to start:', err);
  process.exit(1);
});
```

--------------------------------

### Install PNPM Globally

Source: https://github.com/temporalio/samples-typescript/blob/main/food-delivery/README.md

Installs the PNPM package manager globally using npm. This is a prerequisite for running the project's installation and development scripts.

```bash
npm install --global pnpm
```

--------------------------------

### Example Workflow Output

Source: https://github.com/temporalio/samples-typescript/blob/main/continue-as-new/README.md

This output shows a Workflow that continues as new multiple times, indicated by the increasing iteration count.

```text
[loopingWorkflow(loop-0)] Running Workflow iteration: 0
[loopingWorkflow(loop-0)] Running Workflow iteration: 1
[loopingWorkflow(loop-0)] Running Workflow iteration: 2
[loopingWorkflow(loop-0)] Running Workflow iteration: 3
[loopingWorkflow(loop-0)] Running Workflow iteration: 4
[loopingWorkflow(loop-0)] Running Workflow iteration: 5
[loopingWorkflow(loop-0)] Running Workflow iteration: 6
[loopingWorkflow(loop-0)] Running Workflow iteration: 7
[loopingWorkflow(loop-0)] Running Workflow iteration: 8
[loopingWorkflow(loop-0)] Running Workflow iteration: 9

```

--------------------------------

### Make HTTP Request in Activity

Source: https://github.com/temporalio/samples-typescript/blob/main/README.md

Example of making an external HTTP request within a Temporal Activity using the 'axios' library. Ensure 'axios' is installed as a dependency.

```typescript
import { Activity } from '@temporalio/activity';
import axios from 'axios';

export async function makeHTTPRequest(): Promise<void> {
  const response = await axios.get('https://example.com');
  Activity.logger.info('Received response', { status: response.status });
}
```

--------------------------------

### Run Workflow

Source: https://github.com/temporalio/samples-typescript/blob/main/activities-examples/README.md

Execute the main workflow that initiates an HTTP request. Ensure Temporal Server is running and dependencies are installed.

```bash
temporal server start-dev
npm install
npm run start.watch
npm run workflow
```

--------------------------------

### Start a Schedule

Source: https://github.com/temporalio/samples-typescript/blob/main/schedules/README.md

Use this script to initiate a new schedule for a Workflow. Ensure Temporal Server and the Worker are running.

```bash
npm run schedule.start
```

--------------------------------

### Start Production Worker

Source: https://github.com/temporalio/samples-typescript/blob/main/nestjs-exchange-rates/README.md

Runs the Temporal worker application from its production build.

```bash
npm run start:worker:prod
```

--------------------------------

### Start and Control Child Workflows

Source: https://github.com/temporalio/samples-typescript/blob/main/README.md

Demonstrates the process of starting and controlling Child Workflows from a parent Workflow. This is essential for breaking down complex processes into smaller, manageable units.

```typescript
import {
  ChildWorkflowHandle,
  startChildWorkflow,
  WorkflowInfo,
} from "@temporalio/workflow";

export async function parentWorkflow(): Promise<string> {
  const childHandle: ChildWorkflowHandle = await startChildWorkflow(
    "ChildWorkflowType", // The type of the child workflow
    { 
      args: ["input data"], // Arguments for the child workflow
      workflowId: "child-workflow-id", // Optional: specific workflow ID for the child
      // Other options like taskQueue, timeouts, etc.
    }
  );

  const childResult = await childHandle.result(); // Wait for child workflow to complete
  console.log("Child workflow completed with result:", childResult);

  return "Parent workflow finished";
}

// Define your ChildWorkflowType elsewhere
// export async function ChildWorkflowType(input: string): Promise<string> {
//   // Child workflow logic
//   return `Processed: ${input}`;
// }
```

--------------------------------

### Setup Nexus Endpoint

Source: https://github.com/temporalio/samples-typescript/blob/main/nexus-hello/README.md

Configures a Nexus endpoint on the caller namespace, targeting a specific namespace and task queue.

```bash
temporal operator nexus endpoint create \
  --name my-nexus-endpoint-name \
  --target-namespace my-target-namespace \
  --target-task-queue my-handler-task-queue
```

--------------------------------

### Console Telemetry Output Example

Source: https://github.com/temporalio/samples-typescript/blob/main/interceptors-opentelemetry/README.md

Example of tracing data output to the console when the sample is run with default configuration. This includes resource information, trace IDs, and span names.

```json
{
  resource: { attributes: { 'service.name': 'interceptors-sample' } },
  traceId: '8613431a77bcf95cdfcbbe40f2cdc934',
  id: '15f2ca795e852236'
  parentId: undefined
  name: 'RunWorkflow:example',
  [...]
}
{
  resource: { attributes: { 'service.name': 'interceptors-sample' } },
  traceId: '8613431a77bcf95cdfcbbe40f2cdc934',
  id: '945c3e4ee7ae9b4d'
  parentId: '15f2ca795e852236',
  name: 'StartActivity:greet',
  [...]
}
{
  resource: { attributes: { 'service.name': 'interceptors-sample' } },
  traceId: '8613431a77bcf95cdfcbbe40f2cdc934',
  parentId: "945c3e4ee7ae9b4d"
  id: '056ec5cce08a1796'
  name: 'RunActivity:greet',
  [...]
}
```

--------------------------------

### Start Temporal Worker with Watch Mode

Source: https://github.com/temporalio/samples-typescript/blob/main/hello-world-mtls/README.md

Execute this command to start the Temporal Worker. The `.watch` script typically enables hot-reloading for development.

```bash
npm run start.watch to start the Worker
```

--------------------------------

### Run Development Servers and Worker

Source: https://github.com/temporalio/samples-typescript/blob/main/food-delivery/README.md

Starts the Next.js development servers for the menu and driver portals, along with the Temporal Worker. Ensure Temporal Server is running locally before executing.

```bash
pnpm dev
```

--------------------------------

### Workflow Execution Logs for Updatable Timer

Source: https://github.com/temporalio/samples-typescript/blob/main/timer-examples/README.md

Example logs showing the progression of a workflow using an updatable timer, including initial setting and subsequent updates.

```bash
[countdownWorkflow(6c0c152b-aead-4b1a-acf0-17e809acf0fc)] timer set for: Tue Nov 02 2021 03:03:57 GMT-0700 (Pacific Daylight Time)
[countdownWorkflow(6c0c152b-aead-4b1a-acf0-17e809acf0fc)] timer now set for: Mon Nov 01 2021 03:03:50 GMT-0700 (Pacific Daylight Time)
[countdownWorkflow(d0a3cb4d-05b1-4cfa-af25-c9223fd34140)] countdown done!

```

--------------------------------

### API Response Example

Source: https://github.com/temporalio/samples-typescript/blob/main/nextjs-ecommerce-oneclick/README.md

This is an example JSON response from the Next.js API route after interacting with Temporal. It shows a simple data structure.

```json
{ "name": "John Doe" }
```

--------------------------------

### Example Terminal Logs

Source: https://github.com/temporalio/samples-typescript/blob/main/monorepo-folders/README.md

Shows typical log output from the Temporal worker and API server during workflow execution, demonstrating inter-package communication.

```bash
[worker] [WorkflowA(a19adbef-9e67-416a-ada6-234e73081e74)] Hello from WorkflowA
[worker] hello from activityA Temporal
[worker] hello from activityB Temporal
[api-server] A: ActivityA result: A-Temporal!, B: ActivityB result: B-Temporal!
[api-server] GET /api/workflow 200 2081.536 ms - 79
[worker] [WorkflowB(68f37547-5e72-46ea-8fd0-54c3adddee53)] Hello from WorkflowB
[worker] hello from activityC in WorkflowB
[worker] hello from activityD in WorkflowB
```

--------------------------------

### Starting Docker Compose for OpenTelemetry

Source: https://github.com/temporalio/samples-typescript/blob/main/interceptors-opentelemetry/README.md

Launches the OpenTelemetry collector and related services using Docker Compose. This is optional but recommended for full OpenTelemetry integration.

```sh
docker compose up -d
```

--------------------------------

### Containerize Temporal Projects with Tilt

Source: https://github.com/temporalio/samples-typescript/blob/main/README.md

Demonstrates using Tilt for containerizing and managing a Temporal project within a monorepo. Includes setup for `temporalite`, `parcel`, and separate packages for Workflows and Activities.

```yaml
# Example Tiltfile (tilt.yaml)
# This is a conceptual example. Actual Tilt configuration can be more complex.

# Load necessary extensions
# load("ext/docker-compose.lib.yaml")

# Define services
# docker_compose(
#   "docker-compose.yaml",
#   default_env_vars={
#     "TEMPORAL_HOST_PORT": "temporalite:7233",
#   }
# )

# Define resources
# k8s_resource(
#   "temporalite",
#   "path/to/temporalite/deployment.yaml",
#   port_forwards=["7233:7233"]
# )

# Build and deploy the worker
# worker_image = image(
#   "worker",
#   context=".",
#   dockerfile="Dockerfile.worker",
#   live_update=
#     # Configure live update for your worker code
#     sync(
#       local_src="packages/worker/src",
#       container_dest="/app/src"
#     )
# )
# 
# k8s_resource(
#   "worker",
#   "path/to/worker/deployment.yaml",
#   image=worker_image
# )

```

--------------------------------

### Run Production Worker - Node.js

Source: https://github.com/temporalio/samples-typescript/blob/main/production/README.md

Starts the production Worker using the built JavaScript files. Set the NODE_ENV environment variable to 'production'.

```bash
NODE_ENV=production node lib/worker.js
```

--------------------------------

### Configure Custom Logger with Winston

Source: https://context7.com/temporalio/samples-typescript/llms.txt

Integrate Winston logger for production observability. Ensure Winston is installed as a dependency.

```typescript
import { DefaultLogger, makeTelemetryFilterString, Runtime, Worker } from '@temporalio/worker';
import * as winston from 'winston';

const winstonLogger = winston.createLogger({
  level: 'debug',
  format: winston.format.json(),
  transports: [new winston.transports.Console()],
});

Runtime.install({
  logger: new DefaultLogger('DEBUG', (entry) => {
    winstonLogger.log({
      label: entry.meta?.activityId ? 'activity' : entry.meta?.workflowId ? 'workflow' : 'worker',
      level: entry.level.toLowerCase(),
      message: entry.message,
      timestamp: Number(entry.timestampNanos / 1_000_000n),
      ...entry.meta,
    });
  }),
  telemetryOptions: {
    logging: {
      forward: {},
      filter: makeTelemetryFilterString({ core: 'DEBUG' }),
    },
  },
});

const worker = await Worker.create({
  workflowsPath: require.resolve('./workflows'),
  activities,
  taskQueue: 'custom-logger',
});
```

--------------------------------

### Example Worker Output

Source: https://github.com/temporalio/samples-typescript/blob/main/cron-workflows/README.md

This output shows the typical logs from a worker running the cron workflow, illustrating the timing differences between workflow and activity execution.

```bash
Hello from my-schedule, Temporal!
Workflow time:  1636333860201
Activity time: 1636333860241
Hello from my-schedule, Temporal!
Workflow time:  1636333920319
Activity time: 1636333920340
```

--------------------------------

### Start Caller Workflow

Source: https://github.com/temporalio/samples-typescript/blob/main/nexus-messaging/src/callerpattern/README.md

Initiates the caller workflow. This command should be run in a third terminal after the workers are running.

```bash
npm run workflow.callerpattern
```

--------------------------------

### Build Production Worker and Activities - npm

Source: https://github.com/temporalio/samples-typescript/blob/main/production/README.md

Builds the Worker script and Activities code for production deployment. This command should be run before starting the production Worker.

```bash
npm run build
```

--------------------------------

### Organize Workflows and Activities in Monorepos

Source: https://github.com/temporalio/samples-typescript/blob/main/README.md

Provides examples of structuring Temporal projects within a monorepo using yarn workspaces. This includes separating frontend, API server, Worker, and Workflow/Activity packages.

```bash
# Example monorepo structure using yarn workspaces:
#
# my-monorepo/
# ├── package.json
# ├── packages/
# │   ├── frontend/
# │   ├── api-server/
# │   ├── worker/
# │   │   └── src/index.ts  <-- Worker code, imports workflows/activities
# │   └── workflows-activities/
# │       ├── src/workflows.ts
# │       └── src/activities.ts
# └── ...
#
# In packages/worker/src/index.ts:
# import { Worker } from "@temporalio/worker";
# import * as workflows from "@my-monorepo/workflows-activities/lib/workflows";
# import * as activities from "@my-monorepo/workflows-activities/lib/activities";
#
# async function run() {
#   const worker = await Worker.create({
#     taskQueue: "my-task-queue",
#     workflows: Object.values(workflows),
#     activities: Object.values(activities),
#   });
#   await worker.run();
# }
# run().catch(console.error);

```

--------------------------------

### Manually Complete a Workflow with Async Activity Completion

Source: https://github.com/temporalio/samples-typescript/blob/main/README.md

Provides an example of an Expense Reporting Workflow that communicates with a server API and demonstrates how to manually complete a Workflow at a later date. This is useful for integrating with external systems or long-running processes.

```typescript
import {
  CompleteWorkflowHandle,
  WorkflowInfo,
} from "@temporalio/workflow";

// Assume 'CompleteWorkflowHandle' is imported or defined elsewhere
// This is a conceptual example, actual implementation might vary.

export async function expenseReportingWorkflow(expenseReportId: string): Promise<void> {
  // Workflow logic to interact with server API...
  // For example, submit expense report for approval.

  // Later, when an external event occurs (e.g., approval received),
  // the workflow can be manually completed.
  // This typically involves an external trigger or a separate process
  // that calls complete on the workflow handle.

  // Example placeholder for manual completion logic:
  // const approvalStatus = await externalApi.getApprovalStatus(expenseReportId);
  // if (approvalStatus === "approved") {
  //   (workflowHandle as CompleteWorkflowHandle).complete("Approved");
  // }
}

// In a separate client or worker, you might have:
// async function manuallyCompleteExpenseReport(workflowId: string, result: string) {
//   const handle = client.getHandle(workflowId) as CompleteWorkflowHandle;
//   await handle.complete(result);
// }
```

--------------------------------

### Start Caller Worker

Source: https://github.com/temporalio/samples-typescript/blob/main/nexus-hello/README.md

Starts the worker that serves Caller Workflows, connecting to the `my-caller-namespace`.

```bash
npm run start.caller
```

--------------------------------

### Start NestJS Worker

Source: https://github.com/temporalio/samples-typescript/blob/main/nestjs-exchange-rates/README.md

Starts the Temporal worker process that listens for and executes Workflows and Activities.

```bash
npm run start:worker
```

--------------------------------

### Configure Temporal Client Connections with TOML

Source: https://github.com/temporalio/samples-typescript/blob/main/README.md

Demonstrates how to configure Temporal Client connections using TOML configuration files. Supports multiple environment profiles and programmatic overrides for flexibility.

```toml
[default]
temporal_host_port = "localhost:7233"
namespace = "default"

[staging]
temporal_host_port = "staging.temporal.io:7233"
namespace = "staging"
client_identity = "my-staging-client"

[production]
temporal_host_port = "prod.temporal.io:7233"
namespace = "production"
client_identity = "my-prod-client"
# tls_ca_cert_path = "/path/to/ca.pem"
# tls_cert_path = "/path/to/cert.pem"
# tls_key_path = "/path/to/key.pem"

```

--------------------------------

### Start Caller Worker

Source: https://github.com/temporalio/samples-typescript/blob/main/nexus-messaging/src/ondemandpattern/README.md

Starts the caller worker. This worker initiates and manages remote workflow instances.

```bash
npm run start.ondemandpattern.caller
```

--------------------------------

### Production Build for Faster Worker Startup

Source: https://github.com/temporalio/samples-typescript/blob/main/README.md

Explains how to build code in advance for faster Worker startup times in a production environment. This involves pre-compiling or bundling your workflow and activity code.

```bash
# Example build command (using esbuild)
# This assumes your workflow/activity files are in ./src
# and your output directory is ./dist
esbuild src/index.ts --bundle --outfile=dist/index.js --platform=node --format=cjs --external:@temporalio/workflow --external:@temporalio/activity

# In your production deployment, you would run the worker using the bundled code:
# node dist/index.js

```

--------------------------------

### Start Caller Worker

Source: https://github.com/temporalio/samples-typescript/blob/main/nexus-messaging/src/callerpattern/README.md

Starts the caller worker, which manages the caller workflow. This command should be run in a separate terminal.

```bash
npm run start.callerpattern.caller
```

--------------------------------

### Start Handler Worker

Source: https://github.com/temporalio/samples-typescript/blob/main/nexus-messaging/src/ondemandpattern/README.md

Starts the handler worker for the on-demand pattern. This worker processes requests directed to the Nexus endpoint.

```bash
npm run start.ondemandpattern.service
```

--------------------------------

### Start Nexus Service Worker

Source: https://github.com/temporalio/samples-typescript/blob/main/nexus-hello/README.md

Starts the worker that serves Nexus Operation handlers and associated Workflows, connecting to the `my-target-namespace`.

```bash
npm run start.service
```

--------------------------------

### Running the Mutex Sample

Source: https://github.com/temporalio/samples-typescript/blob/main/mutex/README.md

Execute these commands in parallel to observe the mutex behavior. The second workflow will wait for the first to release the lock.

```bash
npm run workflow my-lock-id
```

--------------------------------

### Start Handler Worker

Source: https://github.com/temporalio/samples-typescript/blob/main/nexus-messaging/src/callerpattern/README.md

Starts the handler worker, which is responsible for running the NexusGreetingService and handling incoming Nexus operations. This command should be run in a dedicated terminal.

```bash
npm run start.callerpattern.service
```

--------------------------------

### Scaffold New Temporal Project

Source: https://github.com/temporalio/samples-typescript/blob/main/README.md

Creates a new Temporal project from a sample using the `@temporalio/create` package. You can specify a sample name or choose from a list.

```sh
npx @temporalio/create@latest my-project --sample sample-name
```

```sh
npx @temporalio/create@latest my-project
```

--------------------------------

### Start Worker with Watch Mode

Source: https://github.com/temporalio/samples-typescript/blob/main/ai-sdk/README.md

Starts the Temporal worker in watch mode, automatically restarting on code changes. This command should be run after setting up dependencies and environment variables.

```bash
npm run start.watch
```

--------------------------------

### Load Default Profile from config.toml

Source: https://github.com/temporalio/samples-typescript/blob/main/env-config/README.md

Demonstrates loading the 'default' profile from the config.toml file for local development. Ensure the config.toml file exists and is correctly formatted.

```text
--- Loading default profile from config.toml ---
Loaded 'default' profile from /path/to/config.toml.
  Address: localhost:7233
  Namespace: default
  gRPC Metadata: {"my-custom-header":"development-value","trace-id":"dev-trace-123"}

Attempting to connect to client...
✅ Client connected successfully!
```

--------------------------------

### Run Tests

Source: https://github.com/temporalio/samples-typescript/blob/main/empty/README.md

Execute all defined tests for the project.

```bash
npm run test
```

--------------------------------

### AI Agent Workflow with Temporal Provider

Source: https://context7.com/temporalio/samples-typescript/llms.txt

Demonstrates using the Temporal AI SDK provider with the Vercel AI SDK for AI agent workflows. Requires importing polyfills and specific functions for AI generation.

```typescript
import '@temporalio/ai-sdk/lib/load-polyfills';
import { generateText, stepCountIs, tool } from 'ai';
import { temporalProvider } from '@temporalio/ai-sdk';
import { proxyActivities } from '@temporalio/workflow';
import z from 'zod';

const { getWeather } = proxyActivities<typeof activities>({
  startToCloseTimeout: '1 minute',
});

export async function haikuAgent(prompt: string): Promise<string> {
  const result = await generateText({
    model: temporalProvider.languageModel('gpt-4o-mini'),
    prompt,
    system: 'You only respond in haikus.',
  });
  return result.text;
}

export async function toolsAgent(question: string): Promise<string> {
  const result = await generateText({
    model: temporalProvider.languageModel('gpt-4o-mini'),
    prompt: question,
    system: 'You are a helpful agent.',
    tools: {
      getWeather: tool({
        description: 'Get the weather for a given city',
        inputSchema: z.object({
          location: z.string().describe('The location to get the weather for'),
        }),
        execute: getWeather,
      }),
    },
    stopWhen: stepCountIs(5),
  });
  return result.text;
}
```

--------------------------------

### Run Temporal Workflow Execution

Source: https://github.com/temporalio/samples-typescript/blob/main/hello-world-mtls/README.md

Use this command in a separate shell to initiate a Workflow execution after the Worker has started.

```bash
npm run workflow to run the Workflow
```

--------------------------------

### Define Basic Workflow and Activity

Source: https://context7.com/temporalio/samples-typescript/llms.txt

Defines a simple greeting Activity and a Workflow that orchestrates it. Use `proxyActivities` for type-safe activity stubs with configurable timeouts.

```typescript
// src/activities.ts
export async function greet(name: string): Promise<string> {
  return `Hello, ${name}!`;
}

// src/workflows.ts
import { proxyActivities } from '@temporalio/workflow';
import type * as activities from './activities';

const { greet } = proxyActivities<typeof activities>({
  startToCloseTimeout: '1 minute',
});

export async function example(name: string): Promise<string> {
  return await greet(name);
}
```

--------------------------------

### Execute Child Workflows

Source: https://context7.com/temporalio/samples-typescript/llms.txt

Starts child workflows using `executeChild`. Child workflows run independently but can be awaited and have their own history.

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

export async function parentWorkflow(...names: string[]): Promise<string> {
  const responseArray = await Promise.all(
    names.map((name) =>
      executeChild(childWorkflow, {
        args: [name],
        // cancellationType: ChildWorkflowCancellationType.WAIT_CANCELLATION_COMPLETED,
        // parentClosePolicy: ParentClosePolicy.PARENT_CLOSE_POLICY_TERMINATE
      }),
    ),
  );
  return responseArray.join('\n');
}

export async function childWorkflow(name: string): Promise<string> {
  return `I am a child named ${name}`;
}
```

--------------------------------

### Run Workflow Client

Source: https://github.com/temporalio/samples-typescript/blob/main/encryption/README.md

Execute the workflow client in a separate shell to initiate the workflow.

```bash
npm run workflow
```

--------------------------------

### Running Child Workflows Sample

Source: https://github.com/temporalio/samples-typescript/blob/main/child-workflows/README.md

This code block shows the expected output when running the child workflows sample. It indicates the successful completion and return values from child workflows.

```text
I am a child named Alice
I am a child named Bob
I am a child named Charlie
```

--------------------------------

### Run On-Demand Pattern Workflow

Source: https://github.com/temporalio/samples-typescript/blob/main/nexus-messaging/src/ondemandpattern/README.md

Executes the caller workflow that demonstrates the on-demand pattern. This will start, query, and modify remote workflows.

```bash
npm run workflow.ondemandpattern
```

--------------------------------

### Build Server for Production

Source: https://github.com/temporalio/samples-typescript/blob/main/nestjs-exchange-rates/README.md

Creates a production-optimized build of the NestJS server application using webpack.

```bash
npm run build:server:prod
```

--------------------------------

### Build and Test Mutex Sample

Source: https://github.com/temporalio/samples-typescript/blob/main/mutex/README.md

Compile the TypeScript code and run the unit tests to verify the mutex implementation.

```bash
npm run build && npm test
```

--------------------------------

### Upgrade SDK Versions

Source: https://github.com/temporalio/samples-typescript/blob/main/README.md

Command to upgrade Temporal SDK versions across all package.json files in the repository. Replace VERSION_STRING_HERE with the desired version.

```bash
pnpm run upgrade-versions -- 'VERSION_STRING_HERE'
pnpm run format
```

--------------------------------

### Use Protobufs for Data Serialization

Source: https://github.com/temporalio/samples-typescript/blob/main/README.md

Demonstrates how to use Protocol Buffers (Protobufs) for data serialization within Temporal. This is often used for security and efficient data transfer.

```typescript
import { Worker } from "@temporalio/worker";
import { Client } from "@temporalio/client";
import { protobuf } from "@temporalio/proto-converter"; // Assuming this is the correct import path

// Define your Protobuf messages (e.g., using .proto files and a compiler)
// import { MyMessage } from "./proto/my_messages";

async function setupWorkerAndClient() {
  // Configure the Worker with Protobuf data converter
  const worker = await Worker.create({
    // ... other worker options
    taskQueue: "my-task-queue",
    workflows: [/* your workflows */],
    activities: [/* your activities */],
    dataConverter: protobuf({ /* proto definitions or paths */ }),
  });

  // Configure the Client with Protobuf data converter
  const client = new Client({
    // ... client options
    dataConverter: protobuf({ /* proto definitions or paths */ }),
  });

  // Example usage within a workflow:
  // async function myWorkflow(input: MyMessage) { ... }
  // Example usage with client:
  // await client.execute(myWorkflow, { args: [myMessageInstance], ... });
}

// runWorkerAndClientSetup().catch(console.error);

```

--------------------------------

### Create Temporal Namespaces

Source: https://github.com/temporalio/samples-typescript/blob/main/nexus-hello/README.md

Creates the necessary namespaces for the caller and target environments.

```bash
temporal operator namespace create --namespace my-caller-namespace
```

```bash
temporal operator namespace create --namespace my-target-namespace
```

--------------------------------

### Workflow Application Failure Example

Source: https://github.com/temporalio/samples-typescript/blob/main/snippets/README.md

This workflow implementation sometimes fails by throwing an ApplicationFailure. This is useful for testing retry policies and error handling mechanisms.

```typescript
import {
	ApplicationFailure,
	proxyActivities,
	ExecuteInput,
	WorkflowInfo,
} from "@temporalio/workflow";

// Define activities
const activities = proxyActivities({
	sstartType: "@temporalio/workflow",
	// Use the same options as the client
	taskQueue: "hello-world",
	retry: {
		initialInterval: 1000,
		backoffCoefficient: 2,
		maximumInterval: 10000,
		maximumAttempts: 3,
	},
});

export async function myWorkflow(input: ExecuteInput):
	Promise<string> {
	const workflowInfo = WorkflowInfo;

	console.log(`Workflow ${workflowInfo.workflowId} started with input:`, input);

	// Simulate a failure on the 3rd attempt
	if (workflowInfo.attempt === 3) {
		throw new ApplicationFailure("Workflow failed on attempt 3", "MyCustomError");
	}

	const result = await activities.myActivity("World");
	return `Workflow completed with result: ${result}`;
}

```

--------------------------------

### Workflow Output

Source: https://github.com/temporalio/samples-typescript/blob/main/hello-world-js/README.md

The expected output from the Hello World workflow.

```text
Hello, Temporal!
```

--------------------------------

### Implement Nexus Service Handler

Source: https://context7.com/temporalio/samples-typescript/llms.txt

Implement handlers for Nexus service operations, including starting Temporal workflows. Requires `@temporalio/nexus` and the service API definition.

```typescript
// service/handler.ts - Operation handlers
import * as nexus from 'nexus-rpc';
import * as temporalNexus from '@temporalio/nexus';
import { helloService } from '../api';
import { helloWorkflow } from './workflows';

export const helloServiceHandler = nexus.serviceHandler(helloService, {
  echo: async (ctx, input) => input,
  hello: new temporalNexus.WorkflowRunOperationHandler(
    async (ctx, input) => {
      return await temporalNexus.startWorkflow(ctx, helloWorkflow, {
        args: [input],
        workflowId: ctx.requestId ?? crypto.randomUUID(),
      });
    },
  ),
});
```

--------------------------------

### Implement Signals and Queries

Source: https://context7.com/temporalio/samples-typescript/llms.txt

Shows how to implement signals for sending data into running workflows and queries for reading workflow state. Uses `defineSignal`, `defineQuery`, and `setHandler` for message passing.

```typescript
import * as wf from '@temporalio/workflow';

export const unblockSignal = wf.defineSignal('unblock');
export const isBlockedQuery = wf.defineQuery<boolean>('isBlocked');

export async function unblockOrCancel(): Promise<void> {
  let isBlocked = true;
  wf.setHandler(unblockSignal, () => void (isBlocked = false));
  wf.setHandler(isBlockedQuery, () => isBlocked);
  wf.log.info('Blocked');
  try {
    await wf.condition(() => !isBlocked);
    wf.log.info('Unblocked');
  } catch (err) {
    if (err instanceof wf.CancelledFailure) {
      wf.log.info('Cancelled');
    }
    throw err;
  }
}

// Client usage:
// await handle.signal(unblockSignal);
// const blocked = await handle.query(isBlockedQuery);
```

--------------------------------

### Expected Output of On-Demand Pattern

Source: https://github.com/temporalio/samples-typescript/blob/main/nexus-messaging/src/ondemandpattern/README.md

The expected output when the on-demand pattern workflow completes successfully. This shows the results of starting, querying, and updating remote workflows.

```text
started workflow one for user: UserId_One
started workflow two for user: UserId_Two
workflow one languages: chinese, english
workflow one: set language to spanish, previous was: english
workflow two current language: english
workflow two: set language to hindi, previous was: english
approved both workflows
workflow one result: Hola, mundo
workflow two result: नमस्ते दुनिया
```

--------------------------------

### Send Email Notification with Workflow Sleep

Source: https://github.com/temporalio/samples-typescript/blob/main/timer-examples/README.md

Use `sleep` to introduce a delay in a workflow, useful for conditional notifications. This example sends an email if an order takes too long.

```typescript
await workflow.sleep(Duration.from({ hours: 1 }));
  await client.sendEmail(orderId);

```

--------------------------------

### Run Codec Server

Source: https://github.com/temporalio/samples-typescript/blob/main/encryption/README.md

Run the codec server using npm to handle encryption and decryption requests. It listens on port 8888.

```bash
npm run codec-server
```