feat: medusa-react admin hooks (#978)

* add: medusa admin hooks + tests * fix: remove unneeded props * fix: deps * fix: deps * fix: deps * fix: failing tests * fix: failing tests * fix: query key * add: yarn workspaces * fix: linting medusa-react * fix: add prepare script * fix: buildOptions * fix: useAdminShippingOptions query * fix: use qs instead for query params (#1019) * fix: formatting * debug: ci pipeline * debug: log node_modules structure * debug: use lerna bootstrap * debug: update node version * debug: print pkgs in workspace * debug: print pkgs in workspace * debug: print pkgs in workspace * debug: print pkgs in workspace * debug: add explicit build step * fix: jsdoc * debug: run build step * debug: fix build errors * debug: add build step to integration tests * fix: failing test * cleanup Co-authored-by: Sebastian Rindom <seb@medusajs.com> Co-authored-by: Sebastian Rindom <skrindom@gmail.com>
2022-02-02 17:10:56 +01:00
parent 24175025d1
commit 2e384842d5
209 changed files with 27917 additions and 2727 deletions
@@ -6,7 +6,7 @@ import {
  useSetPaymentSession,
  useUpdateCart,
  useCreatePaymentSession,
-} from "../hooks/carts"
+} from "../hooks/store/"
 import { Cart } from "../types"

 interface CartState {
@@ -75,7 +75,7 @@ export const CartProvider = ({
  const completeCheckout = useCompleteCart(cart?.id)

  const totalItems = cart?.items
-    .map((i) => i.quantity)
+    .map(i => i.quantity)
    .reduce((acc, curr) => acc + curr, 0)

  return (
@@ -20,17 +20,23 @@ interface MedusaProviderProps {
  baseUrl: string
  queryClientProviderProps: QueryClientProviderProps
  children: React.ReactNode
+  apiKey?: string
 }

 export const MedusaProvider = ({
  queryClientProviderProps,
  baseUrl,
+  apiKey,
  children,
 }: MedusaProviderProps) => {
-  const medusaClient = new Medusa({ baseUrl, maxRetries: 0 })
+  const medusaClient = new Medusa({ baseUrl, maxRetries: 0, apiKey })
  return (
    <QueryClientProvider {...queryClientProviderProps}>
-      <MedusaContext.Provider value={{ client: medusaClient }}>
+      <MedusaContext.Provider
+        value={{
+          client: medusaClient,
+        }}
+      >
        {children}
      </MedusaContext.Provider>
    </QueryClientProvider>
@@ -1,7 +1,7 @@
 import React, { useContext, useEffect } from "react"
 import { useLocalStorage } from "../hooks/utils"
 import { RegionInfo, ProductVariant } from "../types"
-import { getVariantPrice } from "../utils"
+import { getVariantPrice } from "../helpers"
 import { isArray, isEmpty, isObject } from "lodash"

 interface Item {
@@ -72,7 +72,7 @@ const reducer = (state: SessionCartState, action: Action) => {
    }
    case ACTION_TYPES.ADD_ITEM: {
      const duplicateVariantIndex = state.items.findIndex(
-        (item) => item.variant.id === action.payload?.variant?.id
+        item => item.variant.id === action.payload?.variant?.id
      )
      if (duplicateVariantIndex !== -1) {
        state.items.splice(duplicateVariantIndex, 1)
@@ -81,7 +81,7 @@ const reducer = (state: SessionCartState, action: Action) => {
      return generateCartState(state, items)
    }
    case ACTION_TYPES.UPDATE_ITEM: {
-      const items = state.items.map((item) =>
+      const items = state.items.map(item =>
        item.variant.id === action.payload.id
          ? { ...item, ...action.payload.item }
          : item
@@ -91,7 +91,7 @@ const reducer = (state: SessionCartState, action: Action) => {
    }
    case ACTION_TYPES.REMOVE_ITEM: {
      const items = state.items.filter(
-        (item) => item.variant.id !== action.payload.id
+        item => item.variant.id !== action.payload.id
      )
      return generateCartState(state, items)
    }
@@ -122,7 +122,7 @@ export const generateCartState = (state: SessionCartState, items: Item[]) => {
 }

 const generateItems = (region: RegionInfo, items: Item[]) => {
-  return items.map((item) => ({
+  return items.map(item => ({
    ...item,
    total: getVariantPrice(item.variant, region),
  }))
@@ -171,7 +171,7 @@ export const SessionCartProvider = ({
  }

  const getItem = (id: string) => {
-    return state.items.find((item) => item.variant.id === id)
+    return state.items.find(item => item.variant.id === id)
  }

  const setItems = (items: Item[]) => {
@@ -65,8 +65,7 @@ export const getVariantPrice = (
  region: RegionInfo
 ) => {
  let price = variant?.prices?.find(
-    (p) =>
-      p.currency_code.toLowerCase() === region?.currency_code?.toLowerCase()
+    p => p.currency_code.toLowerCase() === region?.currency_code?.toLowerCase()
  )

  return price?.amount || 0
@@ -0,0 +1,30 @@
+import { AdminAuthRes, AdminPostAuthReq } from "@medusajs/medusa"
+import { Response } from "@medusajs/medusa-js"
+import { useMutation, UseMutationOptions, useQueryClient } from "react-query"
+import { adminAuthKeys } from "."
+import { useMedusa } from "../../../contexts/medusa"
+import { buildOptions } from "../../utils/buildOptions"
+
+export const useAdminLogin = (
+  options?: UseMutationOptions<Response<AdminAuthRes>, Error, AdminPostAuthReq>
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (payload: AdminPostAuthReq) => client.admin.auth.createSession(payload),
+    buildOptions(queryClient, adminAuthKeys.details(), options)
+  )
+}
+
+export const useAdminDeleteSession = (
+  options?: UseMutationOptions<Response<void>, Error, void>
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    () => client.admin.auth.deleteSession(),
+    buildOptions(queryClient, adminAuthKeys.details(), options)
+  )
+}
@@ -0,0 +1,28 @@
+import { AdminAuthRes } from "@medusajs/medusa"
+import { Response } from "@medusajs/medusa-js"
+import { useQuery } from "react-query"
+import { useMedusa } from "../../../contexts"
+import { UseQueryOptionsWrapper } from "../../../types"
+import { queryKeysFactory } from "../../utils/index"
+
+const ADMIN_AUTH_QUERY_KEY = `admin_auth` as const
+
+export const adminAuthKeys = queryKeysFactory(ADMIN_AUTH_QUERY_KEY)
+
+type AuthQueryKey = typeof adminAuthKeys
+
+export const useAdminGetSession = (
+  options?: UseQueryOptionsWrapper<
+    Response<AdminAuthRes>,
+    Error,
+    ReturnType<AuthQueryKey["details"]>
+  >
+) => {
+  const { client } = useMedusa()
+  const { data, ...rest } = useQuery(
+    adminAuthKeys.details(),
+    () => client.admin.auth.getSession(),
+    options
+  )
+  return { ...data, ...rest } as const
+}
@@ -0,0 +1,134 @@
+import { adminOrderKeys } from "./../orders/queries"
+import {
+  AdminOrdersRes,
+  AdminPostOrdersOrderClaimsClaimFulfillmentsReq,
+  AdminPostOrdersOrderClaimsClaimReq,
+  AdminPostOrdersOrderClaimsClaimShipmentsReq,
+  AdminPostOrdersOrderClaimsReq,
+} from "@medusajs/medusa"
+import { Response } from "@medusajs/medusa-js"
+import { useMutation, UseMutationOptions, useQueryClient } from "react-query"
+import { useMedusa } from "../../../contexts/medusa"
+import { buildOptions } from "../../utils/buildOptions"
+
+export const useAdminCreateClaim = (
+  orderId: string,
+  options?: UseMutationOptions<
+    Response<AdminOrdersRes>,
+    Error,
+    AdminPostOrdersOrderClaimsReq
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (payload: AdminPostOrdersOrderClaimsReq) =>
+      client.admin.orders.createClaim(orderId, payload),
+    buildOptions(queryClient, adminOrderKeys.detail(orderId), options)
+  )
+}
+
+export const useAdminUpdateClaim = (
+  orderId: string,
+  options?: UseMutationOptions<
+    Response<AdminOrdersRes>,
+    Error,
+    AdminPostOrdersOrderClaimsClaimReq & { claim_id: string }
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    ({
+      claim_id,
+      ...payload
+    }: AdminPostOrdersOrderClaimsClaimReq & { claim_id: string }) =>
+      client.admin.orders.updateClaim(orderId, claim_id, payload),
+    buildOptions(queryClient, adminOrderKeys.detail(orderId), options)
+  )
+}
+
+export const useAdminCancelClaim = (
+  orderId: string,
+  options?: UseMutationOptions<Response<AdminOrdersRes>, Error, string>
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (claimId: string) => client.admin.orders.cancelClaim(orderId, claimId),
+    buildOptions(queryClient, adminOrderKeys.detail(orderId), options)
+  )
+}
+
+export const useAdminFulfillClaim = (
+  orderId: string,
+  options?: UseMutationOptions<
+    Response<AdminOrdersRes>,
+    Error,
+    AdminPostOrdersOrderClaimsClaimFulfillmentsReq & { claim_id: string }
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    ({
+      claim_id,
+      ...payload
+    }: AdminPostOrdersOrderClaimsClaimFulfillmentsReq & { claim_id: string }) =>
+      client.admin.orders.fulfillClaim(orderId, claim_id, payload),
+    buildOptions(queryClient, adminOrderKeys.detail(orderId), options)
+  )
+}
+
+export const useAdminCancelClaimFulfillment = (
+  orderId: string,
+  options?: UseMutationOptions<
+    Response<AdminOrdersRes>,
+    Error,
+    { claim_id: string; fulfillment_id: string }
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    ({
+      claim_id,
+      fulfillment_id,
+    }: {
+      claim_id: string
+      fulfillment_id: string
+    }) =>
+      client.admin.orders.cancelClaimFulfillment(
+        orderId,
+        claim_id,
+        fulfillment_id
+      ),
+    buildOptions(queryClient, adminOrderKeys.detail(orderId), options)
+  )
+}
+
+export const useAdminCreateClaimShipment = (
+  orderId: string,
+  options?: UseMutationOptions<
+    Response<AdminOrdersRes>,
+    Error,
+    AdminPostOrdersOrderClaimsClaimShipmentsReq & { claim_id: string }
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    ({
+      claim_id,
+      ...payload
+    }: AdminPostOrdersOrderClaimsClaimShipmentsReq & { claim_id: string }) =>
+      client.admin.orders.createClaimShipment(orderId, claim_id, payload),
+    buildOptions(queryClient, adminOrderKeys.detail(orderId), options)
+  )
+}
@@ -0,0 +1,64 @@
+import {
+  AdminCollectionsDeleteRes,
+  AdminCollectionsRes,
+  AdminPostCollectionsCollectionReq,
+  AdminPostCollectionsReq,
+} from "@medusajs/medusa"
+import { Response } from "@medusajs/medusa-js"
+import { useMutation, UseMutationOptions, useQueryClient } from "react-query"
+import { adminCollectionKeys } from "."
+import { useMedusa } from "../../../contexts/medusa"
+import { buildOptions } from "../../utils/buildOptions"
+
+export const useAdminCreateCollection = (
+  options?: UseMutationOptions<
+    Response<AdminCollectionsRes>,
+    Error,
+    AdminPostCollectionsReq
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+  return useMutation(
+    (payload: AdminPostCollectionsReq) =>
+      client.admin.collections.create(payload),
+    buildOptions(queryClient, adminCollectionKeys.lists(), options)
+  )
+}
+
+export const useAdminUpdateCollection = (
+  id: string,
+  options?: UseMutationOptions<
+    Response<AdminCollectionsRes>,
+    Error,
+    AdminPostCollectionsCollectionReq
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+  return useMutation(
+    (payload: AdminPostCollectionsCollectionReq) =>
+      client.admin.collections.update(id, payload),
+    buildOptions(
+      queryClient,
+      [adminCollectionKeys.lists(), adminCollectionKeys.detail(id)],
+      options
+    )
+  )
+}
+
+export const useAdminDeleteCollection = (
+  id: string,
+  options?: UseMutationOptions<Response<AdminCollectionsDeleteRes>, Error, void>
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+  return useMutation(
+    () => client.admin.collections.delete(id),
+    buildOptions(
+      queryClient,
+      [adminCollectionKeys.lists(), adminCollectionKeys.detail(id)],
+      options
+    )
+  )
+}
@@ -0,0 +1,50 @@
+import {
+  AdminCollectionsListRes,
+  AdminCollectionsRes,
+  AdminGetCollectionsParams,
+} from "@medusajs/medusa"
+import { Response } from "@medusajs/medusa-js"
+import { useQuery } from "react-query"
+import { useMedusa } from "../../../contexts"
+import { UseQueryOptionsWrapper } from "../../../types"
+import { queryKeysFactory } from "../../utils/index"
+
+const ADMIN_COLLECTIONS_QUERY_KEY = `admin_collections` as const
+
+export const adminCollectionKeys = queryKeysFactory(ADMIN_COLLECTIONS_QUERY_KEY)
+
+type CollectionsQueryKey = typeof adminCollectionKeys
+
+export const useAdminCollections = (
+  query?: AdminGetCollectionsParams,
+  options?: UseQueryOptionsWrapper<
+    Response<AdminCollectionsListRes>,
+    Error,
+    ReturnType<CollectionsQueryKey["list"]>
+  >
+) => {
+  const { client } = useMedusa()
+  const { data, ...rest } = useQuery(
+    adminCollectionKeys.list(query),
+    () => client.admin.collections.list(query),
+    options
+  )
+  return { ...data, ...rest } as const
+}
+
+export const useAdminCollection = (
+  id: string,
+  options?: UseQueryOptionsWrapper<
+    Response<AdminCollectionsRes>,
+    Error,
+    ReturnType<CollectionsQueryKey["detail"]>
+  >
+) => {
+  const { client } = useMedusa()
+  const { data, ...rest } = useQuery(
+    adminCollectionKeys.detail(id),
+    () => client.admin.collections.retrieve(id),
+    options
+  )
+  return { ...data, ...rest } as const
+}
@@ -0,0 +1,43 @@
+import { adminCustomerKeys } from "./queries"
+import { AdminCustomersRes, AdminPostCustomersReq } from "@medusajs/medusa"
+import { Response } from "@medusajs/medusa-js"
+import { useMutation, UseMutationOptions, useQueryClient } from "react-query"
+import { useMedusa } from "../../../contexts/medusa"
+import { buildOptions } from "../../utils/buildOptions"
+
+export const useAdminCreateCustomer = (
+  options?: UseMutationOptions<
+    Response<AdminCustomersRes>,
+    Error,
+    AdminPostCustomersReq
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (payload: AdminPostCustomersReq) => client.admin.customers.create(payload),
+    buildOptions(queryClient, adminCustomerKeys.lists(), options)
+  )
+}
+
+export const useAdminUpdateCustomer = (
+  id: string,
+  options?: UseMutationOptions<
+    Response<AdminCustomersRes>,
+    Error,
+    AdminPostCustomersReq
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+  return useMutation(
+    (payload: AdminPostCustomersReq) =>
+      client.admin.customers.update(id, payload),
+    buildOptions(
+      queryClient,
+      [adminCustomerKeys.lists(), adminCustomerKeys.detail(id)],
+      options
+    )
+  )
+}
@@ -0,0 +1,50 @@
+import {
+  AdminCustomersListRes,
+  AdminCustomersRes,
+  AdminGetCustomersParams,
+} from "@medusajs/medusa"
+import { Response } from "@medusajs/medusa-js"
+import { useQuery } from "react-query"
+import { useMedusa } from "../../../contexts"
+import { UseQueryOptionsWrapper } from "../../../types"
+import { queryKeysFactory } from "../../utils/index"
+
+const ADMIN_CUSTOMERS_QUERY_KEY = `admin_customers` as const
+
+export const adminCustomerKeys = queryKeysFactory(ADMIN_CUSTOMERS_QUERY_KEY)
+
+type CustomerQueryKeys = typeof adminCustomerKeys
+
+export const useAdminCustomers = (
+  query?: AdminGetCustomersParams,
+  options?: UseQueryOptionsWrapper<
+    Response<AdminCustomersListRes>,
+    Error,
+    ReturnType<CustomerQueryKeys["list"]>
+  >
+) => {
+  const { client } = useMedusa()
+  const { data, ...rest } = useQuery(
+    adminCustomerKeys.list(query),
+    () => client.admin.customers.list(query),
+    options
+  )
+  return { ...data, ...rest } as const
+}
+
+export const useAdminCustomer = (
+  id: string,
+  options?: UseQueryOptionsWrapper<
+    Response<AdminCustomersRes>,
+    Error,
+    ReturnType<CustomerQueryKeys["detail"]>
+  >
+) => {
+  const { client } = useMedusa()
+  const { data, ...rest } = useQuery(
+    adminCustomerKeys.detail(id),
+    () => client.admin.customers.retrieve(id),
+    options
+  )
+  return { ...data, ...rest } as const
+}
@@ -0,0 +1,2 @@
+export * from "./queries"
+export * from "./mutations"
@@ -0,0 +1,143 @@
+import { adminDiscountKeys } from "./queries"
+import { buildOptions } from "../../utils/buildOptions"
+import {
+  AdminDiscountsDeleteRes,
+  AdminDiscountsRes,
+  AdminPostDiscountsDiscountDynamicCodesReq,
+  AdminPostDiscountsDiscountReq,
+  AdminPostDiscountsReq,
+} from "@medusajs/medusa"
+import { Response } from "@medusajs/medusa-js"
+import { useMutation, UseMutationOptions, useQueryClient } from "react-query"
+import { useMedusa } from "../../../contexts/medusa"
+
+export const useAdminCreateDiscount = (
+  options?: UseMutationOptions<
+    Response<AdminDiscountsRes>,
+    Error,
+    AdminPostDiscountsReq
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+  return useMutation(
+    (payload: AdminPostDiscountsReq) => client.admin.discounts.create(payload),
+    buildOptions(queryClient, adminDiscountKeys.lists(), options)
+  )
+}
+
+export const useAdminUpdateDiscount = (
+  id: string,
+  options?: UseMutationOptions<
+    Response<AdminDiscountsRes>,
+    Error,
+    AdminPostDiscountsDiscountReq
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+  return useMutation(
+    (payload: AdminPostDiscountsDiscountReq) =>
+      client.admin.discounts.update(id, payload),
+    buildOptions(queryClient, adminDiscountKeys.detail(id), options)
+  )
+}
+
+export const useAdminDeleteDiscount = (
+  id: string,
+  options?: UseMutationOptions<Response<AdminDiscountsDeleteRes>, Error, void>
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+  return useMutation(
+    () => client.admin.discounts.delete(id),
+    buildOptions(queryClient, adminDiscountKeys.lists(), options)
+  )
+}
+
+export const useAdminDiscountAddRegion = (
+  id: string,
+  options?: UseMutationOptions<Response<AdminDiscountsRes>, Error, string>
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+  return useMutation(
+    (regionId: string) => client.admin.discounts.addRegion(id, regionId),
+    buildOptions(queryClient, adminDiscountKeys.detail(id), options)
+  )
+}
+
+export const useAdminDiscountRemoveRegion = (
+  id: string,
+  options?: UseMutationOptions<Response<AdminDiscountsRes>, Error, string>
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+  return useMutation(
+    (regionId: string) => client.admin.discounts.removeRegion(id, regionId),
+    buildOptions(queryClient, adminDiscountKeys.detail(id), options)
+  )
+}
+
+export const useAdminDiscountAddValidProduct = (
+  id: string,
+  options?: UseMutationOptions<Response<AdminDiscountsRes>, Error, string>
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+  return useMutation(
+    (productId: string) =>
+      client.admin.discounts.addValidProduct(id, productId),
+    buildOptions(queryClient, adminDiscountKeys.detail(id), options)
+  )
+}
+
+export const useAdminDiscountRemoveValidProduct = (
+  id: string,
+  options?: UseMutationOptions<Response<AdminDiscountsRes>, Error, string>
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+  return useMutation(
+    (productId: string) =>
+      client.admin.discounts.removeValidProduct(id, productId),
+    buildOptions(queryClient, adminDiscountKeys.detail(id), options)
+  )
+}
+
+export const useAdminCreateDynamicDiscountCode = (
+  id: string,
+  options?: UseMutationOptions<
+    Response<AdminDiscountsRes>,
+    Error,
+    AdminPostDiscountsDiscountDynamicCodesReq
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+  return useMutation(
+    (payload: AdminPostDiscountsDiscountDynamicCodesReq) =>
+      client.admin.discounts.createDynamicCode(id, payload),
+    buildOptions(
+      queryClient,
+      [adminDiscountKeys.lists(), adminDiscountKeys.detail(id)],
+      options
+    )
+  )
+}
+
+export const useAdminDeleteDynamicDiscountCode = (
+  id: string,
+  options?: UseMutationOptions<Response<AdminDiscountsRes>, Error, string>
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+  return useMutation(
+    (code: string) => client.admin.discounts.deleteDynamicCode(id, code),
+    buildOptions(
+      queryClient,
+      [adminDiscountKeys.lists(), adminDiscountKeys.detail(id)],
+      options
+    )
+  )
+}
@@ -0,0 +1,67 @@
+import {
+  AdminDiscountsListRes,
+  AdminDiscountsRes,
+  AdminGetDiscountsParams,
+} from "@medusajs/medusa"
+import { Response } from "@medusajs/medusa-js"
+import { useQuery } from "react-query"
+import { useMedusa } from "../../../contexts"
+import { UseQueryOptionsWrapper } from "../../../types"
+import { queryKeysFactory } from "../../utils/index"
+
+const ADMIN_DISCOUNTS_QUERY_KEY = `admin_discounts` as const
+
+export const adminDiscountKeys = queryKeysFactory(ADMIN_DISCOUNTS_QUERY_KEY)
+
+type DiscountQueryKeys = typeof adminDiscountKeys
+
+export const useAdminDiscounts = (
+  query?: AdminGetDiscountsParams,
+  options?: UseQueryOptionsWrapper<
+    Response<AdminDiscountsListRes>,
+    Error,
+    ReturnType<DiscountQueryKeys["list"]>
+  >
+) => {
+  const { client } = useMedusa()
+  const { data, ...rest } = useQuery(
+    adminDiscountKeys.list(query),
+    () => client.admin.discounts.list(query),
+    options
+  )
+  return { ...data, ...rest } as const
+}
+
+export const useAdminDiscount = (
+  id: string,
+  options?: UseQueryOptionsWrapper<
+    Response<AdminDiscountsRes>,
+    Error,
+    ReturnType<DiscountQueryKeys["detail"]>
+  >
+) => {
+  const { client } = useMedusa()
+  const { data, ...rest } = useQuery(
+    adminDiscountKeys.detail(id),
+    () => client.admin.discounts.retrieve(id),
+    options
+  )
+  return { ...data, ...rest } as const
+}
+
+export const useAdminGetDiscountByCode = (
+  code: string,
+  options?: UseQueryOptionsWrapper<
+    Response<AdminDiscountsRes>,
+    Error,
+    ReturnType<DiscountQueryKeys["detail"]>
+  >
+) => {
+  const { client } = useMedusa()
+  const { data, ...rest } = useQuery(
+    adminDiscountKeys.detail(code),
+    () => client.admin.discounts.retrieveByCode(code),
+    options
+  )
+  return { ...data, ...rest } as const
+}
@@ -0,0 +1,2 @@
+export * from "./queries"
+export * from "./mutations"
@@ -0,0 +1,131 @@
+import { adminDraftOrderKeys } from "./queries"
+import {
+  AdminDraftOrdersDeleteRes,
+  AdminDraftOrdersRes,
+  AdminPostDraftOrdersDraftOrderLineItemsItemReq,
+  AdminPostDraftOrdersDraftOrderLineItemsReq,
+  AdminPostDraftOrdersDraftOrderRegisterPaymentRes,
+  AdminPostDraftOrdersDraftOrderReq,
+} from "@medusajs/medusa"
+import { Response } from "@medusajs/medusa-js"
+import { useMutation, UseMutationOptions, useQueryClient } from "react-query"
+import { useMedusa } from "../../../contexts/medusa"
+import { buildOptions } from "../../utils/buildOptions"
+
+export const useAdminCreateDraftOrder = (
+  options?: UseMutationOptions<
+    Response<AdminDraftOrdersRes>,
+    Error,
+    AdminPostDraftOrdersDraftOrderReq
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+  return useMutation(
+    (payload: AdminPostDraftOrdersDraftOrderReq) =>
+      client.admin.draftOrders.create(payload),
+    buildOptions(queryClient, adminDraftOrderKeys.lists(), options)
+  )
+}
+
+export const useAdminUpdateDraftOrder = (
+  id: string,
+  options?: UseMutationOptions<
+    Response<AdminDraftOrdersRes>,
+    Error,
+    AdminPostDraftOrdersDraftOrderReq
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+  return useMutation(
+    (payload: AdminPostDraftOrdersDraftOrderReq) =>
+      client.admin.draftOrders.update(id, payload),
+    buildOptions(
+      queryClient,
+      [adminDraftOrderKeys.detail(id), adminDraftOrderKeys.lists()],
+      options
+    )
+  )
+}
+
+export const useAdminDeleteDraftOrder = (
+  id: string,
+  options?: UseMutationOptions<Response<AdminDraftOrdersDeleteRes>, Error, void>
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+  return useMutation(
+    () => client.admin.draftOrders.delete(id),
+    buildOptions(
+      queryClient,
+      [adminDraftOrderKeys.detail(id), adminDraftOrderKeys.lists()],
+      options
+    )
+  )
+}
+
+export const useAdminDraftOrderRegisterPayment = (
+  id: string,
+  options?: UseMutationOptions<
+    Response<AdminPostDraftOrdersDraftOrderRegisterPaymentRes>,
+    Error,
+    void
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+  return useMutation(
+    () => client.admin.draftOrders.markPaid(id),
+    buildOptions(queryClient, adminDraftOrderKeys.detail(id), options)
+  )
+}
+
+export const useAdminDraftOrderAddLineItem = (
+  id: string,
+  options?: UseMutationOptions<
+    Response<AdminDraftOrdersRes>,
+    Error,
+    AdminPostDraftOrdersDraftOrderLineItemsReq
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+  return useMutation(
+    (payload: AdminPostDraftOrdersDraftOrderLineItemsReq) =>
+      client.admin.draftOrders.addLineItem(id, payload),
+    buildOptions(queryClient, adminDraftOrderKeys.detail(id), options)
+  )
+}
+
+export const useAdminDraftOrderRemoveLineItem = (
+  id: string,
+  options?: UseMutationOptions<Response<AdminDraftOrdersRes>, Error, string>
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+  return useMutation(
+    (itemId: string) => client.admin.draftOrders.removeLineItem(id, itemId),
+    buildOptions(queryClient, adminDraftOrderKeys.detail(id), options)
+  )
+}
+
+export const useAdminDraftOrderUpdateLineItem = (
+  id: string,
+  options?: UseMutationOptions<
+    Response<AdminDraftOrdersRes>,
+    Error,
+    AdminPostDraftOrdersDraftOrderLineItemsItemReq & { item_id: string }
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+  return useMutation(
+    ({
+      item_id,
+      ...payload
+    }: AdminPostDraftOrdersDraftOrderLineItemsItemReq & { item_id: string }) =>
+      client.admin.draftOrders.updateLineItem(id, item_id, payload),
+    buildOptions(queryClient, adminDraftOrderKeys.detail(id), options)
+  )
+}
@@ -0,0 +1,52 @@
+import {
+  AdminDraftOrdersListRes,
+  AdminDraftOrdersRes,
+  AdminGetDraftOrdersParams,
+} from "@medusajs/medusa"
+import { Response } from "@medusajs/medusa-js"
+import { useQuery } from "react-query"
+import { useMedusa } from "../../../contexts"
+import { UseQueryOptionsWrapper } from "../../../types"
+import { queryKeysFactory } from "../../utils/index"
+
+const ADMIN_DRAFT_ORDERS_QUERY_KEY = `admin_draft_orders` as const
+
+export const adminDraftOrderKeys = queryKeysFactory(
+  ADMIN_DRAFT_ORDERS_QUERY_KEY
+)
+
+type DraftOrderQueryKeys = typeof adminDraftOrderKeys
+
+export const useAdminDraftOrders = (
+  query?: AdminGetDraftOrdersParams,
+  options?: UseQueryOptionsWrapper<
+    Response<AdminDraftOrdersListRes>,
+    Error,
+    ReturnType<DraftOrderQueryKeys["list"]>
+  >
+) => {
+  const { client } = useMedusa()
+  const { data, ...rest } = useQuery(
+    adminDraftOrderKeys.list(query),
+    () => client.admin.draftOrders.list(query),
+    options
+  )
+  return { ...data, ...rest } as const
+}
+
+export const useAdminDraftOrder = (
+  id: string,
+  options?: UseQueryOptionsWrapper<
+    Response<AdminDraftOrdersRes>,
+    Error,
+    ReturnType<DraftOrderQueryKeys["detail"]>
+  >
+) => {
+  const { client } = useMedusa()
+  const { data, ...rest } = useQuery(
+    adminDraftOrderKeys.detail(id),
+    () => client.admin.draftOrders.retrieve(id),
+    options
+  )
+  return { ...data, ...rest } as const
+}
@@ -0,0 +1,2 @@
+export * from "./queries"
+export * from "./mutations"
@@ -0,0 +1,63 @@
+import {
+  AdminGiftCardsDeleteRes,
+  AdminGiftCardsRes,
+  AdminPostGiftCardsReq,
+} from "@medusajs/medusa"
+import { Response } from "@medusajs/medusa-js"
+import { useMutation, UseMutationOptions, useQueryClient } from "react-query"
+import { adminGiftCardKeys } from "."
+import { useMedusa } from "../../../contexts/medusa"
+import { buildOptions } from "../../utils/buildOptions"
+
+export const useAdminCreateGiftCard = (
+  options?: UseMutationOptions<
+    Response<AdminGiftCardsRes>,
+    Error,
+    AdminPostGiftCardsReq
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+  return useMutation(
+    (payload: AdminPostGiftCardsReq) => client.admin.giftCards.create(payload),
+    buildOptions(queryClient, adminGiftCardKeys.lists(), options)
+  )
+}
+
+export const useAdminUpdateGiftCard = (
+  id: string,
+  options?: UseMutationOptions<
+    Response<AdminGiftCardsRes>,
+    Error,
+    AdminPostGiftCardsReq
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (payload: AdminPostGiftCardsReq) =>
+      client.admin.giftCards.update(id, payload),
+    buildOptions(
+      queryClient,
+      [adminGiftCardKeys.lists(), adminGiftCardKeys.detail(id)],
+      options
+    )
+  )
+}
+
+export const useAdminDeleteGiftCard = (
+  id: string,
+  options?: UseMutationOptions<Response<AdminGiftCardsDeleteRes>, Error, void>
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+  return useMutation(
+    () => client.admin.giftCards.delete(id),
+    buildOptions(
+      queryClient,
+      [adminGiftCardKeys.lists(), adminGiftCardKeys.detail(id)],
+      options
+    )
+  )
+}
@@ -0,0 +1,50 @@
+import {
+  AdminGiftCardsListRes,
+  AdminGiftCardsRes,
+  AdminGetGiftCardsParams,
+} from "@medusajs/medusa"
+import { Response } from "@medusajs/medusa-js"
+import { useQuery } from "react-query"
+import { useMedusa } from "../../../contexts"
+import { UseQueryOptionsWrapper } from "../../../types"
+import { queryKeysFactory } from "../../utils/index"
+
+const ADMIN_GIFT_CARDS_QUERY_KEY = `admin_gift_cards` as const
+
+export const adminGiftCardKeys = queryKeysFactory(ADMIN_GIFT_CARDS_QUERY_KEY)
+
+type GiftCardQueryKeys = typeof adminGiftCardKeys
+
+export const useAdminGiftCards = (
+  query?: AdminGetGiftCardsParams,
+  options?: UseQueryOptionsWrapper<
+    Response<AdminGiftCardsListRes>,
+    Error,
+    ReturnType<GiftCardQueryKeys["list"]>
+  >
+) => {
+  const { client } = useMedusa()
+  const { data, ...rest } = useQuery(
+    adminGiftCardKeys.list(query),
+    () => client.admin.giftCards.list(query),
+    options
+  )
+  return { ...data, ...rest } as const
+}
+
+export const useAdminGiftCard = (
+  id: string,
+  options?: UseQueryOptionsWrapper<
+    Response<AdminGiftCardsRes>,
+    Error,
+    ReturnType<GiftCardQueryKeys["detail"]>
+  >
+) => {
+  const { client } = useMedusa()
+  const { data, ...rest } = useQuery(
+    adminGiftCardKeys.detail(id),
+    () => client.admin.giftCards.retrieve(id),
+    options
+  )
+  return { ...data, ...rest } as const
+}
@@ -0,0 +1,21 @@
+export * from "./auth"
+export * from "./collections"
+export * from "./claims"
+export * from "./customers"
+export * from "./discounts"
+export * from "./draft-orders"
+export * from "./gift-cards"
+export * from "./orders"
+export * from "./products"
+export * from "./return-reasons"
+export * from "./regions"
+export * from "./shipping-options"
+export * from "./shipping-profiles"
+export * from "./notes"
+export * from "./invites"
+export * from "./notifications"
+export * from "./returns"
+export * from "./store"
+export * from "./swaps"
+export * from "./users"
+export * from "./variants"
@@ -0,0 +1,2 @@
+export * from "./queries"
+export * from "./mutations"
@@ -0,0 +1,63 @@
+import { buildOptions } from "../../utils/buildOptions"
+import {
+  AdminInviteDeleteRes,
+  AdminPostInvitesInviteAcceptReq,
+} from "@medusajs/medusa"
+import { Response, AdminPostInvitesPayload } from "@medusajs/medusa-js"
+import { useMutation, UseMutationOptions, useQueryClient } from "react-query"
+import { useMedusa } from "../../../contexts/medusa"
+import { adminInviteKeys } from "./queries"
+
+export const useAdminAcceptInvite = (
+  options?: UseMutationOptions<
+    Response<void>,
+    Error,
+    AdminPostInvitesInviteAcceptReq
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (payload: AdminPostInvitesInviteAcceptReq) =>
+      client.admin.invites.accept(payload),
+    buildOptions(queryClient, adminInviteKeys.lists(), options)
+  )
+}
+
+export const useAdminResendInvite = (
+  id: string,
+  options?: UseMutationOptions
+) => {
+  const { client } = useMedusa()
+  return useMutation(() => client.admin.invites.resend(id), options)
+}
+
+export const useAdminCreateInvite = (
+  options?: UseMutationOptions<Response<void>, Error, AdminPostInvitesPayload>
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (payload: AdminPostInvitesPayload) => client.admin.invites.create(payload),
+    buildOptions(queryClient, adminInviteKeys.lists(), options)
+  )
+}
+
+export const useAdminDeleteInvite = (
+  id: string,
+  options?: UseMutationOptions<Response<AdminInviteDeleteRes>, Error, void>
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    () => client.admin.invites.delete(id),
+    buildOptions(
+      queryClient,
+      [adminInviteKeys.lists(), adminInviteKeys.detail(id)],
+      options
+    )
+  )
+}
@@ -0,0 +1,28 @@
+import { AdminListInvitesRes } from "@medusajs/medusa"
+import { Response } from "@medusajs/medusa-js"
+import { useQuery } from "react-query"
+import { useMedusa } from "../../../contexts"
+import { UseQueryOptionsWrapper } from "../../../types"
+import { queryKeysFactory } from "../../utils/index"
+
+const ADMIN_INVITES_QUERY_KEY = `admin_invites` as const
+
+export const adminInviteKeys = queryKeysFactory(ADMIN_INVITES_QUERY_KEY)
+
+type InviteQueryKeys = typeof adminInviteKeys
+
+export const useAdminInvites = (
+  options?: UseQueryOptionsWrapper<
+    Response<AdminListInvitesRes>,
+    Error,
+    ReturnType<InviteQueryKeys["lists"]>
+  >
+) => {
+  const { client } = useMedusa()
+  const { data, ...rest } = useQuery(
+    adminInviteKeys.lists(),
+    () => client.admin.invites.list(),
+    options
+  )
+  return { ...data, ...rest } as const
+}
@@ -0,0 +1,2 @@
+export * from "./queries"
+export * from "./mutations"
@@ -0,0 +1,64 @@
+import {
+  AdminNotesDeleteRes,
+  AdminNotesRes,
+  AdminPostNotesNoteReq,
+  AdminPostNotesReq,
+} from "@medusajs/medusa"
+import { Response } from "@medusajs/medusa-js"
+import { useMutation, UseMutationOptions, useQueryClient } from "react-query"
+import { adminNoteKeys } from "."
+import { useMedusa } from "../../../contexts/medusa"
+import { buildOptions } from "../../utils/buildOptions"
+
+export const useAdminCreateNote = (
+  options?: UseMutationOptions<
+    Response<AdminNotesRes>,
+    Error,
+    AdminPostNotesReq
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+  return useMutation(
+    (payload: AdminPostNotesReq) => client.admin.notes.create(payload),
+    buildOptions(queryClient, adminNoteKeys.lists(), options)
+  )
+}
+
+export const useAdminUpdateNote = (
+  id: string,
+  options?: UseMutationOptions<
+    Response<AdminNotesRes>,
+    Error,
+    AdminPostNotesNoteReq
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (payload: AdminPostNotesNoteReq) => client.admin.notes.update(id, payload),
+    buildOptions(
+      queryClient,
+      [adminNoteKeys.detail(id), adminNoteKeys.lists()],
+      options
+    )
+  )
+}
+
+export const useAdminDeleteNote = (
+  id: string,
+  options?: UseMutationOptions<Response<AdminNotesDeleteRes>, Error, void>
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    () => client.admin.notes.delete(id),
+    buildOptions(
+      queryClient,
+      [adminNoteKeys.detail(id), adminNoteKeys.lists()],
+      options
+    )
+  )
+}
@@ -0,0 +1,50 @@
+import {
+  AdminNotesListRes,
+  AdminNotesRes,
+  AdminGetNotesParams,
+} from "@medusajs/medusa"
+import { Response } from "@medusajs/medusa-js"
+import { useQuery } from "react-query"
+import { useMedusa } from "../../../contexts"
+import { UseQueryOptionsWrapper } from "../../../types"
+import { queryKeysFactory } from "../../utils/index"
+
+const ADMIN_NOTE_QUERY_KEY = `admin_notes` as const
+
+export const adminNoteKeys = queryKeysFactory(ADMIN_NOTE_QUERY_KEY)
+
+type NoteQueryKeys = typeof adminNoteKeys
+
+export const useAdminNotes = (
+  query?: AdminGetNotesParams,
+  options?: UseQueryOptionsWrapper<
+    Response<AdminNotesListRes>,
+    Error,
+    ReturnType<NoteQueryKeys["list"]>
+  >
+) => {
+  const { client } = useMedusa()
+  const { data, ...rest } = useQuery(
+    adminNoteKeys.list(query),
+    () => client.admin.notes.list(query),
+    options
+  )
+  return { ...data, ...rest } as const
+}
+
+export const useAdminNote = (
+  id: string,
+  options?: UseQueryOptionsWrapper<
+    Response<AdminNotesRes>,
+    Error,
+    ReturnType<NoteQueryKeys["detail"]>
+  >
+) => {
+  const { client } = useMedusa()
+  const { data, ...rest } = useQuery(
+    adminNoteKeys.detail(id),
+    () => client.admin.notes.retrieve(id),
+    options
+  )
+  return { ...data, ...rest } as const
+}
@@ -0,0 +1,2 @@
+export * from "./queries"
+export * from "./mutations"
@@ -0,0 +1,31 @@
+import {
+  AdminNotificationsRes,
+  AdminPostNotificationsNotificationResendReq,
+} from "@medusajs/medusa"
+import { Response } from "@medusajs/medusa-js"
+import { useMutation, UseMutationOptions, useQueryClient } from "react-query"
+import { useMedusa } from "../../../contexts/medusa"
+import { adminNotificationKeys } from "./queries"
+import { buildOptions } from "../../utils/buildOptions"
+
+export const useAdminResendNotification = (
+  id: string,
+  options?: UseMutationOptions<
+    Response<AdminNotificationsRes>,
+    Error,
+    AdminPostNotificationsNotificationResendReq
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (payload: AdminPostNotificationsNotificationResendReq) =>
+      client.admin.notifications.resend(id, payload),
+    buildOptions(
+      queryClient,
+      [adminNotificationKeys.lists(), adminNotificationKeys.detail(id)],
+      options
+    )
+  )
+}
@@ -0,0 +1,34 @@
+import {
+  AdminGetNotificationsParams,
+  AdminNotificationsListRes,
+} from "@medusajs/medusa"
+import { Response } from "@medusajs/medusa-js"
+import { useQuery } from "react-query"
+import { useMedusa } from "../../../contexts"
+import { UseQueryOptionsWrapper } from "../../../types"
+import { queryKeysFactory } from "../../utils/index"
+
+const ADMIN_NOTIFICATIONS_QUERY_KEY = `admin_notifications` as const
+
+export const adminNotificationKeys = queryKeysFactory(
+  ADMIN_NOTIFICATIONS_QUERY_KEY
+)
+
+type NotificationQueryKeys = typeof adminNotificationKeys
+
+export const useAdminNotifications = (
+  query?: AdminGetNotificationsParams,
+  options?: UseQueryOptionsWrapper<
+    Response<AdminNotificationsListRes>,
+    Error,
+    ReturnType<NotificationQueryKeys["list"]>
+  >
+) => {
+  const { client } = useMedusa()
+  const { data, ...rest } = useQuery(
+    adminNotificationKeys.list(query),
+    () => client.admin.notifications.list(query),
+    options
+  )
+  return { ...data, ...rest } as const
+}
@@ -0,0 +1,2 @@
+export * from "./queries"
+export * from "./mutations"
@@ -0,0 +1,249 @@
+import { adminOrderKeys } from "./queries"
+import {
+  AdminOrdersRes,
+  AdminPostOrdersOrderFulfillmentsReq,
+  AdminPostOrdersOrderRefundsReq,
+  AdminPostOrdersOrderReq,
+  AdminPostOrdersOrderReturnsReq,
+  AdminPostOrdersOrderShipmentReq,
+  AdminPostOrdersOrderShippingMethodsReq,
+  AdminPostOrdersReq,
+} from "@medusajs/medusa"
+import { Response } from "@medusajs/medusa-js"
+import { useMutation, UseMutationOptions, useQueryClient } from "react-query"
+import { useMedusa } from "../../../contexts/medusa"
+import { buildOptions } from "../../utils/buildOptions"
+
+export const useAdminCreateOrder = (
+  options?: UseMutationOptions<
+    Response<AdminOrdersRes>,
+    Error,
+    AdminPostOrdersReq
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+  return useMutation(
+    (payload: AdminPostOrdersReq) => client.admin.orders.create(payload),
+    buildOptions(queryClient, adminOrderKeys.lists(), options)
+  )
+}
+
+export const useAdminUpdateOrder = (
+  id: string,
+  options?: UseMutationOptions<
+    Response<AdminOrdersRes>,
+    Error,
+    AdminPostOrdersOrderReq
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (payload: AdminPostOrdersOrderReq) =>
+      client.admin.orders.update(id, payload),
+    buildOptions(
+      queryClient,
+      [adminOrderKeys.lists(), adminOrderKeys.detail(id)],
+      options
+    )
+  )
+}
+
+export const useAdminCancelOrder = (
+  id: string,
+  options?: UseMutationOptions<Response<AdminOrdersRes>, Error, void>
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    () => client.admin.orders.cancel(id),
+    buildOptions(
+      queryClient,
+      [adminOrderKeys.lists(), adminOrderKeys.detail(id)],
+      options
+    )
+  )
+}
+
+export const useAdminCompleteOrder = (
+  id: string,
+  options?: UseMutationOptions<Response<AdminOrdersRes>, Error, void>
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    () => client.admin.orders.complete(id),
+    buildOptions(
+      queryClient,
+      [adminOrderKeys.lists(), adminOrderKeys.detail(id)],
+      options
+    )
+  )
+}
+
+export const useAdminCapturePayment = (
+  id: string,
+  options?: UseMutationOptions<Response<AdminOrdersRes>, Error, void>
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    () => client.admin.orders.capturePayment(id),
+    buildOptions(
+      queryClient,
+      [adminOrderKeys.lists(), adminOrderKeys.detail(id)],
+      options
+    )
+  )
+}
+
+export const useAdminRefundPayment = (
+  id: string,
+  options?: UseMutationOptions<
+    Response<AdminOrdersRes>,
+    Error,
+    AdminPostOrdersOrderRefundsReq
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (payload: AdminPostOrdersOrderRefundsReq) =>
+      client.admin.orders.refundPayment(id, payload),
+    buildOptions(
+      queryClient,
+      [adminOrderKeys.lists(), adminOrderKeys.detail(id)],
+      options
+    )
+  )
+}
+
+export const useAdminCreateFulfillment = (
+  orderId: string,
+  options?: UseMutationOptions<
+    Response<AdminOrdersRes>,
+    Error,
+    AdminPostOrdersOrderFulfillmentsReq
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (payload: AdminPostOrdersOrderFulfillmentsReq) =>
+      client.admin.orders.createFulfillment(orderId, payload),
+    buildOptions(
+      queryClient,
+      [adminOrderKeys.lists(), adminOrderKeys.detail(orderId)],
+      options
+    )
+  )
+}
+
+export const useAdminCancelFulfillment = (
+  orderId: string,
+  options?: UseMutationOptions<Response<AdminOrdersRes>, Error, string>
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (fulfillmentId: string) =>
+      client.admin.orders.cancelFulfillment(orderId, fulfillmentId),
+    buildOptions(
+      queryClient,
+      [adminOrderKeys.lists(), adminOrderKeys.detail(orderId)],
+      options
+    )
+  )
+}
+
+export const useAdminCreateShipment = (
+  orderId: string,
+  options?: UseMutationOptions<
+    Response<AdminOrdersRes>,
+    Error,
+    AdminPostOrdersOrderShipmentReq
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (payload: AdminPostOrdersOrderShipmentReq) =>
+      client.admin.orders.createShipment(orderId, payload),
+    buildOptions(queryClient, adminOrderKeys.detail(orderId), options)
+  )
+}
+
+export const useAdminRequestReturn = (
+  orderId: string,
+  options?: UseMutationOptions<
+    Response<AdminOrdersRes>,
+    Error,
+    AdminPostOrdersOrderReturnsReq
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (payload: AdminPostOrdersOrderReturnsReq) =>
+      client.admin.orders.requestReturn(orderId, payload),
+    buildOptions(queryClient, adminOrderKeys.detail(orderId), options)
+  )
+}
+
+export const useAdminAddShippingMethod = (
+  orderId: string,
+  options?: UseMutationOptions<
+    Response<AdminOrdersRes>,
+    Error,
+    AdminPostOrdersOrderShippingMethodsReq
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (payload: AdminPostOrdersOrderShippingMethodsReq) =>
+      client.admin.orders.addShippingMethod(orderId, payload),
+    buildOptions(queryClient, adminOrderKeys.detail(orderId), options)
+  )
+}
+
+export const useAdminArchiveOrder = (
+  id: string,
+  options?: UseMutationOptions<Response<AdminOrdersRes>, Error, void>
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    () => client.admin.orders.archive(id),
+    buildOptions(
+      queryClient,
+      [adminOrderKeys.lists(), adminOrderKeys.detail(id)],
+      options
+    )
+  )
+}
+
+export const useAdminDeleteOrderMetadata = (
+  id: string,
+  options?: UseMutationOptions<Response<AdminOrdersRes>, Error, string>
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (key: string) => client.admin.orders.deleteMetadata(id, key),
+    buildOptions(queryClient, adminOrderKeys.detail(id), options)
+  )
+}
@@ -0,0 +1,50 @@
+import {
+  AdminOrdersListRes,
+  AdminOrdersRes,
+  AdminGetOrdersParams,
+} from "@medusajs/medusa"
+import { Response } from "@medusajs/medusa-js"
+import { useQuery } from "react-query"
+import { useMedusa } from "../../../contexts"
+import { UseQueryOptionsWrapper } from "../../../types"
+import { queryKeysFactory } from "../../utils/index"
+
+const ADMIN_ORDERS_QUERY_KEY = `admin_orders` as const
+
+export const adminOrderKeys = queryKeysFactory(ADMIN_ORDERS_QUERY_KEY)
+
+type OrderQueryKeys = typeof adminOrderKeys
+
+export const useAdminOrders = (
+  query?: AdminGetOrdersParams,
+  options?: UseQueryOptionsWrapper<
+    Response<AdminOrdersListRes>,
+    Error,
+    ReturnType<OrderQueryKeys["list"]>
+  >
+) => {
+  const { client } = useMedusa()
+  const { data, ...rest } = useQuery(
+    adminOrderKeys.list(query),
+    () => client.admin.orders.list(query),
+    options
+  )
+  return { ...data, ...rest } as const
+}
+
+export const useAdminOrder = (
+  id: string,
+  options?: UseQueryOptionsWrapper<
+    Response<AdminOrdersRes>,
+    Error,
+    ReturnType<OrderQueryKeys["detail"]>
+  >
+) => {
+  const { client } = useMedusa()
+  const { data, ...rest } = useQuery(
+    adminOrderKeys.detail(id),
+    () => client.admin.orders.retrieve(id),
+    options
+  )
+  return { ...data, ...rest } as const
+}
@@ -0,0 +1,2 @@
+export * from "./queries"
+export * from "./mutations"
@@ -0,0 +1,196 @@
+import { adminProductKeys } from "./queries"
+import {
+  AdminProductsDeleteRes,
+  AdminProductsRes,
+  AdminPostProductsProductReq,
+  AdminPostProductsReq,
+  AdminPostProductsProductVariantsReq,
+  AdminProductsDeleteVariantRes,
+  AdminPostProductsProductOptionsReq,
+  AdminPostProductsProductOptionsOption,
+  AdminProductsDeleteOptionRes,
+} from "@medusajs/medusa"
+import { Response } from "@medusajs/medusa-js"
+import { useMutation, UseMutationOptions, useQueryClient } from "react-query"
+import { useMedusa } from "../../../contexts/medusa"
+import { buildOptions } from "../../utils/buildOptions"
+
+export const useAdminCreateProduct = (
+  options?: UseMutationOptions<
+    Response<AdminProductsRes>,
+    Error,
+    AdminPostProductsReq
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+  return useMutation(
+    (payload: AdminPostProductsReq) => client.admin.products.create(payload),
+    buildOptions(queryClient, adminProductKeys.lists(), options)
+  )
+}
+
+export const useAdminUpdateProduct = (
+  id: string,
+  options?: UseMutationOptions<
+    Response<AdminProductsRes>,
+    Error,
+    AdminPostProductsProductReq
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (payload: AdminPostProductsProductReq) =>
+      client.admin.products.update(id, payload),
+    buildOptions(
+      queryClient,
+      [adminProductKeys.lists(), adminProductKeys.detail(id)],
+      options
+    )
+  )
+}
+
+export const useAdminDeleteProduct = (
+  id: string,
+  options?: UseMutationOptions<Response<AdminProductsDeleteRes>, Error, void>
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    () => client.admin.products.delete(id),
+    buildOptions(
+      queryClient,
+      [adminProductKeys.lists(), adminProductKeys.detail(id)],
+      options
+    )
+  )
+}
+
+export const useAdminCreateVariant = (
+  productId: string,
+  options?: UseMutationOptions<
+    Response<AdminProductsRes>,
+    Error,
+    AdminPostProductsProductVariantsReq
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (payload: AdminPostProductsProductVariantsReq) =>
+      client.admin.products.createVariant(productId, payload),
+    buildOptions(
+      queryClient,
+      [adminProductKeys.lists(), adminProductKeys.detail(productId)],
+      options
+    )
+  )
+}
+
+export const useAdminUpdateVariant = (
+  productId: string,
+  options?: UseMutationOptions<
+    Response<AdminProductsRes>,
+    Error,
+    AdminPostProductsProductVariantsReq & { variant_id: string }
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    ({
+      variant_id,
+      ...payload
+    }: AdminPostProductsProductVariantsReq & { variant_id: string }) =>
+      client.admin.products.updateVariant(productId, variant_id, payload),
+    buildOptions(
+      queryClient,
+      [adminProductKeys.lists(), adminProductKeys.detail(productId)],
+      options
+    )
+  )
+}
+
+export const useAdminDeleteVariant = (
+  productId: string,
+  options?: UseMutationOptions<
+    Response<AdminProductsDeleteVariantRes>,
+    Error,
+    string
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (variantId: string) =>
+      client.admin.products.deleteVariant(productId, variantId),
+    buildOptions(
+      queryClient,
+      [adminProductKeys.lists(), adminProductKeys.detail(productId)],
+      options
+    )
+  )
+}
+
+export const useAdminCreateProductOption = (
+  productId: string,
+  options?: UseMutationOptions<
+    Response<AdminProductsRes>,
+    Error,
+    AdminPostProductsProductOptionsReq
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (payload: AdminPostProductsProductOptionsReq) =>
+      client.admin.products.addOption(productId, payload),
+    buildOptions(queryClient, adminProductKeys.detail(productId), options)
+  )
+}
+
+export const useAdminUpdateProductOption = (
+  productId: string,
+  options?: UseMutationOptions<
+    Response<AdminProductsRes>,
+    Error,
+    AdminPostProductsProductOptionsOption & { option_id: string }
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    ({
+      option_id,
+      ...payload
+    }: AdminPostProductsProductOptionsOption & { option_id: string }) =>
+      client.admin.products.updateOption(productId, option_id, payload),
+    buildOptions(queryClient, adminProductKeys.detail(productId), options)
+  )
+}
+
+export const useAdminDeleteProductOption = (
+  productId: string,
+  options?: UseMutationOptions<
+    Response<AdminProductsDeleteOptionRes>,
+    Error,
+    string
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (optionId: string) =>
+      client.admin.products.deleteOption(productId, optionId),
+    buildOptions(queryClient, adminProductKeys.detail(productId), options)
+  )
+}
@@ -0,0 +1,84 @@
+import {
+  AdminProductsListRes,
+  AdminProductsRes,
+  AdminGetProductsParams,
+  AdminProductsListTypesRes,
+  AdminProductsListTagsRes,
+} from "@medusajs/medusa"
+import { Response } from "@medusajs/medusa-js"
+import { useQuery } from "react-query"
+import { useMedusa } from "../../../contexts"
+import { UseQueryOptionsWrapper } from "../../../types"
+import { queryKeysFactory } from "../../utils/index"
+
+const ADMIN_PRODUCTS_QUERY_KEY = `admin_products` as const
+
+export const adminProductKeys = queryKeysFactory(ADMIN_PRODUCTS_QUERY_KEY)
+
+type ProductQueryKeys = typeof adminProductKeys
+
+export const useAdminProducts = (
+  query?: AdminGetProductsParams,
+  options?: UseQueryOptionsWrapper<
+    Response<AdminProductsListRes>,
+    Error,
+    ReturnType<ProductQueryKeys["list"]>
+  >
+) => {
+  const { client } = useMedusa()
+  const { data, ...rest } = useQuery(
+    adminProductKeys.list(query),
+    () => client.admin.products.list(query),
+    options
+  )
+  return { ...data, ...rest } as const
+}
+
+export const useAdminProduct = (
+  id: string,
+  options?: UseQueryOptionsWrapper<
+    Response<AdminProductsRes>,
+    Error,
+    ReturnType<ProductQueryKeys["detail"]>
+  >
+) => {
+  const { client } = useMedusa()
+  const { data, ...rest } = useQuery(
+    adminProductKeys.detail(id),
+    () => client.admin.products.retrieve(id),
+    options
+  )
+  return { ...data, ...rest } as const
+}
+
+export const useAdminProductTypes = (
+  options?: UseQueryOptionsWrapper<
+    Response<AdminProductsListTypesRes>,
+    Error,
+    ReturnType<ProductQueryKeys["detail"]>
+  >
+) => {
+  const { client } = useMedusa()
+  const { data, ...rest } = useQuery(
+    adminProductKeys.detail("types"),
+    () => client.admin.products.listTypes(),
+    options
+  )
+  return { ...data, ...rest } as const
+}
+
+export const useAdminProductTags = (
+  options?: UseQueryOptionsWrapper<
+    Response<AdminProductsListTagsRes>,
+    Error,
+    ReturnType<ProductQueryKeys["detail"]>
+  >
+) => {
+  const { client } = useMedusa()
+  const { data, ...rest } = useQuery(
+    adminProductKeys.detail("tags"),
+    () => client.admin.products.listTags(),
+    options
+  )
+  return { ...data, ...rest } as const
+}
@@ -0,0 +1,2 @@
+export * from "./queries"
+export * from "./mutations"
@@ -0,0 +1,197 @@
+import { adminRegionKeys } from "./queries"
+import {
+  AdminRegionsDeleteRes,
+  AdminRegionsRes,
+  AdminPostRegionsRegionReq,
+  AdminPostRegionsReq,
+  AdminPostRegionsRegionMetadata,
+  AdminPostRegionsRegionCountriesReq,
+  AdminPostRegionsRegionFulfillmentProvidersReq,
+  AdminPostRegionsRegionPaymentProvidersReq,
+} from "@medusajs/medusa"
+import { Response } from "@medusajs/medusa-js"
+import { useMutation, UseMutationOptions, useQueryClient } from "react-query"
+import { useMedusa } from "../../../contexts/medusa"
+import { buildOptions } from "../../utils/buildOptions"
+
+export const useAdminCreateRegion = (
+  options?: UseMutationOptions<
+    Response<AdminRegionsRes>,
+    Error,
+    AdminPostRegionsReq
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (payload: AdminPostRegionsReq) => client.admin.regions.create(payload),
+    buildOptions(queryClient, adminRegionKeys.lists(), options)
+  )
+}
+
+export const useAdminUpdateRegion = (
+  id: string,
+  options?: UseMutationOptions<
+    Response<AdminRegionsRes>,
+    Error,
+    AdminPostRegionsRegionReq
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (payload: AdminPostRegionsRegionReq) =>
+      client.admin.regions.update(id, payload),
+    buildOptions(
+      queryClient,
+      [adminRegionKeys.lists(), adminRegionKeys.detail(id)],
+      options
+    )
+  )
+}
+
+export const useAdminDeleteRegion = (
+  id: string,
+  options?: UseMutationOptions<Response<AdminRegionsDeleteRes>, Error, void>
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    () => client.admin.regions.delete(id),
+    buildOptions(
+      queryClient,
+      [adminRegionKeys.lists(), adminRegionKeys.detail(id)],
+      options
+    )
+  )
+}
+
+export const useAdminSetRegionMetadata = (
+  id: string,
+  options?: UseMutationOptions<
+    Response<AdminRegionsRes>,
+    Error,
+    AdminPostRegionsRegionMetadata
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (metadata: AdminPostRegionsRegionMetadata) =>
+      client.admin.regions.setMetadata(id, metadata),
+    buildOptions(queryClient, adminRegionKeys.detail(id), options)
+  )
+}
+
+export const useAdminDeleteRegionMetadata = (
+  id: string,
+  options?: UseMutationOptions<Response<AdminRegionsRes>, Error, string>
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (key: string) => client.admin.regions.deleteMetadata(id, key),
+    buildOptions(queryClient, adminRegionKeys.detail(id), options)
+  )
+}
+
+export const useAdminRegionAddCountry = (
+  id: string,
+  options?: UseMutationOptions<
+    Response<AdminRegionsRes>,
+    Error,
+    AdminPostRegionsRegionCountriesReq
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (payload: AdminPostRegionsRegionCountriesReq) =>
+      client.admin.regions.addCountry(id, payload),
+    buildOptions(queryClient, adminRegionKeys.detail(id), options)
+  )
+}
+
+export const useAdminRegionRemoveCountry = (
+  id: string,
+  options?: UseMutationOptions<Response<AdminRegionsRes>, Error, string>
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (country_code: string) =>
+      client.admin.regions.deleteCountry(id, country_code),
+    buildOptions(queryClient, adminRegionKeys.detail(id), options)
+  )
+}
+
+export const useAdminRegionAddFulfillmentProvider = (
+  id: string,
+  options?: UseMutationOptions<
+    Response<AdminRegionsRes>,
+    Error,
+    AdminPostRegionsRegionFulfillmentProvidersReq
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (payload: AdminPostRegionsRegionFulfillmentProvidersReq) =>
+      client.admin.regions.addFulfillmentProvider(id, payload),
+    buildOptions(queryClient, adminRegionKeys.detail(id), options)
+  )
+}
+
+export const useAdminRegionDeleteFulfillmentProvider = (
+  id: string,
+  options?: UseMutationOptions<Response<AdminRegionsRes>, Error, string>
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (provider_id: string) =>
+      client.admin.regions.deleteFulfillmentProvider(id, provider_id),
+    buildOptions(queryClient, adminRegionKeys.detail(id), options)
+  )
+}
+
+export const useAdminRegionAddPaymentProvider = (
+  id: string,
+  options?: UseMutationOptions<
+    Response<AdminRegionsRes>,
+    Error,
+    AdminPostRegionsRegionPaymentProvidersReq
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (payload: AdminPostRegionsRegionPaymentProvidersReq) =>
+      client.admin.regions.addPaymentProvider(id, payload),
+    buildOptions(queryClient, adminRegionKeys.detail(id), options)
+  )
+}
+
+export const useAdminRegionDeletePaymentProvider = (
+  id: string,
+  options?: UseMutationOptions<Response<AdminRegionsRes>, Error, string>
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (provider_id: string) =>
+      client.admin.regions.deletePaymentProvider(id, provider_id),
+    buildOptions(queryClient, adminRegionKeys.detail(id), options)
+  )
+}
@@ -0,0 +1,68 @@
+import {
+  AdminRegionsListRes,
+  AdminRegionsRes,
+  AdminGetRegionsParams,
+  AdminGetRegionsRegionFulfillmentOptionsRes,
+} from "@medusajs/medusa"
+import { Response } from "@medusajs/medusa-js"
+import { useQuery } from "react-query"
+import { useMedusa } from "../../../contexts"
+import { UseQueryOptionsWrapper } from "../../../types"
+import { queryKeysFactory } from "../../utils/index"
+
+const ADMIN_REGIONS_QUERY_KEY = `admin_regions` as const
+
+export const adminRegionKeys = queryKeysFactory(ADMIN_REGIONS_QUERY_KEY)
+
+type RegionQueryKeys = typeof adminRegionKeys
+
+export const useAdminRegions = (
+  query?: AdminGetRegionsParams,
+  options?: UseQueryOptionsWrapper<
+    Response<AdminRegionsListRes>,
+    Error,
+    ReturnType<RegionQueryKeys["list"]>
+  >
+) => {
+  const { client } = useMedusa()
+  const { data, ...rest } = useQuery(
+    adminRegionKeys.list(query),
+    () => client.admin.regions.list(query),
+    options
+  )
+  return { ...data, ...rest } as const
+}
+
+export const useAdminRegion = (
+  id: string,
+  options?: UseQueryOptionsWrapper<
+    Response<AdminRegionsRes>,
+    Error,
+    ReturnType<RegionQueryKeys["detail"]>
+  >
+) => {
+  const { client } = useMedusa()
+  const { data, ...rest } = useQuery(
+    adminRegionKeys.detail(id),
+    () => client.admin.regions.retrieve(id),
+    options
+  )
+  return { ...data, ...rest } as const
+}
+
+export const useAdminRegionFulfillmentOptions = (
+  regionId: string,
+  options?: UseQueryOptionsWrapper<
+    Response<AdminGetRegionsRegionFulfillmentOptionsRes>,
+    Error,
+    ReturnType<RegionQueryKeys["detail"]>
+  >
+) => {
+  const { client } = useMedusa()
+  const { data, ...rest } = useQuery(
+    adminRegionKeys.detail(`${regionId}_fullfillment-options`),
+    () => client.admin.regions.retrieveFulfillmentOptions(regionId),
+    options
+  )
+  return { ...data, ...rest } as const
+}
@@ -0,0 +1,2 @@
+export * from "./queries"
+export * from "./mutations"
@@ -0,0 +1,66 @@
+import {
+  AdminPostReturnReasonsReasonReq,
+  AdminPostReturnReasonsReq,
+  AdminReturnReasonsRes,
+} from "@medusajs/medusa"
+import { Response } from "@medusajs/medusa-js"
+import { useMutation, UseMutationOptions, useQueryClient } from "react-query"
+import { adminReturnReasonKeys } from "."
+import { useMedusa } from "../../../contexts/medusa"
+import { buildOptions } from "../../utils/buildOptions"
+
+export const useAdminCreateReturnReason = (
+  options?: UseMutationOptions<
+    Response<AdminReturnReasonsRes>,
+    Error,
+    AdminPostReturnReasonsReq
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (payload: AdminPostReturnReasonsReq) =>
+      client.admin.returnReasons.create(payload),
+    buildOptions(queryClient, adminReturnReasonKeys.lists(), options)
+  )
+}
+
+export const useAdminUpdateReturnReason = (
+  id: string,
+  options?: UseMutationOptions<
+    Response<AdminReturnReasonsRes>,
+    Error,
+    AdminPostReturnReasonsReasonReq
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (payload: AdminPostReturnReasonsReasonReq) =>
+      client.admin.returnReasons.update(id, payload),
+    buildOptions(
+      queryClient,
+      [adminReturnReasonKeys.detail(id), adminReturnReasonKeys.lists()],
+      options
+    )
+  )
+}
+
+export const useAdminDeleteReturnReason = (
+  id: string,
+  options?: UseMutationOptions
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    () => client.admin.returnReasons.delete(id),
+    buildOptions(
+      queryClient,
+      [adminReturnReasonKeys.detail(id), adminReturnReasonKeys.lists()],
+      options
+    )
+  )
+}
@@ -0,0 +1,50 @@
+import {
+  AdminReturnReasonsListRes,
+  AdminReturnReasonsRes,
+} from "@medusajs/medusa"
+import { Response } from "@medusajs/medusa-js"
+import { useQuery } from "react-query"
+import { useMedusa } from "../../../contexts"
+import { UseQueryOptionsWrapper } from "../../../types"
+import { queryKeysFactory } from "../../utils/index"
+
+const ADMIN_RETURNS_REASONS_QUERY_KEY = `admin_return_reasons` as const
+
+export const adminReturnReasonKeys = queryKeysFactory(
+  ADMIN_RETURNS_REASONS_QUERY_KEY
+)
+
+type ReturnReasonQueryKeys = typeof adminReturnReasonKeys
+
+export const useAdminReturnReasons = (
+  options?: UseQueryOptionsWrapper<
+    Response<AdminReturnReasonsListRes>,
+    Error,
+    ReturnType<ReturnReasonQueryKeys["lists"]>
+  >
+) => {
+  const { client } = useMedusa()
+  const { data, ...rest } = useQuery(
+    adminReturnReasonKeys.lists(),
+    () => client.admin.returnReasons.list(),
+    options
+  )
+  return { ...data, ...rest } as const
+}
+
+export const useAdminReturnReason = (
+  id: string,
+  options?: UseQueryOptionsWrapper<
+    Response<AdminReturnReasonsRes>,
+    Error,
+    ReturnType<ReturnReasonQueryKeys["detail"]>
+  >
+) => {
+  const { client } = useMedusa()
+  const { data, ...rest } = useQuery(
+    adminReturnReasonKeys.detail(id),
+    () => client.admin.returnReasons.retrieve(id),
+    options
+  )
+  return { ...data, ...rest } as const
+}
@@ -0,0 +1,2 @@
+export * from "./queries"
+export * from "./mutations"
@@ -0,0 +1,40 @@
+import { AdminReturnsCancelRes, AdminReturnsRes } from "@medusajs/medusa"
+import { Response } from "@medusajs/medusa-js"
+import { useMutation, UseMutationOptions, useQueryClient } from "react-query"
+import { useMedusa } from "../../../contexts/medusa"
+import { buildOptions } from "../../utils/buildOptions"
+import { adminReturnKeys } from "./queries"
+
+export const useAdminReceiveReturn = (
+  id: string,
+  options?: UseMutationOptions<Response<AdminReturnsRes>, Error, void>
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    () => client.admin.returns.receive(id),
+    buildOptions(
+      queryClient,
+      [adminReturnKeys.detail(id), adminReturnKeys.list()],
+      options
+    )
+  )
+}
+
+export const useAdminCancelReturn = (
+  id: string,
+  options?: UseMutationOptions<Response<AdminReturnsCancelRes>, Error, void>
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    () => client.admin.returns.cancel(id),
+    buildOptions(
+      queryClient,
+      [adminReturnKeys.detail(id), adminReturnKeys.list()],
+      options
+    )
+  )
+}
@@ -0,0 +1,28 @@
+import { AdminReturnsListRes } from "@medusajs/medusa"
+import { Response } from "@medusajs/medusa-js"
+import { useQuery } from "react-query"
+import { useMedusa } from "../../../contexts"
+import { UseQueryOptionsWrapper } from "../../../types"
+import { queryKeysFactory } from "../../utils/index"
+
+const ADMIN_RETURNS_QUERY_KEY = `admin_returns` as const
+
+export const adminReturnKeys = queryKeysFactory(ADMIN_RETURNS_QUERY_KEY)
+
+type ReturnQueryKeys = typeof adminReturnKeys
+
+export const useAdminReturns = (
+  options?: UseQueryOptionsWrapper<
+    Response<AdminReturnsListRes>,
+    Error,
+    ReturnType<ReturnQueryKeys["lists"]>
+  >
+) => {
+  const { client } = useMedusa()
+  const { data, ...rest } = useQuery(
+    adminReturnKeys.lists(),
+    () => client.admin.returns.list(),
+    options
+  )
+  return { ...data, ...rest } as const
+}
@@ -0,0 +1,2 @@
+export * from "./queries"
+export * from "./mutations"
@@ -0,0 +1,66 @@
+import { adminShippingOptionKeys } from "./queries"
+import {
+  AdminPostShippingOptionsOptionReq,
+  AdminPostShippingOptionsReq,
+  AdminShippingOptionsRes,
+} from "@medusajs/medusa"
+import { Response } from "@medusajs/medusa-js"
+import { useMutation, UseMutationOptions, useQueryClient } from "react-query"
+import { useMedusa } from "../../../contexts/medusa"
+import { buildOptions } from "../../utils/buildOptions"
+
+export const useAdminCreateShippingOption = (
+  options?: UseMutationOptions<
+    Response<AdminShippingOptionsRes>,
+    Error,
+    AdminPostShippingOptionsReq
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (payload: AdminPostShippingOptionsReq) =>
+      client.admin.shippingOptions.create(payload),
+    buildOptions(queryClient, adminShippingOptionKeys.lists(), options)
+  )
+}
+
+export const useAdminUpdateShippingOption = (
+  id: string,
+  options?: UseMutationOptions<
+    Response<AdminShippingOptionsRes>,
+    Error,
+    AdminPostShippingOptionsOptionReq
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (payload: AdminPostShippingOptionsOptionReq) =>
+      client.admin.shippingOptions.update(id, payload),
+    buildOptions(
+      queryClient,
+      [adminShippingOptionKeys.lists(), adminShippingOptionKeys.detail(id)],
+      options
+    )
+  )
+}
+
+export const useAdminDeleteShippingOption = (
+  id: string,
+  options?: UseMutationOptions
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    () => client.admin.shippingOptions.delete(id),
+    buildOptions(
+      queryClient,
+      [adminShippingOptionKeys.lists(), adminShippingOptionKeys.detail(id)],
+      options
+    )
+  )
+}
@@ -0,0 +1,52 @@
+import {
+  AdminGetShippingOptionsParams,
+  AdminShippingOptionsListRes,
+  AdminShippingOptionsRes,
+} from "@medusajs/medusa"
+import { Response } from "@medusajs/medusa-js"
+import { useQuery } from "react-query"
+import { useMedusa } from "../../../contexts"
+import { UseQueryOptionsWrapper } from "../../../types"
+import { queryKeysFactory } from "../../utils/index"
+
+const ADMIN_SHIPPING_OPTIONS_QUERY_KEY = `admin_shipping_options` as const
+
+export const adminShippingOptionKeys = queryKeysFactory(
+  ADMIN_SHIPPING_OPTIONS_QUERY_KEY
+)
+
+type ShippingOptionQueryKeys = typeof adminShippingOptionKeys
+
+export const useAdminShippingOptions = (
+  query?: AdminGetShippingOptionsParams,
+  options?: UseQueryOptionsWrapper<
+    Response<AdminShippingOptionsListRes>,
+    Error,
+    ReturnType<ShippingOptionQueryKeys["list"]>
+  >
+) => {
+  const { client } = useMedusa()
+  const { data, ...rest } = useQuery(
+    adminShippingOptionKeys.list(query),
+    () => client.admin.shippingOptions.list(query),
+    options
+  )
+  return { ...data, ...rest } as const
+}
+
+export const useAdminShippingOption = (
+  id: string,
+  options?: UseQueryOptionsWrapper<
+    Response<AdminShippingOptionsRes>,
+    Error,
+    ReturnType<ShippingOptionQueryKeys["detail"]>
+  >
+) => {
+  const { client } = useMedusa()
+  const { data, ...rest } = useQuery(
+    adminShippingOptionKeys.detail(id),
+    () => client.admin.shippingOptions.retrieve(id),
+    options
+  )
+  return { ...data, ...rest } as const
+}
@@ -0,0 +1,2 @@
+export * from "./queries"
+export * from "./mutations"
@@ -0,0 +1,69 @@
+import { adminShippingProfileKeys } from "./queries"
+import {
+  AdminDeleteShippingProfileRes,
+  AdminPostShippingProfilesReq,
+  AdminShippingProfilesRes,
+} from "@medusajs/medusa"
+import { Response } from "@medusajs/medusa-js"
+import { useMutation, UseMutationOptions, useQueryClient } from "react-query"
+import { useMedusa } from "../../../contexts/medusa"
+import { buildOptions } from "../../utils/buildOptions"
+
+export const useAdminCreateShippingProfile = (
+  options?: UseMutationOptions<
+    Response<AdminShippingProfilesRes>,
+    Error,
+    AdminPostShippingProfilesReq
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+  return useMutation(
+    (payload: AdminPostShippingProfilesReq) =>
+      client.admin.shippingProfiles.create(payload),
+    buildOptions(queryClient, adminShippingProfileKeys.lists(), options)
+  )
+}
+
+export const useAdminUpdateShippingProfile = (
+  id: string,
+  options?: UseMutationOptions<
+    Response<AdminShippingProfilesRes>,
+    Error,
+    AdminPostShippingProfilesReq
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (payload: AdminPostShippingProfilesReq) =>
+      client.admin.shippingProfiles.update(id, payload),
+    buildOptions(
+      queryClient,
+      [adminShippingProfileKeys.lists(), adminShippingProfileKeys.detail(id)],
+      options
+    )
+  )
+}
+
+export const useAdminDeleteShippingProfile = (
+  id: string,
+  options?: UseMutationOptions<
+    Response<AdminDeleteShippingProfileRes>,
+    Error,
+    void
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    () => client.admin.shippingProfiles.delete(id),
+    buildOptions(
+      queryClient,
+      [adminShippingProfileKeys.lists(), adminShippingProfileKeys.detail(id)],
+      options
+    )
+  )
+}
@@ -0,0 +1,50 @@
+import {
+  AdminShippingProfilesListRes,
+  AdminShippingProfilesRes,
+} from "@medusajs/medusa"
+import { Response } from "@medusajs/medusa-js"
+import { useQuery } from "react-query"
+import { useMedusa } from "../../../contexts"
+import { UseQueryOptionsWrapper } from "../../../types"
+import { queryKeysFactory } from "../../utils/index"
+
+const ADMIN_COLLECTIONS_QUERY_KEY = `admin_shippingProfiles` as const
+
+export const adminShippingProfileKeys = queryKeysFactory(
+  ADMIN_COLLECTIONS_QUERY_KEY
+)
+
+type ShippingProfileQueryKeys = typeof adminShippingProfileKeys
+
+export const useAdminShippingProfiles = (
+  options?: UseQueryOptionsWrapper<
+    Response<AdminShippingProfilesListRes>,
+    Error,
+    ReturnType<ShippingProfileQueryKeys["lists"]>
+  >
+) => {
+  const { client } = useMedusa()
+  const { data, ...rest } = useQuery(
+    adminShippingProfileKeys.lists(),
+    () => client.admin.shippingProfiles.list(),
+    options
+  )
+  return { ...data, ...rest } as const
+}
+
+export const useAdminShippingProfile = (
+  id: string,
+  options?: UseQueryOptionsWrapper<
+    Response<AdminShippingProfilesRes>,
+    Error,
+    ReturnType<ShippingProfileQueryKeys["detail"]>
+  >
+) => {
+  const { client } = useMedusa()
+  const { data, ...rest } = useQuery(
+    adminShippingProfileKeys.detail(id),
+    () => client.admin.shippingProfiles.retrieve(id),
+    options
+  )
+  return { ...data, ...rest } as const
+}
@@ -0,0 +1,2 @@
+export * from "./queries"
+export * from "./mutations"
@@ -0,0 +1,46 @@
+import { adminStoreKeys } from "./queries"
+import { AdminPostStoreReq, AdminStoresRes } from "@medusajs/medusa"
+import { Response } from "@medusajs/medusa-js"
+import { useMutation, UseMutationOptions, useQueryClient } from "react-query"
+import { useMedusa } from "../../../contexts/medusa"
+import { buildOptions } from "../../utils/buildOptions"
+
+export const useAdminUpdateStore = (
+  options?: UseMutationOptions<
+    Response<AdminStoresRes>,
+    Error,
+    AdminPostStoreReq
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (payload: AdminPostStoreReq) => client.admin.store.update(payload),
+    buildOptions(queryClient, adminStoreKeys.details(), options)
+  )
+}
+
+export const useAdminAddStoreCurrency = (
+  options?: UseMutationOptions<Response<AdminStoresRes>, Error, string>
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (currency_code: string) => client.admin.store.deleteCurrency(currency_code),
+    buildOptions(queryClient, adminStoreKeys.details(), options)
+  )
+}
+
+export const useAdminDeleteStoreCurrency = (
+  options?: UseMutationOptions<Response<AdminStoresRes>, Error, string>
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (currency_code: string) => client.admin.store.deleteCurrency(currency_code),
+    buildOptions(queryClient, adminStoreKeys.details(), options)
+  )
+}
@@ -0,0 +1,44 @@
+import { AdminPaymentProvidersList, AdminStoresRes } from "@medusajs/medusa"
+import { Response } from "@medusajs/medusa-js"
+import { useQuery } from "react-query"
+import { useMedusa } from "../../../contexts"
+import { UseQueryOptionsWrapper } from "../../../types"
+import { queryKeysFactory } from "../../utils/index"
+
+const ADMIN_STORE_QUERY_KEY = `admin_store` as const
+
+export const adminStoreKeys = queryKeysFactory(ADMIN_STORE_QUERY_KEY)
+
+type StoreQueryKeys = typeof adminStoreKeys
+
+export const useAdminStorePaymentProviders = (
+  options?: UseQueryOptionsWrapper<
+    Response<AdminPaymentProvidersList>,
+    Error,
+    ReturnType<StoreQueryKeys["detail"]>
+  >
+) => {
+  const { client } = useMedusa()
+  const { data, ...rest } = useQuery(
+    adminStoreKeys.detail("payment_providers"),
+    () => client.admin.store.listPaymentProviders(),
+    options
+  )
+  return { ...data, ...rest } as const
+}
+
+export const useAdminStore = (
+  options?: UseQueryOptionsWrapper<
+    Response<AdminStoresRes>,
+    Error,
+    ReturnType<StoreQueryKeys["details"]>
+  >
+) => {
+  const { client } = useMedusa()
+  const { data, ...rest } = useQuery(
+    adminStoreKeys.details(),
+    () => client.admin.store.retrieve(),
+    options
+  )
+  return { ...data, ...rest } as const
+}
@@ -0,0 +1,2 @@
+export * from "./queries"
+export * from "./mutations"
@@ -0,0 +1,171 @@
+import { adminSwapKeys } from "./queries"
+import {
+  AdminOrdersRes,
+  AdminPostOrdersOrderSwapsReq,
+  AdminPostOrdersOrderSwapsSwapFulfillmentsReq,
+  AdminPostOrdersOrderSwapsSwapReceiveReq,
+  AdminPostOrdersOrderSwapsSwapShipmentsReq,
+} from "@medusajs/medusa"
+import { Response } from "@medusajs/medusa-js"
+import { useMutation, UseMutationOptions, useQueryClient } from "react-query"
+import { adminOrderKeys } from ".."
+import { useMedusa } from "../../../contexts/medusa"
+import { buildOptions } from "../../utils/buildOptions"
+
+export const useAdminCreateSwap = (
+  orderId: string,
+  options?: UseMutationOptions<
+    Response<AdminOrdersRes>,
+    Error,
+    AdminPostOrdersOrderSwapsReq
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+  return useMutation(
+    (payload: AdminPostOrdersOrderSwapsReq) =>
+      client.admin.orders.createSwap(orderId, payload),
+    buildOptions(
+      queryClient,
+      [adminOrderKeys.detail(orderId), adminSwapKeys.lists()],
+      options
+    )
+  )
+}
+
+export const useAdminCancelSwap = (
+  orderId: string,
+  options?: UseMutationOptions<Response<AdminOrdersRes>, Error, string>
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (swapId: string) => client.admin.orders.cancelSwap(orderId, swapId),
+    buildOptions(
+      queryClient,
+      [adminOrderKeys.detail(orderId), adminSwapKeys.lists()],
+      options
+    )
+  )
+}
+
+export const useAdminReceiveSwap = (
+  orderId: string,
+  options?: UseMutationOptions<
+    Response<AdminOrdersRes>,
+    Error,
+    AdminPostOrdersOrderSwapsSwapReceiveReq & { swap_id: string }
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    ({
+      swap_id,
+      ...payload
+    }: AdminPostOrdersOrderSwapsSwapReceiveReq & { swap_id: string }) =>
+      client.admin.orders.receiveSwap(orderId, swap_id, payload),
+    buildOptions(
+      queryClient,
+      [adminOrderKeys.detail(orderId), adminSwapKeys.lists()],
+      options
+    )
+  )
+}
+
+export const useAdminFulfillSwap = (
+  orderId: string,
+  options?: UseMutationOptions<
+    Response<AdminOrdersRes>,
+    Error,
+    AdminPostOrdersOrderSwapsSwapFulfillmentsReq & { swap_id: string }
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    ({
+      swap_id,
+      ...payload
+    }: AdminPostOrdersOrderSwapsSwapFulfillmentsReq & { swap_id: string }) =>
+      client.admin.orders.fulfillSwap(orderId, swap_id, payload),
+    buildOptions(
+      queryClient,
+      [adminOrderKeys.detail(orderId), adminSwapKeys.lists()],
+      options
+    )
+  )
+}
+
+export const useAdminCreateSwapShipment = (
+  orderId: string,
+  options?: UseMutationOptions<
+    Response<AdminOrdersRes>,
+    Error,
+    AdminPostOrdersOrderSwapsSwapShipmentsReq & { swap_id: string }
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    ({
+      swap_id,
+      ...payload
+    }: AdminPostOrdersOrderSwapsSwapShipmentsReq & { swap_id: string }) =>
+      client.admin.orders.createSwapShipment(orderId, swap_id, payload),
+    buildOptions(queryClient, adminOrderKeys.detail(orderId), options)
+  )
+}
+
+export const useAdminProcessSwapPayment = (
+  orderId: string,
+  options?: UseMutationOptions<Response<AdminOrdersRes>, Error, string>
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (swapId: string) => client.admin.orders.processSwapPayment(orderId, swapId),
+    buildOptions(
+      queryClient,
+      [adminOrderKeys.detail(orderId), adminSwapKeys.lists()],
+      options
+    )
+  )
+}
+
+export const useAdminCancelSwapFulfillment = (
+  orderId: string,
+  options?: UseMutationOptions<
+    Response<AdminOrdersRes>,
+    Error,
+    { swap_id: string; fulfillment_id: string }
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    ({
+      swap_id,
+      fulfillment_id,
+    }: {
+      swap_id: string
+      fulfillment_id: string
+    }) =>
+      client.admin.orders.cancelSwapFulfillment(
+        orderId,
+        swap_id,
+        fulfillment_id
+      ),
+    buildOptions(
+      queryClient,
+      [adminOrderKeys.detail(orderId), adminSwapKeys.lists()],
+      options
+    )
+  )
+}
@@ -0,0 +1,50 @@
+import {
+  AdminSwapsListRes,
+  AdminSwapsRes,
+  AdminGetSwapsParams,
+} from "@medusajs/medusa"
+import { Response } from "@medusajs/medusa-js"
+import { useQuery } from "react-query"
+import { useMedusa } from "../../../contexts"
+import { UseQueryOptionsWrapper } from "../../../types"
+import { queryKeysFactory } from "../../utils/index"
+
+const ADMIN_SWAPS_QUERY_KEY = `admin_swaps` as const
+
+export const adminSwapKeys = queryKeysFactory(ADMIN_SWAPS_QUERY_KEY)
+
+type SwapsQueryKey = typeof adminSwapKeys
+
+export const useAdminSwaps = (
+  query?: AdminGetSwapsParams,
+  options?: UseQueryOptionsWrapper<
+    Response<AdminSwapsListRes>,
+    Error,
+    ReturnType<SwapsQueryKey["list"]>
+  >
+) => {
+  const { client } = useMedusa()
+  const { data, ...rest } = useQuery(
+    adminSwapKeys.list(query),
+    () => client.admin.swaps.list(query),
+    options
+  )
+  return { ...data, ...rest } as const
+}
+
+export const useAdminSwap = (
+  id: string,
+  options?: UseQueryOptionsWrapper<
+    Response<AdminSwapsRes>,
+    Error,
+    ReturnType<SwapsQueryKey["detail"]>
+  >
+) => {
+  const { client } = useMedusa()
+  const { data, ...rest } = useQuery(
+    adminSwapKeys.detail(id),
+    () => client.admin.swaps.retrieve(id),
+    options
+  )
+  return { ...data, ...rest } as const
+}
@@ -0,0 +1,2 @@
+export * from "./queries"
+export * from "./mutations"
@@ -0,0 +1,99 @@
+import {
+  AdminDeleteUserRes,
+  AdminResetPasswordRequest,
+  AdminResetPasswordTokenRequest,
+  AdminUserRes,
+} from "@medusajs/medusa"
+import {
+  AdminCreateUserPayload,
+  AdminUpdateUserPayload,
+  Response,
+} from "@medusajs/medusa-js"
+import { useMutation, UseMutationOptions, useQueryClient } from "react-query"
+import { adminCustomerKeys } from ".."
+import { useMedusa } from "../../../contexts/medusa"
+import { buildOptions } from "../../utils/buildOptions"
+
+export const useAdminCreateUser = (
+  options?: UseMutationOptions<
+    Response<AdminUserRes>,
+    Error,
+    AdminCreateUserPayload
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (payload: AdminCreateUserPayload) => client.admin.users.create(payload),
+    buildOptions(queryClient, adminCustomerKeys.lists(), options)
+  )
+}
+
+export const useAdminUpdateUser = (
+  id: string,
+  options?: UseMutationOptions<
+    Response<AdminUserRes>,
+    Error,
+    AdminUpdateUserPayload
+  >
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    (payload: AdminUpdateUserPayload) => client.admin.users.update(id, payload),
+    buildOptions(
+      queryClient,
+      [adminCustomerKeys.lists(), adminCustomerKeys.detail(id)],
+      options
+    )
+  )
+}
+
+export const useAdminDeleteUser = (
+  id: string,
+  options?: UseMutationOptions<Response<AdminDeleteUserRes>, Error, void>
+) => {
+  const { client } = useMedusa()
+  const queryClient = useQueryClient()
+
+  return useMutation(
+    () => client.admin.users.delete(id),
+    buildOptions(
+      queryClient,
+      [adminCustomerKeys.detail(id), adminCustomerKeys.lists()],
+      options
+    )
+  )
+}
+
+export const useAdminResetPassword = (
+  options?: UseMutationOptions<
+    Response<AdminUserRes>,
+    Error,
+    AdminResetPasswordRequest
+  >
+) => {
+  const { client } = useMedusa()
+  return useMutation(
+    (payload: AdminResetPasswordRequest) =>
+      client.admin.users.resetPassword(payload),
+    options
+  )
+}
+
+export const useAdminSendResetPasswordToken = (
+  options?: UseMutationOptions<
+    Response<void>,
+    Error,
+    AdminResetPasswordTokenRequest
+  >
+) => {
+  const { client } = useMedusa()
+  return useMutation(
+    (payload: AdminResetPasswordTokenRequest) =>
+      client.admin.users.sendResetPasswordToken(payload),
+    options
+  )
+}
@@ -0,0 +1,45 @@
+import { AdminUsersListRes, AdminUserRes } from "@medusajs/medusa"
+import { Response } from "@medusajs/medusa-js"
+import { useQuery } from "react-query"
+import { useMedusa } from "../../../contexts"
+import { UseQueryOptionsWrapper } from "../../../types"
+import { queryKeysFactory } from "../../utils/index"
+
+const ADMIN_USERS_QUERY_KEY = `admin_users` as const
+
+export const adminUserKeys = queryKeysFactory(ADMIN_USERS_QUERY_KEY)
+
+type UserQueryKeys = typeof adminUserKeys
+
+export const useAdminUsers = (
+  options?: UseQueryOptionsWrapper<
+    Response<AdminUsersListRes>,
+    Error,
+    ReturnType<UserQueryKeys["lists"]>
+  >
+) => {
+  const { client } = useMedusa()
+  const { data, ...rest } = useQuery(
+    adminUserKeys.lists(),
+    () => client.admin.users.list(),
+    options
+  )
+  return { ...data, ...rest } as const
+}
+
+export const useAdminUser = (
+  id: string,
+  options?: UseQueryOptionsWrapper<
+    Response<AdminUserRes>,
+    Error,
+    ReturnType<UserQueryKeys["detail"]>
+  >
+) => {
+  const { client } = useMedusa()
+  const { data, ...rest } = useQuery(
+    adminUserKeys.detail(id),
+    () => client.admin.users.retrieve(id),
+    options
+  )
+  return { ...data, ...rest } as const
+}
@@ -0,0 +1,29 @@
+import { AdminVariantsListRes, AdminGetVariantsParams } from "@medusajs/medusa"
+import { Response } from "@medusajs/medusa-js"
+import { useQuery } from "react-query"
+import { useMedusa } from "../../../contexts"
+import { UseQueryOptionsWrapper } from "../../../types"
+import { queryKeysFactory } from "../../utils/index"
+
+const ADMIN_VARIANT_QUERY_KEY = `admin_variants` as const
+
+export const adminVariantKeys = queryKeysFactory(ADMIN_VARIANT_QUERY_KEY)
+
+type VariantQueryKeys = typeof adminVariantKeys
+
+export const useAdminVariants = (
+  query?: AdminGetVariantsParams,
+  options?: UseQueryOptionsWrapper<
+    Response<AdminVariantsListRes>,
+    Error,
+    ReturnType<VariantQueryKeys["list"]>
+  >
+) => {
+  const { client } = useMedusa()
+  const { data, ...rest } = useQuery(
+    adminVariantKeys.list(query),
+    () => client.admin.variants.list(query),
+    options
+  )
+  return { ...data, ...rest } as const
+}
@@ -1,13 +1,2 @@
-export * from "./products/"
-export * from "./carts/"
-export * from "./shipping-options/"
-export * from "./regions/"
-export * from "./return-reasons/"
-export * from "./swaps/"
-export * from "./carts/"
-export * from "./orders/"
-export * from "./customers/"
-export * from "./returns/"
-export * from "./gift-cards/"
-export * from "./line-items/"
-export * from "./collections"
+export * from "./store/"
+export * from "./admin/"
@@ -0,0 +1,2 @@
+export * from "./queries"
+export * from "./mutations"
@@ -8,7 +8,7 @@ import {
  StorePostCartsCartShippingMethodReq,
 } from "@medusajs/medusa"
 import { useMutation, UseMutationOptions } from "react-query"
