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

package/dist/browser/index.js

@@ -0,0 +1,70 @@
+import { loadStripe } from "@stripe/stripe-js/pure";
+import { createMedusaImageUrls } from "../core/image-url.js";
+import { createAffiliateReferral } from "./affiliate-referral.js";
+import { endMedusaBrowserSessionWithClient, startMedusaBrowserSessionWithClient } from "./browser-session.js";
+import { createCartMutations } from "./cart-mutations.js";
+import { createRefreshCartAfterMutation } from "./cart-refresh.js";
+import { createCredentialedClientFactory } from "./client.js";
+import { createFreshOrderMarker } from "./fresh-order-marker.js";
+import { createAffiliateApiPaths, createQueryOptions } from "./query-options.js";
+import { createBrowserRegion } from "./region.js";
+import { createUnwrapMedusaAction } from "./unwrap-medusa-action.js";
+export { affiliateQueryKeys, medusaQueryKeys } from "./query-keys.js";
+export { invalidateAffiliateQueries, invalidateCommerceQueries, resetCustomerScopedQueries } from "./query-invalidation.js";
+export { applyCheckoutCouponWithClient, captureAffiliateReferralAfterCartRefreshWithClient, captureAffiliateReferralWithClient, removeCapturedAffiliateReferral, resolveCouponLabelsWithClient, runAffiliateReferralCapture, waitForAffiliateReferralCapture, } from "./affiliate-referral.js";
+export { endMedusaBrowserSessionWithClient, startMedusaBrowserSessionWithClient } from "./browser-session.js";
+export { canReachOtherTabs, openAccountVerificationChannel, parseAccountVerificationMessage, postAccountVerificationMessage } from "./account-verification-channel.js";
+/**
+ * The storefront's browser side: the credentialed Medusa client, cart and
+ * referral calls, react-query options and invalidation. Create it once at
+ * module level in the shop (`storefront.client.ts`); the module state it
+ * relies on (pending refunded-cart replacements, in-flight referral captures)
+ * is shared by the whole page.
+ */
+export function createStorefrontBrowser(config) {
+    const { actions, t } = config;
+    const createCredentialedMedusaClient = createCredentialedClientFactory({ publicBackendUrl: config.publicBackendUrl, publishableKey: config.publishableKey, t });
+    const reportCheckoutError = (error, context = {}) => config.reportError(error, { area: "checkout", context });
+    const startMedusaBrowserSession = (token) => startMedusaBrowserSessionWithClient(createCredentialedMedusaClient(), token);
+    const endMedusaBrowserSession = () => endMedusaBrowserSessionWithClient(createCredentialedMedusaClient());
+    const referral = createAffiliateReferral(createCredentialedMedusaClient);
+    const cart = createCartMutations({ actions, createClient: createCredentialedMedusaClient, referral, reportCheckoutError });
+    const region = createBrowserRegion(createCredentialedMedusaClient);
+    const unwrapMedusaAction = createUnwrapMedusaAction(endMedusaBrowserSession);
+    const apiBasePath = (config.apiBasePath ?? "/api").replace(/\/+$/, "");
+    const affiliateApiPaths = createAffiliateApiPaths(apiBasePath);
+    const queries = createQueryOptions({ actions, affiliateApiPaths, cart, referral, region, t, unwrapMedusaAction });
+    // Loaded on the first call (the payment step), never on other pages: Stripe.js
+    // sets its own cookies. One promise per page, so Elements always gets the same one.
+    let stripePromise;
+    const getStripe = () => {
+        if (stripePromise === undefined) {
+            stripePromise = config.stripePublishableKey ? loadStripe(config.stripePublishableKey) : null;
+        }
+        return stripePromise;
+    };
+    return {
+        actions,
+        t,
+        reportError: config.reportError,
+        reportCheckoutError,
+        createCredentialedMedusaClient,
+        startMedusaBrowserSession,
+        endMedusaBrowserSession,
+        unwrapMedusaAction,
+        cart,
+        referral,
+        region,
+        queries,
+        affiliateApiPaths,
+        callbacks: config.callbacks ?? {},
+        /** Link to the shop's document download Route Handler (`api/documents/[id]/download`). */
+        documentDownloadHref: (documentId) => `${apiBasePath}/documents/${encodeURIComponent(documentId)}/download`,
+        getStripe,
+        hasStripe: Boolean(config.stripePublishableKey),
+        orderConfirmedPath: config.orderConfirmedPath ?? ((countryCode, orderId) => `/${countryCode}/order/${orderId}/confirmed`),
+        refreshCartAfterMutation: createRefreshCartAfterMutation({ cart, queries, reportCheckoutError }),
+        freshOrder: createFreshOrderMarker(config.freshOrderKeyPrefix),
+        imageUrls: createMedusaImageUrls(config.publicBackendUrl),
+    };
+}

