Lock the current cart so the queries do not get refreshed during load

packages/magento-cart/hooks/CurrentCartId.graphql

@@ -2,5 +2,6 @@ query CurrentCartId {
   currentCartId @client {
     __typename
     id
+    locked
   }
 }

packages/magento-cart/hooks/CurrentCartId.graphqls

@@ -4,6 +4,7 @@ extend type Query {
 
 type CurrentCartId {
   id: String
+  locked: Boolean
 }
 
 input RegisterCartIdInput {

packages/magento-cart/hooks/useAssignCurrentCartId.ts

@@ -8,7 +8,7 @@ export const CART_ID_COOKIE = 'cart'
 export function writeCartId(cache: ApolloCache<object>, id: string | null = null) {
   cache.writeQuery({
     query: CurrentCartIdDocument,
-    data: { currentCartId: { __typename: 'CurrentCartId', id } },
+    data: { currentCartId: { __typename: 'CurrentCartId', locked: false, id } },
     broadcast: true,
   })
 }

packages/magento-cart/hooks/useCartQuery.ts

@@ -20,24 +20,20 @@ export function useCartQuery<Q, V extends { cartId: string; [index: string]: unk
 ) {
   const { allowUrl = true, ...queryOptions } = options
   const router = useRouter()
-  const { currentCartId } = useCurrentCartId()
+  const { currentCartId, locked } = useCurrentCartId()
 
   const urlCartId = router.query.cart_id
   const usingUrl = allowUrl && typeof urlCartId === 'string'
   const cartId = usingUrl ? urlCartId : currentCartId
 
   if (usingUrl) queryOptions.fetchPolicy = 'cache-first'
+  if (locked) queryOptions.fetchPolicy = 'standby'
 
   if (usingUrl && typeof queryOptions.returnPartialData === 'undefined')
     queryOptions.returnPartialData = true
 
   queryOptions.variables = { cartId, ...options?.variables } as V
   queryOptions.skip = queryOptions?.skip || !cartId
 
-  const result = useQuery(document, queryOptions as QueryHookOptions<Q, V>)
-
-  return {
-    ...result,
-    // error: called && !currentCartId ? noCartError : result.error,
-  }
+  return useQuery(document, queryOptions as QueryHookOptions<Q, V>)
 }

packages/magento-cart/hooks/useClearCurrentCartId.ts

@@ -10,11 +10,7 @@ export function useClearCurrentCartId() {
     const id = cache.readQuery({ query: CurrentCartIdDocument })?.currentCartId?.id
     if (!id) return
 
-    cache.writeQuery({
-      query: CurrentCartIdDocument,
-      data: { currentCartId: { __typename: 'CurrentCartId', id: null } },
-      broadcast: true,
-    })
+    cache.evict({ fieldName: 'currentCartId', broadcast: true })
     cookie(CART_ID_COOKIE, null)
   }
 }

packages/magento-cart/hooks/useCurrentCartId.ts

@@ -10,5 +10,10 @@ export function useCurrentCartId<
   V extends CurrentCartIdQueryVariables,
 >(options: QueryHookOptions<Q, V> = {}) {
   const queryResults = useQuery<Q, V>(CurrentCartIdDocument, options)
-  return { currentCartId: queryResults.data?.currentCartId?.id || '', ...queryResults }
+
+  return {
+    currentCartId: queryResults.data?.currentCartId?.id || '',
+    locked: queryResults.data?.currentCartId?.locked || false,
+    ...queryResults,
+  }
 }

packages/magento-cart/plugins/useSignInFormMergeCart.ts

@@ -1,39 +1,49 @@
 import { useApolloClient } from '@graphcommerce/graphql'
 import type { useSignInForm } from '@graphcommerce/magento-customer/hooks/useSignInForm'
 import type { MethodPlugin } from '@graphcommerce/next-config'
-import { useCurrentCartId, useAssignCurrentCartId } from '../hooks'
+import { useAssignCurrentCartId } from '../hooks'
+import { CurrentCartIdDocument } from '../hooks/CurrentCartId.gql'
 import { CustomerCartDocument } from '../hooks/CustomerCart.gql'
 import { UseMergeCustomerCartDocument } from '../hooks/UseMergeCustomerCart.gql'
 
 export const func = 'useSignInForm'
 export const exported = '@graphcommerce/magento-customer/hooks/useSignInForm'
 
 const useSignInFormMergeCart: MethodPlugin<typeof useSignInForm> = (useSignInForm, options) => {
-  const { currentCartId } = useCurrentCartId()
   const client = useApolloClient()
   const assignCurrentCartId = useAssignCurrentCartId()
 
   return useSignInForm({
     ...options,
     onComplete: async (data, variables) => {
+      const currentCartId = client.cache.readQuery({ query: CurrentCartIdDocument })?.currentCartId
+      if (currentCartId?.id && !currentCartId.locked) {
+        client.cache.writeQuery({
+          query: CurrentCartIdDocument,
+          data: { currentCartId: { ...currentCartId, locked: true } },
+        })
+      }
+
       await options.onComplete?.(data, variables)
 
-      const destinationCartId = (
-        await client.query({ query: CustomerCartDocument, fetchPolicy: 'network-only' })
-      ).data.customerCart.id
+      const customerCart = await client.query({
+        query: CustomerCartDocument,
+        fetchPolicy: 'network-only',
+      })
+      const destinationCartId = customerCart.data.customerCart.id
 
       // If we don't have a customer cart, we're done
       // If the vistor cart is the same as the customer cart, we're done
-      if (!destinationCartId || currentCartId === destinationCartId) return
+      if (!destinationCartId || currentCartId?.id === destinationCartId) return
 
       // Assign the customer cart as the new cart id
       assignCurrentCartId(destinationCartId)
 
-      if (currentCartId) {
+      if (currentCartId?.id) {
         await client
           .mutate({
             mutation: UseMergeCustomerCartDocument,
-            variables: { sourceCartId: currentCartId, destinationCartId },
+            variables: { sourceCartId: currentCartId.id, destinationCartId },
           })
           // We're not handling exceptions here:
           // If the merge returns an error, we'll use the customer cart without merging the guest cart.

packages/magento-customer/hooks/CustomerToken.graphqls

@@ -3,6 +3,6 @@ extend type Query {
 }
 
 extend type CustomerToken {
-  createdAt: String
+  createdAt: String @deprecated(reason: "Value is not used in GraphCommerce, but still filled in.")
   valid: Boolean
 }