Moved auth & cart hooks + several fixes

framework/shopify/cart/use-update-item.tsx

@@ -1,85 +1,110 @@
 import { useCallback } from 'react'
 import debounce from 'lodash.debounce'
-import type { HookFetcher } from '@commerce/utils/types'
+import type {
+  HookFetcherContext,
+  MutationHookContext,
+} from '@commerce/utils/types'
 import { ValidationError } from '@commerce/utils/errors'
-import useCartUpdateItem, {
-  UpdateItemInput as UseUpdateItemInput,
+import useUpdateItem, {
+  UpdateItemInput as UpdateItemInputBase,
+  UseUpdateItem,
 } from '@commerce/cart/use-update-item'
 
-import { fetcher as removeFetcher } from './use-remove-item'
-
 import useCart from './use-cart'
-
-import type { Cart, LineItem, UpdateCartItemBody } from '@commerce/types'
+import { handler as removeItemHandler } from './use-remove-item'
+import type { Cart, LineItem, UpdateCartItemBody } from '../types'
 import { checkoutToCart } from './utils'
-import checkoutLineItemUpdateMutation from '@framework/utils/mutations/checkout-line-item-update'
-import getCheckoutId from '@framework/utils/get-checkout-id'
-
-const defaultOpts = {
-  query: checkoutLineItemUpdateMutation,
-}
+import { getCheckoutId, checkoutLineItemUpdateMutation } from '../utils'
+import {
+  Mutation,
+  MutationCheckoutLineItemsUpdateArgs,
+} from '@framework/schema'
 
 export type UpdateItemInput<T = any> = T extends LineItem
-  ? Partial<UseUpdateItemInput<LineItem>>
-  : UseUpdateItemInput<LineItem>
+  ? Partial<UpdateItemInputBase<LineItem>>
+  : UpdateItemInputBase<LineItem>
 
-export const fetcher: HookFetcher<Cart | null, any> = async (
-  options,
-  { item, checkoutId },
-  fetch
-) => {
-  if (Number.isInteger(item.quantity)) {
-    // Also allow the update hook to remove an item if the quantity is lower than 1
-    if (item.quantity! < 1) {
-      return removeFetcher(null, { itemId: item.id, checkoutId }, fetch)
+export default useUpdateItem as UseUpdateItem<typeof handler>
+
+export const handler = {
+  fetchOptions: {
+    query: checkoutLineItemUpdateMutation,
+  },
+  async fetcher({
+    input: { itemId, item },
+    options,
+    fetch,
+  }: HookFetcherContext<UpdateCartItemBody>) {
+    if (Number.isInteger(item.quantity)) {
+      // Also allow the update hook to remove an item if the quantity is lower than 1
+      if (item.quantity! < 1) {
+        return removeItemHandler.fetcher({
+          options: removeItemHandler.fetchOptions,
+          input: { itemId },
+          fetch,
+        })
+      }
+    } else if (item.quantity) {
+      throw new ValidationError({
+        message: 'The item quantity has to be a valid integer',
+      })
     }
-  } else if (item.quantity) {
-    throw new ValidationError({
-      message: 'The item quantity has to be a valid integer',
+    const { checkoutLineItemsUpdate } = await fetch<
+      Mutation,
+      MutationCheckoutLineItemsUpdateArgs
+    >({
+      ...options,
+      variables: {
+        checkoutId: getCheckoutId(),
+        lineItems: [
+          {
+            id: itemId,
+            quantity: item.quantity,
+          },
+        ],
+      },
     })
-  }
-  const data = await fetch<any, any>({
-    ...defaultOpts,
-    ...options,
-    variables: { checkoutId, lineItems: [item] },
-  })
 
-  return checkoutToCart(data.checkoutLineItemsUpdate)
-}
-
-function extendHook(customFetcher: typeof fetcher, cfg?: { wait?: number }) {
-  const useUpdateItem = <T extends LineItem | undefined = undefined>(
-    item?: T
+    return checkoutToCart(checkoutLineItemsUpdate)
+  },
+  useHook: ({
+    fetch,
+  }: MutationHookContext<Cart | null, UpdateCartItemBody>) => <
+    T extends LineItem | undefined = undefined
+  >(
+    ctx: {
+      item?: T
+      wait?: number
+    } = {}
   ) => {
-    const { mutate, data: cart } = useCart()
-    const fn = useCartUpdateItem<Cart | null, any>(defaultOpts, customFetcher)
+    const { item } = ctx
+    const { mutate } = useCart() as any
 
     return useCallback(
       debounce(async (input: UpdateItemInput<T>) => {
         const itemId = input.id ?? item?.id
+        const productId = input.productId ?? item?.productId
         const variantId = input.productId ?? item?.variantId
-
-        if (!itemId || !variantId) {
+        if (!itemId || !productId || !variantId) {
           throw new ValidationError({
             message: 'Invalid input used for this operation',
           })
         }
 
-        const data = await fn({
-          item: { id: itemId, variantId, quantity: input.quantity },
-          checkoutId: getCheckoutId(cart?.id),
+        const data = await fetch({
+          input: {
+            item: {
+              productId,
+              variantId,
+              quantity: input.quantity,
+            },
+            itemId,
+          },
         })
-
         await mutate(data, false)
         return data
-      }, cfg?.wait ?? 500),
-      [fn, mutate]
+      }, ctx.wait ?? 500),
+      [fetch, mutate]
     )
-  }
-
-  useUpdateItem.extend = extendHook
-
-  return useUpdateItem
+  },
 }
-
-export default extendHook(fetcher)