@gigamusic/checkout 4.4.0 → 4.6.0

package/dist/index.js

@@ -15,6 +15,24 @@ function resolveUnitAmount(overrideCents, catalogCents) {
   }
   return catalogCents;
 }
+function apportion(totalCents, members) {
+  const result = /* @__PURE__ */ new Map();
+  if (members.length === 0) return result;
+  const total = Math.max(0, Math.round(totalCents));
+  const sum = members.reduce((s, m) => s + Math.max(0, m.price), 0);
+  const weights = sum > 0 ? members.map((m) => Math.max(0, m.price) / sum) : members.map(() => 1 / members.length);
+  const exact = weights.map((w) => total * w);
+  const base = exact.map((v) => Math.floor(v));
+  let remainder = total - base.reduce((s, v) => s + v, 0);
+  const order = members.map((m, i) => ({ i, frac: exact[i] - base[i], price: m.price, id: m.id })).sort((a, b) => b.frac - a.frac || b.price - a.price || a.id - b.id);
+  for (const { i } of order) {
+    if (remainder <= 0) break;
+    base[i] += 1;
+    remainder -= 1;
+  }
+  members.forEach((m, i) => result.set(m.id, base[i]));
+  return result;
+}
 function createCheckoutHandler(deps) {
   const {
     stripeSecret,
@@ -24,7 +42,8 @@ function createCheckoutHandler(deps) {
     successPath = "/checkout/success",
     cancelPath = "/cart",
     currency = "usd",
-    catalogPurchase
+    catalogPurchase,
+    bundlePurchase
   } = deps;
   const stripe = new Stripe(stripeSecret, { typescript: true });
   return async (req) => {
@@ -41,6 +60,14 @@ function createCheckoutHandler(deps) {
     const successUrl = `${baseUrl}${successPath}?session_id={CHECKOUT_SESSION_ID}`;
     const cancelUrl = `${baseUrl}${cancelPath}`;
     const isCatalogPurchase = items.some((i) => i.kind === "catalog");
+    const bundleIds = [
+      ...new Set(
+        items.filter((i) => i.kind === "bundle" && typeof i.bundleId === "string").map((i) => i.bundleId)
+      )
+    ];
+    if (isCatalogPurchase && bundleIds.length > 0) {
+      return jsonError("Cannot mix a catalog purchase with a bundle", 400);
+    }
     try {
       if (isCatalogPurchase) {
         const resolved = typeof catalogPurchase === "function" ? await catalogPurchase() : catalogPurchase;
@@ -73,9 +100,12 @@ function createCheckoutHandler(deps) {
       }
       const releaseIds = items.filter((i) => i.kind === "release" && i.id != null).map((i) => i.id);
       const trackIds = items.filter((i) => i.kind === "track" && i.id != null).map((i) => i.id);
-      if (releaseIds.length === 0 && trackIds.length === 0) {
+      if (releaseIds.length === 0 && trackIds.length === 0 && bundleIds.length === 0) {
         return jsonError("No valid items found", 400);
       }
+      if (bundleIds.length > 0 && typeof bundlePurchase !== "function") {
+        return jsonError("Bundle purchases are not configured", 400);
+      }
       const releaseAmountOverride = new Map(
         items.filter(
           (i) => i.kind === "release" && i.id != null && typeof i.priceCents === "number"
@@ -97,7 +127,7 @@ function createCheckoutHandler(deps) {
       }
       const releaseLineItems = releaseIds.map((id) => releaseById.get(id)).filter((r) => r !== void 0).map((r) => {
         const amount = resolveUnitAmount(releaseAmountOverride.get(r.id), r.price);
-        chargedAmounts[`r${r.id}`] = amount;
+        chargedAmounts[`r${r.id}`] = (chargedAmounts[`r${r.id}`] ?? 0) + amount;
         return {
           price_data: {
             currency,
@@ -117,7 +147,7 @@ function createCheckoutHandler(deps) {
           trackAmountOverride.get(track.id),
           track.price
         );
-        chargedAmounts[`t${track.id}`] = amount;
+        chargedAmounts[`t${track.id}`] = (chargedAmounts[`t${track.id}`] ?? 0) + amount;
         return {
           price_data: {
             currency,
@@ -130,12 +160,57 @@ function createCheckoutHandler(deps) {
           quantity: 1
         };
       });
-      const lineItems = [...releaseLineItems, ...trackLineItems];
+      const bundleLineItems = [];
+      const bundleMemberIds = [];
+      const unavailableBundleIds = [];
+      for (const bundleId of bundleIds) {
+        const resolved = await bundlePurchase(bundleId);
+        const members = (resolved?.releaseIds ?? []).map((id) => releaseById.get(id)).filter((r) => r !== void 0);
+        if (!resolved || members.length === 0) {
+          unavailableBundleIds.push(bundleId);
+          continue;
+        }
+        const total = Math.max(
+          STRIPE_MIN_CHARGE_CENTS,
+          Math.round(resolved.totalCents)
+        );
+        const cover = members.find((m) => m.coverImageUrl)?.coverImageUrl;
+        bundleLineItems.push({
+          price_data: {
+            currency,
+            product_data: {
+              name: resolved.productName,
+              ...cover ? { images: [toAbsoluteUrl(cover, baseUrl)] } : {}
+            },
+            unit_amount: total
+          },
+          quantity: 1
+        });
+        for (const [id, cents] of apportion(
+          total,
+          members.map((m) => ({ id: m.id, price: m.price }))
+        )) {
+          chargedAmounts[`r${id}`] = (chargedAmounts[`r${id}`] ?? 0) + cents;
+          bundleMemberIds.push(id);
+        }
+      }
+      if (unavailableBundleIds.length > 0) {
+        return Response.json(
+          { error: "bundle-unavailable", bundleIds: unavailableBundleIds },
+          { status: 409 }
+        );
+      }
+      const lineItems = [...bundleLineItems, ...releaseLineItems, ...trackLineItems];
       if (lineItems.length === 0) {
         return jsonError("No valid items found", 400);
       }
-      const resolvedReleaseIds = releaseLineItems.length ? releaseIds.filter((id) => releaseById.has(id)) : [];
-      const resolvedTrackIds = trackLineItems.length ? trackIds.filter((id) => trackContext.has(id)) : [];
+      const resolvedReleaseIds = [
+        .../* @__PURE__ */ new Set([
+          ...releaseLineItems.length ? releaseIds.filter((id) => releaseById.has(id)) : [],
+          ...bundleMemberIds
+        ])
+      ];
+      const resolvedTrackIds = trackLineItems.length ? [...new Set(trackIds.filter((id) => trackContext.has(id)))] : [];
       const session = await stripe.checkout.sessions.create({
         mode: "payment",
         line_items: lineItems,
@@ -143,7 +218,10 @@ function createCheckoutHandler(deps) {
           site,
           release_ids: JSON.stringify(resolvedReleaseIds),
           track_ids: JSON.stringify(resolvedTrackIds),
-          amounts: JSON.stringify(chargedAmounts)
+          amounts: JSON.stringify(chargedAmounts),
+          // Ignored by fulfillment — bundles decompose into per-release order
+          // items — but invaluable when supporting "what did I actually buy?".
+          ...bundleIds.length > 0 ? { bundle_ids: JSON.stringify(bundleIds) } : {}
         },
         success_url: successUrl,
         cancel_url: cancelUrl
@@ -170,13 +248,74 @@ function jsonError(message, status, cause) {
   }
   return Response.json({ error: message }, { status });
 }
-function createStripeWebhookHandler(deps) {
+async function fulfillCheckoutSession(session, deps) {
+  const { queries, site } = deps;
+  if (session.metadata?.site !== site) {
+    return { status: "skipped", reason: "site-mismatch" };
+  }
+  if (session.payment_status === "unpaid") {
+    return { status: "skipped", reason: "unpaid" };
+  }
+  const existing = await queries.getOrderByStripeSessionId(session.id);
+  if (existing) {
+    return { status: "already-recorded", order: existing };
+  }
+  const releaseIds = safeJsonIdList(session.metadata?.release_ids);
+  const trackIds = safeJsonIdList(session.metadata?.track_ids);
+  const chargedAmounts = safeAmountMap(session.metadata?.amounts);
+  if (releaseIds.length === 0 && trackIds.length === 0) {
+    return { status: "skipped", reason: "no-items" };
+  }
+  const allReleases = await queries.listPublishedReleases();
+  const releaseById = new Map(allReleases.map((r) => [r.id, r]));
+  const trackContext = /* @__PURE__ */ new Map();
+  for (const release of allReleases) {
+    for (const track of release.tracks) {
+      trackContext.set(track.id, { track, release });
+    }
+  }
+  const matchedReleases = releaseIds.map((id) => releaseById.get(id)).filter((r) => r !== void 0);
+  const matchedTracks = trackIds.map((id) => trackContext.get(id)).filter(
+    (c) => c !== void 0
+  );
+  const orderItems = [
+    ...matchedReleases.map((r) => ({
+      releaseId: r.id,
+      price: chargedAmounts[`r${r.id}`] ?? r.price
+    })),
+    ...matchedTracks.map(({ track }) => ({
+      trackId: track.id,
+      price: chargedAmounts[`t${track.id}`] ?? track.price
+    }))
+  ];
+  const customerEmail = session.customer_details?.email ?? "";
+  const totalCents = session.amount_total ?? 0;
+  let order;
+  try {
+    order = await queries.recordCompletedOrder({
+      stripeSessionId: session.id,
+      stripePaymentId: typeof session.payment_intent === "string" ? session.payment_intent : null,
+      email: customerEmail,
+      amountTotal: totalCents,
+      items: orderItems
+    });
+  } catch (err) {
+    if (isUniqueConstraintError(err)) {
+      return {
+        status: "already-recorded",
+        order: await queries.getOrderByStripeSessionId(session.id) ?? null
+      };
+    }
+    throw err;
+  }
+  const itemNames = [
+    ...matchedReleases.map((r) => r.name),
+    ...matchedTracks.map(({ track, release }) => `${release.name} \u2014 ${track.name}`)
+  ];
+  return { status: "created", order, itemNames, customerEmail, totalCents };
+}
+async function sendPurchaseConfirmation(args, deps) {
   const {
-    stripe: stripeOverride,
-    stripeSecret,
-    webhookSecret,
-    queries,
-    site,
     email,
     branding,
     emailFrom,
@@ -186,119 +325,33 @@ function createStripeWebhookHandler(deps) {
     verifyPath = "/orders/verify",
     renderConfirmation = renderPurchaseConfirmation
   } = deps;
-  if (!stripeOverride && !stripeSecret) {
-    throw new Error(
-      "createStripeWebhookHandler: must supply either `stripe` or `stripeSecret`"
+  if (!args.customerEmail) {
+    console.warn(
+      `[gigamusic/checkout] order ${args.orderId} has no customer email \u2014 recorded, but the customer cannot retrieve downloads.`
     );
+    return;
   }
-  const stripe = stripeOverride ?? new Stripe(stripeSecret, { typescript: true });
-  return async (req) => {
-    const body = await req.text();
-    const sig = req.headers.get("stripe-signature");
-    if (!sig) {
-      return Response.json({ error: "Missing signature" }, { status: 400 });
-    }
-    let event;
-    try {
-      event = stripe.webhooks.constructEvent(body, sig, webhookSecret);
-    } catch {
-      return Response.json({ error: "Invalid signature" }, { status: 400 });
-    }
-    if (event.type !== "checkout.session.completed") {
-      return Response.json({ received: true });
-    }
-    const session = event.data.object;
-    if (session.metadata?.site !== site) {
-      return Response.json({ received: true });
-    }
-    const existing = await queries.getOrderByStripeSessionId(session.id);
-    if (existing) {
-      return Response.json({ received: true });
-    }
-    const releaseIds = safeJsonIdList(session.metadata?.release_ids);
-    const trackIds = safeJsonIdList(session.metadata?.track_ids);
-    const chargedAmounts = safeAmountMap(session.metadata?.amounts);
-    if (releaseIds.length === 0 && trackIds.length === 0) {
-      return Response.json({ received: true });
-    }
-    const allReleases = await queries.listPublishedReleases();
-    const releaseById = new Map(allReleases.map((r) => [r.id, r]));
-    const trackContext = /* @__PURE__ */ new Map();
-    for (const release of allReleases) {
-      for (const track of release.tracks) {
-        trackContext.set(track.id, { track, release });
-      }
-    }
-    const matchedReleases = releaseIds.map((id) => releaseById.get(id)).filter((r) => r !== void 0);
-    const matchedTracks = trackIds.map((id) => trackContext.get(id)).filter(
-      (c) => c !== void 0
-    );
-    const orderItems = [
-      ...matchedReleases.map((r) => ({
-        releaseId: r.id,
-        price: chargedAmounts[`r${r.id}`] ?? r.price
-      })),
-      ...matchedTracks.map(({ track }) => ({
-        trackId: track.id,
-        price: chargedAmounts[`t${track.id}`] ?? track.price
-      }))
-    ];
-    const customerEmail = session.customer_details?.email ?? "";
-    let recordedOrder;
-    try {
-      recordedOrder = await queries.recordCompletedOrder({
-        stripeSessionId: session.id,
-        stripePaymentId: typeof session.payment_intent === "string" ? session.payment_intent : null,
-        email: customerEmail,
-        amountTotal: session.amount_total ?? 0,
-        items: orderItems
-      });
-    } catch (err) {
-      if (isUniqueConstraintError(err)) {
-        return Response.json({ received: true });
-      }
-      throw err;
-    }
-    if (!customerEmail) {
-      console.warn(
-        `[stripe-webhook] checkout.session.completed (session=${session.id}) has no customer_details.email \u2014 order recorded but customer cannot retrieve downloads.`
-      );
-      return Response.json({ received: true });
-    }
-    const itemNames = [
-      ...matchedReleases.map((r) => r.name),
-      ...matchedTracks.map(({ track, release }) => `${release.name} \u2014 ${track.name}`)
-    ];
-    after(async () => {
-      try {
-        const verifyToken = await signOrderToken({
-          orderId: String(recordedOrder.id),
-          email: customerEmail,
-          secret: orderTokenSecret,
-          expiresIn: orderTokenExpiry
-        });
-        const verifyUrl = `${baseUrl}${verifyPath}?token=${verifyToken}`;
-        const { subject, html } = await renderConfirmation({
-          branding,
-          verifyUrl,
-          itemNames,
-          totalCents: session.amount_total ?? 0
-        });
-        await email.send({
-          from: emailFrom,
-          to: customerEmail,
-          subject,
-          html
-        });
-      } catch (err) {
-        console.error(
-          `[stripe-webhook] failed to send purchase confirmation to ${customerEmail} for session ${session.id}:`,
-          err
-        );
-      }
+  try {
+    const verifyToken = await signOrderToken({
+      orderId: String(args.orderId),
+      email: args.customerEmail,
+      secret: orderTokenSecret,
+      expiresIn: orderTokenExpiry
     });
-    return Response.json({ received: true });
-  };
+    const verifyUrl = `${baseUrl}${verifyPath}?token=${verifyToken}`;
+    const { subject, html } = await renderConfirmation({
+      branding,
+      verifyUrl,
+      itemNames: args.itemNames,
+      totalCents: args.totalCents
+    });
+    await email.send({ from: emailFrom, to: args.customerEmail, subject, html });
+  } catch (err) {
+    console.error(
+      `[gigamusic/checkout] failed to send purchase confirmation to ${args.customerEmail} for order ${args.orderId}:`,
+      err
+    );
+  }
 }
 function safeAmountMap(value) {
   if (!value) return {};
@@ -326,6 +379,50 @@ function safeJsonIdList(value) {
   }
 }
 
+// src/webhook.ts
+function createStripeWebhookHandler(deps) {
+  const { stripe: stripeOverride, stripeSecret, webhookSecret, queries, site } = deps;
+  if (!stripeOverride && !stripeSecret) {
+    throw new Error(
+      "createStripeWebhookHandler: must supply either `stripe` or `stripeSecret`"
+    );
+  }
+  const stripe = stripeOverride ?? new Stripe(stripeSecret, { typescript: true });
+  return async (req) => {
+    const body = await req.text();
+    const sig = req.headers.get("stripe-signature");
+    if (!sig) {
+      return Response.json({ error: "Missing signature" }, { status: 400 });
+    }
+    let event;
+    try {
+      event = stripe.webhooks.constructEvent(body, sig, webhookSecret);
+    } catch {
+      return Response.json({ error: "Invalid signature" }, { status: 400 });
+    }
+    if (event.type !== "checkout.session.completed") {
+      return Response.json({ received: true });
+    }
+    const session = event.data.object;
+    const result = await fulfillCheckoutSession(session, { queries, site });
+    if (result.status !== "created") {
+      return Response.json({ received: true });
+    }
+    after(
+      () => sendPurchaseConfirmation(
+        {
+          orderId: result.order.id,
+          customerEmail: result.customerEmail,
+          itemNames: result.itemNames,
+          totalCents: result.totalCents
+        },
+        deps
+      )
+    );
+    return Response.json({ received: true });
+  };
+}
+
 // src/download.ts
 function createDownloadHandler(deps) {
   const { queries, storage } = deps;
@@ -757,6 +854,6 @@ function createSwZipFallbackHandler() {
   };
 }
 
-export { createCheckoutHandler, createDownloadHandler, createDownloadZipHandler, createDownloadZipStreamHandler, createStripeWebhookHandler, createSwZipFallbackHandler };
+export { createCheckoutHandler, createDownloadHandler, createDownloadZipHandler, createDownloadZipStreamHandler, createStripeWebhookHandler, createSwZipFallbackHandler, fulfillCheckoutSession, sendPurchaseConfirmation };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map