Supabase Edge Functions创建与部署 #

# 创建新函数
supabase functions new hello-world

# 创建后的目录结构
supabase/
└── functions/
    └── hello-world/
        └── index.ts

// functions/hello-world/index.ts
Deno.serve(async (req: Request) => {
  const { name } = await req.json()
  const data = {
    message: `Hello ${name}!`,
  }

  return new Response(JSON.stringify(data), {
    headers: {
      'Content-Type': 'application/json',
      Connection: 'keep-alive',
    },
  })
})

# 启动所有本地服务（包括函数）
supabase start

# 只启动函数服务
supabase functions serve

# 使用curl测试
curl -i --location --request POST 'http://localhost:54321/functions/v1/hello-world' \
  --header 'Authorization: Bearer YOUR_ANON_KEY' \
  --header 'Content-Type: application/json' \
  --data '{"name":"World"}'

# 函数服务会自动检测文件变化并重新加载
# 修改 index.ts 后自动生效

# 部署到远程
supabase functions deploy hello-world

# 指定项目
supabase functions deploy hello-world --project-ref your-project-ref

# 部署所有函数
supabase functions deploy

# 输出
Deploying Function (hello-world)
Function deployed successfully
URL: https://your-project.supabase.co/functions/v1/hello-world

# supabase/.env
MY_SECRET=secret-value
API_KEY=your-api-key

# 设置单个密钥
supabase secrets set MY_SECRET=secret-value

# 从文件设置
supabase secrets set --env-file .env

# 查看密钥列表
supabase secrets list

# 删除密钥
supabase secrets delete MY_SECRET

Deno.serve(async (req) => {
  const mySecret = Deno.env.get('MY_SECRET')
  
  return new Response(JSON.stringify({ secret: mySecret }), {
    headers: { 'Content-Type': 'application/json' },
  })
})

// functions/api/index.ts
import { createClient } from 'https://esm.sh/@supabase/supabase-js@2'

Deno.serve(async (req) => {
  const supabase = createClient(
    Deno.env.get('SUPABASE_URL')!,
    Deno.env.get('SUPABASE_SERVICE_ROLE_KEY')!
  )

  const method = req.method
  const url = new URL(req.url)
  const path = url.pathname.split('/').filter(Boolean)

  // GET /api/users
  if (method === 'GET' && path[1] === 'users') {
    const { data, error } = await supabase
      .from('users')
      .select('*')
    
    return new Response(JSON.stringify({ data, error }), {
      headers: { 'Content-Type': 'application/json' },
    })
  }

  // POST /api/users
  if (method === 'POST' && path[1] === 'users') {
    const body = await req.json()
    const { data, error } = await supabase
      .from('users')
      .insert(body)
      .select()
    
    return new Response(JSON.stringify({ data, error }), {
      headers: { 'Content-Type': 'application/json' },
    })
  }

  return new Response('Not Found', { status: 404 })
})

// functions/webhook/index.ts
Deno.serve(async (req) => {
  const signature = req.headers.get('x-webhook-signature')
  
  if (!signature) {
    return new Response('Missing signature', { status: 401 })
  }

  const body = await req.json()
  
  // 验证签名
  // 处理webhook数据
  
  console.log('Webhook received:', body)

  return new Response(JSON.stringify({ received: true }), {
    headers: { 'Content-Type': 'application/json' },
  })
})

// functions/send-email/index.ts
Deno.serve(async (req) => {
  const { to, subject, body } = await req.json()

  // 使用第三方邮件服务
  const response = await fetch('https://api.resend.com/emails', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${Deno.env.get('RESEND_API_KEY')}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      from: 'noreply@example.com',
      to,
      subject,
      html: body,
    }),
  })

  const data = await response.json()

  return new Response(JSON.stringify(data), {
    headers: { 'Content-Type': 'application/json' },
  })
})

// functions/cron/index.ts
import { createClient } from 'https://esm.sh/@supabase/supabase-js@2'

Deno.serve(async (req) => {
  // 验证定时任务密钥
  const authHeader = req.headers.get('Authorization')
  if (authHeader !== `Bearer ${Deno.env.get('CRON_SECRET')}`) {
    return new Response('Unauthorized', { status: 401 })
  }

  const supabase = createClient(
    Deno.env.get('SUPABASE_URL')!,
    Deno.env.get('SUPABASE_SERVICE_ROLE_KEY')!
  )

  // 执行清理任务
  const { error } = await supabase
    .from('sessions')
    .delete()
    .lt('expires_at', new Date().toISOString())

  if (error) {
    console.error('Cleanup failed:', error)
    return new Response('Cleanup failed', { status: 500 })
  }

  return new Response('Cleanup completed')
})

# supabase/config.toml

[functions.hello-world]
verify_jwt = false  # 是否验证JWT

[functions.api]
verify_jwt = true

Deno.serve(async (req) => {
  console.log('=== Debug Info ===')
  console.log('Method:', req.method)
  console.log('URL:', req.url)
  console.log('Headers:', Object.fromEntries(req.headers))
  
  const body = await req.text()
  console.log('Body:', body)
  
  // 处理逻辑...
  
  return new Response('OK')
})

# 实时查看日志
supabase functions logs hello-world --follow

# 查看最近日志
supabase functions logs hello-world --limit 100

Deno.serve(async (req) => {
  try {
    const body = await req.json()
    
    // 验证输入
    if (!body.required_field) {
      return new Response(
        JSON.stringify({ error: 'required_field is required' }),
        { status: 400, headers: { 'Content-Type': 'application/json' } }
      )
    }
    
    // 处理逻辑
    const result = await processRequest(body)
    
    return new Response(
      JSON.stringify({ success: true, data: result }),
      { headers: { 'Content-Type': 'application/json' } }
    )
  } catch (error) {
    console.error('Error:', error)
    return new Response(
      JSON.stringify({ error: 'Internal server error' }),
      { status: 500, headers: { 'Content-Type': 'application/json' } }
    )
  }
})

// 成功响应
function successResponse(data: any) {
  return new Response(
    JSON.stringify({ success: true, data }),
    { headers: { 'Content-Type': 'application/json' } }
  )
}

// 错误响应
function errorResponse(message: string, status = 400) {
  return new Response(
    JSON.stringify({ success: false, error: message }),
    { status, headers: { 'Content-Type': 'application/json' } }
  )
}