1# JavaScript (Node.js) — Azure Functions v4 Triggers & Bindings
2 
3> **Model**: JavaScript v4 programming model. **NO** `function.json` files.
4> Import: `const { app, input, output } = require('@azure/functions');`
5 
6## Lambda Migration Rules
7 
8> Shared rules (bindings over SDKs, latest runtime, identity-first auth) → [global-rules.md](../global-rules.md)
9 
10JS-specific:
11- Use `extraInputs` / `extraOutputs` with binding path expressions (e.g., `{queueTrigger}`) for dynamic blob I/O
12- Access metadata via `context.triggerMetadata`
13- `package.json`: `"@azure/functions": "^4.0.0"`
14 
15### Correct Migration Pattern
16 
17```javascript
18const { app, input, output } = require('@azure/functions');
19 
20// Use bindings for blob I/O instead of BlobServiceClient SDK
21const blobInput = input.storageBlob({
22  path: 'source-container/{queueTrigger}',
23  connection: 'AzureWebJobsStorage'
24});
25 
26const blobOutput = output.storageBlob({
27  path: 'destination-container/{queueTrigger}',
28  connection: 'AzureWebJobsStorage'
29});
30 
31app.storageQueue('processImage', {
32  queueName: 'image-processing',
33  connection: 'AzureWebJobsStorage',
34  extraInputs: [blobInput],
35  extraOutputs: [blobOutput],
36  handler: async (queueItem, context) => {
37    const sourceBlob = context.extraInputs.get(blobInput);
38    context.log(`Processing blob: ${queueItem}`);
39    // Process the blob...
40    context.extraOutputs.set(blobOutput, processedBuffer);
41  }
42});
43```
44 
45> ❌ Do NOT use legacy v1-v3 `module.exports` — always use `app.*()` registration.
46 
47## HTTP Trigger
48 
49```javascript
50app.http('httpFunction', {
51  methods: ['GET', 'POST'],
52  authLevel: 'anonymous',
53  handler: async (request, context) => {
54    const name = request.query.get('name') || (await request.text());
55    return { body: `Hello, ${name}!` };
56  }
57});
58```
59 
60## Blob Storage
61 
62```javascript
63// Trigger (use EventGrid source for reliability)
64app.storageBlob('blobTrigger', {
65  path: 'samples-workitems/{name}',
66  connection: 'AzureWebJobsStorage',
67  source: 'EventGrid',
68  handler: async (blob, context) => {
69    context.log(`Blob: ${context.triggerMetadata.name}, Size: ${blob.length}`);
70  }
71});
72 
73// Input binding
74const blobInput = input.storageBlob({
75  path: 'samples-workitems/{queueTrigger}',
76  connection: 'AzureWebJobsStorage'
77});
78 
79// Output binding
80const blobOutput = output.storageBlob({
81  path: 'samples-output/{name}-out',
82  connection: 'AzureWebJobsStorage'
83});
84```
85 
86> **⚠️ Flex Consumption + EventGrid Source Requirements:**
87> When using `source: 'EventGrid'` on a Flex Consumption plan, three infrastructure requirements MUST be met or the trigger will silently fail:
88>
89> 1. **Always-ready instances**: Configure `alwaysReady: [{ name: 'blob', instanceCount: 1 }]` in Bicep. Without this, the trigger group never starts and the Event Grid webhook endpoint is never registered.
90> 2. **Queue endpoint**: Set `AzureWebJobsStorage__queueServiceUri` in app settings. The blob extension uses queues internally for poison-message tracking with EventGrid source, even though you're not using a queue trigger.
91> 3. **Event Grid subscription via Bicep/ARM**: Do NOT create event subscriptions via CLI — webhook validation times out on Flex Consumption. Deploy as a Bicep resource using `listKeys()` to obtain the `blobs_extension` system key.
92>
93> See [lambda-to-functions.md](../lambda-to-functions.md#flex-consumption--blob-trigger-with-eventgrid-source) for full Bicep patterns.
94 
95### Using Azure AI Services with UAMI
96 
97When calling Azure AI services (Computer Vision, etc.) from a function, use `DefaultAzureCredential` with explicit UAMI client ID:
98 
99```javascript
100const { DefaultAzureCredential } = require('@azure/identity');
101const createClient = require('@azure-rest/ai-vision-image-analysis').default;
102 
103const credential = new DefaultAzureCredential({
104  managedIdentityClientId: process.env.AZURE_CLIENT_ID  // Required for UAMI
105});
106const client = createClient(process.env.COMPUTER_VISION_ENDPOINT, credential);
107 
108const result = await client.path('/imageanalysis:analyze').post({
109  body: { url: blobUrl },
110  queryParameters: { features: ['People'] }  // Use 'People' for face detection
111});
112```
113 
114> **Note**: `@azure-rest/ai-vision-image-analysis` is still in beta. Pin explicitly: `"1.0.0-beta.3"` — the `^1.0.0` semver range does NOT resolve.
115 
116## Queue Storage
117 
118```javascript
119// Trigger
120app.storageQueue('queueTrigger', {
121  queueName: 'myqueue-items',
122  connection: 'AzureWebJobsStorage',
123  handler: async (queueItem, context) => {
124    context.log('Queue item:', queueItem);
125  }
126});
127 
128// Output
129const queueOutput = output.storageQueue({
130  queueName: 'outqueue',
131  connection: 'AzureWebJobsStorage'
132});
133```
134 
135## Timer
136 
137```javascript
138app.timer('timerFunction', {
139  schedule: '0 */5 * * * *', // Every 5 minutes (NCRONTAB)
140  handler: async (myTimer, context) => {
141    context.log('Timer fired at:', myTimer.scheduleStatus.last);
142  }
143});
144```
145 
146## Event Grid
147 
148```javascript
149// Trigger
150app.eventGrid('eventGridTrigger', {
151  handler: async (event, context) => {
152    context.log('Event:', event.subject, event.eventType);
153  }
154});
155 
156// Output
157const eventGridOutput = output.eventGrid({
158  topicEndpointUri: 'MyEventGridTopicUriSetting',
159  topicKeySetting: 'MyEventGridTopicKeySetting'
160});
161```
162 
163## Cosmos DB
164 
165```javascript
166// Trigger (Change Feed)
167app.cosmosDB('cosmosDBTrigger', {
168  connectionStringSetting: 'CosmosDBConnection',
169  databaseName: 'mydb',
170  containerName: 'mycontainer',
171  createLeaseContainerIfNotExists: true,
172  handler: async (documents, context) => {
173    documents.forEach(doc => context.log('Changed doc:', doc.id));
174  }
175});
176 
177// Input
178const cosmosInput = input.cosmosDB({
179  connectionStringSetting: 'CosmosDBConnection',
180  databaseName: 'mydb',
181  containerName: 'mycontainer',
182  id: '{id}',
183  partitionKey: '{partitionKey}'
184});
185 
186// Output
187const cosmosOutput = output.cosmosDB({
188  connectionStringSetting: 'CosmosDBConnection',
189  databaseName: 'mydb',
190  containerName: 'mycontainer'
191});
192```
193 
194## Service Bus
195 
196```javascript
197// Queue Trigger
198app.serviceBusQueue('sbQueueTrigger', {
199  queueName: 'myqueue',
200  connection: 'ServiceBusConnection',
201  handler: async (message, context) => {
202    context.log('Message:', message);
203  }
204});
205 
206// Topic Trigger
207app.serviceBusTopic('sbTopicTrigger', {
208  topicName: 'mytopic',
209  subscriptionName: 'mysubscription',
210  connection: 'ServiceBusConnection',
211  handler: async (message, context) => {
212    context.log('Topic message:', message);
213  }
214});
215 
216// Output
217const sbOutput = output.serviceBusQueue({
218  queueName: 'outqueue',
219  connection: 'ServiceBusConnection'
220});
221```
222 
223## Event Hubs
224 
225```javascript
226// Trigger
227app.eventHub('eventHubTrigger', {
228  eventHubName: 'myeventhub',
229  connection: 'EventHubConnection',
230  cardinality: 'many',
231  handler: async (events, context) => {
232    events.forEach(event => context.log('Event:', event));
233  }
234});
235 
236// Output
237const ehOutput = output.eventHub({
238  eventHubName: 'outeventhub',
239  connection: 'EventHubConnection'
240});
241```
242 
243## Table Storage
244 
245```javascript
246// Input
247const tableInput = input.table({
248  tableName: 'mytable',
249  partitionKey: '{partitionKey}',
250  rowKey: '{rowKey}',
251  connection: 'AzureWebJobsStorage'
252});
253 
254// Output
255const tableOutput = output.table({
256  tableName: 'mytable',
257  connection: 'AzureWebJobsStorage'
258});
259```
260 
261## SQL
262 
263```javascript
264// Trigger
265app.generic('sqlTrigger', {
266  trigger: { type: 'sqlTrigger', tableName: 'dbo.MyTable', connectionStringSetting: 'SqlConnection' },
267  handler: async (changes, context) => {
268    changes.forEach(change => context.log('Change:', change));
269  }
270});
271 
272// Input
273const sqlInput = input.sql({
274  commandText: 'SELECT * FROM dbo.MyTable WHERE Id = @Id',
275  commandType: 'Text',
276  parameters: '@Id={id}',
277  connectionStringSetting: 'SqlConnection'
278});
279 
280// Output
281const sqlOutput = output.sql({
282  commandText: 'dbo.MyTable',
283  connectionStringSetting: 'SqlConnection'
284});
285```
286 
287## SignalR
288 
289```javascript
290// Output
291const signalROutput = output.generic({
292  type: 'signalR',
293  hubName: 'myhub',
294  connectionStringSetting: 'AzureSignalRConnectionString'
295});
296```
297 
298## SendGrid
299 
300```javascript
301const sendGridOutput = output.generic({
302  type: 'sendGrid',
303  apiKey: 'SendGridApiKey',
304  from: '[email protected]',
305  to: '{email}'
306});
307```
308 
309## Using Bindings with Functions
310 
311```javascript
312// Combine trigger with input/output bindings
313app.http('processItem', {
314  methods: ['POST'],
315  extraInputs: [cosmosInput],
316  extraOutputs: [queueOutput],
317  handler: async (request, context) => {
318    const doc = context.extraInputs.get(cosmosInput);
319    context.extraOutputs.set(queueOutput, JSON.stringify(doc));
320    return { body: 'Processed' };
321  }
322});
323```
324 
325> Full reference: [Azure Functions JavaScript developer guide](https://learn.microsoft.com/en-us/azure/azure-functions/functions-reference-node)
326