@doswiftly/storefront-sdk 11.2.0 → 11.3.1

package/dist/__tests__/unit/test-helpers.js

@@ -1,72 +0,0 @@
-/**
- * Shared test helpers — mock fetch factory, mock client builder.
- */
-/**
- * Create a mock fetch that returns the specified GraphQL response.
- */
-export function createMockFetch(responseData, options) {
-    const { errors, status = 200, delay: delayMs } = options ?? {};
-    return async (_url, _init) => {
-        if (delayMs) {
-            await new Promise(r => setTimeout(r, delayMs));
-        }
-        // Check for abort signal
-        if (_init?.signal?.aborted) {
-            throw new DOMException('The operation was aborted', 'AbortError');
-        }
-        const body = { data: responseData };
-        if (errors)
-            body.errors = errors;
-        return new Response(JSON.stringify(body), {
-            status,
-            headers: { 'Content-Type': 'application/json' },
-        });
-    };
-}
-/**
- * Create a mock fetch that tracks all calls and returns specified response.
- */
-export function createSpyFetch(responseData, options) {
-    const calls = [];
-    const { errors, status = 200 } = options ?? {};
-    const fetchFn = async (url, init) => {
-        calls.push({ url: url.toString(), init: init });
-        if (init?.signal?.aborted) {
-            throw new DOMException('The operation was aborted', 'AbortError');
-        }
-        const body = { data: responseData };
-        if (errors)
-            body.errors = errors;
-        return new Response(JSON.stringify(body), {
-            status,
-            headers: { 'Content-Type': 'application/json' },
-        });
-    };
-    return { fetch: fetchFn, calls };
-}
-/**
- * Create a mock fetch that fails with a network error.
- */
-export function createNetworkErrorFetch(errorMessage = 'fetch failed') {
-    return async () => {
-        throw new TypeError(errorMessage);
-    };
-}
-/**
- * Create a mock fetch that returns different responses on subsequent calls.
- */
-export function createSequenceFetch(responses) {
-    let index = 0;
-    const fetchFn = async (_url, _init) => {
-        const response = responses[Math.min(index, responses.length - 1)];
-        index++;
-        const body = { data: response.data ?? null };
-        if (response.errors)
-            body.errors = response.errors;
-        return new Response(JSON.stringify(body), {
-            status: response.status ?? 200,
-            headers: { 'Content-Type': 'application/json' },
-        });
-    };
-    return { fetch: fetchFn, callCount: () => index };
-}

package/dist/__tests__/unit/use-cart-manager.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=use-cart-manager.test.d.ts.map

package/dist/__tests__/unit/use-cart-manager.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"use-cart-manager.test.d.ts","sourceRoot":"","sources":["../../../src/__tests__/unit/use-cart-manager.test.tsx"],"names":[],"mappings":""}

package/dist/__tests__/unit/use-cart-manager.test.js

