{
  "name": "database_create_order",
  "arguments": {
    "customer_name": "Alice",
    "items": [{ "product": "Widget", "price": 10 }]
  }
}

await db.create('Order', {
  customer: $.Person({ name: 'Alice' }),
  items: [$.Product({ name: 'Widget', price: 10 })],
})

{
  "name": "do",
  "description": "Execute TypeScript against sdk.do modules. Semantic Business-as-Code primitives.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "script": {
        "type": "string",
        "description": "TypeScript code to execute, or '{module}.md' for documentation"
      },
      "module": {
        "type": "string",
        "description": "MDXLD module definition with yaml frontmatter ($type, $id, $context), markdown content, and MDX/JSX components. Defines persistent entities like Workflow, Agent, or WebSite."
      }
    }
  }
}

$: Proxy<$.Subject.predicate.Object>

db: {
  ;(list<T>(type), get<T>(type, id), create<T>(type, data), update<T>(type, id, data), delete (type, id), relate(from, rel, to))
}

ai: {
  ;(generate<T>(opts), embed(text), batch(requests))
}

api: {
  ;(fetch(url, opts), proxy(service, path, opts))
}

on: <Event>(pattern, handler)

send: <Event>(pattern, data)

every: (schedule, handler)

user: {
  ;(current(), session(), can(action, resource))
}

// Simple query - executes and returns immediately
await db.list('Business')

// Complex multi-step operation
const customer = await db.create('Person', {
  name: 'Alice',
  email: '[email protected]',
})

const order = await db.create('Order', {
  customer,
  items: [$.Product({ name: 'Widget', price: 29.99 })],
  total: 29.99,
})

// Send notification
await send($.Email.send, {
  to: customer.email,
  subject: 'Order Confirmation',
  body: `Your order #${order.id} has been confirmed`,
})

// Return final result
order

// Returns the result of db.list
await db.list('Order')

// Returns 42
const x = 10
const y = 32
x + y

// Returns the order object
const order = await db.create('Order', { ... })
order

// Returns nothing (undefined)
const result = await db.create('Order', { ... })
await send($.Email.send, { ... })

// Returns array of results
const orders = await db.list('Order')
orders.map(o => ({ id: o.id, total: o.total }))

// Event handler - registers and persists
on($.Order.created, async (order) => {
  await send($.Email.send, {
    to: order.customer.email,
    subject: 'Order Confirmation',
  })
})

// Scheduled task - registers and persists
every('0 9 * * *', async () => {
  const pending = await db.list('Order', {
    where: { status: 'pending' },
  })

  for (const order of pending) {
    await send($.Order.reminder, { orderId: order.id })
  }
})

// This registers a handler but doesn't execute it immediately
on($.Order.created, async (order) => {
  console.log('New order:', order.id)
  await send($.Email.send, { ... })
})

// Multiple handlers can be registered
on($.Order.created, handler1)
on($.Order.updated, handler2)
every('0 * * * *', handler3)

// Handlers execute when triggered:
// - Order created → handler1 fires
// - Order updated → handler2 fires
// - Every hour → handler3 fires

---
$type: Workflow
$id: /workflows/order-fulfillment
$context: https://platform.do
title: Order Fulfillment Workflow
description: Automated order processing and notification
---

# Order Fulfillment

This workflow handles the complete order lifecycle from creation to delivery.

## Features

- Automatic customer notifications
- Payment processing
- Inventory management
- Shipping coordination

import { OrderStatus } from './components'

export const config = {
  timeout: 30000,
  retries: 3,
}

<OrderStatus showProgress={true} />

on($.Order.created, async (order) => {
  await send($.Payment.process, { orderId: order.id })
  await send($.Email.send, {
    to: order.customer.email,
    subject: 'Order Confirmation',
  })
})

on($.Payment.completed, async (payment) => {
  await db.update('Order', payment.orderId, { status: 'paid' })
  await send($.Inventory.allocate, { orderId: payment.orderId })
})

every('0 */6 * * *', async () => {
  const stale = await db.list('Order', {
    where: { status: 'pending', createdAt: { before: '24 hours ago' } },
  })
  for (const order of stale) {
    await send($.Order.reminder, { orderId: order.id })
  }
})

await client.useTool('do', {
  module: `---
$type: Agent
$id: /agents/customer-support
$context: https://platform.do
---

# Customer Support Agent

Handles customer inquiries and support tickets.

on($.Ticket.created, async (ticket) => {
  const response = await ai.generate({
    prompt: \`Respond to: \${ticket.message}\`,
    schema: $.Response
  })

  await db.create('Response', {
    ticketId: ticket.id,
    message: response.text,
    sentiment: response.sentiment
  })

  if (response.escalate) {
    await send($.Human.review, { ticketId: ticket.id })
  }
})
`,
})

// Register persistent event handlers
on($.Order.created, async (order) => {
  await send($.Email.send, {
    to: order.customer.email,
    subject: 'Order Confirmation',
  })
})

on($.Payment.succeeded, async (payment) => {
  await db.update('Order', payment.orderId, {
    status: 'paid',
  })
})

// Execute immediate operation
const order = await db.create('Order', {
  customer: $.Person({ name: 'Alice' }),
  items: [$.Product({ name: 'Widget', price: 29.99 })],
  total: 29.99,
})

// Trigger the event (handlers above will fire)
await send($.Order.created, order)

// Return the order
order

// Request $ documentation
'$.md'

// Request db documentation
'db.md'

// Request ai documentation
'ai.md'

const person = $.Person({ name: 'Alice' })
const org = $.Organization({ name: 'Acme Corp' })
const order = $.Order({ customer: person, seller: org })

// Event patterns
on($.Order.created, handler)
await send($.Email.send, { ... })