package/dist/browser/query-invalidation.d.ts

@@ -0,0 +1,4 @@
+import type { QueryClient } from "@tanstack/react-query";
+export declare function invalidateCommerceQueries(queryClient: QueryClient, cartId?: string): Promise<void>;
+export declare function resetCustomerScopedQueries(queryClient: QueryClient): Promise<void>;
+export declare function invalidateAffiliateQueries(queryClient: QueryClient): Promise<void>;

package/dist/browser/query-invalidation.js

@@ -0,0 +1,39 @@
+import { affiliateQueryKeys, medusaQueryKeys } from "./query-keys.js";
+// An always-mounted cart widget keeps the active cart an observed query on
+// every storefront page, so invalidateQueries already triggers its refetch -
+// no separate refetchQueries call is needed on top.
+export async function invalidateCommerceQueries(queryClient, cartId) {
+    await Promise.all([
+        queryClient.invalidateQueries({ queryKey: medusaQueryKeys.activeCart() }),
+        queryClient.invalidateQueries({ queryKey: medusaQueryKeys.customer() }),
+        ...(cartId ? [queryClient.invalidateQueries({ queryKey: medusaQueryKeys.shippingOptions(cartId) })] : []),
+    ]);
+}
+// Called on logout and after every successful login/registration. Orders,
+// documents and affiliate portal data are customer-scoped and cache no
+// customer id in their query key, so a second account on the same tab must
+// never see the first account's cached data - they are removed outright
+// rather than just invalidated. They are not observed at login/logout
+// except the checkout coupon form's cart-referral/coupon-label queries, for
+// which a transient refetch is harmless.
+//
+// Shipping options are cart-scoped, not customer-scoped, and are observed
+// during a checkout login - they are only invalidated, same as the active
+// cart and customer queries below.
+//
+// The active cart and customer queries are deliberately NOT removed here:
+// queryCache.remove() would make their observers rebuild a fresh pending
+// query, and the checkout (pending cart -> skeleton) and the account gate
+// would unmount their subtree mid-flow and lose their login state. Those two
+// keys are always observed by a mounted component, so invalidateCommerceQueries
+// refetching them in place is the correct reset.
+export async function resetCustomerScopedQueries(queryClient) {
+    queryClient.removeQueries({ queryKey: medusaQueryKeys.ordersAll() });
+    queryClient.removeQueries({ queryKey: medusaQueryKeys.documents() });
+    queryClient.removeQueries({ queryKey: medusaQueryKeys.taxIdentifications() });
+    queryClient.removeQueries({ queryKey: affiliateQueryKeys.all });
+    await Promise.all([queryClient.invalidateQueries({ queryKey: medusaQueryKeys.shippingOptionsAll() }), invalidateCommerceQueries(queryClient)]);
+}
+export async function invalidateAffiliateQueries(queryClient) {
+    await queryClient.invalidateQueries({ queryKey: affiliateQueryKeys.all });
+}

package/dist/browser/query-keys.d.ts

