Merge branch 'nodejs-provider' of https://github.com/vercel/commerce into shopify-updates

framework/bigcommerce/api/endpoints/catalog/products/get-products.ts

@@ -12,7 +12,7 @@ const LIMIT = 12
 // Return current cart info
 const getProducts: ProductsEndpoint['handlers']['getProducts'] = async ({
   res,
-  body: { search, category, brand, sort },
+  body: { search, categoryId, brandId, sort },
   config,
   commerce,
 }) => {
@@ -24,11 +24,11 @@ const getProducts: ProductsEndpoint['handlers']['getProducts'] = async ({
 
   if (search) url.searchParams.set('keyword', search)
 
-  if (category && Number.isInteger(Number(category)))
+  if (categoryId && Number.isInteger(Number(categoryId)))
-    url.searchParams.set('categories:in', category)
+    url.searchParams.set('categories:in', categoryId)
 
-  if (brand && Number.isInteger(Number(brand)))
+  if (brandId && Number.isInteger(Number(brandId)))
-    url.searchParams.set('brand_id', brand)
+    url.searchParams.set('brand_id', brandId)
 
   if (sort) {
     const [_sort, direction] = sort.split('-')

framework/bigcommerce/api/utils/fetch-graphql-api.ts

@@ -3,13 +3,13 @@ import type { GraphQLFetcher } from '@commerce/api'
 import { provider } from '..'
 import fetch from './fetch'
 
-const { config } = provider
 const fetchGraphqlApi: GraphQLFetcher = async (
   query: string,
   { variables, preview } = {},
   fetchOptions
 ) => {
   // log.warn(query)
+  const { config } = provider
   const res = await fetch(config.commerceUrl + (preview ? '/preview' : ''), {
     ...fetchOptions,
     method: 'POST',

framework/bigcommerce/api/utils/fetch-store-api.ts

@@ -3,12 +3,11 @@ import { provider } from '..'
 import { BigcommerceApiError, BigcommerceNetworkError } from './errors'
 import fetch from './fetch'
 
-const { config } = provider
-
 export default async function fetchStoreApi<T>(
   endpoint: string,
   options?: RequestInit
 ): Promise<T> {
+  const { config } = provider
   let res: Response
 
   try {

framework/bigcommerce/auth/use-login.tsx

@@ -2,12 +2,12 @@ import { useCallback } from 'react'
 import type { MutationHook } from '@commerce/utils/types'
 import { CommerceError } from '@commerce/utils/errors'
 import useLogin, { UseLogin } from '@commerce/auth/use-login'
-import type { LoginBody } from '../api/customers/login'
+import type { LoginHook } from '../types/login'
 import useCustomer from '../customer/use-customer'
 
 export default useLogin as UseLogin<typeof handler>
 
-export const handler: MutationHook<null, {}, LoginBody> = {
+export const handler: MutationHook<LoginHook> = {
   fetchOptions: {
     url: '/api/bigcommerce/customers/login',
     method: 'POST',

framework/bigcommerce/auth/use-logout.tsx

@@ -1,11 +1,12 @@
 import { useCallback } from 'react'
 import type { MutationHook } from '@commerce/utils/types'
 import useLogout, { UseLogout } from '@commerce/auth/use-logout'
+import type { LogoutHook } from '../types/logout'
 import useCustomer from '../customer/use-customer'
 
 export default useLogout as UseLogout<typeof handler>
 
-export const handler: MutationHook<null> = {
+export const handler: MutationHook<LogoutHook> = {
   fetchOptions: {
     url: '/api/bigcommerce/customers/logout',
     method: 'GET',

framework/bigcommerce/auth/use-signup.tsx

@@ -2,12 +2,12 @@ import { useCallback } from 'react'
 import type { MutationHook } from '@commerce/utils/types'
 import { CommerceError } from '@commerce/utils/errors'
 import useSignup, { UseSignup } from '@commerce/auth/use-signup'
-import type { SignupBody } from '../api/customers/signup'
+import type { SignupHook } from '../types/signup'
 import useCustomer from '../customer/use-customer'
 
 export default useSignup as UseSignup<typeof handler>
 
-export const handler: MutationHook<null, {}, SignupBody, SignupBody> = {
+export const handler: MutationHook<SignupHook> = {
   fetchOptions: {
     url: '/api/bigcommerce/customers/signup',
     method: 'POST',

framework/bigcommerce/customer/use-customer.tsx

@@ -1,16 +1,16 @@
 import { SWRHook } from '@commerce/utils/types'
 import useCustomer, { UseCustomer } from '@commerce/customer/use-customer'
-import type { Customer, CustomerData } from '../api/customers'
+import type { CustomerHook } from '../types/customer'
 
 export default useCustomer as UseCustomer<typeof handler>
 
-export const handler: SWRHook<Customer | null> = {
+export const handler: SWRHook<CustomerHook> = {
   fetchOptions: {
-    url: '/api/bigcommerce/customers',
+    url: '/api/customer',
     method: 'GET',
   },
   async fetcher({ options, fetch }) {
-    const data = await fetch<CustomerData | null>(options)
+    const data = await fetch(options)
     return data?.customer ?? null
   },
   useHook: ({ useData }) => (input) => {

framework/bigcommerce/product/use-search.tsx

@@ -1,6 +1,6 @@
 import { SWRHook } from '@commerce/utils/types'
 import useSearch, { UseSearch } from '@commerce/product/use-search'
-import type { SearchProductsData } from '../api/catalog/products'
+import type { SearchProductsHook } from '../types/product'
 
 export default useSearch as UseSearch<typeof handler>
 
@@ -11,13 +11,9 @@ export type SearchProductsInput = {
   sort?: string
 }
 
-export const handler: SWRHook<
+export const handler: SWRHook<SearchProductsHook> = {
-  SearchProductsData,
-  SearchProductsInput,
-  SearchProductsInput
-> = {
   fetchOptions: {
-    url: '/api/bigcommerce/catalog/products',
+    url: '/api/catalog/products',
     method: 'GET',
   },
   fetcher({ input: { search, categoryId, brandId, sort }, options, fetch }) {

framework/bigcommerce/types/common.ts

@@ -0,0 +1 @@
+export * from '@commerce/types/common'

framework/bigcommerce/types/index.ts

@@ -1,2 +1,25 @@
-export * from '@commerce/types'
+import * as Cart from './cart'
-export * from './cart'
+import * as Checkout from './checkout'
+import * as Common from './common'
+import * as Customer from './customer'
+import * as Login from './login'
+import * as Logout from './logout'
+import * as Page from './page'
+import * as Product from './product'
+import * as Signup from './signup'
+import * as Site from './site'
+import * as Wishlist from './wishlist'
+
+export type {
+  Cart,
+  Checkout,
+  Common,
+  Customer,
+  Login,
+  Logout,
+  Page,
+  Product,
+  Signup,
+  Site,
+  Wishlist,
+}

framework/bigcommerce/wishlist/use-add-item.tsx

@@ -2,15 +2,15 @@ import { useCallback } from 'react'
 import type { MutationHook } from '@commerce/utils/types'
 import { CommerceError } from '@commerce/utils/errors'
 import useAddItem, { UseAddItem } from '@commerce/wishlist/use-add-item'
-import type { ItemBody, AddItemBody } from '../api/wishlist'
+import type { AddItemHook } from '../types/wishlist'
 import useCustomer from '../customer/use-customer'
 import useWishlist from './use-wishlist'
 
 export default useAddItem as UseAddItem<typeof handler>
 
-export const handler: MutationHook<any, {}, ItemBody, AddItemBody> = {
+export const handler: MutationHook<AddItemHook> = {
   fetchOptions: {
-    url: '/api/bigcommerce/wishlist',
+    url: '/api/wishlist',
     method: 'POST',
   },
   useHook: ({ fetch }) => () => {

framework/bigcommerce/wishlist/use-remove-item.tsx

@@ -2,23 +2,17 @@ import { useCallback } from 'react'
 import type { MutationHook } from '@commerce/utils/types'
 import { CommerceError } from '@commerce/utils/errors'
 import useRemoveItem, {
-  RemoveItemInput,
   UseRemoveItem,
 } from '@commerce/wishlist/use-remove-item'
-import type { RemoveItemBody, Wishlist } from '../api/wishlist'
+import type { RemoveItemHook } from '../types/wishlist'
 import useCustomer from '../customer/use-customer'
-import useWishlist, { UseWishlistInput } from './use-wishlist'
+import useWishlist from './use-wishlist'
 
 export default useRemoveItem as UseRemoveItem<typeof handler>
 
-export const handler: MutationHook<
+export const handler: MutationHook<RemoveItemHook> = {
-  Wishlist | null,
-  { wishlist?: UseWishlistInput },
-  RemoveItemInput,
-  RemoveItemBody
-> = {
   fetchOptions: {
-    url: '/api/bigcommerce/wishlist',
+    url: '/api/wishlist',
     method: 'DELETE',
   },
   useHook: ({ fetch }) => ({ wishlist } = {}) => {

framework/bigcommerce/wishlist/use-wishlist.tsx

@@ -1,19 +1,12 @@
 import { useMemo } from 'react'
 import { SWRHook } from '@commerce/utils/types'
 import useWishlist, { UseWishlist } from '@commerce/wishlist/use-wishlist'
-import type { Wishlist } from '../api/wishlist'
+import type { GetWishlistHook } from '../types/wishlist'
 import useCustomer from '../customer/use-customer'
 
-export type UseWishlistInput = { includeProducts?: boolean }
-
 export default useWishlist as UseWishlist<typeof handler>
 
-export const handler: SWRHook<
+export const handler: SWRHook<GetWishlistHook> = {
-  Wishlist | null,
-  UseWishlistInput,
-  { customerId?: number } & UseWishlistInput,
-  { isEmpty?: boolean }
-> = {
   fetchOptions: {
     url: '/api/bigcommerce/wishlist',
     method: 'GET',

framework/commerce/api/operations.ts

@@ -14,7 +14,16 @@ const noop = () => {
   throw new Error('Not implemented')
 }
 
-export const OPERATIONS = ['login'] as const
+export const OPERATIONS = [
+  'login',
+  'getAllPages',
+  'getPage',
+  'getSiteInfo',
+  'getCustomerWishlist',
+  'getAllProductPaths',
+  'getAllProducts',
+  'getProduct',
+] as const
 
 export const defaultOperations = OPERATIONS.reduce((ops, k) => {
   ops[k] = noop

framework/commerce/auth/use-login.tsx

@@ -1,13 +1,14 @@
 import { useHook, useMutationHook } from '../utils/use-hook'
 import { mutationFetcher } from '../utils/default-fetcher'
 import type { MutationHook, HookFetcherFn } from '../utils/types'
+import type { LoginHook } from '../types/login'
 import type { Provider } from '..'
 
 export type UseLogin<
-  H extends MutationHook<any, any, any> = MutationHook<null, {}, {}>
+  H extends MutationHook<LoginHook<any>> = MutationHook<LoginHook>
 > = ReturnType<H['useHook']>
 
-export const fetcher: HookFetcherFn<null, {}> = mutationFetcher
+export const fetcher: HookFetcherFn<LoginHook> = mutationFetcher
 
 const fn = (provider: Provider) => provider.auth?.useLogin!
 

framework/commerce/auth/use-logout.tsx

@@ -1,13 +1,14 @@
 import { useHook, useMutationHook } from '../utils/use-hook'
 import { mutationFetcher } from '../utils/default-fetcher'
 import type { HookFetcherFn, MutationHook } from '../utils/types'
+import type { LogoutHook } from '../types/logout'
 import type { Provider } from '..'
 
 export type UseLogout<
-  H extends MutationHook<any, any, any> = MutationHook<null>
+  H extends MutationHook<LogoutHook<any>> = MutationHook<LogoutHook>
 > = ReturnType<H['useHook']>
 
-export const fetcher: HookFetcherFn<null> = mutationFetcher
+export const fetcher: HookFetcherFn<LogoutHook> = mutationFetcher
 
 const fn = (provider: Provider) => provider.auth?.useLogout!
 

framework/commerce/auth/use-signup.tsx

@@ -1,13 +1,14 @@
 import { useHook, useMutationHook } from '../utils/use-hook'
 import { mutationFetcher } from '../utils/default-fetcher'
 import type { HookFetcherFn, MutationHook } from '../utils/types'
+import type { SignupHook } from '../types/signup'
 import type { Provider } from '..'
 
 export type UseSignup<
-  H extends MutationHook<any, any, any> = MutationHook<null>
+  H extends MutationHook<SignupHook<any>> = MutationHook<SignupHook>
 > = ReturnType<H['useHook']>
 
-export const fetcher: HookFetcherFn<null> = mutationFetcher
+export const fetcher: HookFetcherFn<SignupHook> = mutationFetcher
 
 const fn = (provider: Provider) => provider.auth?.useSignup!
 

framework/commerce/cart/use-add-item.tsx

@@ -8,10 +8,6 @@ export type UseAddItem<
   H extends MutationHook<AddItemHook<any>> = MutationHook<AddItemHook>
 > = ReturnType<H['useHook']>
 
-export type UseAddItem2<
-  H extends MutationHook<any> = MutationHook<AddItemHook>
-> = ReturnType<H['useHook']>
-
 export const fetcher: HookFetcherFn<AddItemHook> = mutationFetcher
 
 const fn = (provider: Provider) => provider.cart?.useAddItem!

framework/commerce/customer/use-customer.tsx

@@ -1,14 +1,14 @@
 import { useHook, useSWRHook } from '../utils/use-hook'
 import { SWRFetcher } from '../utils/default-fetcher'
+import type { CustomerHook } from '../types/customer'
 import type { HookFetcherFn, SWRHook } from '../utils/types'
-import type { Customer } from '../types'
+import type { Provider } from '..'
-import { Provider } from '..'
 
 export type UseCustomer<
-  H extends SWRHook<any, any, any> = SWRHook<Customer | null>
+  H extends SWRHook<CustomerHook<any>> = SWRHook<CustomerHook>
 > = ReturnType<H['useHook']>
 
-export const fetcher: HookFetcherFn<Customer | null, any> = SWRFetcher
+export const fetcher: HookFetcherFn<CustomerHook> = SWRFetcher
 
 const fn = (provider: Provider) => provider.customer?.useCustomer!
 

framework/commerce/product/use-search.tsx

@@ -1,14 +1,14 @@
 import { useHook, useSWRHook } from '../utils/use-hook'
 import { SWRFetcher } from '../utils/default-fetcher'
 import type { HookFetcherFn, SWRHook } from '../utils/types'
-import type { SearchProductsData } from '../types'
+import type { SearchProductsHook } from '../types/product'
-import { Provider } from '..'
+import type { Provider } from '..'
 
 export type UseSearch<
-  H extends SWRHook<any, any, any> = SWRHook<SearchProductsData>
+  H extends SWRHook<SearchProductsHook<any>> = SWRHook<SearchProductsHook>
 > = ReturnType<H['useHook']>
 
-export const fetcher: HookFetcherFn<SearchProductsData, any> = SWRFetcher
+export const fetcher: HookFetcherFn<SearchProductsHook> = SWRFetcher
 
 const fn = (provider: Provider) => provider.products?.useSearch!
 

framework/commerce/types/customer.ts

@@ -5,6 +5,13 @@ export type CustomerTypes = {
   customer: Customer
 }
 
+export type CustomerHook<T extends CustomerTypes = CustomerTypes> = {
+  data: T['customer'] | null
+  fetchData: { customer: T['customer'] } | null
+  // actionInput: T['body']
+  // fetchInput: T['body']
+}
+
 export type CustomerSchema<T extends CustomerTypes = CustomerTypes> = {
   endpoint: {
     options: {}

framework/commerce/types/index.ts

@@ -1,14 +1,25 @@
-import type { Wishlist as BCWishlist } from '../../bigcommerce/api/wishlist'
+import * as Cart from './cart'
-import type { Customer as BCCustomer } from '../../bigcommerce/api/customers'
+import * as Checkout from './checkout'
-import type { SearchProductsData as BCSearchProductsData } from '../../bigcommerce/api/catalog/products'
+import * as Common from './common'
+import * as Customer from './customer'
+import * as Login from './login'
+import * as Logout from './logout'
+import * as Page from './page'
+import * as Product from './product'
+import * as Signup from './signup'
+import * as Site from './site'
+import * as Wishlist from './wishlist'
 
-export * from './common'
+export type {
-
+  Cart,
-// TODO: Properly define this type
+  Checkout,
-export interface Wishlist extends BCWishlist {}
+  Common,
-
+  Customer,
-// TODO: Properly define this type
+  Login,
-export interface Customer extends BCCustomer {}
+  Logout,
-
+  Page,
-// TODO: Properly define this type
+  Product,
-export interface SearchProductsData extends BCSearchProductsData {}
+  Signup,
+  Site,
+  Wishlist,
+}

framework/commerce/types/login.ts

@@ -7,14 +7,18 @@ export type LoginTypes = {
   body: LoginBody
 }
 
+export type LoginHook<T extends LoginTypes = LoginTypes> = {
+  data: null
+  actionInput: LoginBody
+  fetchInput: LoginBody
+  body: T['body']
+}
+
 export type LoginSchema<T extends LoginTypes = LoginTypes> = {
   endpoint: {
     options: {}
     handlers: {
-      login: {
+      login: LoginHook<T>
-        data: null
-        body: T['body']
-      }
     }
   }
 }

framework/commerce/types/logout.ts

@@ -1,11 +1,17 @@
-export type LogoutSchema = {
+export type LogoutTypes = {
+  body: { redirectTo?: string }
+}
+
+export type LogoutHook<T extends LogoutTypes = LogoutTypes> = {
+  data: null
+  body: T['body']
+}
+
+export type LogoutSchema<T extends LogoutTypes = LogoutTypes> = {
   endpoint: {
     options: {}
     handlers: {
-      logout: {
+      logout: LogoutHook<T>
-        data: null
-        body: { redirectTo?: string }
-      }
     }
   }
 }

framework/commerce/types/product.ts

@@ -42,8 +42,23 @@ export type Product = {
   options: ProductOption[]
 }
 
+export type SearchProductsBody = {
+  search?: string
+  categoryId?: string
+  brandId?: string
+  sort?: string
+}
+
 export type ProductTypes = {
   product: Product
+  searchBody: SearchProductsBody
+}
+
+export type SearchProductsHook<T extends ProductTypes = ProductTypes> = {
+  data: T['product'][]
+  body: T['searchBody']
+  input: T['searchBody']
+  fetchInput: T['searchBody']
 }
 
 export type ProductsSchema<T extends ProductTypes = ProductTypes> = {
@@ -55,12 +70,7 @@ export type ProductsSchema<T extends ProductTypes = ProductTypes> = {
           products: T['product'][]
           found: boolean
         }
-        body: {
+        body: SearchProductsHook<T>['body']
-          search?: string
-          category?: string
-          brand?: string
-          sort?: string
-        }
       }
     }
   }

framework/commerce/types/signup.ts

@@ -9,14 +9,18 @@ export type SignupTypes = {
   body: SignupBody
 }
 
+export type SignupHook<T extends SignupTypes = SignupTypes> = {
+  data: null
+  body: T['body']
+  actionInput: T['body']
+  fetchInput: T['body']
+}
+
 export type SignupSchema<T extends SignupTypes = SignupTypes> = {
   endpoint: {
     options: {}
     handlers: {
-      signup: {
+      signup: SignupHook<T>
-        data: null
-        body: T['body']
-      }
     }
   }
 }

framework/commerce/types/wishlist.ts

@@ -11,21 +11,42 @@ export type WishlistTypes = {
   itemBody: WishlistItemBody
 }
 
+export type GetWishlistHook<T extends WishlistTypes = WishlistTypes> = {
+  data: T['wishlist'] | null
+  body: { includeProducts?: boolean }
+  input: { includeProducts?: boolean }
+  fetchInput: { customerId: string; includeProducts?: boolean }
+  swrState: { isEmpty: boolean }
+}
+
+export type AddItemHook<T extends WishlistTypes = WishlistTypes> = {
+  data: T['wishlist']
+  body: { item: T['itemBody'] }
+  fetchInput: { item: T['itemBody'] }
+  actionInput: T['itemBody']
+}
+
+export type RemoveItemHook<T extends WishlistTypes = WishlistTypes> = {
+  data: T['wishlist'] | null
+  body: { itemId: string }
+  fetchInput: { itemId: string }
+  actionInput: { id: string }
+  input: { wishlist?: { includeProducts?: boolean } }
+}
+
 export type WishlistSchema<T extends WishlistTypes = WishlistTypes> = {
   endpoint: {
     options: {}
     handlers: {
-      getWishlist: {
+      getWishlist: GetWishlistHook<T> & {
         data: T['wishlist'] | null
-        body: { customerToken?: string; includeProducts?: boolean }
+        body: { customerToken?: string }
       }
-      addItem: {
+      addItem: AddItemHook<T> & {
-        data: T['wishlist']
+        body: { customerToken?: string }
-        body: { customerToken?: string; item: T['itemBody'] }
       }
-      removeItem: {
+      removeItem: RemoveItemHook<T> & {
-        data: T['wishlist'] | null
+        body: { customerToken?: string }
-        body: { customerToken?: string; itemId: string }
       }
     }
   }

framework/commerce/utils/types.ts

@@ -43,7 +43,12 @@ export type HookFetcherFn<H extends HookSchemaBase> = (
 export type HookFetcherContext<H extends HookSchemaBase> = {
   options: HookFetcherOptions
   input: H['fetchInput']
-  fetch: <T = any, B = H['body']>(options: FetcherOptions<B>) => Promise<T>
+  fetch: {
+    (
+      options: FetcherOptions<H['body'] extends {} ? H['body'] : never>
+    ): Promise<H['fetchData'] extends {} | null ? H['fetchData'] : any>
+    <T = any, B = any>(options: FetcherOptions<B>): Promise<T>
+  }
 }
 
 export type HookFetcherOptions = { method?: string } & (
@@ -67,19 +72,21 @@ export type HookFunction<
   : (input: Input) => T
 
 export type HookSchemaBase = {
-  // Data obj returned by the hook and fetch operation
+  // Data obj returned by the hook
   data: any
   // Input expected by the hook
-  input: {}
+  input?: {}
   // Input expected before doing a fetch operation (aka fetch handler)
   fetchInput?: {}
-  // Data expected by the fetch operation
+  // Body object expected by the fetch operation
   body?: {}
+  // Data returned by the fetch operation
+  fetchData?: any
 }
 
 export type SWRHookSchemaBase = HookSchemaBase & {
   // Custom state added to the response object of SWR
-  swrState: {}
+  swrState?: {}
 }
 
 export type MutationSchemaBase = HookSchemaBase & {
@@ -101,8 +108,6 @@ export type SWRHook<H extends SWRHookSchemaBase> = {
   fetcher?: HookFetcherFn<H>
 }
 
-type X = {} & undefined
-
 export type SWRHookContext<H extends SWRHookSchemaBase> = {
   useData(context?: {
     input?: HookFetchInput | HookSWRInput

framework/commerce/utils/use-data.tsx

@@ -2,10 +2,11 @@ import useSWR, { responseInterface } from 'swr'
 import type {
   HookSWRInput,
   HookFetchInput,
-  Fetcher,
-  SwrOptions,
   HookFetcherOptions,
   HookFetcherFn,
+  Fetcher,
+  SwrOptions,
+  SWRHookSchemaBase,
 } from './types'
 import defineProperty from './define-property'
 import { CommerceError } from './errors'
@@ -14,15 +15,15 @@ export type ResponseState<Result> = responseInterface<Result, CommerceError> & {
   isLoading: boolean
 }
 
-export type UseData = <Data = any, FetchInput extends HookFetchInput = {}>(
+export type UseData = <H extends SWRHookSchemaBase>(
   options: {
     fetchOptions: HookFetcherOptions
-    fetcher: HookFetcherFn<Data, FetchInput>
+    fetcher: HookFetcherFn<H>
   },
   input: HookFetchInput | HookSWRInput,
   fetcherFn: Fetcher,
-  swrOptions?: SwrOptions<Data, FetchInput>
+  swrOptions?: SwrOptions<H['data'], H['fetchInput']>
-) => ResponseState<Data>
+) => ResponseState<H['data']>
 
 const useData: UseData = (options, input, fetcherFn, swrOptions) => {
   const hookInput = Array.isArray(input) ? input : Object.entries(input)

framework/commerce/utils/use-hook.ts

@@ -10,14 +10,14 @@ export function useFetcher() {
 
 export function useHook<
   P extends Provider,
-  H extends MutationHook<any, any, any> | SWRHook<any, any, any>
+  H extends MutationHook<any> | SWRHook<any>
 >(fn: (provider: P) => H) {
   const { providerRef } = useCommerce<P>()
   const provider = providerRef.current
   return fn(provider)
 }
 
-export function useSWRHook<H extends SWRHook<any, any, any>>(
+export function useSWRHook<H extends SWRHook<any>>(
   hook: PickRequired<H, 'fetcher'>
 ) {
   const fetcher = useFetcher()
@@ -30,7 +30,7 @@ export function useSWRHook<H extends SWRHook<any, any, any>>(
   })
 }
 
-export function useMutationHook<H extends MutationHook<any, any, any>>(
+export function useMutationHook<H extends MutationHook<any>>(
   hook: PickRequired<H, 'fetcher'>
 ) {
   const fetcher = useFetcher()

framework/commerce/wishlist/use-add-item.tsx

@@ -1,10 +1,11 @@
 import { useHook, useMutationHook } from '../utils/use-hook'
 import { mutationFetcher } from '../utils/default-fetcher'
 import type { MutationHook } from '../utils/types'
+import type { AddItemHook } from '../types/wishlist'
 import type { Provider } from '..'
 
 export type UseAddItem<
-  H extends MutationHook<any, any, any> = MutationHook<any, {}, {}>
+  H extends MutationHook<AddItemHook<any>> = MutationHook<AddItemHook>
 > = ReturnType<H['useHook']>
 
 export const fetcher = mutationFetcher

framework/commerce/wishlist/use-remove-item.tsx

@@ -1,28 +1,20 @@
 import { useHook, useMutationHook } from '../utils/use-hook'
 import { mutationFetcher } from '../utils/default-fetcher'
 import type { HookFetcherFn, MutationHook } from '../utils/types'
+import type { RemoveItemHook } from '../types/wishlist'
 import type { Provider } from '..'
 
-export type RemoveItemInput = {
-  id: string | number
-}
-
 export type UseRemoveItem<
-  H extends MutationHook<any, any, any> = MutationHook<
+  H extends MutationHook<RemoveItemHook<any>> = MutationHook<RemoveItemHook>
-    any | null,
-    { wishlist?: any },
-    RemoveItemInput,
-    {}
-  >
 > = ReturnType<H['useHook']>
 
-export const fetcher: HookFetcherFn<any | null, {}> = mutationFetcher
+export const fetcher: HookFetcherFn<RemoveItemHook> = mutationFetcher
 
 const fn = (provider: Provider) => provider.wishlist?.useRemoveItem!
 
-const useRemoveItem: UseRemoveItem = (input) => {
+const useRemoveItem: UseRemoveItem = (...args) => {
   const hook = useHook(fn)
-  return useMutationHook({ fetcher, ...hook })(input)
+  return useMutationHook({ fetcher, ...hook })(...args)
 }
 
 export default useRemoveItem

framework/commerce/wishlist/use-wishlist.tsx

@@ -1,25 +1,20 @@
 import { useHook, useSWRHook } from '../utils/use-hook'
 import { SWRFetcher } from '../utils/default-fetcher'
 import type { HookFetcherFn, SWRHook } from '../utils/types'
-import type { Wishlist } from '../types'
+import type { GetWishlistHook } from '../types/wishlist'
 import type { Provider } from '..'
 
 export type UseWishlist<
-  H extends SWRHook<any, any, any> = SWRHook<
+  H extends SWRHook<GetWishlistHook<any>> = SWRHook<GetWishlistHook>
-    Wishlist | null,
-    { includeProducts?: boolean },
-    { customerId?: number; includeProducts: boolean },
-    { isEmpty?: boolean }
-  >
 > = ReturnType<H['useHook']>
 
-export const fetcher: HookFetcherFn<Wishlist | null, any> = SWRFetcher
+export const fetcher: HookFetcherFn<GetWishlistHook> = SWRFetcher
 
 const fn = (provider: Provider) => provider.wishlist?.useWishlist!
 
-const useWishlist: UseWishlist = (input) => {
+const useWishlist: UseWishlist = (...args) => {
   const hook = useHook(fn)
-  return useSWRHook({ fetcher, ...hook })(input)
+  return useSWRHook({ fetcher, ...hook })(...args)
 }
 
 export default useWishlist