Functions

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

on($.Support.ticket.created, async ({ ticket }) => {
  const response = await $.AI.generate({
    model: 'gpt-5',
    prompt: `Draft a response to: ${ticket.description}`,
    context: { customerHistory, productDocs }
  })

  return response
})

const agent = $.Agent.define({
  name: 'customer-success',
  goal: 'Maximize customer satisfaction and retention',
  capabilities: ['analyze-usage', 'identify-issues', 'take-action'],

  on: {
    daily: async () => {
      // Agent autonomously analyzes and acts
    }
  }
})

on($.Contract.ready_for_review, async ({ contract }) => {
  await $.Task.create({
    type: 'legal-review',
    assignTo: 'legal-team',
    title: `Review contract for ${contract.customer.name}`,
    data: { contract }
  })
})

// React to data changes
on($.Project.updated, async ({ project, changes }) => {
  // Function runs when project is updated
})

// React to time-based events
on($.Schedule.daily({ hour: 9 }), async () => {
  // Function runs every day at 9am
})

// React to webhooks
on($.Webhook.received, async ({ payload, source }) => {
  // Function runs when webhook arrives
})

// React to user actions
on($.Button.clicked, async ({ button, user }) => {
  // Function runs when button is clicked
})

// 1. Code function processes incoming data
on($.Lead.created, async ({ lead }) => {
  const enrichedLead = await enrichLeadData(lead)
  await $.Lead.update(lead.id, enrichedLead)
})

// 2. Generative function scores the lead
on($.Lead.updated, async ({ lead }) => {
  const score = await $.AI.generate({
    model: 'gpt-5',
    prompt: `Score this lead from 0-100 based on fit: ${JSON.stringify(lead)}`,
    schema: { score: 'number', reasoning: 'string' }
  })

  await $.Lead.update(lead.id, { score: score.score })
})

// 3. Agentic function nurtures high-value leads
const salesAgent = $.Agent.define({
  name: 'lead-nurturer',
  on: {
    '$.Lead.scored': async ({ lead }) => {
      if (lead.score > 80) {
        // Agent autonomously engages
        await personalizeOutreach(lead)
        await scheduleFollowups(lead)
      }
    }
  }
})

// 4. Human function handles final conversion
on($.Lead.ready_for_sales, async ({ lead }) => {
  await $.Task.create({
    type: 'sales-call',
    assignTo: lead.assignedRep,
    priority: lead.score > 90 ? 'high' : 'normal'
  })
})

on($.Event.occurred, async ({ event }) => {
  // Read from database (multi-tenant automatic)
  const data = await $.Data.find(event.dataId)

  // Read from KV (fast key-value)
  const cache = await $.KV.get(`cache:${event.id}`)

  // Read from R2 (object storage)
  const file = await $.Storage.get(event.fileKey)

  // Call other services (RPC)
  const result = await env.OTHER_WORKER.doSomething()
})

on($.Order.created, async ({ order }) => {
  try {
    await processPayment(order)
  } catch (error) {
    // Automatic retry with exponential backoff
    if (error.code === 'PAYMENT_GATEWAY_TIMEOUT') {
      throw new RetryableError(error)
    }

    // Dead letter queue for permanent failures
    if (error.code === 'INVALID_CARD') {
      await $.Order.update(order.id, { status: 'payment_failed' })
      await send($.Email.send, {
        to: order.customer.email,
        template: 'payment-failed'
      })
    }

    // Automatic error logging
    // Platform logs all errors for debugging
  }
})

// Real-time logs
on($.Function.executed, async ({ function, duration, success }) => {
  console.log(`${function.name} executed in ${duration}ms (${success ? 'success' : 'error'})`)
})

// Metrics
const metrics = await $.Function.getMetrics('order-processor', {
  period: 'last_24h'
})
// Returns: invocations, errors, duration, success rate

// Tracing
// Platform automatically traces function execution
// View full request path in dashboard

# Local development
do dev
# Functions hot-reload on change

# Deploy to production
git push origin main
# Platform automatically:
# - Bundles functions
# - Runs tests
# - Deploys to edge
# - Zero downtime

// Good: Single responsibility
on($.Order.created, async ({ order }) => {
  await send($.Payment.process, { order })
})

// Avoid: Doing too much in one function
on($.Order.created, async ({ order }) => {
  await processPayment(order)
  await updateInventory(order)
  await sendEmail(order)
  await notifyWarehouse(order)
  await updateAnalytics(order)
  // Too much in one place - split into separate functions
})

on($.Event.occurred, async ({ event }) => {
  try {
    await processEvent(event)
  } catch (error) {
    // Log error
    console.error('Event processing failed:', error)

    // Notify if critical
    if (isCritical(event)) {
      await $.Alert.send({
        severity: 'high',
        message: `Critical event failed: ${error.message}`
      })
    }

    // Retry if transient
    if (isTransient(error)) {
      throw new RetryableError(error)
    }
  }
})

// Cache frequently accessed data
const cached = await $.KV.get(`cache:${key}`)
if (cached) return cached

const result = await expensiveOperation()
await $.KV.set(`cache:${key}`, result, { ttl: 3600 })

// Parallelize independent operations
const [user, orders, analytics] = await Promise.all([
  $.User.find(userId),
  $.Order.list({ userId }),
  $.Analytics.get({ userId })
])