-import { useMedusa } from "../../contexts/medusa"
+import { useMedusa } from "../../../contexts/medusa"

 export const useCreateCart = (
  options?: UseMutationOptions<
@@ -1,13 +1,13 @@
-import { makeKeysFactory } from "./../utils/index"
+import { queryKeysFactory } from "../../utils/index"
 import { StoreCartsRes } from "@medusajs/medusa"
 import { Response } from "@medusajs/medusa-js"
 import { useQuery } from "react-query"
-import { useMedusa } from "../../contexts/medusa"
-import { UseQueryOptionsWrapper } from "../../types"
+import { useMedusa } from "../../../contexts/medusa"
+import { UseQueryOptionsWrapper } from "../../../types"

 const CARTS_QUERY_KEY = `carts` as const

-export const cartKeys = makeKeysFactory(CARTS_QUERY_KEY)
+export const cartKeys = queryKeysFactory(CARTS_QUERY_KEY)
 type CartQueryKey = typeof cartKeys

 export const useGetCart = (
@@ -5,13 +5,13 @@ import {
 } from "@medusajs/medusa"
 import { Response } from "@medusajs/medusa-js"
 import { useQuery } from "react-query"
-import { useMedusa } from "../../contexts/medusa"
-import { UseQueryOptionsWrapper } from "./../../types"
-import { makeKeysFactory } from "./../utils/index"
+import { useMedusa } from "../../../contexts/medusa"
+import { UseQueryOptionsWrapper } from "../../../types"
+import { queryKeysFactory } from "../../utils/index"

 const COLLECTIONS_QUERY_KEY = `collections` as const

-export const collectionKeys = makeKeysFactory(COLLECTIONS_QUERY_KEY)
+export const collectionKeys = queryKeysFactory(COLLECTIONS_QUERY_KEY)

 type CollectionQueryKey = typeof collectionKeys

@@ -0,0 +1,2 @@
+export * from "./queries"
+export * from "./mutations"
@@ -4,7 +4,7 @@ import {
  StorePostCustomersReq,
 } from "@medusajs/medusa"
 import { useMutation, UseMutationOptions } from "react-query"
-import { useMedusa } from "../../contexts/medusa"
+import { useMedusa } from "../../../contexts/medusa"

 export const useCreateCustomer = (
  options?: UseMutationOptions<StoreCustomersRes, Error, StorePostCustomersReq>
@@ -5,14 +5,14 @@ import {
 } from "@medusajs/medusa"
 import { useQuery } from "react-query"
 import { Response } from "@medusajs/medusa-js"
-import { useMedusa } from "../../contexts"
-import { UseQueryOptionsWrapper } from "../../types"
-import { makeKeysFactory } from "./../utils/index"
+import { useMedusa } from "../../../contexts"
+import { UseQueryOptionsWrapper } from "../../../types"
+import { queryKeysFactory } from "../../utils/index"

 const CUSTOMERS_QUERY_KEY = `customers` as const

 export const customerKeys = {
-  ...makeKeysFactory(CUSTOMERS_QUERY_KEY),
+  ...queryKeysFactory(CUSTOMERS_QUERY_KEY),
  orders: (id: string) => [...customerKeys.detail(id), "orders"] as const,
 }

@@ -1,13 +1,13 @@
-import { makeKeysFactory } from "./../utils/index"
+import { queryKeysFactory } from "../../utils/index"
 import { StoreGiftCardsRes } from "@medusajs/medusa"
 import { Response } from "@medusajs/medusa-js"
 import { useQuery } from "react-query"
-import { useMedusa } from "../../contexts"
-import { UseQueryOptionsWrapper } from "../../types"
+import { useMedusa } from "../../../contexts"
+import { UseQueryOptionsWrapper } from "../../../types"

 const GIFT_CARDS_QUERY_KEY = `gift_cards` as const

-export const giftCardKeys = makeKeysFactory(GIFT_CARDS_QUERY_KEY)
+export const giftCardKeys = queryKeysFactory(GIFT_CARDS_QUERY_KEY)

 type GiftCardQueryKey = typeof giftCardKeys

@@ -0,0 +1,13 @@
+export * from "./products/"
+export * from "./carts/"
+export * from "./shipping-options/"
+export * from "./regions/"
+export * from "./return-reasons/"
+export * from "./swaps/"
+export * from "./carts/"
+export * from "./orders/"
+export * from "./customers/"
+export * from "./returns/"
+export * from "./gift-cards/"
+export * from "./line-items/"
+export * from "./collections"
@@ -4,7 +4,7 @@ import {
  StorePostCartsCartLineItemsItemReq,
 } from "@medusajs/medusa"
 import { useMutation, UseMutationOptions } from "react-query"
-import { useMedusa } from "../../contexts"
+import { useMedusa } from "../../../contexts"

 export const useCreateLineItem = (
  cartId: string,
@@ -1,14 +1,14 @@
-import { makeKeysFactory } from "./../utils/index"
+import { queryKeysFactory } from "../../utils/index"
 import { StoreOrdersRes, StoreGetOrdersParams } from "@medusajs/medusa"
 import { useQuery } from "react-query"
-import { useMedusa } from "../../contexts"
-import { UseQueryOptionsWrapper } from "../../types"
+import { useMedusa } from "../../../contexts"
+import { UseQueryOptionsWrapper } from "../../../types"
 import { Response } from "@medusajs/medusa-js"

 const ORDERS_QUERY_KEY = `orders` as const

 export const orderKeys = {
-  ...makeKeysFactory<typeof ORDERS_QUERY_KEY, StoreGetOrdersParams>(
+  ...queryKeysFactory<typeof ORDERS_QUERY_KEY, StoreGetOrdersParams>(
    ORDERS_QUERY_KEY
  ),
  cart: (cartId: string) => [...orderKeys.details(), "cart", cartId] as const,
@@ -52,7 +52,7 @@ export const useCartOrder = (
  return { ...data, ...rest } as const
 }

-export const useOrderLookup = (
+export const useOrders = (
  query: StoreGetOrdersParams,
  options?: UseQueryOptionsWrapper<
    Response<StoreOrdersRes>,
@@ -5,13 +5,13 @@ import {
  StoreProductsRes,
 } from "@medusajs/medusa"
 import { useQuery } from "react-query"
-import { useMedusa } from "../../contexts"
-import { UseQueryOptionsWrapper } from "../../types"
-import { makeKeysFactory } from "./../utils/index"
+import { useMedusa } from "../../../contexts"
+import { UseQueryOptionsWrapper } from "../../../types"
+import { queryKeysFactory } from "../../utils/index"

 const PRODUCTS_QUERY_KEY = `products` as const

-export const productKeys = makeKeysFactory<
+export const productKeys = queryKeysFactory<
  typeof PRODUCTS_QUERY_KEY,
  StoreGetProductsParams
 >(PRODUCTS_QUERY_KEY)
@@ -1,13 +1,13 @@
-import { makeKeysFactory } from "./../utils/index"
-import { UseQueryOptionsWrapper } from "../../types"
+import { queryKeysFactory } from "../../utils/index"
+import { UseQueryOptionsWrapper } from "../../../types"
 import { useQuery } from "react-query"
-import { useMedusa } from "../../contexts"
+import { useMedusa } from "../../../contexts"
 import { StoreRegionsRes, StoreRegionsListRes } from "@medusajs/medusa"
 import { Response } from "@medusajs/medusa-js"

 const REGIONS_QUERY_KEY = `regions` as const

-const regionsKey = makeKeysFactory(REGIONS_QUERY_KEY)
+const regionsKey = queryKeysFactory(REGIONS_QUERY_KEY)

 type RegionQueryType = typeof regionsKey

@@ -1,16 +1,16 @@
-import { makeKeysFactory } from "./../utils/index"
+import { queryKeysFactory } from "../../utils/index"
 import {
  StoreReturnReasonsListRes,
  StoreReturnReasonsRes,
 } from "@medusajs/medusa"
 import { Response } from "@medusajs/medusa-js"
 import { useQuery } from "react-query"
-import { useMedusa } from "../../contexts"
-import { UseQueryOptionsWrapper } from "../../types"
+import { useMedusa } from "../../../contexts"
+import { UseQueryOptionsWrapper } from "../../../types"

 const RETURNS_REASONS_QUERY_KEY = `return_reasons` as const

-const returnReasonsKey = makeKeysFactory(RETURNS_REASONS_QUERY_KEY)
+const returnReasonsKey = queryKeysFactory(RETURNS_REASONS_QUERY_KEY)

 type ReturnReasonsQueryKey = typeof returnReasonsKey

@@ -0,0 +1 @@
+export * from "./mutations"
@@ -1,6 +1,6 @@
 import { StoreReturnsRes, StorePostReturnsReq } from "@medusajs/medusa"
 import { useMutation, UseMutationOptions } from "react-query"
-import { useMedusa } from "../../contexts"
+import { useMedusa } from "../../../contexts"

 export const useCreateReturn = (
  options?: UseMutationOptions<StoreReturnsRes, Error, StorePostReturnsReq>
@@ -0,0 +1 @@
+export * from "./queries"
@@ -1,7 +1,7 @@
-import { makeKeysFactory } from "./../utils/index"
-import { UseQueryOptionsWrapper } from "../../types"
+import { queryKeysFactory } from "../../utils/index"
+import { UseQueryOptionsWrapper } from "../../../types"
 import { useQuery } from "react-query"
-import { useMedusa } from "../../contexts"
+import { useMedusa } from "../../../contexts"
 import {
  StoreShippingOptionsListRes,
  StoreGetShippingOptionsParams,
@@ -11,7 +11,7 @@ import { Response } from "@medusajs/medusa-js"
 const SHIPPING_OPTION_QUERY_KEY = `shipping_options` as const

 const shippingOptionKey = {
-  ...makeKeysFactory(SHIPPING_OPTION_QUERY_KEY),
+  ...queryKeysFactory(SHIPPING_OPTION_QUERY_KEY),
  cart: (cartId: string) => [...shippingOptionKey.all, "cart", cartId] as const,
 }

@@ -0,0 +1,2 @@
+export * from "./queries"
+export * from "./mutations"
@@ -1,6 +1,6 @@
 import { StoreSwapsRes, StorePostSwapsReq } from "@medusajs/medusa"
 import { useMutation, UseMutationOptions } from "react-query"
-import { useMedusa } from "../../contexts"
+import { useMedusa } from "../../../contexts"

 export const useCreateSwap = (
  options?: UseMutationOptions<StoreSwapsRes, Error, StorePostSwapsReq>
@@ -1,14 +1,14 @@
-import { makeKeysFactory } from "./../utils/index"
+import { queryKeysFactory } from "../../utils/index"
 import { StoreSwapsRes } from "@medusajs/medusa"
 import { Response } from "@medusajs/medusa-js"
 import { useQuery } from "react-query"
-import { useMedusa } from "../../contexts"
-import { UseQueryOptionsWrapper } from "../../types"
+import { useMedusa } from "../../../contexts"
+import { UseQueryOptionsWrapper } from "../../../types"

 const SWAPS_QUERY_KEY = `swaps` as const

 const swapKey = {
-  ...makeKeysFactory(SWAPS_QUERY_KEY),
+  ...queryKeysFactory(SWAPS_QUERY_KEY),
  cart: (cartId: string) => [...swapKey.all, "cart", cartId] as const,
 }

@@ -0,0 +1,28 @@
+import { QueryClient, QueryKey, UseMutationOptions } from "react-query"
+
+export const buildOptions = <
+  TData,
+  TError,
+  TVariables,
+  TContext,
+  TKey extends Array<QueryKey>
+>(
+  queryClient: QueryClient,
+  queryKey: TKey[] | TKey,
+  options?: UseMutationOptions<TData, TError, TVariables, TContext>
+): UseMutationOptions<TData, TError, TVariables, TContext> => {
+  return {
+    ...options,
+    onSuccess: (...args) => {
+      if (options?.onSuccess) {
+        return options.onSuccess(...args)
+      }
+
+      if (queryKey.filter(Array.isArray).length > 0) {
+        queryKey.forEach(key => queryClient.invalidateQueries(key))
+      } else {
+        queryClient.invalidateQueries(queryKey)
+      }
+    },
+  }
+}
@@ -1,62 +1,2 @@
-import * as React from "react"
-
-type TQueryKey<TKey, TListQuery = any, TDetailQuery = string> = {
-  all: [TKey]
-  lists: () => [...TQueryKey<TKey>["all"], "list"]
-  list: (
-    query?: TListQuery
-  ) => [
-    ...ReturnType<TQueryKey<TKey>["lists"]>,
-    { query: TListQuery | undefined }
-  ]
-  details: () => [...TQueryKey<TKey>["all"], "detail"]
-  detail: (
-    id: TDetailQuery
-  ) => [...ReturnType<TQueryKey<TKey>["details"]>, TDetailQuery]
-}
-
-export const makeKeysFactory = <
-  T,
-  TListQueryType = any,
-  TDetailQueryType = string
->(
-  globalKey: T
-) => {
-  const queryKeyFactory: TQueryKey<T, TListQueryType, TDetailQueryType> = {
-    all: [globalKey],
-    lists: () => [...queryKeyFactory.all, "list"],
-    list: (query?: TListQueryType) => [...queryKeyFactory.lists(), { query }],
-    details: () => [...queryKeyFactory.all, "detail"],
-    detail: (id: TDetailQueryType) => [...queryKeyFactory.details(), id],
-  }
-  return queryKeyFactory
-}
-
-export const useLocalStorage = (key: string, initialState: string) => {
-  const [item, setItem] = React.useState(() => {
-    try {
-      const item =
-        typeof window !== "undefined" && window.localStorage.getItem(key)
-
-      return item || initialState
-    } catch (err) {
-      return initialState
-    }
-  })
-
-  const save = (data: string) => {
-    setItem(data)
-
-    if (typeof window !== "undefined") {
-      window.localStorage.setItem(key, data)
-    }
-  }
-
-  const remove = () => {
-    if (typeof window !== "undefined") {
-      window.localStorage.removeItem(key)
-    }
-  }
-
-  return [item, save, remove] as const
-}
+export * from "./queryKeysFactory"
+export * from "./useLocalStorage"
@@ -0,0 +1,18 @@
+import { TQueryKey } from "../../types"
+
+export const queryKeysFactory = <
+  T,
+  TListQueryType = any,
+  TDetailQueryType = string
+>(
+  globalKey: T
+) => {
+  const queryKeyFactory: TQueryKey<T, TListQueryType, TDetailQueryType> = {
+    all: [globalKey],
+    lists: () => [...queryKeyFactory.all, "list"],
+    list: (query?: TListQueryType) => [...queryKeyFactory.lists(), { query }],
+    details: () => [...queryKeyFactory.all, "detail"],
+    detail: (id: TDetailQueryType) => [...queryKeyFactory.details(), id],
+  }
+  return queryKeyFactory
+}
@@ -0,0 +1,30 @@
+import * as React from "react"
+
+export const useLocalStorage = (key: string, initialState: string) => {
+  const [item, setItem] = React.useState(() => {
+    try {
+      const item =
+        typeof window !== "undefined" && window.localStorage.getItem(key)
+
+      return item || initialState
+    } catch (err) {
+      return initialState
+    }
+  })
+
+  const save = (data: string) => {
+    setItem(data)
+
+    if (typeof window !== "undefined") {
+      window.localStorage.setItem(key, data)
+    }
+  }
+
+  const remove = () => {
+    if (typeof window !== "undefined") {
+      window.localStorage.removeItem(key)
+    }
+  }
+
+  return [item, save, remove] as const
+}
@@ -1,3 +1,3 @@
 export * from "./contexts"
 export * from "./hooks/"
-export * from "./utils/"
+export * from "./helpers"
--- a/Show More
+++ b/Show More