// CRUD operations
await db.list('Business')
await db.get('Order', 'ord_123')
await db.create('Order', { ... })
await db.update('Order', 'ord_123', { ... })
await db.delete('Order', 'ord_123')

// Relationships
await db.relate(order, 'customer', person)

// Generate with schema
const plan = await ai.generate({
  prompt: 'Create a business plan',
  schema: $.BusinessPlan,
  model: 'claude-sonnet-4.5',
})

// Embeddings
const embedding = await ai.embed('search text')

// Batch processing
const results = await ai.batch([
  { type: 'generate', prompt: 'Write a slogan' },
  { type: 'embed', text: 'product description' },
])

// External APIs
const data = await api.fetch('https://api.example.com/data')

// Integrated services
const customer = await api.proxy('stripe', '/v1/customers/cus_123')

on($.Order.created, async (order) => {
  await send($.Email.send, {
    to: order.customer.email,
    subject: 'Order Confirmation',
  })
})

on($.Payment.succeeded, async (payment) => {
  await db.update('Order', payment.orderId, {
    status: 'paid',
  })
})

// Send email
await send($.Email.send, {
  to: '[email protected]',
  subject: 'Welcome!',
  body: 'Thank you for signing up',
})

// Domain event
await send($.Order.created, {
  orderId: 'ord_123',
  customerId: 'cus_456',
})

// Run every hour
every('0 * * * *', async () => {
  const pending = await db.list('Order', {
    where: { status: 'pending' },
  })

  for (const order of pending) {
    await send($.Order.reminder, { orderId: order.id })
  }
})

// Daily at 9 AM
every('0 9 * * *', async () => {
  await send($.Report.daily, { date: new Date() })
})

// Current user
const currentUser = user.current()
if (currentUser) {
  console.log('User ID:', currentUser.id)
  console.log('Email:', currentUser.email)
}

// Permissions
if (user.can('create', 'Order')) {
  await db.create('Order', { ... })
}

// List all businesses
await db.list('Business')

// Get specific order
await db.get('Order', 'ord_123')

// Filter and sort
await db.list('Order', {
  where: { status: 'pending' },
  sort: { createdAt: 'desc' },
  limit: 10,
})

// Create customer
const customer = await db.create('Person', {
  name: 'Alice',
  email: '[email protected]',
})

// Create order with relationship
const order = await db.create('Order', {
  customer: customer,
  items: [$.Product({ name: 'Widget', price: 29.99 })],
  total: 29.99,
  status: 'pending',
})

// Send confirmation
await send($.Email.send, {
  to: customer.email,
  subject: 'Order Confirmation',
  body: `Your order #${order.id} has been confirmed`,
})

order

// Get all products
const products = await db.list('Product')

// Generate descriptions with AI
const results = await Promise.all(
  products.map(async (product) => {
    const description = await ai.generate({
      prompt: `Write a compelling product description for ${product.name}`,
      schema: $.Text,
      model: 'gpt-5',
    })

    await db.update('Product', product.id, {
      description: description.text,
    })

    return { id: product.id, updated: true }
  })
)

results

// Order created handler
on($.Order.created, async (order) => {
  // Send confirmation email
  await send($.Email.send, {
    to: order.customer.email,
    subject: 'Order Confirmation',
    body: `Your order #${order.id} has been received`,
  })

  // Update inventory
  for (const item of order.items) {
    const product = await db.get('Product', item.productId)
    await db.update('Product', item.productId, {
      stock: product.stock - item.quantity,
    })
  }

  // Trigger fulfillment
  await send($.Fulfillment.start, { orderId: order.id })
})

// Payment succeeded handler
on($.Payment.succeeded, async (payment) => {
  await db.update('Order', payment.orderId, {
    status: 'paid',
    paidAt: new Date(),
  })

  await send($.Order.paid, {
    orderId: payment.orderId,
    amount: payment.amount,
  })
})

// Clean up stale orders every 6 hours
every('0 */6 * * *', async () => {
  const staleOrders = await db.list('Order', {
    where: {
      status: 'pending',
      createdAt: { lt: Date.now() - 24 * 60 * 60 * 1000 }, // 24 hours ago
    },
  })

  for (const order of staleOrders) {
    await db.update('Order', order.id, {
      status: 'cancelled',
      cancelledAt: new Date(),
    })

    await send($.Order.cancelled, { orderId: order.id })
  }
})

// Daily report at 9 AM
every('0 9 * * *', async () => {
  const yesterday = new Date(Date.now() - 24 * 60 * 60 * 1000)

  const orders = await db.list('Order', {
    where: { createdAt: { gte: yesterday } },
  })

  const revenue = orders.reduce((sum, o) => sum + o.total, 0)

  await send($.Email.send, {
    to: '[email protected]',
    subject: 'Daily Report',
    body: `Orders: ${orders.length}, Revenue: $${revenue}`,
  })
})

// Complex workflow in single script
const businesses = await db.list('Business', {
  where: { industry: 'Technology' },
})

// Filter high-growth businesses
const highGrowth = businesses.filter((b) => b.growthRate > 0.5)

// Generate AI insights for each
const insights = await Promise.all(
  highGrowth.map(async (biz) => {
    const insight = await ai.generate({
      prompt: `Analyze growth trends for ${biz.name}. Growth rate: ${biz.growthRate}`,
      schema: $.Article,
      model: 'claude-sonnet-4.5',
    })

    // Store insight
    await db.create('Article', {
      about: $.Organization({ id: biz.id }),
      headline: insight.headline,
      articleBody: insight.articleBody,
      author: $.Person({ name: 'AI Analyst' }),
    })

    // Notify stakeholders
    await send($.Notification.send, {
      type: 'business-insight',
      businessId: biz.id,
      insightId: insight.id,
    })

    return insight
  })
)

