Order Summary

"use client"

import type { Cart } from "../cart/cart"
import { OrderSummary } from "@/components/blocks/order-summary/order-summary"
import { DiscountCodeError } from "@/components/blocks/order-summary/summary"

type ShopifyMoney = { amount: string; currencyCode: string }

type ShopifyCart = {
  id: string
  discountCodes: { code: string; applicable: boolean }[]
  discountAllocations: {
    discountedAmount: ShopifyMoney
    code?: string
    title?: string
  }[]
  cost: { subtotalAmount: ShopifyMoney; totalTaxAmount: ShopifyMoney | null }
  lines: {
    nodes: {
      id: string
      quantity: number
      cost: { amountPerQuantity: ShopifyMoney; compareAtAmountPerQuantity: ShopifyMoney | null }
      merchandise: {
        id: string
        title: string
        image: { url: string; altText: string | null } | null
        product: { id: string; title: string }
      }
    }[]
  }
}

const mutation = `
  mutation cartDiscountCodesUpdate($cartId: ID!, $discountCodes: [String!]) {
    cartDiscountCodesUpdate(cartId: $cartId, discountCodes: $discountCodes) {
      cart { id discountCodes { code applicable } }
      userErrors { field message }
    }
  }
`

function toCart(cart: ShopifyCart): Cart {
  return {
    id: cart.id,
    currencyCode: cart.cost.subtotalAmount.currencyCode,
    tax: cart.cost.totalTaxAmount,
    lines: cart.lines.nodes.map((line) => ({
      id: line.id,
      quantity: line.quantity,
      price: line.cost.amountPerQuantity,
      compareAtPrice: line.cost.compareAtAmountPerQuantity,
      merchandise: {
        id: line.merchandise.id,
        productId: line.merchandise.product.id,
        productTitle: line.merchandise.product.title,
        variantTitle: line.merchandise.title,
        image: line.merchandise.image
          ? {
              id: line.merchandise.image.url,
              src: line.merchandise.image.url,
              alt: line.merchandise.image.altText ?? "",
            }
          : undefined,
      },
    })),
    discounts: cart.discountAllocations.map((allocation) => ({
      code: allocation.code ?? allocation.title ?? "Discount",
      label: allocation.title,
      automatic: !allocation.code,
      amount: allocation.discountedAmount,
    })),
  }
}

export function ShopifyOrderSummary({
  cart,
  storefront,
  refetch,
}: {
  cart: ShopifyCart
  storefront: <T>(query: string, variables: Record<string, unknown>) => Promise<T>
  refetch: () => Promise<ShopifyCart>
}) {
  const codes = cart.discountCodes.map((item) => item.code)

  const update = async (discountCodes: string[]) => {
    const result = await storefront<{
      cartDiscountCodesUpdate: { userErrors: { message: string }[] }
    }>(mutation, { cartId: cart.id, discountCodes })
    const error = result.cartDiscountCodesUpdate.userErrors[0]
    if (error) throw new Error(error.message)
    return refetch()
  }

  return (
    <OrderSummary
      cart={toCart(cart)}
      collapsible
      onApplyCode={async (code) => {
        const next = await update([...codes, code])
        const added = next.discountCodes.find((item) => item.code.toUpperCase() === code)
        if (!added?.applicable) {
          await update(codes)
          throw DiscountCodeError.notFound(code)
        }
        return toCart(next)
      }}
      onRemoveCode={async (code) =>
        toCart(await update(codes.filter((item) => item !== code)))
      }
    />
  )
}

import { fromMinorUnits, toMinorUnits, type Money } from "../price/money"
import { DiscountCodeError } from "@/components/blocks/order-summary/summary"

type StripePromotionCode = {
  code: string
  active: boolean
  expires_at: number | null
  restrictions: { minimum_amount: number | null; minimum_amount_currency: string | null }
  coupon: { percent_off: number | null; amount_off: number | null; valid: boolean }
}

type StripeClient = {
  promotionCodes: {
    list: (params: { code: string; limit: number }) => Promise<{ data: StripePromotionCode[] }>
  }
}

export async function checkPromotionCode(
  stripe: StripeClient,
  code: string,
  subtotal: Money
): Promise<Money> {
  const { data } = await stripe.promotionCodes.list({ code, limit: 1 })
  const promotion = data[0]
  if (!promotion) throw DiscountCodeError.notFound(code)

  if (promotion.expires_at && promotion.expires_at * 1000 < Date.now()) {
    throw DiscountCodeError.expired(code, new Date(promotion.expires_at * 1000))
  }
  if (!promotion.active || !promotion.coupon.valid) {
    throw DiscountCodeError.notFound(code)
  }

  const minimum = promotion.restrictions.minimum_amount
  if (minimum && toMinorUnits(subtotal) < minimum) {
    throw DiscountCodeError.minimum(
      code,
      fromMinorUnits(minimum - toMinorUnits(subtotal), subtotal.currencyCode)
    )
  }

  const { percent_off, amount_off } = promotion.coupon
  const off = percent_off
    ? Math.round((toMinorUnits(subtotal) * percent_off) / 100)
    : (amount_off ?? 0)
  return fromMinorUnits(off, subtotal.currencyCode)
}

"use client"

import type { Cart } from "../cart/cart"
import { OrderSummary } from "@/components/blocks/order-summary/order-summary"

type DiscountResult =
  | { ok: true; cart: Cart }
  | { ok: false; message: string }

export function CheckoutSummary({
  cart,
  applyDiscount,
  removeDiscount,
}: {
  cart: Cart
  applyDiscount: (cartId: string, code: string) => Promise<DiscountResult>
  removeDiscount: (cartId: string, code: string) => Promise<DiscountResult>
}) {
  const run = async (result: Promise<DiscountResult>) => {
    const outcome = await result
    if (!outcome.ok) throw new Error(outcome.message)
    return outcome.cart
  }

  return (
    <OrderSummary
      cart={cart}
      shipping="pending"
      tax={{ amount: cart.tax ?? null, estimated: true, basis: "Estimated for your location" }}
      collapsible
      onApplyCode={(code) => run(applyDiscount(cart.id, code))}
      onRemoveCode={(code) => run(removeDiscount(cart.id, code))}
    />
  )
}