Discount Builder

"use client"

import type { Product } from "../variant-picker/product"
import type { Discount, DiscountErrors, DiscountField } from "@/components/blocks/discount-builder/discount"
import { DiscountBuilder } from "@/components/blocks/discount-builder/discount-builder"

const basicCreate = `
  mutation discountCodeBasicCreate($basicCodeDiscount: DiscountCodeBasicInput!) {
    discountCodeBasicCreate(basicCodeDiscount: $basicCodeDiscount) {
      codeDiscountNode { id }
      userErrors { field message }
    }
  }
`

const bxgyCreate = `
  mutation discountAutomaticBxgyCreate($automaticBxgyDiscount: DiscountAutomaticBxgyInput!) {
    discountAutomaticBxgyCreate(automaticBxgyDiscount: $automaticBxgyDiscount) {
      automaticDiscountNode { id }
      userErrors { field message }
    }
  }
`

type UserError = { field: string[] | null; message: string }

function items(type: "products" | "collections", ids: string[]) {
  return type === "products" ? { products: { productsToAdd: ids } } : { collections: { add: ids } }
}

function basicInput(discount: Discount) {
  return {
    title: discount.code,
    code: discount.code,
    startsAt: discount.startsAt,
    endsAt: discount.endsAt,
    usageLimit: discount.usage.limitTotal ? discount.usage.total : null,
    appliesOncePerCustomer: discount.usage.oncePerCustomer,
    context: discount.eligibility.type === "segments" ? { customerSegments: { add: discount.eligibility.ids } } : discount.eligibility.type === "customers" ? { customers: { add: discount.eligibility.ids } } : { all: "ALL" },
    combinesWith: {
      productDiscounts: discount.combinesWith.product,
      orderDiscounts: discount.combinesWith.order,
      shippingDiscounts: discount.combinesWith.shipping,
    },
    minimumRequirement:
      discount.minimum.type === "amount"
        ? { subtotal: { greaterThanOrEqualToSubtotal: discount.minimum.value } }
        : discount.minimum.type === "quantity"
          ? { quantity: { greaterThanOrEqualToQuantity: String(discount.minimum.value) } }
          : null,
    customerGets: {
      value:
        discount.valueType === "percentage"
          ? { percentage: (discount.value ?? 0) / 100 }
          : { discountAmount: { amount: discount.value, appliesOnEachItem: discount.type === "amount_off_products" } },
      items:
        discount.type === "amount_off_order" || discount.appliesTo.type === "all"
          ? { all: true }
          : items(discount.appliesTo.type, discount.appliesTo.ids),
    },
  }
}

function bxgyInput(discount: Discount) {
  return {
    title: discount.title,
    startsAt: discount.startsAt,
    endsAt: discount.endsAt,
    usesPerOrderLimit: discount.gets.limitPerOrder ? String(discount.gets.maxUsesPerOrder) : null,
    customerBuys: {
      value:
        discount.buys.type === "quantity"
          ? { quantity: String(discount.buys.value) }
          : { amount: String(discount.buys.value) },
      items: items(discount.buys.items.type, discount.buys.items.ids),
    },
    customerGets: {
      value: {
        discountOnQuantity: {
          quantity: String(discount.gets.quantity),
          effect: { percentage: discount.gets.effect === "free" ? 1 : (discount.gets.percentage ?? 0) / 100 },
        },
      },
      items: items(discount.gets.items.type, discount.gets.items.ids),
    },
  }
}

const fieldMap: Record<string, DiscountField> = {
  code: "code",
  title: "title",
  endsAt: "endsAt",
  startsAt: "startsAt",
  usageLimit: "usageLimit",
}

async function saveToShopify(discount: Discount): Promise<DiscountErrors | void> {
  const bxgy = discount.type === "buy_x_get_y" && discount.method === "automatic"
  const response = await fetch("/api/shopify/graphql", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify(
      bxgy
        ? { query: bxgyCreate, variables: { automaticBxgyDiscount: bxgyInput(discount) } }
        : { query: basicCreate, variables: { basicCodeDiscount: basicInput(discount) } }
    ),
  })
  if (!response.ok) throw new Error("Shopify didn’t respond.")
  const { data } = await response.json()
  const result = bxgy ? data.discountAutomaticBxgyCreate : data.discountCodeBasicCreate
  const errors: DiscountErrors = {}
  for (const error of result.userErrors as UserError[]) {
    const field = fieldMap[error.field?.at(-1) ?? ""]
    if (field) errors[field] = error.message
    else throw new Error(error.message)
  }
  return errors
}

async function saveDraft(discount: Discount): Promise<DiscountErrors | void> {
  const response = await fetch("/api/discount-drafts", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify(discount),
  })
  if (!response.ok) throw new Error("The draft wasn’t saved.")
}

export function NewShopifyDiscount({ discount, products }: { discount: Discount; products: Product[] }) {
  return (
    <DiscountBuilder
      discount={discount}
      products={products}
      timeZone="America/New_York"
      showTypePicker={false}
      existingDiscounts={[{ code: "FREESHIP", type: "free_shipping" }]}
      onSave={(next, { intent }) => (intent === "draft" ? saveDraft(next) : saveToShopify(next))}
      onCheckCode={async (code, { signal }) => {
        const response = await fetch(`/api/discounts/check?code=${encodeURIComponent(code)}`, { signal })
        const { available } = await response.json()
        return available
      }}
    />
  )
}