@@ -0,0 +1,43 @@
+import type { ListStoreAffiliateCouponCodesRequest, PartnerPortalCommissionsRequest } from "@hartl-services/medusa-contracts/types/affiliate-store";
+export declare const medusaQueryKeys: {
+    activeCart: () => readonly ["medusa", "cart", "active"];
+    customer: () => readonly ["medusa", "customer"];
+    customerPasswordPolicy: () => readonly ["medusa", "customer-password-policy"];
+    documents: () => readonly ["medusa", "documents"];
+    orders: (page: {
+        limit: number;
+        offset: number;
+    }) => readonly ["medusa", "orders", {
+        limit: number;
+        offset: number;
+    }];
+    orderDetail: (orderId: string) => readonly ["medusa", "orders", "detail", string];
+    ordersAll: () => readonly ["medusa", "orders"];
+    paymentProviders: (regionId: string) => readonly ["medusa", "payment-providers", string];
+    pluginFeatures: () => readonly ["medusa", "plugin-features"];
+    region: (countryCode: string) => readonly ["medusa", "region", string];
+    regions: () => readonly ["medusa", "regions"];
+    shippingOptions: (cartId: string) => readonly ["medusa", "shipping-options", string];
+    shippingOptionsAll: () => readonly ["medusa", "shipping-options"];
+    taxIdentifications: () => readonly ["medusa", "tax-identifications"];
+};
+export declare const affiliateQueryKeys: {
+    all: readonly ["affiliate"];
+    cartReferral: (cartId: string) => readonly ["affiliate", "cart-referral", string];
+    commissions: (query: PartnerPortalCommissionsRequest) => readonly ["affiliate", "commissions", {
+        from?: string | undefined;
+        to?: string | undefined;
+        limit?: string | number | undefined;
+        offset?: string | number | undefined;
+    }];
+    consignmentInventory: () => readonly ["affiliate", "consignment", "inventory"];
+    consignmentReports: () => readonly ["affiliate", "consignment", "reports"];
+    context: () => readonly ["affiliate", "context"];
+    couponCodes: (query: ListStoreAffiliateCouponCodesRequest) => readonly ["affiliate", "coupon-codes", {
+        status?: "enabled" | "revoked" | undefined;
+        limit?: string | number | undefined;
+        offset?: string | number | undefined;
+    }];
+    couponLabels: (codes: string[]) => readonly ["affiliate", "coupon-labels", string[]];
+    slugs: () => readonly ["affiliate", "slugs"];
+};

package/dist/browser/query-keys.js

@@ -0,0 +1,28 @@
+export const medusaQueryKeys = {
+    activeCart: () => ["medusa", "cart", "active"],
+    customer: () => ["medusa", "customer"],
+    customerPasswordPolicy: () => ["medusa", "customer-password-policy"],
+    documents: () => ["medusa", "documents"],
+    orders: (page) => ["medusa", "orders", page],
+    // Under ordersAll, so everything that resets the orders resets a detail too.
+    orderDetail: (orderId) => ["medusa", "orders", "detail", orderId],
+    ordersAll: () => ["medusa", "orders"],
+    paymentProviders: (regionId) => ["medusa", "payment-providers", regionId],
+    pluginFeatures: () => ["medusa", "plugin-features"],
+    region: (countryCode) => ["medusa", "region", countryCode.toLowerCase()],
+    regions: () => ["medusa", "regions"],
+    shippingOptions: (cartId) => ["medusa", "shipping-options", cartId],
+    shippingOptionsAll: () => ["medusa", "shipping-options"],
+    taxIdentifications: () => ["medusa", "tax-identifications"],
+};
+export const affiliateQueryKeys = {
+    all: ["affiliate"],
+    cartReferral: (cartId) => ["affiliate", "cart-referral", cartId],
+    commissions: (query) => ["affiliate", "commissions", query],
+    consignmentInventory: () => ["affiliate", "consignment", "inventory"],
+    consignmentReports: () => ["affiliate", "consignment", "reports"],
+    context: () => ["affiliate", "context"],
+    couponCodes: (query) => ["affiliate", "coupon-codes", query],
+    couponLabels: (codes) => ["affiliate", "coupon-labels", [...codes].sort()],
+    slugs: () => ["affiliate", "slugs"],
+};