insights

await db.list('Business')
await db.get('Order', 'ord_123')
await ai.embed('search text')
await api.fetch('https://api.example.com/data') // GET only

await db.create('Order', { ... })      // Write operation
await db.update('Order', id, { ... })  // Write operation
await send($.Email.send, { ... })      // Side effect
await ai.generate({ ... })             // Side effect (cost)
every('0 * * * *', handler)            // Persistent subscription
on($.Order.created, handler)           // Persistent subscription

// Check authentication
const currentUser = user.current()

if (currentUser) {
  // Full access
  await db.create('Order', { ... })
  await send($.Email.send, { ... })
  await ai.generate({ ... })
} else {
  // Readonly only
  await db.list('Business')
  await db.get('Order', 'ord_123')
}

// Check permissions before operations
if (user.can('create', 'Order')) {
  await db.create('Order', { ... })
} else {
  throw new Error('Permission denied: cannot create orders')
}

if (user.can('delete', 'Order')) {
  await db.delete('Order', orderId)
}

// Admin check
if (user.can('admin', '*')) {
  // Admin operations
}

{
  "content": [
    {
      "type": "text",
      "text": "Error: Cannot read property 'name' of undefined\n  at line 3:15"
    }
  ],
  "isError": true
}

{
  "content": [
    {
      "type": "text",
      "text": "Readonly violations detected:\n- db.create() at line 5\n- send() at line 8"
    }
  ],
  "isError": true
}

{
  "content": [
    {
      "type": "text",
      "text": "Execution timeout after 10000ms"
    }
  ],
  "isError": true
}

{
  "content": [
    {
      "type": "text",
      "text": "Authentication required for write operations"
    }
  ],
  "isError": true
}

// ✅ Good: Semantic types
await db.create('Order', {
  customer: $.Person({ name: 'Alice' }),
  seller: $.Organization({ name: 'Acme' }),
})

// ❌ Bad: Plain objects
await db.create('Order', {
  customer_name: 'Alice',
  seller_name: 'Acme',
})

// ✅ Good: Await async operations
const result = await db.list('Business')

// ❌ Bad: Forgot await
const result = db.list('Business') // Returns Promise

// ✅ Good: Types inferred from schema
const plan = await ai.generate({
  prompt: 'Create a business plan',
  schema: $.BusinessPlan,
})
// plan.executive_summary is type-safe

// ❌ Bad: No schema
const plan = await ai.generate({
  prompt: 'Create a business plan',
})
// plan is 'any' type

// ✅ Good: Single script with multiple operations
const customer = await db.create('Person', { ... })
const order = await db.create('Order', { customer, ... })
await send($.Email.send, { to: customer.email })
order

// ❌ Bad: Multiple separate tool calls
// (Requires AI round-trips between each step)

// ✅ Good: Single batch call
await ai.batch([
  { type: 'embed', text: texts[0] },
  { type: 'embed', text: texts[1] },
  { type: 'embed', text: texts[2] },
])

// ❌ Bad: Multiple separate calls
for (const text of texts) {
  await ai.embed(text)
}

// ✅ Good: Parallel
const [orders, customers] = await Promise.all([db.list('Order'), db.list('Customer')])

// ❌ Bad: Sequential
const orders = await db.list('Order')
const customers = await db.list('Customer')

// Fetch only what you need
const recentOrders = await db.list('Order', {
  limit: 10,
  sort: { createdAt: 'desc' },
})

// Filter at database level
const activeOrders = await db.list('Order', {
  where: { status: 'active' },
})

// Not in application code
const allOrders = await db.list('Order')
const activeOrders = allOrders.filter((o) => o.status === 'active')

// Process multiple items in single batch
const results = await ai.batch(
  products.map((p) => ({
    type: 'generate',
    prompt: `Describe ${p.name}`,
    schema: $.Text,
  }))
)

// Cache AI results
const cached = await db.get('Cache', cacheKey)
if (cached) {
  return cached.value
}

const result = await ai.generate({ ... })
await db.create('Cache', {
  key: cacheKey,
  value: result,
  expiresAt: Date.now() + 3600000  // 1 hour
})

return result

const orders = await db.list('Order')
console.log('Found orders:', orders.length)

for (const order of orders) {
  console.log('Processing order:', order.id)
  await processOrder(order)
}

const customer = await db.get('Person', 'per_123')
console.log('Customer:', JSON.stringify(customer, null, 2))

const order = await db.create('Order', { customer, ... })
console.log('Created order:', order)

try {
  const result = await db.create('Order', { ... })
  console.log('Success:', result)
} catch (error) {
  console.error('Failed:', error.message)
  throw error
}

// Define reusable order processing function
export async function processOrder(orderId: string) {
  const order = await db.get('Order', orderId)
  const customer = await db.get('Person', order.customerId)

  // Validate order
  if (!order || order.status !== 'pending') {
    throw new Error('Invalid order state')
  }

  // Process payment
  const payment = await api.proxy('stripe', '/v1/charges', {
    method: 'POST',
    body: {
      amount: order.total * 100,
      currency: 'usd',
      customer: customer.stripeId,
    },
  })

  // Update order
  await db.update('Order', orderId, {
    status: 'paid',
    paidAt: new Date(),
    paymentId: payment.id,
  })

  // Send confirmation
  await send($.Email.send, {
    to: customer.email,
    subject: 'Payment Confirmed',
    body: `Your payment of $${order.total} has been processed.`,
  })

  return { orderId, paymentId: payment.id, status: 'paid' }
}

