Server Routes

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

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

  const posts = await fetchQuery(
    config.public.convex.url,
    api.posts.list,
    { status: 'published' }
  )

  return posts
})

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

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

  await fetchMutation(
    config.public.convex.url,
    api.tasks.complete,
    { taskId: body.taskId }
  )

  return { success: true }
})

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

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

  const report = await fetchAction(
    config.public.convex.url,
    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 config = useRuntimeConfig()
  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 fetchMutation(
        config.public.convex.url,
        api.subscriptions.activate,
        {
          userId: session.metadata!.userId,
          stripeSubscriptionId: session.subscription as string,
        }
      )
      break
    }

    case 'customer.subscription.deleted': {
      const subscription = stripeEvent.data.object
      await fetchMutation(
        config.public.convex.url,
        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 fetchQuery(
    config.public.convex.url,
    api.users.getProfile,
    {},
    { authToken: tokenResponse.token }
  )

  return profile
})

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

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

  // 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 fetchAction(
    config.public.convex.url,
    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/')) {
    const config = useRuntimeConfig()

    // Fire and forget - don't await
    fetchMutation(
      config.public.convex.url,
      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 config = useRuntimeConfig()
  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 fetchMutation(
    config.public.convex.url,
    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
    },
  },
})