@hartl-services/medusa-storefront 0.0.0-stage → 0.2.0

package/dist/browser/cart-mutations.js

@@ -0,0 +1,137 @@
+import { checkoutStorePaths } from "@hartl-services/medusa-contracts/paths/checkout";
+import { buildReplacementCart, getCustomerCouponCodes } from "../core/cart/refunded-cart.js";
+import { hasCartPromotionCode } from "../core/checkout/checkout-coupon.js";
+import { isPluginFeatureEnabled } from "../core/plugin-features.js";
+// One per browser page, shared by every active-cart fetch: concurrent fetches
+// of a refunded cart share one replacement.
+const refundedCartReplacements = new Map();
+// Cart creation/mutation runs through the browser-credentialed client, not a
+// Server Action - Medusa's own host-only cookies must be attached directly
+// from the browser.
+export function createCartMutations({ actions, createClient, referral, reportCheckoutError }) {
+    async function createCartNow(data) {
+        const sdk = createClient();
+        const { cart } = await sdk.store.cart.create(data);
+        await actions.syncCartId(cart.id);
+        return (await actions.applyCustomerDefaultsToActiveCart()) ?? cart;
+    }
+    // Best effort through the coupon field's own path (affiliate coupon first,
+    // Medusa promotion on 404): a code that no longer applies is simply left off.
+    // A shipping coupon cannot apply before a shipping method is chosen.
+    async function reapplyCouponCodes(codes) {
+        if (codes.length === 0) {
+            return;
+        }
+        const cart = await actions.getActiveCart();
+        if (!cart) {
+            return;
+        }
+        try {
+            const useAffiliatePath = isPluginFeatureEnabled(await actions.fetchPluginFeatures(), "affiliate", "coupons");
+            for (const code of codes.filter((code) => !hasCartPromotionCode(cart, code))) {
+                await referral.applyCheckoutCoupon(cart.id, code, { useAffiliatePath }).catch((error) => reportCheckoutError(error, { cartId: cart.id }));
+            }
+        }
+        catch (error) {
+            // The replacement cart already exists; only its coupons are missing.
+            reportCheckoutError(error, { cartId: cart.id });
+        }
+    }
+    async function createCart(data) {
+        await referral.waitForAffiliateReferralCapture();
+        return await createCartNow(data);
+    }
+    async function addCartLineItem(cartId, data) {
+        const sdk = createClient();
+        const { cart } = await sdk.store.cart.createLineItem(cartId, data);
+        return cart;
+    }
+    return {
+        createCart,
+        // Swaps a cart whose payment was refunded (see refunded-cart.ts) for a fresh
+        // one with the same contents, so the customer simply pays again. Concurrent
+        // active-cart fetches share one replacement. Deliberately skips the referral
+        // wait: a "?ref=" capture refreshes the active cart itself and would wait on
+        // this replacement in turn; it then captures onto the new cart.
+        replaceRefundedCart(cart) {
+            const pending = refundedCartReplacements.get(cart.id);
+            if (pending) {
+                return pending;
+            }
+            const replacement = createCartNow(buildReplacementCart(cart))
+                .then(() => reapplyCouponCodes(getCustomerCouponCodes(cart)))
+                .then(() => actions.getActiveCart())
+                .catch((error) => {
+                // The refunded cart stays usable for display; its own error handling applies.
+                reportCheckoutError(error, { cartId: cart.id });
+                return cart;
+            })
+                .finally(() => refundedCartReplacements.delete(cart.id));
+            refundedCartReplacements.set(cart.id, replacement);
+            return replacement;
+        },
+        addCartLineItem,
+        async updateCartLineItem(cartId, lineItemId, data) {
+            const sdk = createClient();
+            const { cart } = await sdk.store.cart.updateLineItem(cartId, lineItemId, data);
+            return cart;
+        },
+        async removeCartLineItem(cartId, lineItemId) {
+            const sdk = createClient();
+            return await sdk.store.cart.deleteLineItem(cartId, lineItemId);
+        },
+        async updateCart(cartId, data) {
+            const sdk = createClient();
+            const { cart } = await sdk.store.cart.update(cartId, data);
+            return cart;
+        },
+        async addCartShippingMethod(cartId, data) {
+            const sdk = createClient();
+            const { cart } = await sdk.store.cart.addShippingMethod(cartId, data);
+            return cart;
+        },
+        async addCartPromotion(cartId, data) {
+            const sdk = createClient();
+            const { cart } = await sdk.store.cart.addPromotions(cartId, data);
+            return cart;
+        },
+        async removeCartPromotion(cartId, data) {
+            const sdk = createClient();
+            const { cart } = await sdk.store.cart.removePromotions(cartId, data);
+            return cart;
+        },
+        async initiateCartPayment(cartId, data) {
+            const sdk = createClient();
+            const { cart } = await sdk.store.cart.retrieve(cartId);
+            return (await sdk.store.payment.initiatePaymentSession(cart, data)).payment_collection;
+        },
+        // Runs every check the completion runs, without completing. Stripe captures
+        // when the payment is confirmed, so a refusal must come before that, not
+        // after (Medusa then refunds). Same transport and credentials as completeCart,
+        // so the registered-email gate sees the same session.
+        async checkCartCompletion(cartId) {
+            const sdk = createClient();
+            return await sdk.client.fetch(checkoutStorePaths.post.completionCheck(cartId), {
+                credentials: "include",
+                method: "POST",
+            });
+        },
+        async completeCart(cartId) {
+            const sdk = createClient();
+            const result = await sdk.store.cart.complete(cartId);
+            if (result.type === "order") {
+                await actions.clearCartId();
+            }
+            return result;
+        },
+        /** Adds one unit of a variant, creating the cart first when there is none. */
+        async addProductToCart({ activeCart, quantity = 1, regionId, variantId }) {
+            const cart = activeCart ?? (await createCart({ region_id: regionId }));
+            await addCartLineItem(cart.id, {
+                quantity,
+                variant_id: variantId,
+            });
+            return cart;
+        },
+    };
+}