// Export utility function
export async function calculateOrderTotal(items: Array<any>) {
  let total = 0
  for (const item of items) {
    const product = await db.get('Product', item.productId)
    total += product.price * item.quantity
  }
  return total
}

// Customer onboarding workflow
export async function onboardCustomer(data: { name: string; email: string; company?: string }) {
  // Step 1: Create customer record
  const customer = await db.create('Person', {
    name: data.name,
    email: data.email,
    status: 'active',
    createdAt: new Date(),
  })

  // Step 2: Create company if provided
  if (data.company) {
    const company = await db.create('Organization', {
      name: data.company,
      legalName: data.company,
    })

    await db.relate(customer, 'worksFor', company)
  }

  // Step 3: Generate welcome email with AI
  const welcomeEmail = await ai.generate({
    prompt: `Write a warm welcome email for ${data.name}. Include a brief intro to our platform and next steps.`,
    schema: $.EmailMessage,
    model: 'claude-sonnet-4.5',
  })

  // Step 4: Send welcome email
  await send($.Email.send, {
    to: data.email,
    from: '[email protected]',
    subject: welcomeEmail.subject,
    body: welcomeEmail.body,
  })

  // Step 5: Schedule follow-up
  await send($.Schedule.create, {
    type: 'email',
    recipientId: customer.id,
    template: 'onboarding-day-3',
    sendAt: new Date(Date.now() + 3 * 24 * 60 * 60 * 1000),
  })

  // Step 6: Trigger onboarding event
  await send($.Customer.onboarded, {
    customerId: customer.id,
    timestamp: new Date(),
  })

  return customer
}

// Product catalog sync workflow
export async function syncProductCatalog(source: string) {
  const products = await api.fetch(`https://api.${source}.com/products`)

  const results = []
  for (const productData of products) {
    // Check if product exists
    const existing = await db.list('Product', {
      where: { sku: productData.sku },
      limit: 1,
    })

    if (existing.length > 0) {
      // Update existing product
      const updated = await db.update('Product', existing[0].id, {
        name: productData.name,
        price: productData.price,
        stock: productData.stock,
        updatedAt: new Date(),
      })
      results.push({ sku: productData.sku, action: 'updated', id: updated.id })
    } else {
      // Create new product
      const created = await db.create('Product', {
        sku: productData.sku,
        name: productData.name,
        price: productData.price,
        stock: productData.stock,
        source: source,
        createdAt: new Date(),
      })
      results.push({ sku: productData.sku, action: 'created', id: created.id })
    }
  }

  return {
    source,
    totalProcessed: results.length,
    created: results.filter((r) => r.action === 'created').length,
    updated: results.filter((r) => r.action === 'updated').length,
    timestamp: new Date(),
  }
}

// E-commerce event handlers module
export function setupEcommerceHandlers() {
  // Order lifecycle handlers
  on($.Order.created, async (order) => {
    const customer = await db.get('Person', order.customerId)

    await send($.Email.send, {
      to: customer.email,
      subject: `Order Confirmation #${order.orderNumber}`,
      body: `Thank you for your order! Total: $${order.total}`,
    })

    await send($.Analytics.track, {
      event: 'order_created',
      userId: customer.id,
      properties: { orderId: order.id, total: order.total },
    })
  })

  on($.Order.paid, async (event) => {
    await db.update('Order', event.orderId, {
      status: 'processing',
      processingStartedAt: new Date(),
    })

    await send($.Fulfillment.start, {
      orderId: event.orderId,
      priority: event.amount > 500 ? 'high' : 'normal',
    })
  })

  on($.Order.shipped, async (event) => {
    const order = await db.get('Order', event.orderId)
    const customer = await db.get('Person', order.customerId)

    await send($.Email.send, {
      to: customer.email,
      subject: 'Your Order Has Shipped!',
      body: `Tracking: ${event.trackingNumber}`,
    })
  })

  // Inventory management handlers
  on($.Product.lowStock, async (product) => {
    if (product.stock < 10) {
      await send($.Email.send, {
        to: '[email protected]',
        subject: `Low Stock Alert: ${product.name}`,
        body: `Current stock: ${product.stock}. Reorder recommended.`,
      })
    }
  })

  // Customer engagement handlers
  on($.Customer.inactive, async (customer) => {
    const email = await ai.generate({
      prompt: `Write a re-engagement email for ${customer.name}. They haven't made a purchase in 90 days. Offer 15% discount code: COMEBACK15`,
      schema: $.EmailMessage,
      model: 'gpt-5',
    })

    await send($.Email.send, {
      to: customer.email,
      subject: email.subject,
      body: email.body,
    })
  })
}

// Register all handlers
setupEcommerceHandlers()

// Analytics and reporting tasks
export function setupAnalyticsTasks() {
  // Daily sales report
  every('0 9 * * *', async () => {
    const yesterday = new Date(Date.now() - 24 * 60 * 60 * 1000)
    const orders = await db.list('Order', {
      where: { createdAt: { gte: yesterday.toISOString() } },
    })

    const report = {
      date: yesterday.toLocaleDateString(),
      totalOrders: orders.length,
      totalRevenue: orders.reduce((sum, o) => sum + o.total, 0),
      avgOrderValue: orders.length > 0 ? orders.reduce((sum, o) => sum + o.total, 0) / orders.length : 0,
    }

    await send($.Email.send, {
      to: '[email protected]',
      subject: `Daily Sales Report - ${report.date}`,
      body: JSON.stringify(report, null, 2),
    })
  })

  // Weekly customer segmentation
  every('0 8 * * MON', async () => {
    const customers = await db.list('Person')

    for (const customer of customers) {
      const orders = await db.list('Order', {
        where: { customerId: customer.id },
      })

      const totalSpent = orders.reduce((sum, o) => sum + o.total, 0)
      const segment = totalSpent > 1000 ? 'VIP' : totalSpent > 500 ? 'Premium' : 'Regular'

      await db.update('Person', customer.id, {
        segment,
        totalSpent,
        lastSegmentedAt: new Date(),
      })
    }
  })

  // Hourly stale order cleanup
  every('0 * * * *', async () => {
    const staleOrders = await db.list('Order', {
      where: {
        status: 'pending',
        createdAt: { lt: new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString() },
      },
    })

    for (const order of staleOrders) {
      await db.update('Order', order.id, {
        status: 'cancelled',
        cancelledAt: new Date(),
        cancelReason: 'stale',
      })

      await send($.Order.cancelled, { orderId: order.id })
    }
  })
}

