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>

packages/medusa-react/.eslintignore

@@ -0,0 +1 @@
+src/types.ts

packages/medusa-react/.eslintrc.js

@@ -1,12 +1,12 @@
 module.exports = {
-  "extends": [
+  extends: [
     "react-app",
     "prettier/@typescript-eslint",
-    "plugin:prettier/recommended"
+    "plugin:prettier/recommended",
   ],
-  "settings": {
-    "react": {
-      "version": "detect"
-    }
-  }
-}
+  settings: {
+    react: {
+      version: "detect",
+    },
+  },
+}

packages/medusa-react/.prettierrc

@@ -0,0 +1,8 @@
+{
+  "endOfLine": "auto",
+  "semi": false,
+  "singleQuote": false,
+  "tabWidth": 2,
+  "trailingComma": "es5",
+  "arrowParens": "always"
+}

packages/medusa-react/jest.config.js

@@ -6,5 +6,8 @@ module.exports = {
       isolatedModules: true,
     },
   },
+  transform: {
+    ".(ts|tsx)$": require.resolve("ts-jest/dist/"),
+  },
   setupFilesAfterEnv: ["./jest.setup.js"],
 }

packages/medusa-react/mocks/data/fixtures.json

@@ -556,6 +556,7 @@
     "user": {
       "id": "admin_user",
       "email": "admin@medusa.js",
+      "role": "admin",
       "first_name": null,
       "last_name": null,
       "api_token": "test_token",
@@ -1050,6 +1051,175 @@
       "updated_at": "2021-03-17 12:09:59.156058+01",
       "metadata": null,
       "parent_return_reason_id": null
+    },
+    "product_type": {
+      "id": "ptype_ZXDBABWJVW6115VEMZXDBAB",
+      "value": "clothing",
+      "created_at": "2021-03-16T21:24:35.828Z",
+      "updated_at": "2021-03-16T21:24:35.828Z",
+      "deleted_at": null,
+      "metadata": null
+    },
+    "product_tag": {
+      "id": "ptag_ZXDBABWJVW6115VEMZXDBAB",
+      "value": "pants",
+      "created_at": "2021-03-16T21:24:35.828Z",
+      "updated_at": "2021-03-16T21:24:35.828Z",
+      "deleted_at": null,
+      "metadata": null
+    },
+    "note": {
+      "id": "note_01F0ZXDBAB9KVZWJVW6115VEM7",
+      "value": "customer contacted",
+      "resource_type": "swap",
+      "resource_id": "swap_01F0YET86Y9G92D3YDR9Y6V676",
+      "author_id": "admin_user",
+      "created_at": "2021-03-17 11:58:56.975971+01",
+      "updated_at": "2021-03-17 12:09:59.156058+01",
+      "metadata": null
+    },
+    "invite": {
+      "id": "invite_320ZXDBAB4WJVW6115VEM7",
+      "user_email": "lebron@james.com",
+      "role": "admin",
+      "accepted": true,
+      "token": "secret_token",
+      "expires_at": "2021-03-18 11:58:56.975971+01",
+      "created_at": "2021-03-17 11:58:56.975971+01",
+      "updated_at": "2021-03-17 12:09:59.156058+01",
+      "metadata": null
+    },
+    "draft_order": {
+      "id": "dorder_01FGKMYKMJ4E8HP3RGEW28E7CZ",
+      "status": "open",
+      "display_id": 1,
+      "cart_id": "cart_01FGKMYKM9V8FVEJE23Q26FG5B",
+      "cart": {
+        "id": "cart_01FGKMYKM9V8FVEJE23Q26FG5B",
+        "email": "jane@medusa.test",
+        "billing_address_id": null,
+        "billing_address": null,
+        "shipping_address_id": "addr_01FGKMYKKQ3S1Q4ZC9HV4REXC6",
+        "shipping_address": {
+          "id": "addr_01FGKMYKKQ3S1Q4ZC9HV4REXC6",
+          "customer_id": null,
+          "company": null,
+          "first_name": "Jane",
+          "last_name": "Medusan",
+          "address_1": null,
+          "address_2": null,
+          "city": null,
+          "country_code": "dk",
+          "province": null,
+          "postal_code": null,
+          "phone": null,
+          "created_at": "2021-09-27T12:51:21.335Z",
+          "updated_at": "2021-09-27T12:51:21.335Z",
+          "deleted_at": null,
+          "metadata": null
+        },
+        "items": [
+          {
+            "id": "item_01FGKMYKM9AKV5D146N28QFPX7",
+            "cart_id": "cart_01FGKMYKM9V8FVEJE23Q26FG5B",
+            "order_id": null,
+            "swap_id": null,
+            "claim_order_id": null,
+            "title": "Basic Tee - One Size",
+            "description": "Soft and sweet",
+            "thumbnail": "https://test.js/1234",
+            "is_giftcard": false,
+            "should_merge": true,
+            "allow_discounts": true,
+            "has_shipping": null,
+            "unit_price": 8000,
+            "variant_id": "variant_01FGKMYKJVY3DYDZWCRB2GZS0G",
+            "variant": {
+              "id": "variant_01FGKMYKJVY3DYDZWCRB2GZS0G",
+              "title": "One Size",
+              "product_id": "prod_01FGKMYKJJMZ6XFN37JBGTZ46G",
+              "sku": null,
+              "barcode": null,
+              "ean": null,
+              "upc": null,
+              "inventory_quantity": 1,
+              "allow_backorder": false,
+              "manage_inventory": true,
+              "hs_code": null,
+              "origin_country": null,
+              "mid_code": null,
+              "material": null,
+              "weight": null,
+              "length": null,
+              "height": null,
+              "width": null,
+              "created_at": "2021-09-27T12:51:21.307Z",
+              "updated_at": "2021-09-27T12:51:21.307Z",
+              "deleted_at": null,
+              "metadata": null
+            },
+            "quantity": 1,
+            "fulfilled_quantity": 1,
+            "returned_quantity": null,
+            "shipped_quantity": null,
+            "created_at": "2021-09-27T12:51:21.352Z",
+            "updated_at": "2021-09-27T12:51:21.352Z",
+            "metadata": null
+          }
+        ],
+        "region_id": "reg_01FGKMYKKG6ACZANRNHR3XVRN3",
+        "region": {
+          "id": "reg_01FGKMYKKG6ACZANRNHR3XVRN3",
+          "name": "United States",
+          "currency_code": "usd",
+          "tax_rate": "0",
+          "tax_code": null,
+          "payment_providers": [
+            {
+              "id": "test-pay",
+              "is_installed": true
+            }
+          ],
+          "fulfillment_providers": [],
+          "created_at": "2021-09-27T12:51:21.328Z",
+          "updated_at": "2021-09-27T12:51:21.328Z",
+          "deleted_at": null,
+          "metadata": null
+        },
+        "discounts": [],
+        "gift_cards": [],
+        "customer_id": "cus_01FGKMYKM2TAKTGZ1XMEW45RJZ",
+        "payment_sessions": [],
+        "payment_id": null,
+        "payment": null,
+        "shipping_methods": [],
+        "type": "draft_order",
+        "completed_at": null,
+        "payment_authorized_at": null,
+        "created_at": "2021-09-27T12:51:21.352Z",
+        "updated_at": "2021-09-27T12:51:21.352Z",
+        "deleted_at": null,
+        "metadata": null,
+        "idempotency_key": null,
+        "context": null,
+        "shipping_total": 0,
+        "discount_total": 0,
+        "tax_total": 0,
+        "gift_card_total": 0,
+        "subtotal": 8000,
+        "total": 8000
+      },
+      "order_id": null,
+      "order": null,
+      "canceled_at": null,
+      "created_at": "2021-09-27T12:51:21.360Z",
+      "updated_at": "2021-09-27T12:51:21.360Z",
+      "no_notification_order": null,
+      "metadata": null
+    },
+    "fulfillment_option": {
+      "provider_id": "test-ful",
+      "options": []
     }
   }
 }