package/dist/browser/cart-refresh.d.ts

@@ -0,0 +1,11 @@
+import type { QueryClient } from "@tanstack/react-query";
+import type { BrowserCartMutations } from "./cart-mutations.js";
+import type { BrowserQueryOptions } from "./query-options.js";
+interface CartRefreshDependencies {
+    cart: Pick<BrowserCartMutations, "initiateCartPayment">;
+    queries: Pick<BrowserQueryOptions, "activeCart">;
+    reportCheckoutError: (error: unknown, context?: Record<string, unknown>) => void;
+}
+export declare function createRefreshCartAfterMutation({ cart, queries, reportCheckoutError }: CartRefreshDependencies): (queryClient: QueryClient, cartId?: string) => Promise<import("@medusajs/types").StoreCart | null>;
+export type RefreshCartAfterMutation = ReturnType<typeof createRefreshCartAfterMutation>;
+export {};

package/dist/browser/cart-refresh.js

@@ -0,0 +1,33 @@
+import { findPendingPaymentSession, isPaymentSessionOutdated } from "../core/cart/payment-session.js";
+import { invalidateCommerceQueries } from "./query-invalidation.js";
+import { affiliateQueryKeys } from "./query-keys.js";
+// The single "cart price changed" boundary: it reloads the cart, re-initiates a
+// still-pending payment session whose amount no longer matches the cart (Medusa
+// creates a fresh Stripe PaymentIntent / client_secret), and reloads again so
+// the payment step's <Elements key={clientSecret}> remounts on the new secret.
+// When Medusa already deleted the sessions because the amount changed, there is
+// nothing to re-initiate and the payment step's auto-initiate takes over instead.
+export function createRefreshCartAfterMutation({ cart, queries, reportCheckoutError }) {
+    return async function refreshCartAfterMutation(queryClient, cartId) {
+        await Promise.all([invalidateCommerceQueries(queryClient, cartId), cartId ? queryClient.invalidateQueries({ queryKey: affiliateQueryKeys.cartReferral(cartId) }) : Promise.resolve()]);
+        const activeCart = await queryClient.fetchQuery(queries.activeCart());
+        if (!activeCart) {
+            return null;
+        }
+        const pendingSession = findPendingPaymentSession(activeCart);
+        if (!pendingSession || !isPaymentSessionOutdated(activeCart, pendingSession)) {
+            return activeCart;
+        }
+        try {
+            await cart.initiateCartPayment(activeCart.id, { provider_id: pendingSession.provider_id });
+        }
+        catch (error) {
+            // The mutation itself succeeded; a failed re-initiate must not surface as
+            // "cart could not be updated". The payment step's auto-initiate retries.
+            reportCheckoutError(error, { cartId: activeCart.id, providerId: pendingSession.provider_id });
+            return activeCart;
+        }
+        await invalidateCommerceQueries(queryClient, activeCart.id);
+        return await queryClient.fetchQuery(queries.activeCart());
+    };
+}