setupAnalyticsTasks()

// Import from another module
import { processOrder, calculateOrderTotal } from './order-processing'
import { onboardCustomer } from './customer-workflows'
import { setupEcommerceHandlers } from './event-handlers'

// Use imported functions in scripts
const items = [
  { productId: 'prod_123', quantity: 2 },
  { productId: 'prod_456', quantity: 1 },
]

const total = await calculateOrderTotal(items)
console.log('Order total:', total)

// Use in event handlers
on($.Order.pendingPayment, async (order) => {
  try {
    await processOrder(order.id)
  } catch (error) {
    console.error('Failed to process order:', error)
    await send($.Order.paymentFailed, { orderId: order.id, error: error.message })
  }
})

// Compose workflows
const newCustomer = await onboardCustomer({
  name: 'Alice Smith',
  email: '[email protected]',
  company: 'Acme Corp',
})

// Set up all event handlers
setupEcommerceHandlers()

// Complete order fulfillment in one script
async function fulfillOrder(orderId: string) {
  // Step 1: Get order and validate
  const order = await db.get('Order', orderId)
  if (!order || order.status !== 'paid') {
    throw new Error('Order not ready for fulfillment')
  }

  // Step 2: Check inventory
  const inventoryOk = true
  for (const item of order.items) {
    const product = await db.get('Product', item.productId)
    if (product.stock < item.quantity) {
      inventoryOk = false
      break
    }
  }

  if (!inventoryOk) {
    await send($.Order.backorder, { orderId })
    return { status: 'backorder' }
  }

  // Step 3: Reserve inventory
  for (const item of order.items) {
    const product = await db.get('Product', item.productId)
    await db.update('Product', item.productId, {
      stock: product.stock - item.quantity,
    })
  }

  // Step 4: Generate shipping label
  const customer = await db.get('Person', order.customerId)
  const shipping = await api.proxy('shippo', '/shipments', {
    method: 'POST',
    body: {
      address_to: customer.address,
      parcels: order.items.map((i) => ({ weight: i.weight })),
    },
  })

  // Step 5: Update order
  await db.update('Order', orderId, {
    status: 'shipped',
    trackingNumber: shipping.tracking_number,
    shippedAt: new Date(),
  })

  // Step 6: Notify customer
  await send($.Email.send, {
    to: customer.email,
    subject: 'Your Order Has Shipped!',
    body: `Tracking: ${shipping.tracking_number}`,
  })

  // Step 7: Trigger analytics
  await send($.Analytics.track, {
    event: 'order_shipped',
    properties: { orderId, trackingNumber: shipping.tracking_number },
  })

  return {
    status: 'shipped',
    trackingNumber: shipping.tracking_number,
    trackingUrl: shipping.tracking_url,
  }
}

// Execute workflow
await fulfillOrder('ord_123')

// Error handling with try-catch
async function processOrderWithErrorHandling(orderId: string) {
  try {
    const order = await db.get('Order', orderId)

    if (!order) {
      throw new Error('Order not found')
    }

    const result = await api.proxy('stripe', '/v1/charges', {
      method: 'POST',
      body: { amount: order.total * 100, currency: 'usd' },
    })

    await db.update('Order', orderId, {
      status: 'paid',
      paymentId: result.id,
    })

    return { success: true, paymentId: result.id }
  } catch (error) {
    console.error('Payment failed:', error.message)

    await db.update('Order', orderId, {
      status: 'payment_failed',
      errorMessage: error.message,
    })

    await send($.Order.paymentFailed, {
      orderId,
      error: error.message,
      timestamp: new Date(),
    })

    return { success: false, error: error.message }
  }
}

// Retry pattern with exponential backoff
async function withRetry<T>(fn: () => Promise<T>, maxRetries = 3, baseDelay = 1000): Promise<T> {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await fn()
    } catch (error) {
      if (i === maxRetries - 1) throw error

      const delay = baseDelay * Math.pow(2, i)
      console.log(`Attempt ${i + 1} failed, retrying in ${delay}ms...`)
      await new Promise((resolve) => setTimeout(resolve, delay))
    }
  }
  throw new Error('Max retries reached')
}

// Use retry pattern
const result = await withRetry(
  async () => {
    return await api.fetch('https://api.external.com/data')
  },
  3,
  1000
)