packages/medusa-react/mocks/handlers/index.ts

@@ -0,0 +1,2 @@
+export * from "./store"
+export * from "./admin"

packages/medusa-react/mocks/handlers/store.ts

@@ -1,7 +1,7 @@
-import { fixtures } from "./data/"
+import { fixtures } from "../data"
 import { rest } from "msw"
 
-export const handlers = [
+export const storeHandlers = [
   rest.get("/store/products", (req, res, ctx) => {
     const limit = parseInt(req.url.searchParams.get("limit") || "2")
     const offset = parseInt(req.url.searchParams.get("offset") || "0")

packages/medusa-react/mocks/server.ts

@@ -1,4 +1,4 @@
 import { setupServer } from "msw/node"
-import { handlers } from "./handlers"
+import { storeHandlers, adminHandlers } from "./handlers"
 
-export const server = setupServer(...handlers)
+export const server = setupServer(...[...storeHandlers, ...adminHandlers])

packages/medusa-react/package.json

@@ -13,9 +13,9 @@
   "scripts": {
     "start": "tsdx watch",
     "build": "tsdx build",
+    "prepare": "tsdx build",
     "test": "tsdx test --passWithNoTests",
     "lint": "tsdx lint",
-    "prepare": "tsdx build",
     "size": "size-limit",
     "analyze": "size-limit --why",
     "storybook": "start-storybook -p 6006 -s public",
@@ -61,15 +61,12 @@
     "@storybook/react": "^6.3.12",
     "@testing-library/react": "^12.1.2",
     "@testing-library/react-hooks": "^7.0.2",
+    "@types/jest": "^27.0.3",
     "@types/lodash": "^4.14.177",
     "@types/react": "^17.0.33",
     "@types/react-dom": "^17.0.10",
-    "@typescript-eslint/eslint-plugin": "^5.4.0",
-    "@typescript-eslint/parser": "^5.4.0",
     "axios": "^0.24.0",
     "babel-loader": "^8.2.3",
-    "eslint-config-react-app": "^6.0.0",
-    "eslint-plugin-prettier": "3.4.1",
     "husky": "^7.0.4",
     "msw": "^0.35.0",
     "msw-storybook-addon": "^1.5.0",
@@ -90,10 +87,6 @@
     "react-query": "^3.31.0"
   },
   "resolutions": {
-    "**/@typescript-eslint/eslint-plugin": "^4.11.1",
-    "**/@typescript-eslint/parser": "^4.11.1",
-    "**/jest": "^26.6.3",
-    "**/ts-jest": "^26.4.4",
     "**/typescript": "^4.1.3"
   },
   "msw": {

packages/medusa-react/src/contexts/cart.tsx

@@ -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 (

packages/medusa-react/src/contexts/medusa.tsx

@@ -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>

packages/medusa-react/src/contexts/session-cart.tsx

@@ -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[]) => {

packages/medusa-react/src/helpers/index.ts

@@ -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

packages/medusa-react/src/hooks/admin/auth/mutations.ts

@@ -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)
+  )
+}

packages/medusa-react/src/hooks/admin/auth/queries.ts

@@ -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
+}

packages/medusa-react/src/hooks/admin/claims/mutations.ts

@@ -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)
+  )
+}

