1# Durable Task Scheduler — JavaScript
2 
3## Learn More
4 
5- [Durable Task Scheduler documentation](https://learn.microsoft.com/azure/durable-task-scheduler/)
6- [Durable Functions JavaScript guide](https://learn.microsoft.com/azure/azure-functions/durable/durable-functions-overview?tabs=javascript)
7 
8## Durable Functions Setup
9 
10### Required npm Packages
11 
12```json
13{
14  "dependencies": {
15    "@azure/functions": "^4.0.0",
16    "durable-functions": "^3.0.0"
17  }
18}
19```
20 
21> **💡 Finding latest versions**: Run `npm view durable-functions version` or check [npmjs.com/package/durable-functions](https://www.npmjs.com/package/durable-functions) for the latest stable release.
22 
23### host.json
24 
25```json
26{
27  "version": "2.0",
28  "extensions": {
29    "durableTask": {
30      "hubName": "default",
31      "storageProvider": {
32        "type": "durabletask-scheduler",
33        "connectionStringName": "DURABLE_TASK_SCHEDULER_CONNECTION_STRING"
34      }
35    }
36  },
37  "extensionBundle": {
38    "id": "Microsoft.Azure.Functions.ExtensionBundle",
39    "version": "[4.*, 5.0.0)"
40  }
41}
42```
43 
44### local.settings.json
45 
46```json
47{
48  "IsEncrypted": false,
49  "Values": {
50    "FUNCTIONS_WORKER_RUNTIME": "node",
51    "AzureWebJobsStorage": "UseDevelopmentStorage=true",
52    "DURABLE_TASK_SCHEDULER_CONNECTION_STRING": "Endpoint=http://localhost:8080;TaskHub=default;Authentication=None"
53  }
54}
55```
56 
57## Minimal Example
58 
59```javascript
60const { app } = require("@azure/functions");
61const df = require("durable-functions");
62 
63// Activity
64df.app.activity("sayHello", {
65  handler: (city) => `Hello ${city}!`,
66});
67 
68// Orchestrator
69df.app.orchestration("myOrchestration", function* (context) {
70  const result1 = yield context.df.callActivity("sayHello", "Tokyo");
71  const result2 = yield context.df.callActivity("sayHello", "Seattle");
72  return `${result1}, ${result2}`;
73});
74 
75// HTTP Starter
76app.http("HttpStart", {
77  route: "orchestrators/{orchestrationName}",
78  methods: ["POST"],
79  authLevel: "function",
80  extraInputs: [df.input.durableClient()],
81  handler: async (request, context) => {
82    const client = df.getClient(context);
83    const instanceId = await client.startNew(request.params.orchestrationName);
84    return client.createCheckStatusResponse(request, instanceId);
85  },
86});
87```
88 
89## Workflow Patterns
90 
91### Fan-Out/Fan-In
92 
93```javascript
94df.app.orchestration("fanOutFanIn", function* (context) {
95  const cities = ["Tokyo", "Seattle", "London", "Paris", "Berlin"];
96 
97  // Fan-out: schedule all activities in parallel
98  const tasks = cities.map((city) => context.df.callActivity("sayHello", city));
99 
100  // Fan-in: wait for all to complete
101  const results = yield context.df.Task.all(tasks);
102  return results;
103});
104```
105 
106### Human Interaction
107 
108```javascript
109df.app.orchestration("approvalWorkflow", function* (context) {
110  yield context.df.callActivity("sendApprovalRequest", context.df.getInput());
111 
112  // Wait for approval event with timeout
113  const expiration = new Date(context.df.currentUtcDateTime);
114  expiration.setDate(expiration.getDate() + 3);
115 
116  const approvalTask = context.df.waitForExternalEvent("ApprovalEvent");
117  const timeoutTask = context.df.createTimer(expiration);
118 
119  const winner = yield context.df.Task.any([approvalTask, timeoutTask]);
120 
121  if (winner === approvalTask) {
122    return approvalTask.result ? "Approved" : "Rejected";
123  }
124  return "Timed out";
125});
126```
127 
128## Orchestration Determinism
129 
130| ❌ NEVER | ✅ ALWAYS USE |
131|----------|--------------|
132| `new Date()` | `context.df.currentUtcDateTime` |
133| `Math.random()` | Pass random values from activities |
134| `setTimeout()` | `context.df.createTimer()` |
135| Direct I/O, HTTP, database | `context.df.callActivity()` |
136 
137### Replay-Safe Logging
138 
139```javascript
140df.app.orchestration("myOrchestration", function* (context) {
141  if (!context.df.isReplaying) {
142    console.log("Started");  // Only logs once, not on replay
143  }
144  const result = yield context.df.callActivity("myActivity", "input");
145  return result;
146});
147```
148 
149## Error Handling & Retry
150 
151```javascript
152df.app.orchestration("workflowWithRetry", function* (context) {
153  const retryOptions = new df.RetryOptions(5000, 3); // firstRetryInterval, maxAttempts
154  retryOptions.backoffCoefficient = 2.0;
155  retryOptions.maxRetryIntervalInMilliseconds = 60000;
156 
157  try {
158    const result = yield context.df.callActivityWithRetry(
159      "unreliableService",
160      retryOptions,
161      context.df.getInput()
162    );
163    return result;
164  } catch (ex) {
165    context.df.setCustomStatus({ error: ex.message });
166    yield context.df.callActivity("compensationActivity", context.df.getInput());
167    return "Compensated";
168  }
169});
170```
171 
172## Durable Task SDK (Non-Functions)
173 
174For applications running outside Azure Functions (containers, VMs, Azure Container Apps, Azure Kubernetes Service):
175 
176```javascript
177const { createAzureManagedWorkerBuilder, createAzureManagedClient } = require("@microsoft/durabletask-js-azuremanaged");
178 
179const connectionString = "Endpoint=http://localhost:8080;Authentication=None;TaskHub=default";
180 
181// Activity
182const sayHello = async (_ctx, name) => `Hello ${name}!`;
183 
184// Orchestrator
185const myOrchestration = async function* (ctx, name) {
186  const result = yield ctx.callActivity(sayHello, name);
187  return result;
188};
189 
190async function main() {
191  // Worker
192  const worker = createAzureManagedWorkerBuilder(connectionString)
193    .addOrchestrator(myOrchestration)
194    .addActivity(sayHello)
195    .build();
196 
197  await worker.start();
198 
199  // Client
200  const client = createAzureManagedClient(connectionString);
201  const instanceId = await client.scheduleNewOrchestration("myOrchestration", "World");
202  const state = await client.waitForOrchestrationCompletion(instanceId, true, 30);
203  console.log("Output:", state.serializedOutput);
204 
205  await client.stop();
206  await worker.stop();
207}
208 
209main().catch(console.error);
210```
211 
212