// Transaction pattern with rollback
async function transferInventory(fromProductId: string, toProductId: string, quantity: number) {
  const operations = []

  try {
    // Step 1: Deduct from source
    const fromProduct = await db.get('Product', fromProductId)
    if (fromProduct.stock < quantity) {
      throw new Error('Insufficient stock')
    }

    const updatedFrom = await db.update('Product', fromProductId, {
      stock: fromProduct.stock - quantity,
    })
    operations.push({ type: 'update', id: fromProductId, rollback: { stock: fromProduct.stock } })

    // Step 2: Add to destination
    const toProduct = await db.get('Product', toProductId)
    const updatedTo = await db.update('Product', toProductId, {
      stock: toProduct.stock + quantity,
    })
    operations.push({ type: 'update', id: toProductId, rollback: { stock: toProduct.stock } })

    // Step 3: Create transfer record
    const transfer = await db.create('InventoryTransfer', {
      fromProductId,
      toProductId,
      quantity,
      timestamp: new Date(),
    })
    operations.push({ type: 'create', id: transfer.id })

    return { success: true, transferId: transfer.id }
  } catch (error) {
    console.error('Transfer failed, rolling back:', error.message)

    // Rollback in reverse order
    for (const op of operations.reverse()) {
      try {
        if (op.type === 'update') {
          await db.update('Product', op.id, op.rollback)
        } else if (op.type === 'create') {
          await db.delete('InventoryTransfer', op.id)
        }
      } catch (rollbackError) {
        console.error('Rollback failed:', rollbackError.message)
      }
    }

    throw error
  }
}

// Execute with rollback support
await transferInventory('prod_123', 'prod_456', 10)

// Batch processing with progress tracking
async function batchUpdateProducts(updates: Array<{ id: string; data: any }>) {
  const batchSize = 10
  const results = []

  for (let i = 0; i < updates.length; i += batchSize) {
    const batch = updates.slice(i, i + batchSize)

    console.log(`Processing batch ${i / batchSize + 1} of ${Math.ceil(updates.length / batchSize)}`)

    const batchResults = await Promise.allSettled(batch.map((update) => db.update('Product', update.id, update.data)))

    batchResults.forEach((result, idx) => {
      if (result.status === 'fulfilled') {
        results.push({ id: batch[idx].id, success: true })
      } else {
        results.push({ id: batch[idx].id, success: false, error: result.reason.message })
      }
    })

    // Progress notification
    if ((i + batchSize) % 100 === 0) {
      await send($.Job.progress, {
        type: 'product_update',
        processed: Math.min(i + batchSize, updates.length),
        total: updates.length,
      })
    }

    // Rate limiting
    await new Promise((resolve) => setTimeout(resolve, 100))
  }

  return {
    total: updates.length,
    successful: results.filter((r) => r.success).length,
    failed: results.filter((r) => !r.success).length,
    errors: results.filter((r) => !r.success).map((r) => ({ id: r.id, error: r.error })),
  }
}

// Execute batch operation
const updates = [
  { id: 'prod_1', data: { price: 29.99 } },
  { id: 'prod_2', data: { price: 39.99 } },
  // ... hundreds more
]

await batchUpdateProducts(updates)

// Parallel data fetching
async function loadDashboardData() {
  const [orders, customers, products, revenue] = await Promise.all([
    db.list('Order', { limit: 100, sort: { createdAt: 'desc' } }),
    db.list('Person', { limit: 50 }),
    db.list('Product', { where: { stock: { lt: 10 } } }),
    calculateRevenue(),
  ])

  return {
    recentOrders: orders,
    topCustomers: customers,
    lowStockProducts: products,
    revenueMetrics: revenue,
  }
}

async function calculateRevenue() {
  const orders = await db.list('Order', {
    where: { status: 'paid' },
  })

  return {
    total: orders.reduce((sum, o) => sum + o.total, 0),
    count: orders.length,
    average: orders.length > 0 ? orders.reduce((sum, o) => sum + o.total, 0) / orders.length : 0,
  }
}

// Execute with parallel operations
const dashboard = await loadDashboardData()

// Module: Set up event handlers for order lifecycle
on($.Order.created, async (order) => {
  console.log(`New order created: ${order.id}`)

  // Validate order
  const customer = await db.get('Person', order.customerId)
  if (!customer) {
    throw new Error('Customer not found')
  }

  // Send confirmation email
  await send($.Email.send, {
    to: customer.email,
    subject: `Order Confirmation #${order.orderNumber}`,
    from: '[email protected]',
    body: `
Thank you for your order!

Order #${order.orderNumber}
Total: $${order.total}

We'll notify you when your order ships.
    `
  })

  // Update inventory
  for (const item of order.items) {
    const product = await db.get('Product', item.productId)
    await db.update('Product', item.productId, {
      stock: product.stock - item.quantity
    })

    // Check for low stock
    if (product.stock - item.quantity < 10) {
      await send($.Inventory.lowStock, {
        productId: product.id,
        currentStock: product.stock - item.quantity
      })
    }
  }

  // Trigger fulfillment after 1 hour (to allow for cancellations)
  await send($.Schedule.create, {
    type: 'fulfillment',
    orderId: order.id,
    executeAt: new Date(Date.now() + 60 * 60 * 1000)
  })
})

on($.Payment.succeeded, async (payment) => {
  console.log(`Payment succeeded: ${payment.id}`)

  await db.update('Order', payment.orderId, {
    status: 'paid',
    paidAt: new Date(),
    paymentMethod: payment.method,
    paymentId: payment.id
  })

  // Trigger immediate fulfillment for express orders
  const order = await db.get('Order', payment.orderId)
  if (order.shippingMethod === 'express') {
    await send($.Fulfillment.start, {
      orderId: payment.orderId,
      priority: 'high'
    })
  }
})

