azure-patterns

Files (1)

• SKILL.md

SKILL.md (first lines)

# Azure Patterns

## Azure Functions

### HTTP Trigger (Node.js v4)

```typescript
import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';

app.http('getOrder', {
  methods: ['GET'],
  authLevel: 'function',
  route: 'orders/{orderId}',
  handler: async (request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> => {
    const orderId = request.params.orderId;
    context.log(`Processing order: ${orderId}`);

    try {
      const order = await orderService.getById(orderId);
      if (!order) {
        return { status: 404, jsonBody: { error: 'Order not found' } };
      }
      return { status: 200, jsonBody: order };
    } catch (error) {
      context.error('Failed to get order', error);
      return { status: 500, jsonBody: { error: 'Internal server error' } };
    }
  },
});

// Service Bus trigger with retry
app.serviceBusTopic('processOrderEvent', {
  topicName: 'order-events',
  subscriptionName: 'order-processor',
  connection: 'ServiceBusConnection',
  handler: async (message: unknown, context: InvocationContext) => {
    const event = message as OrderEvent;
    context.log(`Processing event: ${event.type} for order ${event.orderId}`);

    await processEvent(event);
  },
});
```

### Durable Functions (Orchestrator)

```typescript
import * as df from 'durable-functions';

df.app.orchestration('orderWorkflow', function* (context) {
  const orderId = context.df.getInput() as string;

  // Step 1: Validate order
  const order = yield context.df.callActivity('validateOrder', orderId);

  // Step 2: Reserve inventory (with retry)
  const retryOptions = new df.RetryOptions(5000, 3); // 5s interval, 3 attempts
  yield context.df.callActivityWithRetry('reserveInventory', retryOptions, order);

  // Step 3: Charge payment
  yield context.df.callActivity('chargePayment', order);

  // Step 4: Wait for shipping confirmation (with timeout)
  const deadline = new Date(context.df.currentUtcDateTime.getTime() + 24 * 60 * 60 * 1000);
  const shippingEvent = context.df.waitForExternalEvent('shippingConfirmed');
  const timeout = context.df.createTimer(deadline);

  const winner = yield context.df.Task.any([shippingEvent, timeout]);
  if (winner === timeout) {
    yield context.df.callActivity('escalateShipping', orderId);
  }

  return { orderId, status: 'completed' };
});
```

## Cosmos DB Modeling

```typescript
// Partition key design: use tenant/user ID for multi-tenant
interface OrderDocument {
  id: string;                    // Unique document ID
  partitionKey: string;          // = tenantId (good distribution)
  type: 'order';                 // Discriminator for polymorphic container
  customerId: string;
  items: OrderItem[];            // Embed frequently accessed together
  total: number;
  status: string;
  createdAt: string;
  _etag?: string;                // Optimistic concurrency
}

// Optimistic concurrency with ETags
async function updateOrder(order: OrderDocument): Promise<void> {
  const container = cosmosClient.database('shop').container('orders');
  try {
    await container.item(order.id, order.partitionKey).replace(order, {
      accessCondition: { type: 'IfMatch', condition: order._etag },
    });
  } catch (error) {
    if (error.code === 412) {
      throw new ConflictError('Order was modified by another process');
    }
    throw error;
  }
}

// Change feed processor for event-driven updates
const changeFeedProcessor = cosmosClient
  .database('shop')
  .container('orders')
  .getChangeFeedProcessorBuilder('orderProcessor')
  .setFeedProcessorOptions({ startFromBeginning: false, maxItemCount: 25 })
  .setLeaseContainer(leaseContainer)
  .setProcessChanges(async (changes, context) => {
    for (const doc of changes) {
      await publishEvent({ type: 'order.updated', data: doc });
    }
  })

From vibeeval/vibecosystem, MIT.

More from vibeeval/vibecosystem