packages/medusa-react/src/hooks/admin/collections/mutations.ts

@@ -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
+    )
+  )
+}

packages/medusa-react/src/hooks/admin/collections/queries.ts

@@ -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
+}

packages/medusa-react/src/hooks/admin/customers/mutations.ts

@@ -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
+    )
+  )
+}

packages/medusa-react/src/hooks/admin/customers/queries.ts

@@ -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
+}

packages/medusa-react/src/hooks/admin/discounts/index.ts

@@ -0,0 +1,2 @@
+export * from "./queries"
+export * from "./mutations"

packages/medusa-react/src/hooks/admin/discounts/mutations.ts

@@ -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
+    )
+  )
+}

packages/medusa-react/src/hooks/admin/discounts/queries.ts

@@ -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
+}

packages/medusa-react/src/hooks/admin/draft-orders/index.ts

@@ -0,0 +1,2 @@
+export * from "./queries"
+export * from "./mutations"

packages/medusa-react/src/hooks/admin/draft-orders/mutations.ts

@@ -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)
+  )
+}

packages/medusa-react/src/hooks/admin/draft-orders/queries.ts

@@ -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
+}

packages/medusa-react/src/hooks/admin/gift-cards/index.ts

@@ -0,0 +1,2 @@
+export * from "./queries"
+export * from "./mutations"