on($.Fulfillment.start, async (fulfillment) => {
  console.log(`Starting fulfillment: ${fulfillment.orderId}`)

  const order = await db.get('Order', fulfillment.orderId)
  const customer = await db.get('Person', order.customerId)

  // Update order status
  await db.update('Order', order.id, {
    status: 'processing',
    processingStartedAt: new Date()
  })

  // Generate shipping label
  const shipping = await api.proxy('shippo', '/shipments', {
    method: 'POST',
    body: {
      address_to: {
        name: customer.name,
        street1: customer.address.street1,
        city: customer.address.city,
        state: customer.address.state,
        zip: customer.address.zip,
        country: 'US'
      },
      parcels: order.items.map(item => ({
        length: '10',
        width: '8',
        height: '4',
        distance_unit: 'in',
        weight: item.weight || '1',
        mass_unit: 'lb'
      })),
      async: false
    }
  })

  // Update with tracking
  await db.update('Order', order.id, {
    status: 'shipped',
    shippedAt: new Date(),
    trackingNumber: shipping.tracking_number,
    carrier: shipping.carrier
  })

  // Notify customer
  await send($.Email.send, {
    to: customer.email,
    subject: 'Your Order Has Shipped!',
    from: '[email protected]',
    body: `
Your order #${order.orderNumber} has shipped!

Tracking Number: ${shipping.tracking_number}
Carrier: ${shipping.carrier}

Track your package: ${shipping.tracking_url}
    `
  })

  // Trigger shipped event
  await send($.Order.shipped, {
    orderId: order.id,
    trackingNumber: shipping.tracking_number,
    trackingUrl: shipping.tracking_url
  })
})

// Script: Create a new order and trigger the workflow
const customer = await db.create('Person', {
  name: 'Bob Smith',
  email: '[email protected]',
  address: {
    street1: '123 Main St',
    city: 'San Francisco',
    state: 'CA',
    zip: '94102'
  }
})

const products = await Promise.all([
  db.get('Product', 'prod_widget_001'),
  db.get('Product', 'prod_gadget_002')
])

const order = await db.create('Order', {
  orderNumber: `ORD-${Date.now()}`,
  customer: customer,
  customerId: customer.id,
  items: [
    {
      productId: products[0].id,
      name: products[0].name,
      quantity: 2,
      price: products[0].price,
      weight: products[0].weight
    },
    {
      productId: products[1].id,
      name: products[1].name,
      quantity: 1,
      price: products[1].price,
      weight: products[1].weight
    }
  ],
  total: products[0].price * 2 + products[1].price,
  shippingMethod: 'standard',
  status: 'pending',
  createdAt: new Date()
})

// Trigger order created event (activates handlers above)
await send($.Order.created, order)

// Return order details
{
  orderId: order.id,
  orderNumber: order.orderNumber,
  customer: customer.name,
  total: order.total,
  status: order.status,
  items: order.items.length
}

// Content approval workflow
on($.Article.submitted, async (article) => {
  console.log(`Article submitted: ${article.id}`)

  // Run AI content analysis
  const analysis = await ai.generate({
    prompt: `Analyze this article for quality, readability, and SEO:

Title: ${article.headline}
Content: ${article.articleBody}

Provide:
1. Quality score (1-10)
2. Readability grade level
3. SEO recommendations
4. Suggested improvements`,
    schema: $.Analysis,
    model: 'claude-sonnet-4.5',
  })

  // Store analysis
  await db.update('Article', article.id, {
    analysis: analysis,
    analyzedAt: new Date(),
  })

  // Auto-approve high-quality content
  if (analysis.qualityScore >= 8) {
    await send($.Article.approved, {
      articleId: article.id,
      approvedBy: 'ai-auto-approve',
      reason: `High quality score: ${analysis.qualityScore}/10`,
    })
  } else {
    // Send to human review
    await send($.Email.send, {
      to: '[email protected]',
      subject: `Article Needs Review: ${article.headline}`,
      body: `
Article: ${article.headline}
Author: ${article.author.name}
Quality Score: ${analysis.qualityScore}/10

Analysis:
${JSON.stringify(analysis, null, 2)}

Review: https://cms.acme.com/articles/${article.id}/review
      `,
    })
  }
})

on($.Article.approved, async (event) => {
  const article = await db.get('Article', event.articleId)

  // Generate social media posts
  const socialPosts = await ai.generate({
    prompt: `Create social media posts for this article:

Title: ${article.headline}
Summary: ${article.description}

Generate posts for:
1. Twitter (280 chars)
2. LinkedIn (professional tone)
3. Facebook (engaging, conversational)`,
    schema: $.SocialMediaPosts,
    model: 'gpt-5',
  })

  // Generate featured image
  const imagePrompt = await ai.generate({
    prompt: `Create an image generation prompt for this article: ${article.headline}`,
    schema: $.Text,
    model: 'gpt-5',
  })

  // Publish article
  await db.update('Article', article.id, {
    status: 'published',
    publishedAt: new Date(),
    socialPosts: socialPosts,
  })

  // Schedule social posts
  const platforms = ['twitter', 'linkedin', 'facebook']
  for (let i = 0; i < platforms.length; i++) {
    await send($.Schedule.create, {
      type: 'social_post',
      platform: platforms[i],
      content: socialPosts[platforms[i]],
      articleId: article.id,
      executeAt: new Date(Date.now() + i * 60 * 60 * 1000), // Stagger by 1 hour
    })
  }

  // Notify author
  await send($.Email.send, {
    to: article.author.email,
    subject: `Your Article Has Been Published!`,
    body: `
Congratulations! Your article "${article.headline}" is now live.

View it here: https://blog.acme.com/articles/${article.slug}

Social posts scheduled:
- Twitter: ${new Date(Date.now() + 0 * 60 * 60 * 1000).toLocaleString()}
- LinkedIn: ${new Date(Date.now() + 1 * 60 * 60 * 1000).toLocaleString()}
- Facebook: ${new Date(Date.now() + 2 * 60 * 60 * 1000).toLocaleString()}
    `,
  })
})

