feat(dashboard): Migrate to new hooks and API client (#6963)

packages/admin-next/dashboard/src/hooks/api/api-keys.tsx

@@ -0,0 +1,113 @@
+import {
+  MutationOptions,
+  QueryKey,
+  UseMutationOptions,
+  UseQueryOptions,
+  useMutation,
+  useQuery,
+} from "@tanstack/react-query"
+import { client } from "../../lib/client"
+import { queryClient } from "../../lib/medusa"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+import { CreateApiKeyReq, UpdateApiKeyReq } from "../../types/api-payloads"
+import {
+  ApiKeyDeleteRes,
+  ApiKeyListRes,
+  ApiKeyRes,
+} from "../../types/api-responses"
+
+const API_KEYS_QUERY_KEY = "api_keys" as const
+export const apiKeysQueryKeys = queryKeysFactory(API_KEYS_QUERY_KEY)
+
+export const useApiKey = (
+  id: string,
+  query?: Record<string, any>,
+  options?: Omit<
+    UseQueryOptions<ApiKeyRes, Error, ApiKeyRes, QueryKey>,
+    "queryKey" | "queryFn"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => client.apiKeys.retrieve(id, query),
+    queryKey: apiKeysQueryKeys.detail(id),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useApiKeys = (
+  query?: Record<string, any>,
+  options?: Omit<
+    UseQueryOptions<ApiKeyListRes, Error, ApiKeyListRes, QueryKey>,
+    "queryKey" | "queryFn"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => client.apiKeys.list(query),
+    queryKey: apiKeysQueryKeys.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useCreateApiKey = (
+  options?: UseMutationOptions<ApiKeyRes, Error, CreateApiKeyReq>
+) => {
+  return useMutation({
+    mutationFn: (payload) => client.apiKeys.create(payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: apiKeysQueryKeys.lists() })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateApiKey = (
+  id: string,
+  options?: UseMutationOptions<ApiKeyRes, Error, UpdateApiKeyReq>
+) => {
+  return useMutation({
+    mutationFn: (payload) => client.apiKeys.update(id, payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: apiKeysQueryKeys.lists() })
+      queryClient.invalidateQueries({ queryKey: apiKeysQueryKeys.detail(id) })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useRevokeApiKey = (
+  id: string,
+  options?: UseMutationOptions<ApiKeyRes, Error, void>
+) => {
+  return useMutation({
+    mutationFn: () => client.apiKeys.revoke(id),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: apiKeysQueryKeys.lists() })
+      queryClient.invalidateQueries({ queryKey: apiKeysQueryKeys.detail(id) })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+  })
+}
+
+export const useDeleteApiKey = (
+  id: string,
+  options?: MutationOptions<ApiKeyDeleteRes, Error, void>
+) => {
+  return useMutation({
+    mutationFn: () => client.apiKeys.delete(id),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: apiKeysQueryKeys.lists() })
+      queryClient.invalidateQueries({ queryKey: apiKeysQueryKeys.detail(id) })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+  })
+}

packages/admin-next/dashboard/src/hooks/api/auth.tsx

@@ -0,0 +1,22 @@
+import { UseMutationOptions, useMutation } from "@tanstack/react-query"
+
+import { client } from "../../lib/client"
+import { EmailPassReq } from "../../types/api-payloads"
+import { EmailPassRes } from "../../types/api-responses"
+
+export const useEmailPassLogin = (
+  options?: UseMutationOptions<EmailPassRes, Error, EmailPassReq>
+) => {
+  return useMutation({
+    mutationFn: (payload) => client.auth.authenticate.emailPass(payload),
+    onSuccess: async (data: { token: string }, variables, context) => {
+      const { token } = data
+
+      // Create a new session with the token
+      await client.auth.login(token)
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin-next/dashboard/src/hooks/api/collections.tsx

@@ -0,0 +1,123 @@
+import {
+  QueryKey,
+  UseMutationOptions,
+  UseQueryOptions,
+  useMutation,
+  useQuery,
+} from "@tanstack/react-query"
+import { client } from "../../lib/client"
+import { queryClient } from "../../lib/medusa"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+import {
+  CreateProductCollectionReq,
+  UpdateProductCollectionReq,
+} from "../../types/api-payloads"
+import {
+  ProductCollectionDeleteRes,
+  ProductCollectionListRes,
+  ProductCollectionRes,
+} from "../../types/api-responses"
+
+const COLLECTION_QUERY_KEY = "collections" as const
+export const collectionsQueryKeys = queryKeysFactory(COLLECTION_QUERY_KEY)
+
+export const useCollection = (
+  id: string,
+  options?: Omit<
+    UseQueryOptions<
+      ProductCollectionRes,
+      Error,
+      ProductCollectionRes,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryKey: collectionsQueryKeys.detail(id),
+    queryFn: async () => client.collections.retrieve(id),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useCollections = (
+  query?: Record<string, any>,
+  options?: Omit<
+    UseQueryOptions<
+      ProductCollectionListRes,
+      Error,
+      ProductCollectionListRes,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryKey: collectionsQueryKeys.list(query),
+    queryFn: async () => client.collections.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useUpdateCollection = (
+  id: string,
+  options?: UseMutationOptions<
+    ProductCollectionRes,
+    Error,
+    UpdateProductCollectionReq
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload: UpdateProductCollectionReq) =>
+      client.collections.update(id, payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: collectionsQueryKeys.lists() })
+      queryClient.invalidateQueries({
+        queryKey: collectionsQueryKeys.detail(id),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useCreateCollection = (
+  options?: UseMutationOptions<
+    ProductCollectionRes,
+    Error,
+    CreateProductCollectionReq
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => client.collections.create(payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: collectionsQueryKeys.lists() })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useDeleteCollection = (
+  id: string,
+  options?: UseMutationOptions<ProductCollectionDeleteRes, Error, void>
+) => {
+  return useMutation({
+    mutationFn: () => client.collections.delete(id),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: collectionsQueryKeys.lists() })
+      queryClient.invalidateQueries({
+        queryKey: collectionsQueryKeys.detail(id),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin-next/dashboard/src/hooks/api/currencies.tsx

@@ -0,0 +1,39 @@
+import { QueryKey, UseQueryOptions, useQuery } from "@tanstack/react-query"
+import { client } from "../../lib/client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+import { CurrencyListRes, CurrencyRes } from "../../types/api-responses"
+
+const CURRENCIES_QUERY_KEY = "currencies" as const
+const currenciesQueryKeys = queryKeysFactory(CURRENCIES_QUERY_KEY)
+
+export const useCurrencies = (
+  query?: Record<string, any>,
+  options?: Omit<
+    UseQueryOptions<CurrencyListRes, Error, CurrencyListRes, QueryKey>,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => client.currencies.list(query),
+    queryKey: currenciesQueryKeys.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useCurrency = (
+  id: string,
+  options?: Omit<
+    UseQueryOptions<CurrencyRes, Error, CurrencyRes, QueryKey>,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryKey: currenciesQueryKeys.detail(id),
+    queryFn: async () => client.currencies.retrieve(id),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}

packages/admin-next/dashboard/src/hooks/api/customers.tsx

@@ -0,0 +1,77 @@
+import {
+  QueryKey,
+  UseMutationOptions,
+  UseQueryOptions,
+  useMutation,
+  useQuery,
+} from "@tanstack/react-query"
+import { client } from "../../lib/client"
+import { queryClient } from "../../lib/medusa"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+import { CreateCustomerReq, UpdateCustomerReq } from "../../types/api-payloads"
+import { CustomerListRes, CustomerRes } from "../../types/api-responses"
+
+const CUSTOMERS_QUERY_KEY = "customers" as const
+const customersQueryKeys = queryKeysFactory(CUSTOMERS_QUERY_KEY)
+
+export const useCustomer = (
+  id: string,
+  query?: Record<string, any>,
+  options?: Omit<
+    UseQueryOptions<CustomerRes, Error, CustomerRes, QueryKey>,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryKey: customersQueryKeys.detail(id),
+    queryFn: async () => client.customers.retrieve(id, query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useCustomers = (
+  query?: Record<string, any>,
+  options?: Omit<
+    UseQueryOptions<CustomerListRes, Error, CustomerListRes, QueryKey>,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => client.customers.list(query),
+    queryKey: customersQueryKeys.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useCreateCustomer = (
+  options?: UseMutationOptions<CustomerRes, Error, CreateCustomerReq>
+) => {
+  return useMutation({
+    mutationFn: (payload) => client.customers.create(payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: customersQueryKeys.lists() })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateCustomer = (
+  id: string,
+  options?: UseMutationOptions<CustomerRes, Error, UpdateCustomerReq>
+) => {
+  return useMutation({
+    mutationFn: (payload) => client.customers.update(id, payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: customersQueryKeys.lists() })
+      queryClient.invalidateQueries({ queryKey: customersQueryKeys.detail(id) })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin-next/dashboard/src/hooks/api/invites.tsx

@@ -0,0 +1,94 @@
+import {
+  QueryKey,
+  UseMutationOptions,
+  UseQueryOptions,
+  useMutation,
+  useQuery,
+} from "@tanstack/react-query"
+import { client } from "../../lib/client"
+import { queryClient } from "../../lib/medusa"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+import { CreateInviteReq } from "../../types/api-payloads"
+import {
+  InviteDeleteRes,
+  InviteListRes,
+  InviteRes,
+} from "../../types/api-responses"
+
+const INVITES_QUERY_KEY = "invites" as const
+const invitesQueryKeys = queryKeysFactory(INVITES_QUERY_KEY)
+
+export const useInvite = (
+  id: string,
+  options?: Omit<
+    UseQueryOptions<InviteRes, Error, InviteRes, QueryKey>,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryKey: invitesQueryKeys.detail(id),
+    queryFn: async () => client.invites.retrieve(id),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useInvites = (
+  query?: Record<string, any>,
+  options?: Omit<
+    UseQueryOptions<InviteListRes, Error, InviteListRes, QueryKey>,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => client.invites.list(query),
+    queryKey: invitesQueryKeys.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useCreateInvite = (
+  options?: UseMutationOptions<InviteRes, Error, CreateInviteReq>
+) => {
+  return useMutation({
+    mutationFn: (payload) => client.invites.create(payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: invitesQueryKeys.lists() })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useResendInvite = (
+  id: string,
+  options?: UseMutationOptions<InviteRes, Error, void>
+) => {
+  return useMutation({
+    mutationFn: () => client.invites.resend(id),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: invitesQueryKeys.lists() })
+      queryClient.invalidateQueries({ queryKey: invitesQueryKeys.detail(id) })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useDeleteInvite = (
+  id: string,
+  options?: UseMutationOptions<InviteDeleteRes, Error, void>
+) => {
+  return useMutation({
+    mutationFn: () => client.invites.delete(id),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: invitesQueryKeys.lists() })
+      queryClient.invalidateQueries({ queryKey: invitesQueryKeys.detail(id) })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin-next/dashboard/src/hooks/api/product-types.tsx

@@ -0,0 +1,40 @@
+import { QueryKey, UseQueryOptions, useQuery } from "@tanstack/react-query"
+import { client } from "../../lib/client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+import { ProductTypeListRes, ProductTypeRes } from "../../types/api-responses"
+
+const PRODUCT_TYPES_QUERY_KEY = "product_types" as const
+const productTypesQueryKeys = queryKeysFactory(PRODUCT_TYPES_QUERY_KEY)
+
+export const useProductType = (
+  id: string,
+  query?: Record<string, any>,
+  options?: Omit<
+    UseQueryOptions<ProductTypeRes, Error, ProductTypeRes, QueryKey>,
+    "queryKey" | "queryFn"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => client.productTypes.retrieve(id, query),
+    queryKey: productTypesQueryKeys.detail(id),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useProductTypes = (
+  query?: Record<string, any>,
+  options?: Omit<
+    UseQueryOptions<ProductTypeListRes, Error, ProductTypeListRes, QueryKey>,
+    "queryKey" | "queryFn"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => client.productTypes.list(query),
+    queryKey: productTypesQueryKeys.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}

packages/admin-next/dashboard/src/hooks/api/products.tsx

@@ -0,0 +1,40 @@
+import { QueryKey, UseQueryOptions, useQuery } from "@tanstack/react-query"
+import { client } from "../../lib/client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+import { ProductListRes, ProductRes } from "../../types/api-responses"
+
+const PRODUCTS_QUERY_KEY = "products" as const
+export const productsQueryKeys = queryKeysFactory(PRODUCTS_QUERY_KEY)
+
+export const useProduct = (
+  id: string,
+  query?: Record<string, any>,
+  options?: Omit<
+    UseQueryOptions<ProductRes, Error, ProductRes, QueryKey>,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => client.products.retrieve(id, query),
+    queryKey: productsQueryKeys.detail(id),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useProducts = (
+  query?: Record<string, any>,
+  options?: Omit<
+    UseQueryOptions<ProductListRes, Error, ProductListRes, QueryKey>,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => client.products.list(query),
+    queryKey: productsQueryKeys.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}

packages/admin-next/dashboard/src/hooks/api/promotions.tsx

@@ -0,0 +1,41 @@
+import { QueryKey, UseQueryOptions, useQuery } from "@tanstack/react-query"
+
+import { AdminGetPromotionsParams } from "@medusajs/medusa"
+import { client } from "../../lib/client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+import { PromotionListRes, PromotionRes } from "../../types/api-responses"
+
+const PROMOTIONS_QUERY_KEY = "promotions" as const
+const promotionsQueryKeys = queryKeysFactory(PROMOTIONS_QUERY_KEY)
+
+export const usePromotion = (
+  id: string,
+  options?: Omit<
+    UseQueryOptions<PromotionRes, Error, PromotionRes, QueryKey>,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryKey: promotionsQueryKeys.detail(id),
+    queryFn: async () => client.promotions.retrieve(id),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const usePromotions = (
+  query?: AdminGetPromotionsParams,
+  options?: Omit<
+    UseQueryOptions<PromotionListRes, Error, PromotionListRes, QueryKey>,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryKey: promotionsQueryKeys.list(query),
+    queryFn: async () => client.promotions.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}

packages/admin-next/dashboard/src/hooks/api/regions.tsx

@@ -0,0 +1,96 @@
+import {
+  QueryKey,
+  UseMutationOptions,
+  UseQueryOptions,
+  useMutation,
+  useQuery,
+} from "@tanstack/react-query"
+import { client } from "../../lib/client"
+import { queryClient } from "../../lib/medusa"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+import { CreateRegionReq } from "../../types/api-payloads"
+import {
+  RegionDeleteRes,
+  RegionListRes,
+  RegionRes,
+} from "../../types/api-responses"
+
+const REGIONS_QUERY_KEY = "regions" as const
+const regionsQueryKeys = queryKeysFactory(REGIONS_QUERY_KEY)
+
+export const useRegion = (
+  id: string,
+  options?: Omit<
+    UseQueryOptions<RegionRes, Error, RegionRes, QueryKey>,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryKey: regionsQueryKeys.detail(id),
+    queryFn: async () => client.regions.retrieve(id),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useRegions = (
+  query?: Record<string, any>,
+  options?: Omit<
+    UseQueryOptions<RegionListRes, Error, RegionListRes, QueryKey>,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => client.regions.list(query),
+    queryKey: regionsQueryKeys.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useCreateRegion = (
+  options?: UseMutationOptions<RegionRes, Error, CreateRegionReq>
+) => {
+  return useMutation({
+    mutationFn: (payload) => client.regions.create(payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: regionsQueryKeys.lists() })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateRegion = (
+  id: string,
+  options?: UseMutationOptions<RegionRes, Error, CreateRegionReq>
+) => {
+  return useMutation({
+    mutationFn: (payload) => client.regions.update(id, payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: regionsQueryKeys.lists() })
+      queryClient.invalidateQueries({ queryKey: regionsQueryKeys.detail(id) })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useDeleteRegion = (
+  id: string,
+  options?: UseMutationOptions<RegionDeleteRes, Error, void>
+) => {
+  return useMutation({
+    mutationFn: () => client.regions.delete(id),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: regionsQueryKeys.lists() })
+      queryClient.invalidateQueries({ queryKey: regionsQueryKeys.detail(id) })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin-next/dashboard/src/hooks/api/sales-channels.tsx

@@ -0,0 +1,190 @@
+import {
+  QueryKey,
+  UseMutationOptions,
+  UseQueryOptions,
+  useMutation,
+  useQuery,
+} from "@tanstack/react-query"
+
+import { client } from "../../lib/client"
+import { queryClient } from "../../lib/medusa"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+import {
+  AddProductsSalesChannelReq,
+  CreateSalesChannelReq,
+  RemoveProductsSalesChannelReq,
+  UpdateSalesChannelReq,
+} from "../../types/api-payloads"
+import {
+  SalesChannelDeleteRes,
+  SalesChannelListRes,
+  SalesChannelRes,
+} from "../../types/api-responses"
+import { productsQueryKeys } from "./products"
+
+const SALES_CHANNELS_QUERY_KEY = "sales-channels" as const
+const salesChannelsQueryKeys = queryKeysFactory(SALES_CHANNELS_QUERY_KEY)
+
+export const useSalesChannel = (
+  id: string,
+  options?: Omit<
+    UseQueryOptions<SalesChannelRes, Error, SalesChannelRes, QueryKey>,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryKey: salesChannelsQueryKeys.detail(id),
+    queryFn: async () => client.salesChannels.retrieve(id),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useSalesChannels = (
+  query?: Record<string, any>,
+  options?: Omit<
+    UseQueryOptions<SalesChannelListRes, Error, SalesChannelListRes, QueryKey>,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => client.salesChannels.list(query),
+    queryKey: salesChannelsQueryKeys.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useCreateSalesChannel = (
+  options?: UseMutationOptions<SalesChannelRes, Error, CreateSalesChannelReq>
+) => {
+  return useMutation({
+    mutationFn: (payload) => client.salesChannels.create(payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: salesChannelsQueryKeys.lists(),
+      })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateSalesChannel = (
+  id: string,
+  options?: UseMutationOptions<SalesChannelRes, Error, UpdateSalesChannelReq>
+) => {
+  return useMutation({
+    mutationFn: (payload) => client.salesChannels.update(id, payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: salesChannelsQueryKeys.lists(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: salesChannelsQueryKeys.detail(id),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useDeleteSalesChannel = (
+  id: string,
+  options?: UseMutationOptions<SalesChannelDeleteRes, Error, void>
+) => {
+  return useMutation({
+    mutationFn: () => client.salesChannels.delete(id),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: salesChannelsQueryKeys.lists(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: salesChannelsQueryKeys.detail(id),
+      })
+
+      // Invalidate all products to ensure they are updated if they were linked to the sales channel
+      queryClient.invalidateQueries({
+        queryKey: productsQueryKeys.all,
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useSalesChannelRemoveProducts = (
+  id: string,
+  options?: UseMutationOptions<
+    SalesChannelRes,
+    Error,
+    RemoveProductsSalesChannelReq
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => client.salesChannels.removeProducts(id, payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: salesChannelsQueryKeys.lists(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: salesChannelsQueryKeys.detail(id),
+      })
+
+      // Invalidate the products that were removed
+      for (const product of variables?.product_ids || []) {
+        queryClient.invalidateQueries({
+          queryKey: productsQueryKeys.detail(product),
+        })
+      }
+
+      // Invalidate the products list query
+      queryClient.invalidateQueries({
+        queryKey: productsQueryKeys.lists(),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useSalesChannelAddProducts = (
+  id: string,
+  options?: UseMutationOptions<
+    SalesChannelRes,
+    Error,
+    AddProductsSalesChannelReq
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => client.salesChannels.addProducts(id, payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: salesChannelsQueryKeys.lists(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: salesChannelsQueryKeys.detail(id),
+      })
+
+      // Invalidate the products that were removed
+      for (const product of variables?.product_ids || []) {
+        queryClient.invalidateQueries({
+          queryKey: productsQueryKeys.detail(product),
+        })
+      }
+
+      // Invalidate the products list query
+      queryClient.invalidateQueries({
+        queryKey: productsQueryKeys.lists(),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin-next/dashboard/src/hooks/api/stock-locations.tsx

@@ -0,0 +1,117 @@
+import {
+  QueryKey,
+  UseMutationOptions,
+  UseQueryOptions,
+  useMutation,
+  useQuery,
+} from "@tanstack/react-query"
+
+import { client } from "../../lib/client"
+import { queryClient } from "../../lib/medusa"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+import {
+  CreateStockLocationReq,
+  UpdateStockLocationReq,
+} from "../../types/api-payloads"
+import {
+  StockLocationDeleteRes,
+  StockLocationListRes,
+  StockLocationRes,
+} from "../../types/api-responses"
+
+const STOCK_LOCATIONS_QUERY_KEY = "stock_locations" as const
+const stockLocationsQueryKeys = queryKeysFactory(STOCK_LOCATIONS_QUERY_KEY)
+
+export const useStockLocation = (
+  id: string,
+  query?: Record<string, any>,
+  options?: Omit<
+    UseQueryOptions<StockLocationRes, Error, StockLocationRes, QueryKey>,
+    "queryKey" | "queryFn"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => client.stockLocations.retrieve(id, query),
+    queryKey: stockLocationsQueryKeys.detail(id),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useStockLocations = (
+  query?: Record<string, any>,
+  options?: Omit<
+    UseQueryOptions<
+      StockLocationListRes,
+      Error,
+      StockLocationListRes,
+      QueryKey
+    >,
+    "queryKey" | "queryFn"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => client.stockLocations.list(query),
+    queryKey: stockLocationsQueryKeys.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useCreateStockLocation = (
+  options?: UseMutationOptions<StockLocationRes, Error, CreateStockLocationReq>
+) => {
+  return useMutation({
+    mutationFn: (payload) => client.stockLocations.create(payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: stockLocationsQueryKeys.lists(),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateStockLocation = (
+  id: string,
+  options?: UseMutationOptions<StockLocationRes, Error, UpdateStockLocationReq>
+) => {
+  return useMutation({
+    mutationFn: (payload) => client.stockLocations.update(id, payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: stockLocationsQueryKeys.detail(id),
+      })
+      queryClient.invalidateQueries({
+        queryKey: stockLocationsQueryKeys.lists(),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useDeleteStockLocation = (
+  id: string,
+  options?: UseMutationOptions<StockLocationDeleteRes, Error, void>
+) => {
+  return useMutation({
+    mutationFn: () => client.stockLocations.delete(id),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: stockLocationsQueryKeys.lists(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: stockLocationsQueryKeys.detail(id),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin-next/dashboard/src/hooks/api/store.tsx

@@ -0,0 +1,48 @@
+import {
+  MutationOptions,
+  QueryKey,
+  UseQueryOptions,
+  useMutation,
+  useQuery,
+} from "@tanstack/react-query"
+
+import { queryKeysFactory } from "medusa-react"
+import { client } from "../../lib/client"
+import { queryClient } from "../../lib/medusa"
+import { UpdateStoreReq } from "../../types/api-payloads"
+import { StoreRes } from "../../types/api-responses"
+
+const STORE_QUERY_KEY = "store" as const
+const storeQueryKeys = queryKeysFactory(STORE_QUERY_KEY)
+
+export const useStore = (
+  options?: Omit<
+    UseQueryOptions<StoreRes, Error, StoreRes, QueryKey>,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => client.stores.retrieve(),
+    queryKey: storeQueryKeys.details(),
+    ...options,
+  })
+
+  return {
+    ...data,
+    ...rest,
+  }
+}
+
+export const useUpdateStore = (
+  id: string,
+  options?: MutationOptions<StoreRes, Error, UpdateStoreReq>
+) => {
+  return useMutation({
+    mutationFn: (payload) => client.stores.update(id, payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: storeQueryKeys.details() })
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin-next/dashboard/src/hooks/api/users.tsx

@@ -0,0 +1,104 @@
+import {
+  QueryKey,
+  UseMutationOptions,
+  UseQueryOptions,
+  useMutation,
+  useQuery,
+} from "@tanstack/react-query"
+import { client } from "../../lib/client"
+import { queryClient } from "../../lib/medusa"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+import { UpdateUserReq } from "../../types/api-payloads"
+import { UserDeleteRes, UserListRes, UserRes } from "../../types/api-responses"
+
+const USERS_QUERY_KEY = "users" as const
+const usersQueryKeys = {
+  ...queryKeysFactory(USERS_QUERY_KEY),
+  me: () => [USERS_QUERY_KEY, "me"],
+}
+
+export const useMe = (
+  options?: UseQueryOptions<UserRes, Error, UserRes, QueryKey>
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => client.users.me(),
+    queryKey: usersQueryKeys.me(),
+    ...options,
+  })
+
+  return {
+    ...data,
+    ...rest,
+  }
+}
+
+export const useUser = (
+  id: string,
+  query?: Record<string, any>,
+  options?: Omit<
+    UseQueryOptions<UserRes, Error, UserRes, QueryKey>,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => client.users.retrieve(id, query),
+    queryKey: usersQueryKeys.detail(id),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useUsers = (
+  query?: Record<string, any>,
+  options?: Omit<
+    UseQueryOptions<UserListRes, Error, UserListRes, QueryKey>,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => client.users.list(query),
+    queryKey: usersQueryKeys.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useUpdateUser = (
+  id: string,
+  options?: UseMutationOptions<UserRes, Error, UpdateUserReq>
+) => {
+  return useMutation({
+    mutationFn: (payload) => client.users.update(id, payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: usersQueryKeys.detail(id) })
+      queryClient.invalidateQueries({ queryKey: usersQueryKeys.lists() })
+
+      // We invalidate the me query in case the user updates their own profile
+      queryClient.invalidateQueries({ queryKey: usersQueryKeys.me() })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useDeleteUser = (
+  id: string,
+  options?: UseMutationOptions<UserDeleteRes, Error, void>
+) => {
+  return useMutation({
+    mutationFn: () => client.users.delete(id),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: usersQueryKeys.detail(id) })
+      queryClient.invalidateQueries({ queryKey: usersQueryKeys.lists() })
+
+      // We invalidate the me query in case the user updates their own profile
+      queryClient.invalidateQueries({ queryKey: usersQueryKeys.me() })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

packages/admin-next/dashboard/src/hooks/api/workflow-executions.tsx

@@ -0,0 +1,55 @@
+import { QueryKey, UseQueryOptions, useQuery } from "@tanstack/react-query"
+import { client } from "../../lib/client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+import {
+  WorkflowExecutionListRes,
+  WorkflowExecutionRes,
+} from "../../types/api-responses"
+
+const WORKFLOW_EXECUTIONS_QUERY_KEY = "workflow_executions" as const
+const workflowExecutionsQueryKeys = queryKeysFactory(
+  WORKFLOW_EXECUTIONS_QUERY_KEY
+)
+
+export const useWorkflowExecutions = (
+  query?: Record<string, any>,
+  options?: Omit<
+    UseQueryOptions<
+      WorkflowExecutionListRes,
+      Error,
+      WorkflowExecutionListRes,
+      QueryKey
+    >,
+    "queryKey" | "queryFn"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => client.workflowExecutions.list(query),
+    queryKey: workflowExecutionsQueryKeys.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useWorkflowExecution = (
+  id: string,
+  query?: Record<string, any>,
+  options?: Omit<
+    UseQueryOptions<
+      WorkflowExecutionRes,
+      Error,
+      WorkflowExecutionRes,
+      QueryKey
+    >,
+    "queryKey" | "queryFn"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => client.workflowExecutions.retrieve(id, query),
+    queryKey: workflowExecutionsQueryKeys.detail(id),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}

packages/admin-next/dashboard/src/hooks/table/columns/use-product-table-columns.tsx

@@ -1,5 +1,4 @@
-import { Product } from "@medusajs/medusa"
-import { ColumnDef, createColumnHelper } from "@tanstack/react-table"
+import { createColumnHelper } from "@tanstack/react-table"
 import { useMemo } from "react"
 
 import {
@@ -22,8 +21,9 @@ import {
   VariantCell,
   VariantHeader,
 } from "../../../components/table/table-cells/product/variant-cell"
+import { ExtendedProductDTO } from "../../../types/api-responses"
 
-const columnHelper = createColumnHelper<Product>()
+const columnHelper = createColumnHelper<ExtendedProductDTO>()
 
 export const useProductTableColumns = () => {
   return useMemo(
@@ -55,5 +55,5 @@ export const useProductTableColumns = () => {
       }),
     ],
     []
-  ) as ColumnDef<Product>[]
+  )
 }

packages/admin-next/dashboard/src/hooks/table/columns/use-sales-channel-table-columns.tsx

@@ -1,6 +1,6 @@
-import { SalesChannel } from "@medusajs/medusa"
 import { createColumnHelper } from "@tanstack/react-table"
 
+import { SalesChannelDTO } from "@medusajs/types"
 import { useMemo } from "react"
 import {
   DescriptionCell,
@@ -11,7 +11,7 @@ import {
   NameHeader,
 } from "../../../components/table/table-cells/sales-channel/name-cell"
 
-const columnHelper = createColumnHelper<SalesChannel>()
+const columnHelper = createColumnHelper<SalesChannelDTO>()
 
 export const useSalesChannelTableColumns = () => {
   return useMemo(

packages/admin-next/dashboard/src/hooks/table/filters/use-product-table-filters.tsx

@@ -1,12 +1,7 @@
-import {
-  useAdminCollections,
-  useAdminProductCategories,
-  useAdminProductTags,
-  useAdminProductTypes,
-  useAdminSalesChannels,
-} from "medusa-react"
 import { useTranslation } from "react-i18next"
 import { Filter } from "../../../components/table/data-table"
+import { useProductTypes } from "../../api/product-types"
+import { useSalesChannels } from "../../api/sales-channels"
 
 const excludeableFields = ["sales_channel_id", "collections"] as const
 
@@ -15,19 +10,19 @@ export const useProductTableFilters = (
 ) => {
   const { t } = useTranslation()
 
-  const { product_types } = useAdminProductTypes({
+  const { product_types } = useProductTypes({
     limit: 1000,
     offset: 0,
   })
 
-  const { product_tags } = useAdminProductTags({
-    limit: 1000,
-    offset: 0,
-  })
+  // const { product_tags } = useAdminProductTags({
+  //   limit: 1000,
+  //   offset: 0,
+  // })
 
   const isSalesChannelExcluded = exclude?.includes("sales_channel_id")
 
-  const { sales_channels } = useAdminSalesChannels(
+  const { sales_channels } = useSalesChannels(
     {
       limit: 1000,
       fields: "id,name",
@@ -38,24 +33,24 @@ export const useProductTableFilters = (
     }
   )
 
-  const { product_categories } = useAdminProductCategories({
-    limit: 1000,
-    offset: 0,
-    fields: "id,name",
-    expand: "",
-  })
+  // const { product_categories } = useAdminProductCategories({
+  //   limit: 1000,
+  //   offset: 0,
+  //   fields: "id,name",
+  //   expand: "",
+  // })
 
   const isCollectionExcluded = exclude?.includes("collections")
 
-  const { collections } = useAdminCollections(
-    {
-      limit: 1000,
-      offset: 0,
-    },
-    {
-      enabled: !isCollectionExcluded,
-    }
-  )
+  // const { collections } = useAdminCollections(
+  //   {
+  //     limit: 1000,
+  //     offset: 0,
+  //   },
+  //   {
+  //     enabled: !isCollectionExcluded,
+  //   }
+  // )
 
   let filters: Filter[] = []
 
@@ -74,20 +69,20 @@ export const useProductTableFilters = (
     filters = [...filters, typeFilter]
   }
 
-  if (product_tags) {
-    const tagFilter: Filter = {
-      key: "tags",
-      label: t("fields.tag"),
-      type: "select",
-      multiple: true,
-      options: product_tags.map((t) => ({
-        label: t.value,
-        value: t.id,
-      })),
-    }
+  // if (product_tags) {
+  //   const tagFilter: Filter = {
+  //     key: "tags",
+  //     label: t("fields.tag"),
+  //     type: "select",
+  //     multiple: true,
+  //     options: product_tags.map((t) => ({
+  //       label: t.value,
+  //       value: t.id,
+  //     })),
+  //   }
 
-    filters = [...filters, tagFilter]
-  }
+  //   filters = [...filters, tagFilter]
+  // }
 
   if (sales_channels) {
     const salesChannelFilter: Filter = {
@@ -104,35 +99,35 @@ export const useProductTableFilters = (
     filters = [...filters, salesChannelFilter]
   }
 
-  if (product_categories) {
-    const categoryFilter: Filter = {
-      key: "category_id",
-      label: t("fields.category"),
-      type: "select",
-      multiple: true,
-      options: product_categories.map((c) => ({
-        label: c.name,
-        value: c.id,
-      })),
-    }
+  // if (product_categories) {
+  //   const categoryFilter: Filter = {
+  //     key: "category_id",
+  //     label: t("fields.category"),
+  //     type: "select",
+  //     multiple: true,
+  //     options: product_categories.map((c) => ({
+  //       label: c.name,
+  //       value: c.id,
+  //     })),
+  //   }
 
-    filters = [...filters, categoryFilter]
-  }
+  //   filters = [...filters, categoryFilter]
+  // }
 
-  if (collections) {
-    const collectionFilter: Filter = {
-      key: "collection_id",
-      label: t("fields.collection"),
-      type: "select",
-      multiple: true,
-      options: collections.map((c) => ({
-        label: c.title,
-        value: c.id,
-      })),
-    }
+  // if (collections) {
+  //   const collectionFilter: Filter = {
+  //     key: "collection_id",
+  //     label: t("fields.collection"),
+  //     type: "select",
+  //     multiple: true,
+  //     options: collections.map((c) => ({
+  //       label: c.title,
+  //       value: c.id,
+  //     })),
+  //   }
 
-    filters = [...filters, collectionFilter]
-  }
+  //   filters = [...filters, collectionFilter]
+  // }
 
   const giftCardFilter: Filter = {
     key: "is_giftcard",

packages/admin-next/dashboard/src/hooks/table/query/use-sales-channel-table-query.tsx

@@ -21,9 +21,9 @@ export const useSalesChannelTableQuery = ({
     limit: pageSize,
     offset: offset ? Number(offset) : 0,
     order,
-    created_at: created_at ? JSON.parse(created_at) : undefined,
-    updated_at: updated_at ? JSON.parse(updated_at) : undefined,
-    q,
+    // created_at: created_at ? JSON.parse(created_at) : undefined,
+    // updated_at: updated_at ? JSON.parse(updated_at) : undefined,
+    // q, // Re-enable when params are fixed
   }
 
   return {