@@ -1,400 +0,0 @@
-import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
-// @vitest-environment jsdom
-/**
- * Unit tests for useCartManager — DX-first cart hook with automatic stale-cart
- * recovery.
- *
- * Mocks the StorefrontClientContext directly (no full StorefrontProvider stack)
- * so each test owns its CartClient spy and can simulate recoverable / fatal
- * errors per-mutation. Recovery semantics under the hood are covered by
- * cart-recovery.test.ts — these tests focus on the React wrapper:
- *
- *   - per-operation taxonomy reaches the right code path (replay vs bail)
- *   - onExpired subscribers fire on bail / recreate-fail
- *   - isLoading / error state transitions are correct
- *   - cookie-based cart id persistence works through document.cookie
- *
- * Note: hook is rendered via `renderHook` from @testing-library/react. Awaits
- * inside `act(async () => { ... })` flush React effects before assertions.
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { renderHook, act } from '@testing-library/react';
-import { useCartManager } from '../../react/hooks/use-cart-manager';
-import { StorefrontError, ErrorCodes } from '../../core/errors';
-import { CartClient } from '../../core/cart/cart-client';
-// ---------------------------------------------------------------------------
-// Mock StorefrontClientContext — supply our own cartClient per test
-// ---------------------------------------------------------------------------
-let activeCartClient;
-vi.mock('../../react/providers/storefront-client-provider', () => ({
-    useStorefrontClientContext: () => ({
-        client: {},
-        cartClient: activeCartClient,
-        authClient: {},
-    }),
-}));
-// ---------------------------------------------------------------------------
-// Fixtures
-// ---------------------------------------------------------------------------
-function mockStorefrontClient() {
-    return {
-        query: vi.fn(async () => ({})),
-        mutate: vi.fn(async () => ({})),
-        use: vi.fn(),
-    };
-}
-const fakeCart = (id = 'cart-fresh') => ({
-    id,
-    lines: { edges: [], nodes: [], pageInfo: {}, totalCount: 0 },
-    totalQuantity: 0,
-    cost: { total: { amount: '0', currencyCode: 'PLN' }, subtotal: { amount: '0', currencyCode: 'PLN' } },
-});
-const FAKE_CART = fakeCart();
-function recoverableError(code, message) {
-    return new StorefrontError({
-        code: ErrorCodes.USER_ERROR,
-        message: message ?? 'User errors in response',
-        userErrors: [{ message: message ?? 'simulated', code, field: [] }],
-    });
-}
-function nonRecoverableError() {
-    return new StorefrontError({
-        code: ErrorCodes.USER_ERROR,
-        message: 'Out of stock',
-        userErrors: [{ message: 'low stock', code: 'NOT_ENOUGH_IN_STOCK', field: [] }],
-    });
-}
-function setCartCookie(value) {
-    if (value === null) {
-        document.cookie = 'cart-id=;max-age=0;path=/';
-    }
-    else {
-        document.cookie = `cart-id=${value};path=/`;
-    }
-}
-function getCartCookie() {
-    const match = document.cookie.match(/(?:^|;\s*)cart-id=([^;]*)/);
-    return match ? decodeURIComponent(match[1]) : null;
-}
-const Wrapper = ({ children }) => _jsx(_Fragment, { children: children });
-beforeEach(() => {
-    activeCartClient = new CartClient(mockStorefrontClient());
-    setCartCookie(null);
-});
-afterEach(() => {
-    vi.restoreAllMocks();
-    setCartCookie(null);
-});
-// ---------------------------------------------------------------------------
-// addItem — auto-replay
-// ---------------------------------------------------------------------------
-describe('useCartManager — addItem (auto-replay)', () => {
-    it('creates cart on first add when cookie empty (Phase 0)', async () => {
-        const createSpy = vi.spyOn(activeCartClient, 'create').mockResolvedValue({ cart: FAKE_CART, warnings: [] });
-        const addSpy = vi.spyOn(activeCartClient, 'addItems').mockResolvedValue({ cart: FAKE_CART, warnings: [] });
-        const { result } = renderHook(() => useCartManager(), { wrapper: Wrapper });
-        await act(async () => {
-            await result.current.addItem([{ variantId: 'v1', quantity: 1 }]);
-        });
-        expect(createSpy).toHaveBeenCalledTimes(1);
-        expect(addSpy).toHaveBeenCalledWith('cart-fresh', [{ variantId: 'v1', quantity: 1 }]);
-        expect(getCartCookie()).toBe('cart-fresh');
-    });
-    it('uses cookie cart-id on subsequent adds', async () => {
-        setCartCookie('existing-cart');
-        const createSpy = vi.spyOn(activeCartClient, 'create');
-        const addSpy = vi.spyOn(activeCartClient, 'addItems').mockResolvedValue({ cart: FAKE_CART, warnings: [] });
-        const { result } = renderHook(() => useCartManager(), { wrapper: Wrapper });
-        await act(async () => {
-            await result.current.addItem([{ variantId: 'v1', quantity: 1 }]);
-        });
-        expect(createSpy).not.toHaveBeenCalled();
-        expect(addSpy).toHaveBeenCalledWith('existing-cart', [{ variantId: 'v1', quantity: 1 }]);
-    });
-    it('auto-recovers on CART_NOT_FOUND via atomic cartCreate({ lines })', async () => {
-        setCartCookie('stale-cart');
-        const stale = recoverableError('CART_NOT_FOUND');
-        vi.spyOn(activeCartClient, 'addItems').mockRejectedValue(stale);
-        const createSpy = vi.spyOn(activeCartClient, 'create').mockResolvedValue({
-            cart: fakeCart('cart-recovered'),
-            warnings: [],
-        });
-        const { result } = renderHook(() => useCartManager(), { wrapper: Wrapper });
-        await act(async () => {
-            const outcome = await result.current.addItem([{ variantId: 'v1', quantity: 2 }]);
-            expect(outcome.cart.id).toBe('cart-recovered');
-        });
-        // Atomic recreate: cartCreate({ lines: [...] }) — NOT empty create + addItems
-        expect(createSpy).toHaveBeenCalledWith({ lines: [{ variantId: 'v1', quantity: 2 }] });
-        expect(getCartCookie()).toBe('cart-recovered');
-    });
-    it('auto-recovers on ALREADY_COMPLETED (post-checkout locked cart)', async () => {
-        setCartCookie('locked-cart');
-        vi.spyOn(activeCartClient, 'addItems').mockRejectedValue(recoverableError('ALREADY_COMPLETED'));
-        vi.spyOn(activeCartClient, 'create').mockResolvedValue({
-            cart: fakeCart('post-checkout-cart'),
-            warnings: [],
-        });
-        const { result } = renderHook(() => useCartManager(), { wrapper: Wrapper });
-        await act(async () => {
-            await result.current.addItem([{ variantId: 'v1' }]);
-        });
-        expect(getCartCookie()).toBe('post-checkout-cart');
-    });
-    it('PL locale message does not break detection (regression for legacy useCartManager bug)', async () => {
-        setCartCookie('stale');
-        vi.spyOn(activeCartClient, 'addItems').mockRejectedValue(recoverableError('CART_NOT_FOUND', 'Nie znaleziono koszyka'));
-        const createSpy = vi.spyOn(activeCartClient, 'create').mockResolvedValue({
-            cart: fakeCart('pl-recovered'),
-            warnings: [],
-        });
-        const { result } = renderHook(() => useCartManager(), { wrapper: Wrapper });
-        await act(async () => {
-            await result.current.addItem([{ variantId: 'v1' }]);
-        });
-        expect(createSpy).toHaveBeenCalledTimes(1);
-    });
-    it('propagates non-recoverable errors (stock) without recovery', async () => {
-        setCartCookie('cart-1');
-        const stock = nonRecoverableError();
-        vi.spyOn(activeCartClient, 'addItems').mockRejectedValue(stock);
-        const createSpy = vi.spyOn(activeCartClient, 'create');
-        const { result } = renderHook(() => useCartManager(), { wrapper: Wrapper });
-        await act(async () => {
-            await expect(result.current.addItem([{ variantId: 'oos' }])).rejects.toBe(stock);
-        });
-        expect(createSpy).not.toHaveBeenCalled();
-        expect(getCartCookie()).toBe('cart-1');
-        expect(result.current.error).toBe('Out of stock');
-    });
-});
-// ---------------------------------------------------------------------------
-// updateItem / removeItem — bail
-// ---------------------------------------------------------------------------
-describe('useCartManager — updateItem / removeItem (bail)', () => {
-    it('updateItem on CART_NOT_FOUND throws CartRecoveryNotPossibleError + fires onExpired', async () => {
-        setCartCookie('stale');
-        vi.spyOn(activeCartClient, 'updateItems').mockRejectedValue(recoverableError('CART_NOT_FOUND'));
-        const createSpy = vi.spyOn(activeCartClient, 'create');
-        const { result } = renderHook(() => useCartManager(), { wrapper: Wrapper });
-        const listener = vi.fn();
-        act(() => {
-            result.current.onExpired(listener);
-        });
-        await act(async () => {
-            await expect(result.current.updateItem([{ id: 'line-1', quantity: 5 }])).rejects.toMatchObject({ name: 'CartRecoveryNotPossibleError', reason: 'state-dependent' });
-        });
-        expect(createSpy).not.toHaveBeenCalled(); // no replay — operation is state-dependent
-        expect(getCartCookie()).toBeNull(); // cookie cleared
-        expect(listener).toHaveBeenCalledWith(expect.objectContaining({ reason: 'state-dependent', operation: 'updateItem' }));
-    });
-    it('removeItem on ALREADY_COMPLETED bails the same way', async () => {
-        setCartCookie('locked');
-        vi.spyOn(activeCartClient, 'removeItems').mockRejectedValue(recoverableError('ALREADY_COMPLETED'));
-        const { result } = renderHook(() => useCartManager(), { wrapper: Wrapper });
-        const listener = vi.fn();
-        act(() => {
-            result.current.onExpired(listener);
-        });
-        await act(async () => {
-            await expect(result.current.removeItem(['line-1'])).rejects.toMatchObject({
-                name: 'CartRecoveryNotPossibleError',
-            });
-        });
-        expect(listener).toHaveBeenCalledWith(expect.objectContaining({ operation: 'removeItem' }));
-    });
-    it('updateItem propagates non-recoverable error without bail', async () => {
-        setCartCookie('cart-1');
-        const validation = new Error('Quantity must be positive');
-        vi.spyOn(activeCartClient, 'updateItems').mockRejectedValue(validation);
-        const { result } = renderHook(() => useCartManager(), { wrapper: Wrapper });
-        const listener = vi.fn();
-        act(() => {
-            result.current.onExpired(listener);
-        });
-        await act(async () => {
-            await expect(result.current.updateItem([{ id: 'l1', quantity: -1 }])).rejects.toBe(validation);
-        });
-        expect(getCartCookie()).toBe('cart-1'); // cookie not cleared — cart still good
-        expect(listener).not.toHaveBeenCalled();
-    });
-});
-// ---------------------------------------------------------------------------
-// Other auto-replay mutations
-// ---------------------------------------------------------------------------
-describe('useCartManager — checkout-flow mutations (auto-replay)', () => {
-    it('updateDiscountCodes auto-replays via cartCreate({ discountCodes })', async () => {
-        setCartCookie('stale');
-        vi.spyOn(activeCartClient, 'updateDiscountCodes').mockRejectedValue(recoverableError('CART_NOT_FOUND'));
-        const createSpy = vi.spyOn(activeCartClient, 'create').mockResolvedValue({
-            cart: fakeCart('rec'),
-            warnings: [],
-        });
-        const { result } = renderHook(() => useCartManager(), { wrapper: Wrapper });
-        await act(async () => {
-            await result.current.updateDiscountCodes(['SAVE10', 'FREESHIP']);
-        });
-        expect(createSpy).toHaveBeenCalledWith({ discountCodes: ['SAVE10', 'FREESHIP'] });
-    });
-    it('updateNote auto-replays via cartCreate({ note })', async () => {
-        setCartCookie('stale');
-        vi.spyOn(activeCartClient, 'updateNote').mockRejectedValue(recoverableError('CART_NOT_FOUND'));
-        const createSpy = vi.spyOn(activeCartClient, 'create').mockResolvedValue({
-            cart: fakeCart('rec'),
-            warnings: [],
-        });
-        const { result } = renderHook(() => useCartManager(), { wrapper: Wrapper });
-        await act(async () => {
-            await result.current.updateNote('Gift wrap');
-        });
-        expect(createSpy).toHaveBeenCalledWith({ note: 'Gift wrap' });
-    });
-    it('updateBuyerIdentity auto-replays via cartCreate({ buyerIdentity })', async () => {
-        setCartCookie('stale');
-        vi.spyOn(activeCartClient, 'updateBuyerIdentity').mockRejectedValue(recoverableError('CART_NOT_FOUND'));
-        const createSpy = vi.spyOn(activeCartClient, 'create').mockResolvedValue({
-            cart: fakeCart('rec'),
-            warnings: [],
-        });
-        const { result } = renderHook(() => useCartManager(), { wrapper: Wrapper });
-        await act(async () => {
-            await result.current.updateBuyerIdentity({ email: 'user@example.com' });
-        });
-        expect(createSpy).toHaveBeenCalledWith({ buyerIdentity: { email: 'user@example.com' } });
-    });
-    it('setShippingAddress auto-replays via cartCreate({ shippingAddress })', async () => {
-        setCartCookie('stale');
-        vi.spyOn(activeCartClient, 'setShippingAddress').mockRejectedValue(recoverableError('CART_NOT_FOUND'));
-        const createSpy = vi.spyOn(activeCartClient, 'create').mockResolvedValue({
-            cart: fakeCart('rec'),
-            warnings: [],
-        });
-        const { result } = renderHook(() => useCartManager(), { wrapper: Wrapper });
-        const address = {
-            firstName: 'Anna',
-            lastName: 'Nowak',
-            streetLine1: 'ul. Krakowska 1',
-            city: 'Warszawa',
-            country: 'PL',
-            postalCode: '00-001',
-        };
-        await act(async () => {
-            await result.current.setShippingAddress(address);
-        });
-        expect(createSpy).toHaveBeenCalledWith({ shippingAddress: address });
-    });
-});
-// ---------------------------------------------------------------------------
-// getCart — read with auto-clear
-// ---------------------------------------------------------------------------
-describe('useCartManager — getCart', () => {
-    it('returns cart on success', async () => {
-        setCartCookie('existing');
-        vi.spyOn(activeCartClient, 'get').mockResolvedValue(FAKE_CART);
-        const { result } = renderHook(() => useCartManager(), { wrapper: Wrapper });
-        let cart;
-        await act(async () => {
-            cart = await result.current.getCart();
-        });
-        expect(cart).toEqual(FAKE_CART);
-    });
-    it('returns null + clears cookie when backend returns CART_NOT_FOUND via userErrors', async () => {
-        setCartCookie('stale');
-        vi.spyOn(activeCartClient, 'get').mockRejectedValue(recoverableError('CART_NOT_FOUND'));
-        const { result } = renderHook(() => useCartManager(), { wrapper: Wrapper });
-        const listener = vi.fn();
-        act(() => {
-            result.current.onExpired(listener);
-        });
-        let cart;
-        await act(async () => {
-            cart = await result.current.getCart();
-        });
-        expect(cart).toBeNull();
-        expect(getCartCookie()).toBeNull();
-        expect(listener).toHaveBeenCalledWith(expect.objectContaining({ reason: 'state-dependent', operation: 'getCart' }));
-    });
-    it('returns null without fetching when cookie is empty', async () => {
-        const getSpy = vi.spyOn(activeCartClient, 'get');
-        const { result } = renderHook(() => useCartManager(), { wrapper: Wrapper });
-        let cart;
-        await act(async () => {
-            cart = await result.current.getCart();
-        });
-        expect(cart).toBeNull();
-        expect(getSpy).not.toHaveBeenCalled();
-    });
-});
-// ---------------------------------------------------------------------------
-// onExpired lifecycle + reactive state
-// ---------------------------------------------------------------------------
-describe('useCartManager — onExpired + state', () => {
-    it('listener unsubscribe stops further notifications', async () => {
-        setCartCookie('stale');
-        vi.spyOn(activeCartClient, 'updateItems').mockRejectedValue(recoverableError('CART_NOT_FOUND'));
-        const { result } = renderHook(() => useCartManager(), { wrapper: Wrapper });
-        const listener = vi.fn();
-        let unsubscribe;
-        act(() => {
-            unsubscribe = result.current.onExpired(listener);
-        });
-        act(() => {
-            unsubscribe();
-        });
-        await act(async () => {
-            await expect(result.current.updateItem([{ id: 'l1', quantity: 1 }])).rejects.toBeDefined();
-        });
-        expect(listener).not.toHaveBeenCalled();
-    });
-    it('isLoading toggles around a mutation', async () => {
-        setCartCookie('cart-1');
-        let resolveAdd = null;
-        const addPromise = new Promise((r) => {
-            resolveAdd = r;
-        });
-        vi.spyOn(activeCartClient, 'addItems').mockImplementation(() => addPromise);
-        const { result } = renderHook(() => useCartManager(), { wrapper: Wrapper });
-        expect(result.current.isLoading).toBe(false);
-        let pending;
-        act(() => {
-            pending = result.current.addItem([{ variantId: 'v1' }]);
-        });
-        // After invocation but before resolve — isLoading should be true on next tick
-        await act(async () => {
-            await new Promise((r) => setTimeout(r, 0));
-        });
-        expect(result.current.isLoading).toBe(true);
-        await act(async () => {
-            resolveAdd({ cart: FAKE_CART, warnings: [] });
-            await pending;
-        });
-        expect(result.current.isLoading).toBe(false);
-    });
-    it('error state is populated on failure and cleared on subsequent success', async () => {
-        setCartCookie('cart-1');
-        const fail = new Error('boom');
-        const addSpy = vi.spyOn(activeCartClient, 'addItems')
-            .mockRejectedValueOnce(fail)
-            .mockResolvedValueOnce({ cart: FAKE_CART, warnings: [] });
-        const { result } = renderHook(() => useCartManager(), { wrapper: Wrapper });
-        await act(async () => {
-            await expect(result.current.addItem([{ variantId: 'v1' }])).rejects.toBe(fail);
-        });
-        expect(result.current.error).toBe('boom');
-        await act(async () => {
-            await result.current.addItem([{ variantId: 'v1' }]);
-        });
-        expect(result.current.error).toBeNull();
-        expect(addSpy).toHaveBeenCalledTimes(2);
-    });
-    it('clearCart removes the cookie', async () => {
-        setCartCookie('to-clear');
-        const { result } = renderHook(() => useCartManager(), { wrapper: Wrapper });
-        expect(result.current.getCartId()).toBe('to-clear');
-        act(() => {
-            result.current.clearCart();
-        });
-        expect(getCartCookie()).toBeNull();
-        expect(result.current.getCartId()).toBeNull();
-    });
-});