packages/medusa-react/src/hooks/admin/gift-cards/mutations.ts

@@ -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
+    )
+  )
+}

packages/medusa-react/src/hooks/admin/gift-cards/queries.ts

@@ -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
+}

packages/medusa-react/src/hooks/admin/index.ts

@@ -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"

packages/medusa-react/src/hooks/admin/invites/index.ts

@@ -0,0 +1,2 @@
+export * from "./queries"
+export * from "./mutations"

packages/medusa-react/src/hooks/admin/invites/mutations.ts

@@ -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
+    )
+  )
+}

packages/medusa-react/src/hooks/admin/invites/queries.ts

@@ -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
+}

packages/medusa-react/src/hooks/admin/notes/index.ts

@@ -0,0 +1,2 @@
+export * from "./queries"
+export * from "./mutations"

packages/medusa-react/src/hooks/admin/notes/mutations.ts

@@ -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
+    )
+  )
+}

packages/medusa-react/src/hooks/admin/notes/queries.ts

@@ -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
+}

packages/medusa-react/src/hooks/admin/notifications/index.ts

@@ -0,0 +1,2 @@
+export * from "./queries"
+export * from "./mutations"

packages/medusa-react/src/hooks/admin/notifications/mutations.ts

@@ -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
+    )
+  )
+}

packages/medusa-react/src/hooks/admin/notifications/queries.ts

@@ -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
+}

packages/medusa-react/src/hooks/admin/orders/index.ts

@@ -0,0 +1,2 @@
+export * from "./queries"
+export * from "./mutations"

packages/medusa-react/src/hooks/admin/orders/mutations.ts

@@ -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)
+  )
+}

packages/medusa-react/src/hooks/admin/orders/queries.ts

@@ -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
+}

packages/medusa-react/src/hooks/admin/products/index.ts

@@ -0,0 +1,2 @@
+export * from "./queries"
+export * from "./mutations"

packages/medusa-react/src/hooks/admin/products/mutations.ts

@@ -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)
+  )
+}

packages/medusa-react/src/hooks/admin/products/queries.ts

@@ -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
+}

packages/medusa-react/src/hooks/admin/regions/index.ts

@@ -0,0 +1,2 @@
+export * from "./queries"
+export * from "./mutations"

packages/medusa-react/src/hooks/admin/regions/mutations.ts

@@ -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)
+  )
+}

packages/medusa-react/src/hooks/admin/regions/queries.ts

@@ -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
+}

packages/medusa-react/src/hooks/admin/return-reasons/index.ts

@@ -0,0 +1,2 @@
+export * from "./queries"
+export * from "./mutations"

packages/medusa-react/src/hooks/admin/return-reasons/mutations.ts

@@ -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
+    )
+  )
+}

packages/medusa-react/src/hooks/admin/return-reasons/queries.ts

@@ -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
+}

packages/medusa-react/src/hooks/admin/returns/index.ts