package/dist/browser/client.d.ts

@@ -0,0 +1,15 @@
+import Medusa from "@medusajs/js-sdk";
+import type { Translate } from "../core/i18n.js";
+export interface BrowserClientConfig {
+    publicBackendUrl: string;
+    publishableKey: string | undefined;
+    t: Translate;
+}
+export type CredentialedMedusaClient = Medusa;
+/**
+ * Browser-only Medusa client, credentials: "include" - Medusa's own host-only
+ * cookies. This transport is mandatory (not a style choice) for cart
+ * line-item mutations, cart e-mail changes, completeCart, and affiliate
+ * referral/coupon-status calls - never construct a third client elsewhere.
+ */
+export declare function createCredentialedClientFactory({ publicBackendUrl, publishableKey, t }: BrowserClientConfig): () => CredentialedMedusaClient;

package/dist/browser/client.js

@@ -0,0 +1,20 @@
+import Medusa from "@medusajs/js-sdk";
+/**
+ * Browser-only Medusa client, credentials: "include" - Medusa's own host-only
+ * cookies. This transport is mandatory (not a style choice) for cart
+ * line-item mutations, cart e-mail changes, completeCart, and affiliate
+ * referral/coupon-status calls - never construct a third client elsewhere.
+ */
+export function createCredentialedClientFactory({ publicBackendUrl, publishableKey, t }) {
+    const baseUrl = publicBackendUrl.replace(/\/+$/, "");
+    return function createCredentialedMedusaClient() {
+        if (!publishableKey) {
+            throw new Error(t("config.publishable_key_missing"));
+        }
+        return new Medusa({
+            auth: { fetchCredentials: "include", type: "session" },
+            baseUrl,
+            publishableKey,
+        });
+    };
+}

package/dist/browser/fresh-order-marker.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Marks an order the checkout has just completed, so the confirmation page
+ * counts the purchase once: not on a reload and not when opened again from the
+ * order history. Lives in sessionStorage, which can be unavailable (private
+ * mode, blocked site data); the purchase then simply goes uncounted.
+ */
+export declare function createFreshOrderMarker(keyPrefix: string): {
+    markFreshOrder(orderId: string): void;
+    /** True exactly once per marked order. */
+    takeFreshOrder(orderId: string): boolean;
+};

package/dist/browser/fresh-order-marker.js

@@ -0,0 +1,30 @@
+/**
+ * Marks an order the checkout has just completed, so the confirmation page
+ * counts the purchase once: not on a reload and not when opened again from the
+ * order history. Lives in sessionStorage, which can be unavailable (private
+ * mode, blocked site data); the purchase then simply goes uncounted.
+ */
+export function createFreshOrderMarker(keyPrefix) {
+    return {
+        markFreshOrder(orderId) {
+            try {
+                sessionStorage.setItem(`${keyPrefix}${orderId}`, "1");
+            }
+            catch {
+                // Storage unavailable: nothing to mark.
+            }
+        },
+        /** True exactly once per marked order. */
+        takeFreshOrder(orderId) {
+            try {
+                const key = `${keyPrefix}${orderId}`;
+                const isFresh = sessionStorage.getItem(key) !== null;
+                sessionStorage.removeItem(key);
+                return isFresh;
+            }
+            catch {
+                return false;
+            }
+        },
+    };
+}