Quickstart: Create a JavaScript Durable Functions app

Use Durable Functions, a feature of Azure Functions, to write stateful serverless workflows in JavaScript. In this quickstart, you clone and run a sample app that demonstrates two common orchestration patterns:

• Function chaining: Calls activities sequentially (Tokyo → Seattle → London).
• Fan-out/fan-in: Calls activities in parallel across five cities, then aggregates the results.

By the end, you'll have both orchestrations running locally with the Durable Task Scheduler emulator and be able to view their status in the dashboard.

Prerequisites

• Node.js 18+ installed.
• Azure Functions Core Tools v4 or later.
• Docker for running the emulator and Azurite.
• Clone the Durable Task Scheduler GitHub repository to use the quickstart sample.

Set up the Durable Task Scheduler emulator

The Durable Task Scheduler emulator provides a local development environment so you can test orchestrations without an Azure subscription. The Functions host also requires Azurite for local storage.

Start both containers:

docker run -d --name dtsemulator -p 8080:8080 -p 8082:8082 \
  mcr.microsoft.com/dts/dts-emulator:latest

docker run -d --name azurite -p 10000:10000 -p 10001:10001 -p 10002:10002 \
  mcr.microsoft.com/azure-storage/azurite

Run the quickstart sample

1. Navigate to the Hello Cities sample directory:

   cd samples/durable-functions/javascript/HelloCities
   

2. Install dependencies:

   npm install
   

3. Verify that the local.settings.json file contains the following configuration:

   {
     "IsEncrypted": false,
     "Values": {
       "AzureWebJobsStorage": "UseDevelopmentStorage=true",
       "FUNCTIONS_WORKER_RUNTIME": "node",
       "DURABLE_TASK_SCHEDULER_CONNECTION_STRING": "Endpoint=http://localhost:8080;TaskHub=default;Authentication=None"
     }
   }
   

4. Start the function app:

   func start
   

5. In a separate terminal, trigger the function chaining orchestration:

   $response = Invoke-RestMethod -Method POST -Uri http://localhost:7071/api/StartChaining
   $response
   

   The response contains status URLs for the orchestration instance. Copy the statusQueryGetUri value and run it to check the result:

   Invoke-RestMethod -Uri $response.statusQueryGetUri
   

6. Trigger the fan-out/fan-in orchestration:

   $response = Invoke-RestMethod -Method POST -Uri http://localhost:7071/api/StartFanOutFanIn
   Invoke-RestMethod -Uri $response.statusQueryGetUri
   

Expected output

The POST request returns a JSON response with status URLs. For example:

{
  "id": "<instanceId>",
  "statusQueryGetUri": "http://localhost:7071/runtime/webhooks/durabletask/instances/<instanceId>?code=...",
  "sendEventPostUri": "...",
  "terminatePostUri": "...",
  "purgeHistoryDeleteUri": "..."
}

When you query statusQueryGetUri and the orchestration's runtimeStatus is Completed, you can find the greeting results in the output field. The chaining orchestration returns:

{
  "name": "chainingOrchestration",
  "runtimeStatus": "Completed",
  "output": ["Hello Tokyo!", "Hello Seattle!", "Hello London!"]
}

The fan-out/fan-in orchestration returns:

{
  "name": "fanOutFanInOrchestration",
  "runtimeStatus": "Completed",
  "output": ["Hello Tokyo!", "Hello Seattle!", "Hello London!", "Hello Paris!", "Hello Berlin!"]
}

Open the Durable Task Scheduler dashboard at http://localhost:8082 to view the orchestration status and execution history.

Understand the code

The sample uses the Node.js v4 programming model, where all functions are defined in a single file (src/functions/helloCities.js).

Activity function

The sayHello activity takes a city name and returns a greeting:

df.app.activity("sayHello", {
  handler: (city) => {
    return `Hello ${city}!`;
  },
});

Orchestrator functions

The chaining orchestrator calls sayHello sequentially for three cities:

df.app.orchestration("chainingOrchestration", function* (context) {
  const outputs = [];
  outputs.push(yield context.df.callActivity("sayHello", "Tokyo"));
  outputs.push(yield context.df.callActivity("sayHello", "Seattle"));
  outputs.push(yield context.df.callActivity("sayHello", "London"));
  return outputs;
});

The fan-out/fan-in orchestrator schedules activities in parallel:

df.app.orchestration("fanOutFanInOrchestration", function* (context) {
  const cities = ["Tokyo", "Seattle", "London", "Paris", "Berlin"];

  // Fan-out: schedule all activities in parallel
  const tasks = cities.map((city) => context.df.callActivity("sayHello", city));

  // Fan-in: wait for all to complete
  const results = yield context.df.Task.all(tasks);
  return results;
});

Client functions

HTTP-triggered client functions start each orchestration. For example, the chaining starter:

app.http("StartChaining", {
  route: "StartChaining",
  methods: ["POST"],
  authLevel: "anonymous",
  extraInputs: [df.input.durableClient()],
  handler: async (request, context) => {
    const client = df.getClient(context);
    const instanceId = await client.startNew("chainingOrchestration");
    context.log(`Started chaining orchestration with ID = '${instanceId}'.`);
    return client.createCheckStatusResponse(request, instanceId);
  },
});

Configuration

The sample uses the Durable Task Scheduler emulator as its storage backend. This is configured in host.json:

{
  "version": "2.0",
  "logging": {
    "logLevel": {
      "DurableTask.Core": "Warning"
    }
  },
  "extensions": {
    "durableTask": {
      "hubName": "default",
      "storageProvider": {
        "type": "azureManaged",
        "connectionStringName": "DURABLE_TASK_SCHEDULER_CONNECTION_STRING"
      }
    }
  },
  "extensionBundle": {
    "id": "Microsoft.Azure.Functions.ExtensionBundle",
    "version": "[4.*, 5.0.0)"
  }
}

Clean up resources

Stop the emulator containers when you're done:

docker stop dtsemulator azurite && docker rm dtsemulator azurite

Next steps

• Learn about common Durable Functions app patterns.
• Learn about Durable Functions storage providers.