Files
place4bees.com/frontend/src/lib/cart.ts
T
2026-09-17 16:02:51 +02:00

312 lines
11 KiB
TypeScript

import { medusaFetch } from "./medusa";
import { summariseVarieties } from "./subscriptions";
import { varietyName } from "./varieties";
export interface MedusaCartItem {
id: string;
title: string;
thumbnail: string | null;
quantity: number;
unit_price: number;
/** Beim Abo steht hier die Sortenwahl. */
metadata?: {
subscription_selection?: "fixed" | "random";
/** Altbestand: eine Sorte für alle Gläser. */
subscription_variety?: string;
subscription_variant_id?: string;
/** Eine Angabe je Glas, in der Reihenfolge der Auswahl. */
subscription_varieties?: string[];
subscription_variant_ids?: string[];
/** Beim verschenkten Abo gesetzt. */
subscription_gift?: boolean;
/** Bienenpatenschaft: Angaben für Urkunde, Etikett und Beschenkten. */
sponsorship_name?: string;
sponsorship_gift?: boolean;
sponsorship_recipient_email?: string;
sponsorship_sender_name?: string;
subscription_deliveries?: number;
gift_recipient_name?: string;
gift_recipient_email?: string;
gift_sender_name?: string;
/** Geschenkgutschein: geht er direkt an den Beschenkten? */
voucher_gift?: boolean;
voucher_recipient_name?: string;
voucher_recipient_email?: string;
voucher_sender_name?: string;
voucher_message?: string;
} | null;
/** `false` beim Geschenkgutschein: er kommt per E-Mail. */
requires_shipping?: boolean;
variant?: {
id: string;
metadata?: { subscription_interval?: string; subscription_size?: string } | null;
product?: { metadata?: { subscription?: boolean } | null } | null;
} | null;
}
export interface MedusaCart {
id: string;
email: string | null;
currency_code: string;
/** Bestimmt, welche Zahlungsarten zur Verfügung stehen. */
region_id: string | null;
item_total: number;
items: MedusaCartItem[];
/** Nach Abzug eingelöster Gutscheine. */
total?: number;
credit_line_total?: number;
credit_lines?: { id: string; amount: number; reference: string | null; reference_id: string | null }[];
gift_cards?: { id: string; code: string }[];
}
export interface MedusaShippingOption {
id: string;
name: string;
amount: number;
}
export async function createCart(regionId: string): Promise<MedusaCart> {
const data = await medusaFetch("/store/carts", {
method: "POST",
body: JSON.stringify({ region_id: regionId }),
});
return data.cart;
}
// Ohne diese Felder liefert Medusa weder die Posten-Metadaten noch die
// Produktkennzeichnung — beides braucht die Kasse, um ein Abo zu erkennen.
// Dazu die eingelösten Gutscheine und ob ein Posten verschickt wird.
const CART_FIELDS =
"+items.metadata,+items.variant.metadata,+items.variant.product.metadata,+items.requires_shipping," +
"+total,+credit_line_total,+credit_lines.*,+gift_cards.id,+gift_cards.code";
export async function getCart(cartId: string): Promise<MedusaCart> {
const data = await medusaFetch(`/store/carts/${cartId}?fields=${encodeURIComponent(CART_FIELDS)}`);
return data.cart;
}
/** Enthält der Warenkorb ein Abo? Dann läuft die Kasse anders. */
function istAboPosten(item: MedusaCartItem): boolean {
return item.variant?.product?.metadata?.subscription === true;
}
/**
* Ob der Warenkorb ein Abo enthält, das ein Mandat braucht.
*
* Ein verschenktes Abo braucht keines: es ist mit der Bestellung vollständig
* bezahlt und wird nie abgebucht. Es läuft deshalb durch die normale Kasse,
* nicht über die Weiterleitung zu Mollie.
*/
export function cartHasSubscription(cart: MedusaCart | null): boolean {
return (cart?.items ?? []).some(
(item) => istAboPosten(item) && item.metadata?.subscription_gift !== true
);
}
/** Ob im Warenkorb ein verschenktes Abo liegt. */
export function cartHasGiftSubscription(cart: MedusaCart | null): boolean {
return (cart?.items ?? []).some(
(item) => istAboPosten(item) && item.metadata?.subscription_gift === true
);
}
const INTERVAL_LABELS: Record<string, string> = {
monthly: "monatlich",
quarterly: "alle 3 Monate",
biannual: "alle 6 Monate",
};
/**
* Die Angaben, die ein Posten über sich selbst macht.
*
* Bei der Patenschaft sind das Name und Empfänger — sie stehen im Warenkorb
* und an der Kasse, damit ein Tippfehler im Namen auffällt, bevor die
* Urkunde gedruckt ist.
*/
export function describeSponsorshipItem(item: MedusaCartItem): string {
const name = item.metadata?.sponsorship_name;
if (!name) return "";
const teile = [`Auf den Namen: ${name}`];
if (item.metadata?.sponsorship_gift) {
teile.push(`Geschenk an ${item.metadata.sponsorship_recipient_email ?? "—"}`);
}
return teile.join(" · ");
}
/** Beim verschenkten Gutschein: an wen er per E-Mail geht. */
export function describeVoucherItem(item: MedusaCartItem): string {
if (!item.metadata?.voucher_gift || !item.metadata.voucher_recipient_email) return "";
const an = item.metadata.voucher_recipient_name
? `${item.metadata.voucher_recipient_name} (${item.metadata.voucher_recipient_email})`
: item.metadata.voucher_recipient_email;
return `Per E-Mail an ${an}`;
}
/** Ob etwas im Warenkorb verschickt wird. Ein Gutschein allein nicht. */
export function cartRequiresShipping(cart: MedusaCart | null): boolean {
return (cart?.items ?? []).some((item) => item.requires_shipping !== false);
}
/** Gutscheincode am Warenkorb einlösen. */
export async function applyGiftCard(cartId: string, code: string): Promise<void> {
await medusaFetch(`/store/carts/${cartId}/gift-cards`, {
method: "POST",
body: JSON.stringify({ code }),
});
}
/** Eingelösten Gutschein wieder vom Warenkorb nehmen. */
export async function removeGiftCard(cartId: string, code: string): Promise<void> {
await medusaFetch(`/store/carts/${cartId}/gift-cards`, {
method: "DELETE",
body: JSON.stringify({ code }),
});
}
/** Das Guthaben der eingelösten Gutscheine — für den Abzug an der Kasse. */
export async function getGiftCardBalances(cartId: string): Promise<{ code: string; balance: number }[]> {
const data = await medusaFetch(`/store/carts/${cartId}/gift-card-balances`);
return data.gift_cards ?? [];
}
export function describeSubscriptionItem(item: MedusaCartItem): string {
const interval = INTERVAL_LABELS[item.variant?.metadata?.subscription_interval ?? ""] ?? "";
const size = item.variant?.metadata?.subscription_size ?? "";
// Beim Anzeigen kürzen statt beim Speichern: so lesen sich auch Warenkörbe
// kurz, die noch mit den vollen Katalogtiteln angelegt wurden.
const perGlass = summariseVarieties(
(item.metadata?.subscription_varieties ?? []).map(varietyName)
);
const variety =
item.metadata?.subscription_selection === "fixed"
? // Altbestand aus der Zeit vor der Wahl je Glas kennt nur die
// Einzelangabe.
(perGlass || (item.metadata.subscription_variety && varietyName(item.metadata.subscription_variety)) || "feste Sorte")
: "Überraschungshonig";
return [size, interval, variety].filter(Boolean).join(" · ");
}
/** Startet die Abo-Kasse und liefert die Weiterleitungsadresse zu Mollie. */
export async function startSubscriptionCheckout(payload: {
cart_id: string;
email: string;
shipping_address: Record<string, unknown>;
shipping_option_id?: string;
method?: string;
}): Promise<{ checkout_url: string }> {
const data = await medusaFetch("/store/subscriptions/checkout", {
method: "POST",
body: JSON.stringify(payload),
});
return data;
}
export async function addLineItem(
cartId: string,
variantId: string,
quantity = 1,
/**
* Zusatzangaben am Posten. Beim Abo steht hier die Sortenwahl, die
* bewusst keine Produktvariante ist — mit 12 Sorten mal Größe mal
* Intervall gäbe das 78 Varianten.
*/
metadata?: Record<string, unknown>
): Promise<MedusaCart> {
const data = await medusaFetch(`/store/carts/${cartId}/line-items`, {
method: "POST",
body: JSON.stringify({
variant_id: variantId,
quantity,
...(metadata && Object.keys(metadata).length ? { metadata } : {}),
}),
});
return data.cart;
}
export async function updateLineItem(cartId: string, lineId: string, quantity: number): Promise<MedusaCart> {
const data = await medusaFetch(`/store/carts/${cartId}/line-items/${lineId}`, {
method: "POST",
body: JSON.stringify({ quantity }),
});
return data.cart;
}
export async function removeLineItem(cartId: string, lineId: string): Promise<void> {
await medusaFetch(`/store/carts/${cartId}/line-items/${lineId}`, { method: "DELETE" });
}
interface CartAddress {
first_name: string;
last_name: string;
address_1: string;
postal_code: string;
city: string;
country_code: string;
}
export async function updateCart(
cartId: string,
payload: { email?: string; shipping_address?: CartAddress; billing_address?: CartAddress }
): Promise<MedusaCart> {
const data = await medusaFetch(`/store/carts/${cartId}`, {
method: "POST",
body: JSON.stringify(payload),
});
return data.cart;
}
export async function listShippingOptions(cartId: string): Promise<MedusaShippingOption[]> {
const data = await medusaFetch(`/store/shipping-options?cart_id=${cartId}`);
return data.shipping_options;
}
/**
* Versandart setzen. Über die eigene Route statt Medusas `shipping-methods`:
* nur sie rechnet die Versandkostenfreigrenze ohne Gutscheine im Warenkorb.
*/
export async function addShippingMethod(cartId: string, optionId: string): Promise<MedusaCart> {
const data = await medusaFetch(`/store/carts/${cartId}/select-shipping`, {
method: "POST",
body: JSON.stringify({ option_id: optionId }),
});
return data.cart;
}
export interface PaymentMethod {
id: string;
label: string;
description: string;
}
/**
* Die Zahlungsarten, die der Shop zu Ende führen kann.
*
* Bewusst nicht Medusas `/store/payment-providers`: das listet auch
* Anbieter, für die es an der Kasse noch keinen Ablauf gibt.
*/
export async function listPaymentMethods(regionId?: string): Promise<PaymentMethod[]> {
const query = regionId ? `?region_id=${encodeURIComponent(regionId)}` : "";
const data = await medusaFetch(`/store/payment-methods${query}`);
return data.payment_methods ?? [];
}
export async function createPaymentCollection(cartId: string) {
const data = await medusaFetch("/store/payment-collections", {
method: "POST",
body: JSON.stringify({ cart_id: cartId }),
});
return data.payment_collection;
}
export async function createPaymentSession(paymentCollectionId: string, providerId: string) {
const data = await medusaFetch(`/store/payment-collections/${paymentCollectionId}/payment-sessions`, {
method: "POST",
body: JSON.stringify({ provider_id: providerId }),
});
return data.payment_collection;
}
export async function completeCart(cartId: string): Promise<{ type: "order" | "cart"; order?: any; cart?: any; error?: { message: string } }> {
return medusaFetch(`/store/carts/${cartId}/complete`, { method: "POST" });
}