export async function handleCheckoutCompleted(stripe, event) {
 const session = event.data.object
 const subscription = await stripe.subscriptions.retrieve(session.subscription)

 const items = JSON.parse(session.metadata.items)
 items.forEach((item) => {
 item.ref = getDocRef(item.id, item_COLLECTION)
 delete item.id
 })

 const order = await createOrder(
 {
 items,
 subscriptionId: subscription.id,
 status: subscription.status
 },
 session.metadata.userId
 )

 await stripe.subscriptions.update(subscription.id, {
 metadata: {
 orderId: order.orderId
 }
 })
}

import { STRIPE_EVENTS_HANDLERS } from '@/store/constants'
import Stripe from 'stripe'

export async function POST(req) {
  const stripe = new Stripe(process.env.STRIPE_SECRET_KEY)

  const sig = req.headers.get('stripe-signature')
  const payload = await req.text()
  const endpointSecret = process.env.STRIPE_WEBHOOK_SECRET

  try {
    const event = stripe.webhooks.constructEvent(payload, sig, endpointSecret)
    const handlerFunction = STRIPE_EVENTS_HANDLERS[event.type]
    if (handlerFunction) await handlerFunction(stripe, event)
    return new Response('Webhook handled', { status: 200 })
  } catch (err) {
    console.error('Webhook Error:', err.message)
    return new Response(`Webhook Error: ${err.message}`, { status: 400 })
  }
}

'use server'
import { cache } from 'react'

// Memoize a database query or expensive computation
const cachedQuery = cache(async (id) => {
  // Database query or other expensive operation
  return await db.findById(id)
})

export async function myServerAction(id) {
  // The result will be cached based on the id parameter
  const result = await cachedQuery(id)
  
  // Do something with the result
  return result
}

export const getCurrentGoal = cache(async () => {
  try {
    const collectionRef = collection(db, GOALS_COLLECTION)
    const docSnap = await getDocs(collectionRef)

    if (!docSnap.empty) {
      const goalData = docSnap.docs[0].data()

      if (goalData.validCauses) {
        goalData.validCauses = await Promise.all(
          goalData.validCauses.map(async (cause) => {
            const causeData = await resolveDocument(cause)
            return {
              id: causeData.id,
              name: causeData.name
            }
          })
        )
      }
      return goalData
    } else {
      return null
    }
  } catch (error) {
    console.error('Error fetching goals:', error)
    throw error
  }
})

export const getCurrentGoal = cache(async () => {
  try {
    return 'boo'
    }
  } catch (error) {
    console.error('Error fetching goals:', error)
    throw error
  }
})

import { cache } from 'react';

import { NextResponse } from 'next/server'
import {
  SIGN_UP_ROUTE,
  SIGN_IN_ROUTE,
  APP_ROUTE,
  SESSION_COOKIE
} from './store/constants'

export default function middleware(request) {
  const session = request.cookies.get(SESSION_COOKIE)?.value || ''
  const pathname = request.nextUrl.pathname

  if (!session && pathname.startsWith(APP_ROUTE)) {
    const absoluteURL = new URL(SIGN_IN_ROUTE, request.nextUrl.origin)
    return NextResponse.redirect(absoluteURL.toString())
  }

  if (session && (pathname === SIGN_IN_ROUTE || pathname === SIGN_UP_ROUTE)) {
    const absoluteURL = new URL(APP_ROUTE, request.nextUrl.origin)
    return NextResponse.redirect(absoluteURL.toString())
  }
}

import {
  getCurrentGoal
} from '@/app/actions/goals'

export const STRIPE_EVENTS_HANDLERS = {
  'checkout.session.completed': handleCheckoutCompleted,
  'invoice.payment_succeeded': handlePaymentSucceeded,
  'invoice.payment_failed': handlePaymentFailed,
  'customer.subscription.updated': handleSubscriptionUpdated,
  'customer.subscription.deleted': handleSubscriptionDeleted
}