"use server"

import { toMinorUnits, money } from "../price/money"
import type { Discount, DiscountErrors } from "@/components/blocks/discount-builder/discount"

type StripeError = { code?: string; message: string }

const stripeKey = process.env.STRIPE_SECRET_KEY ?? ""

async function stripe(path: string, body: Record<string, string>) {
  const response = await fetch(`https://api.stripe.com/v1/${path}`, {
    method: "POST",
    headers: { Authorization: `Bearer ${stripeKey}`, "Content-Type": "application/x-www-form-urlencoded" },
    body: new URLSearchParams(body),
  })
  const json = await response.json()
  if (!response.ok) throw json.error as StripeError
  return json
}

export async function saveDiscount(discount: Discount): Promise<DiscountErrors | void> {
  if (discount.status === "draft") {
    await fetch(`${process.env.APP_URL}/api/discount-drafts`, { method: "POST", body: JSON.stringify(discount) })
    return
  }
  const coupon = await stripe("coupons", {
    name: discount.code,
    duration: "once",
    ...(discount.valueType === "percentage"
      ? { percent_off: String(discount.value) }
      : {
          amount_off: String(toMinorUnits(money(discount.value ?? 0, discount.currencyCode))),
          currency: discount.currencyCode.toLowerCase(),
        }),
    ...(discount.appliesTo.type === "products"
      ? Object.fromEntries(discount.appliesTo.ids.map((id, index) => [`applies_to[products][${index}]`, id]))
      : {}),
  })

  try {
    await stripe("promotion_codes", {
      coupon: coupon.id,
      code: discount.code,
      ...(discount.usage.limitTotal && discount.usage.total ? { max_redemptions: String(discount.usage.total) } : {}),
      ...(discount.endsAt ? { expires_at: String(Math.floor(Date.parse(discount.endsAt) / 1000)) } : {}),
      ...(discount.eligibility.type === "segments" && discount.eligibility.ids.includes("first-time")
        ? { "restrictions[first_time_transaction]": "true" }
        : {}),
      ...(discount.minimum.type === "amount" && discount.minimum.value
        ? {
            "restrictions[minimum_amount]": String(toMinorUnits(money(discount.minimum.value, discount.currencyCode))),
            "restrictions[minimum_amount_currency]": discount.currencyCode.toLowerCase(),
          }
        : {}),
    })
  } catch (error) {
    const { message } = error as StripeError
    if (/already exists/i.test(message)) return { code: `${discount.code} is already a promotion code in Stripe` }
    throw new Error(message)
  }
}

"use client"

import type { Product } from "../variant-picker/product"
import type { Discount } from "@/components/blocks/discount-builder/discount"
import { DiscountBuilder } from "@/components/blocks/discount-builder/discount-builder"

const admin = "/admin/promotions"

function toPromotion(discount: Discount) {
  const target =
    discount.type === "amount_off_order" ? "order" : discount.type === "free_shipping" ? "shipping_methods" : "items"
  return {
    code: discount.code,
    type: discount.type === "buy_x_get_y" ? "buyget" : "standard",
    is_automatic: discount.method === "automatic",
    status: discount.status === "draft" ? "draft" : "active",
    application_method: {
      type: discount.type === "free_shipping" ? "percentage" : discount.valueType === "percentage" ? "percentage" : "fixed",
      value: discount.type === "free_shipping" ? 100 : discount.value,
      currency_code: discount.currencyCode.toLowerCase(),
      target_type: target,
      allocation: discount.type === "amount_off_products" ? "each" : "across",
      target_rules:
        discount.appliesTo.type === "products"
          ? [{ attribute: "items.product.id", operator: "in", values: discount.appliesTo.ids }]
          : [],
    },
    campaign: {
      name: discount.code || discount.title,
      campaign_identifier: discount.code || discount.title,
      starts_at: discount.startsAt,
      ends_at: discount.endsAt,
      budget: discount.usage.limitTotal ? { type: "usage", limit: discount.usage.total } : undefined,
    },
  }
}

export function MedusaDiscount({ discount, products }: { discount: Discount; products: Product[] }) {
  return (
    <DiscountBuilder
      discount={discount}
      products={products}
      onCheckCode={async (code, { signal }) => {
        const response = await fetch(`${admin}?code=${encodeURIComponent(code)}&limit=1`, { signal, credentials: "include" })
        const { count } = await response.json()
        return { available: count === 0, message: `${code} is already a promotion` }
      }}
      onSave={async (next) => {
        const response = await fetch(discount.id ? `${admin}/${discount.id}` : admin, {
          method: "POST",
          credentials: "include",
          headers: { "Content-Type": "application/json" },
          body: JSON.stringify(toPromotion(next)),
        })
        if (response.ok) return
        const { message } = await response.json()
        if (/code/i.test(message)) return { code: message }
        throw new Error(message)
      }}
    />
  )
}