@@ -0,0 +1,2 @@
+export * from "./queries"
+export * from "./mutations"

packages/medusa-react/src/hooks/admin/returns/mutations.ts

@@ -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
+    )
+  )
+}

packages/medusa-react/src/hooks/admin/returns/queries.ts

@@ -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
+}

packages/medusa-react/src/hooks/admin/shipping-options/index.ts

@@ -0,0 +1,2 @@
+export * from "./queries"
+export * from "./mutations"

packages/medusa-react/src/hooks/admin/shipping-options/mutations.ts

@@ -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
+    )
+  )
+}

packages/medusa-react/src/hooks/admin/shipping-options/queries.ts

@@ -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
+}

packages/medusa-react/src/hooks/admin/shipping-profiles/index.ts

@@ -0,0 +1,2 @@
+export * from "./queries"
+export * from "./mutations"

packages/medusa-react/src/hooks/admin/shipping-profiles/mutations.ts

@@ -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
+    )
+  )
+}

packages/medusa-react/src/hooks/admin/shipping-profiles/queries.ts

@@ -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
+}

packages/medusa-react/src/hooks/admin/store/index.ts

@@ -0,0 +1,2 @@
+export * from "./queries"
+export * from "./mutations"

packages/medusa-react/src/hooks/admin/store/mutations.ts

@@ -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)
+  )
+}

packages/medusa-react/src/hooks/admin/store/queries.ts

@@ -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
+}

packages/medusa-react/src/hooks/admin/swaps/index.ts

@@ -0,0 +1,2 @@
+export * from "./queries"
+export * from "./mutations"

packages/medusa-react/src/hooks/admin/swaps/mutations.ts

@@ -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
+    )
+  )
+}

packages/medusa-react/src/hooks/admin/swaps/queries.ts

@@ -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
+}

packages/medusa-react/src/hooks/admin/users/index.ts

@@ -0,0 +1,2 @@
+export * from "./queries"
+export * from "./mutations"

packages/medusa-react/src/hooks/admin/users/mutations.ts

@@ -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
+  )
+}

packages/medusa-react/src/hooks/admin/users/queries.ts

@@ -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
+}

packages/medusa-react/src/hooks/admin/variants/queries.ts

@@ -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
+}

packages/medusa-react/src/hooks/index.ts

@@ -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/"

packages/medusa-react/src/hooks/store/carts/index.ts

@@ -0,0 +1,2 @@
+export * from "./queries"
+export * from "./mutations"

packages/medusa-react/src/hooks/store/carts/mutations.ts

@@ -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<

packages/medusa-react/src/hooks/store/carts/queries.ts

@@ -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 = (

packages/medusa-react/src/hooks/store/collections/queries.ts

@@ -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
 

packages/medusa-react/src/hooks/store/customers/index.ts

@@ -0,0 +1,2 @@
+export * from "./queries"
+export * from "./mutations"

packages/medusa-react/src/hooks/store/customers/mutations.ts

@@ -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>

packages/medusa-react/src/hooks/store/customers/queries.ts

@@ -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,
 }
 

packages/medusa-react/src/hooks/store/gift-cards/queries.ts

@@ -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
 

packages/medusa-react/src/hooks/store/index.ts

@@ -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"

packages/medusa-react/src/hooks/store/line-items/mutations.ts

@@ -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,

packages/medusa-react/src/hooks/store/orders/queries.ts

@@ -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>,

packages/medusa-react/src/hooks/store/products/queries.ts

@@ -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)

packages/medusa-react/src/hooks/store/regions/queries.ts

@@ -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
 

packages/medusa-react/src/hooks/store/return-reasons/queries.ts

@@ -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
 

packages/medusa-react/src/hooks/store/returns/index.ts

@@ -0,0 +1 @@
+export * from "./mutations"

packages/medusa-react/src/hooks/store/returns/mutations.ts

@@ -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>