// Scheduled content optimization
every('0 2 * * *', async () => {
  console.log('Running content optimization...')

  const articles = await db.list('Article', {
    where: {
      status: 'published',
      updatedAt: { lt: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString() },
    },
    limit: 20,
  })

  for (const article of articles) {
    // Generate updated SEO recommendations
    const seo = await ai.generate({
      prompt: `Analyze and improve SEO for this article:

Title: ${article.headline}
Content: ${article.articleBody.substring(0, 500)}...

Provide updated:
1. Meta description
2. Keywords
3. Internal linking suggestions`,
      schema: $.SEORecommendations,
      model: 'claude-sonnet-4.5',
    })

    await db.update('Article', article.id, {
      seoRecommendations: seo,
      lastOptimized: new Date(),
    })
  }
})

// Comprehensive analytics pipeline
async function generateMonthlyReport() {
  console.log('Generating monthly analytics report...')

  const startDate = new Date()
  startDate.setDate(1) // First day of current month
  startDate.setHours(0, 0, 0, 0)

  // Parallel data fetching
  const [orders, customers, products, revenue, traffic] = await Promise.all([
    db.list('Order', {
      where: { createdAt: { gte: startDate.toISOString() } },
    }),
    db.list('Person', {
      where: { createdAt: { gte: startDate.toISOString() } },
    }),
    db.list('Product'),
    api.fetch('https://analytics.acme.com/api/revenue', {
      method: 'POST',
      body: JSON.stringify({ start: startDate.toISOString() }),
    }),
    api.fetch('https://analytics.acme.com/api/traffic', {
      method: 'POST',
      body: JSON.stringify({ start: startDate.toISOString() }),
    }),
  ])

  // Calculate metrics
  const metrics = {
    orders: {
      total: orders.length,
      revenue: orders.reduce((sum, o) => sum + o.total, 0),
      avgValue: orders.length > 0 ? orders.reduce((sum, o) => sum + o.total, 0) / orders.length : 0,
      byStatus: orders.reduce((acc, o) => {
        acc[o.status] = (acc[o.status] || 0) + 1
        return acc
      }, {}),
    },
    customers: {
      new: customers.length,
      returning: orders.filter((o) => {
        const customerOrders = orders.filter((ord) => ord.customerId === o.customerId)
        return customerOrders.length > 1
      }).length,
      churnRate: calculateChurnRate(customers, orders),
    },
    products: {
      total: products.length,
      lowStock: products.filter((p) => p.stock < 10).length,
      topSellers: getTopProducts(orders, products, 10),
    },
    revenue: {
      total: revenue.total,
      growth: revenue.growth,
      forecast: revenue.forecast,
    },
    traffic: {
      visitors: traffic.visitors,
      pageViews: traffic.pageViews,
      conversionRate: orders.length / traffic.visitors,
    },
  }

  // Generate AI insights
  const insights = await ai.generate({
    prompt: `Analyze this monthly business data and provide strategic insights:

${JSON.stringify(metrics, null, 2)}

Provide:
1. Key achievements and wins
2. Areas of concern
3. Growth opportunities
4. Specific action items
5. Forecast for next month`,
    schema: $.BusinessInsights,
    model: 'claude-sonnet-4.5',
    temperature: 0.3,
  })

  // Create comprehensive report
  const report = await db.create('Report', {
    type: 'monthly',
    period: startDate.toISOString(),
    metrics: metrics,
    insights: insights,
    generatedAt: new Date(),
  })

  // Generate visualizations
  const charts = await Promise.all([
    generateChart('revenue-trend', metrics.revenue),
    generateChart('order-status', metrics.orders.byStatus),
    generateChart('top-products', metrics.products.topSellers),
  ])

  // Send email report
  await send($.Email.send, {
    to: '[email protected]',
    subject: `Monthly Business Report - ${startDate.toLocaleDateString('en-US', { month: 'long', year: 'numeric' })}`,
    from: '[email protected]',
    body: `
# Monthly Business Report

## Executive Summary

${insights.summary}

## Key Metrics

**Orders**
- Total Orders: ${metrics.orders.total}
- Revenue: $${metrics.orders.revenue.toFixed(2)}
- Average Order Value: $${metrics.orders.avgValue.toFixed(2)}

**Customers**
- New Customers: ${metrics.customers.new}
- Returning Customers: ${metrics.customers.returning}
- Churn Rate: ${(metrics.customers.churnRate * 100).toFixed(2)}%

**Products**
- Low Stock Items: ${metrics.products.lowStock}

## AI Insights

${insights.analysis}

## Recommendations

${insights.recommendations.map((r, i) => `${i + 1}. ${r}`).join('\n')}

View full report: https://analytics.acme.com/reports/${report.id}
    `,
    attachments: charts,
  })

  return {
    reportId: report.id,
    metrics,
    insights,
    generated: new Date(),
  }
}

function calculateChurnRate(customers, orders) {
  const activeCustomers = new Set(orders.map((o) => o.customerId))
  const churnedCustomers = customers.filter((c) => !activeCustomers.has(c.id)).length
  return customers.length > 0 ? churnedCustomers / customers.length : 0
}

function getTopProducts(orders, products, limit) {
  const sales = {}
  orders.forEach((order) => {
    order.items.forEach((item) => {
      sales[item.productId] = (sales[item.productId] || 0) + item.quantity
    })
  })

  return Object.entries(sales)
    .sort(([, a], [, b]) => b - a)
    .slice(0, limit)
    .map(([id, quantity]) => {
      const product = products.find((p) => p.id === id)
      return {
        id,
        name: product?.name || 'Unknown',
        quantity,
        revenue: quantity * (product?.price || 0),
      }
    })
}

async function generateChart(type, data) {
  // Generate chart using visualization service
  return await api.fetch('https://charts.acme.com/api/generate', {
    method: 'POST',
    body: JSON.stringify({ type, data }),
  })
}

// Execute monthly report
await generateMonthlyReport()