Sync from monorepo

Template version: 1.0.0-alpha.0

Uses NPM packages @salesforce/storefront-next-* v1.0.0-alpha.0

Synced by: alex-vuong_sfemu

Monorepo SHA: e0139adc75f182232acd1bd53fd40038c451752c

Latest change: e0139adc7 - fix(wishlist): skip 1.5s sleep when create response has id (#1893)

Author: alex-vuong_sfemu

pnpm-lock.yaml

@@ -21,6 +21,7 @@ import { TrackingConsent } from '@/types/tracking-consent';
 import {
     appendWishlistMergeFlag,
     captureGuestWishlistSnapshot,
+    getOrCreateWishlist,
     getWishlist,
     loadWishlistPageData,
     mergeWishlist,
@@ -687,3 +688,56 @@ describe('appendWishlistMergeFlag', () => {
         expect(result2.setCookie).toContain('wishlist_merge');
     });
 });
+
+describe('getOrCreateWishlist — create branch', () => {
+    const mockContext = {} as any;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    test('fast path: returns the POST body without re-fetching when id is present', async () => {
+        // No existing list: getCustomerProductLists returns empty.
+        mockGetCustomerProductLists.mockResolvedValueOnce({ data: { data: [] } });
+
+        const created = { id: 'list-new', type: 'wish_list', customerProductListItems: [] };
+        mockCreateCustomerProductList.mockResolvedValue({ data: created });
+
+        const result = await getOrCreateWishlist(mockContext, 'cust-1');
+
+        expect(result).toEqual(created);
+        expect(mockCreateCustomerProductList).toHaveBeenCalledTimes(1);
+        // Only the initial lookup before create — no second GET after the POST.
+        expect(mockGetCustomerProductLists).toHaveBeenCalledTimes(1);
+        expect(mockLoggerWarn).not.toHaveBeenCalled();
+    });
+
+    test('fallback path: waits for index, re-fetches when POST returns no id', async () => {
+        vi.useFakeTimers();
+        try {
+            // No existing list: initial lookup empty.
+            // After the create, the post-sleep GET returns the indexed list.
+            const created = { id: 'list-indexed', type: 'wish_list', customerProductListItems: [] };
+            mockGetCustomerProductLists
+                .mockResolvedValueOnce({ data: { data: [] } })
+                .mockResolvedValueOnce({ data: { data: [created] } });
+
+            // POST resolves with a body that lacks id (the schema-anomaly we're guarding against).
+            mockCreateCustomerProductList.mockResolvedValue({ data: { type: 'wish_list' } });
+
+            const promise = getOrCreateWishlist(mockContext, 'cust-1');
+            await vi.advanceTimersByTimeAsync(1500);
+            const result = await promise;
+
+            expect(result).toEqual(created);
+            expect(mockCreateCustomerProductList).toHaveBeenCalledTimes(1);
+            expect(mockGetCustomerProductLists).toHaveBeenCalledTimes(2);
+            expect(mockLoggerWarn).toHaveBeenCalledWith(
+                'Wishlist: createCustomerProductList returned without an id, waiting for index propagation',
+                expect.objectContaining({ customerId: 'cust-1' })
+            );
+        } finally {
+            vi.useRealTimers();
+        }
+    });
+});

src/lib/api/wishlist.server.test.ts

@@ -224,10 +224,13 @@ export async function getOrCreateWishlist(
             throw new Error(t('account:wishlist.unableToRetrieveId'));
         }
 
-        // Create a new wishlist if it doesn't exist.
-        // Commerce SDK createCustomerProductList might not return listId immediately
-        // so we re-fetch after creation.
-        await clients.shopperCustomers.createCustomerProductList({
+        // Create a new wishlist if it doesn't exist. The POST response body comes from the
+        // write path and is not subject to the index-propagation delay that affects the GET
+        // endpoints (see the retry branch above and the comment in getWishlist). When the
+        // response carries an id we can return it immediately. Only when it doesn't do we
+        // wait for the index to catch up and re-read — the original behavior — because that
+        // GET is what the indexing-delay sleep was protecting all along.
+        const { data: created } = await clients.shopperCustomers.createCustomerProductList({
             params: {
                 path: { customerId },
             },
@@ -238,6 +241,13 @@ export async function getOrCreateWishlist(
             },
         });
 
+        if (created?.id) {
+            return created;
+        }
+
+        logger.warn('Wishlist: createCustomerProductList returned without an id, waiting for index propagation', {
+            customerId,
+        });
         await new Promise((resolve) => setTimeout(resolve, WISHLIST_CREATION_DELAY_MS));
 
         const { wishlist: createdWishlist, id: createdListId } = await getWishlist(context, customerId);