import { fn } from 'sdk.do'

// Code function - pure code execution
const processOrder = fn('process-order', async ({ orderId }) => {
  const order = await db.get('orders', orderId)
  await validateOrder(order)
  await chargePayment(order)
  return { success: true }
})

import { ai } from 'sdk.do'

// Generative function - AI generates output
const generateStrategy = async ({ company, market }) => {
  return await ai.generate({
    model: 'gpt-5',
    prompt: `Generate a market strategy for ${company} in ${market}`,
  })
}

// AI helper functions (also generative)
const items = await ai.list('Generate a list of competitive advantages')
const isValid = await ai.is('this is a valid business model', businessPlan)
const areValid = await ai.are('these are valid markets', markets)

import { agent } from 'sdk.do'

// Agentic function - autonomous agent
const qualifyLead = await agent.create({
  name: 'lead-qualifier',
  role: 'Sales Development Representative',
  task: async ({ lead }) => {
    // Agent autonomously researches, scores, and qualifies
    const research = await agent.research(lead.company)
    const score = await agent.score(lead, research)
    const decision = await agent.decide('qualify', { lead, score })
    return decision
  },
})

import { user } from 'sdk.do'

// Human function - requires human execution
const approveContract = async ({ contractId }) => {
  // Route to appropriate human
  const approver = await user.getApprover('contracts')

  // Wait for human decision
  const approval = await user.requestApproval({
    userId: approver.id,
    type: 'contract-approval',
    data: { contractId },
    timeout: { hours: 48 },
  })

  return approval
}

// Nouns represent entities
const order = await $.Order.get('order-123')
const user = await $.User.get('user-456')
const product = await $.Product.get('prod-789')

// Verbs represent actions on entities
await $.Order.create({ items, total })
await $.User.update.profile({ userId, name })
await $.Payment.process({ orderId, amount })

// Views represent relationships and queries
const orders = await $.User.has.Orders({ userId })
const items = await $.Order.contains.Items({ orderId })
const reviews = await $.Product.has.Reviews({ productId })

// Agents perform autonomous actions
await $.Agent.qualify.Lead({ leadId })
await $.Agent.generate.Report({ reportType })
await $.Agent.analyze.Market({ marketId })

// Basic triple: $.Subject.predicate.Object
await $.User.assign.Role({ userId, roleId })
await $.Order.fulfill.Payment({ orderId })
await $.Team.add.Member({ teamId, userId })

// With prepositional phrases: $.Subject.predicate.Object.in.Thing
await $.User.assign.Role.in.Organization({ userId, roleId, orgId })
await $.Task.assign.User.in.Project({ taskId, userId, projectId })
await $.Product.add.Category.in.Catalog({ productId, categoryId, catalogId })

// Chained relationships
const managers = await $.Organization.has.Teams.with.Members.where.role.equals('manager')

import { fn, ai, user, db, on, send, every, api, decide } from 'sdk.do'

// Code function - pure execution
const process = fn('process', async (data) => {
  /* ... */
})

// AI function - ai SDK object (1 of 8 core)
const generate = async (prompt) => await ai.generate({ model: 'gpt-5', prompt })

// Human function - user SDK object (1 of 8 core)
const approve = async (item) => await user.requestApproval({ item })

// Database function - db SDK object (1 of 8 core)
const fetch = async (id) => await db.get('items', id)

// Event function - on SDK object (1 of 8 core)
on('item.created', async ({ item }) => {
  /* handle event */
})

// Analytics function - send SDK object (1 of 8 core)
const track = async (event) => await send('analytics.track', event)

// Scheduled function - every SDK object (1 of 8 core)
every('daily at 9am', async () => {
  /* run daily */
})

// Integration function - api SDK object (1 of 8 core)
const integrate = async (action) => await api.action('github.create_issue', action)

// Experiment function - decide SDK object (1 of 8 core)
const test = async (user) => await decide.get('button-color-test', { userId: user.id })

import { workflow, every, on } from 'sdk.do'

// Workflow = Code Function + Triggers + Durable Execution
workflow('process-order', async ({ order }) => {
  // This is a code function with durable execution
  await validateOrder(order)
  await chargePayment(order)
  await createShipment(order)
})

// Time-based trigger (every)
every('daily at 9am', async () => {
  await workflow('daily-report', async () => {
    // Durable execution with automatic retries
    const data = await gatherData()
    await generateReport(data)
  })
})

// Event-based trigger (on)
on('order.created', async ({ order }) => {
  await workflow('fulfill-order', async () => {
    // State persisted automatically
    await processOrder(order)
  })
})

import { fn, $, ai, user } from 'sdk.do'

// Example combining all 4 function types

// 1. Code function
const validateOrder = fn('validate', async ({ order }) => {
  if (order.total < 0) throw new Error('Invalid total')
  return { valid: true }
})

// 2. Generative function (AI)
const generateDescription = async ({ product }) => {
  return await ai.generate({
    model: 'gpt-5',
    prompt: `Write a compelling product description for ${product.name}`,
  })
}

// 3. Agentic function (Agent)
const qualifyLead = async ({ lead }) => {
  return await $.Agent.qualify.Lead({
    leadId: lead.id,
    autonomousResearch: true,
  })
}

// 4. Human function (Human-in-Loop)
const reviewContract = async ({ contract }) => {
  const approver = await user.getApprover('legal')
  return await user.requestApproval({
    userId: approver.id,
    type: 'contract-review',
    data: { contractId: contract.id },
  })
}

// Use semantic triples
await $.Order.validate({ orderId: 'order-123' })
await $.Product.generate.Description({ productId: 'prod-456' })
await $.Agent.qualify.Lead({ leadId: 'lead-789' })
await $.Contract.request.Approval({ contractId: 'contract-999' })

const result = await fn('process-order', async ({ orderId }) => {
  /* ... */
})({ orderId: '123' })

do fn deploy process-order --file ./functions/process-order.ts --timeout 300

curl -X POST https://api.do/v1/functions/process-order/invoke -d '{"orderId":"123"}'

Deploy function "process-order" from file ./functions/process-order.ts