Server Routes

import { api } from '~~/convex/_generated/api'

export default defineEventHandler(async (event) => {
  const posts = await serverConvexQuery(event, api.posts.list, { status: 'published' })

  return posts
})

import { api } from '~~/convex/_generated/api'

export default defineEventHandler(async (event) => {
  const body = await readBody(event)

  await serverConvexMutation(event, api.tasks.complete, { taskId: body.taskId })

  return { success: true }
})

import { api } from '~~/convex/_generated/api'

export default defineEventHandler(async (event) => {
  const body = await readBody(event)

  const report = await serverConvexAction(event, api.reports.generate, {
    month: body.month,
    year: body.year,
  })

  return report
})

import { api } from '~~/convex/_generated/api'
import Stripe from 'stripe'

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!)

export default defineEventHandler(async (event) => {
  const body = await readRawBody(event)
  const signature = getHeader(event, 'stripe-signature')!

  // Verify webhook
  const stripeEvent = stripe.webhooks.constructEvent(
    body!,
    signature,
    process.env.STRIPE_WEBHOOK_SECRET!,
  )

  // Handle the event
  switch (stripeEvent.type) {
    case 'checkout.session.completed': {
      const session = stripeEvent.data.object
      await serverConvexMutation(event, api.subscriptions.activate, {
        userId: session.metadata!.userId,
        stripeSubscriptionId: session.subscription as string,
      })
      break
    }

    case 'customer.subscription.deleted': {
      const subscription = stripeEvent.data.object
      await serverConvexMutation(event, api.subscriptions.cancel, {
        stripeSubscriptionId: subscription.id,
      })
      break
    }
  }

  return { received: true }
})

import { api } from '~~/convex/_generated/api'

export default defineEventHandler(async (event) => {
  const config = useRuntimeConfig()

  // Get auth token from session cookie
  const sessionCookie = getCookie(event, 'better-auth.session_token')
  if (!sessionCookie) {
    throw createError({ statusCode: 401, message: 'Unauthorized' })
  }

  // Exchange session for JWT token
  const tokenResponse = await $fetch<{ token?: string }>(
    `${config.public.convex.siteUrl}/api/auth/convex/token`,
    { headers: { Cookie: `better-auth.session_token=${sessionCookie}` } },
  )

  if (!tokenResponse?.token) {
    throw createError({ statusCode: 401, message: 'Invalid session' })
  }

  // Fetch with auth
  const profile = await serverConvexQuery(
    event,
    api.users.getProfile,
    {},
    { authToken: tokenResponse.token },
  )

  return profile
})

import { api } from '~~/convex/_generated/api'

export default defineEventHandler(async (event) => {
  // Verify cron secret
  const cronSecret = getHeader(event, 'x-cron-secret')
  if (cronSecret !== process.env.CRON_SECRET) {
    throw createError({ statusCode: 401 })
  }

  // Trigger digest generation
  const result = await serverConvexAction(event, api.notifications.sendDailyDigests, {})

  return { sent: result.count }
})

import { api } from '~~/convex/_generated/api'

export default defineEventHandler(async (event) => {
  // Only track page views
  if (!event.path.startsWith('/api/')) {
    // Fire and forget - don't await
    serverConvexMutation(event, api.analytics.trackPageView, {
      path: event.path,
      userAgent: getHeader(event, 'user-agent') ?? '',
      timestamp: Date.now(),
    }).catch(() => {
      // Ignore errors - analytics shouldn't break the request
    })
  }
})

import { api } from '~~/convex/_generated/api'

export default defineEventHandler(async (event) => {
  const { repoUrl } = await readBody(event)

  // Fetch from external API
  const [owner, repo] = repoUrl.replace('https://github.com/', '').split('/')
  const issues = await $fetch(`https://api.github.com/repos/${owner}/${repo}/issues`, {
    headers: { Authorization: `Bearer ${process.env.GITHUB_TOKEN}` },
  })

  // Store in Convex
  const imported = await serverConvexMutation(event, api.issues.importFromGithub, {
    repoUrl,
    issues: issues.map((i: any) => ({
      title: i.title,
      body: i.body,
      githubId: i.id,
    })),
  })

  return { imported: imported.count }
})

export default defineNuxtConfig({
  convex: {
    url: process.env.CONVEX_URL,
    logging: {
      enabled: true, // Enable canonical log events
    },
  },
})