@medusajs/dashboard 3.0.0-snapshot-20251216145629 → 3.0.0-snapshot-20260102125810

package/src/hooks/api/index.ts

@@ -2,6 +2,7 @@ export * from "./api-keys"
 export * from "./auth"
 export * from "./campaigns"
 export * from "./categories"
+export * from "./cloud"
 export * from "./collections"
 export * from "./currencies"
 export * from "./customer-groups"
@@ -18,6 +19,7 @@ export * from "./payment-collections"
 export * from "./payments"
 export * from "./plugins"
 export * from "./price-lists"
+export * from "./product-options"
 export * from "./product-types"
 export * from "./product-variants"
 export * from "./products"
@@ -26,8 +28,8 @@ export * from "./refund-reasons"
 export * from "./regions"
 export * from "./reservations"
 export * from "./sales-channels"
-export * from "./shipping-options"
 export * from "./shipping-option-types"
+export * from "./shipping-options"
 export * from "./shipping-profiles"
 export * from "./stock-locations"
 export * from "./store"

package/src/hooks/api/product-options.tsx

@@ -0,0 +1,151 @@
+import { FetchError } from "@medusajs/js-sdk"
+import {
+  QueryKey,
+  useMutation,
+  UseMutationOptions,
+  useQuery,
+  UseQueryOptions,
+} from "@tanstack/react-query"
+import { sdk } from "../../lib/client"
+import { queryKeysFactory } from "../../lib/query-key-factory"
+import { HttpTypes } from "@medusajs/types"
+import { queryClient } from "../../lib/query-client.ts"
+
+const PRODUCT_OPTIONS_QUERY_KEY = "product_options" as const
+export const productOptionsQueryKeys = queryKeysFactory(
+  PRODUCT_OPTIONS_QUERY_KEY
+)
+
+export const useProductOption = (
+  id: string,
+  query?: HttpTypes.AdminProductOptionParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminProductOptionResponse,
+      FetchError,
+      HttpTypes.AdminProductOptionResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryKey: productOptionsQueryKeys.detail(id, query),
+    queryFn: () => sdk.admin.productOption.retrieve(id, query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useProductOptions = (
+  query?: HttpTypes.AdminProductOptionListParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminProductOptionListResponse,
+      FetchError,
+      HttpTypes.AdminProductOptionListResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.productOption.list(query),
+    queryKey: productOptionsQueryKeys.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useCreateProductOption = (
+  options?: UseMutationOptions<
+    HttpTypes.AdminProductOptionResponse,
+    FetchError,
+    HttpTypes.AdminCreateProductOption
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.productOption.create(payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: productOptionsQueryKeys.lists(),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useUpdateProductOption = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminProductOptionResponse,
+    FetchError,
+    HttpTypes.AdminUpdateProductOption
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.productOption.update(id, payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: productOptionsQueryKeys.lists(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: productOptionsQueryKeys.detail(id),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useDeleteProductOption = (
+  id: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminProductOptionDeleteResponse,
+    FetchError,
+    void
+  >
+) => {
+  return useMutation({
+    mutationFn: () => sdk.admin.productOption.delete(id),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: productOptionsQueryKeys.lists(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: productOptionsQueryKeys.detail(id),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useDeleteProductOptionLazy = (
+  options?: UseMutationOptions<
+    HttpTypes.AdminProductOptionDeleteResponse,
+    FetchError,
+    string
+  >
+) => {
+  return useMutation({
+    mutationFn: (id: string) => sdk.admin.productOption.delete(id),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: productOptionsQueryKeys.lists(),
+      })
+      queryClient.invalidateQueries({
+        queryKey: productOptionsQueryKeys.details(),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}

package/src/hooks/api/products.tsx

@@ -13,6 +13,7 @@ import { sdk } from "../../lib/client"
 import { queryClient } from "../../lib/query-client"
 import { queryKeysFactory } from "../../lib/query-key-factory"
 import { inventoryItemsQueryKeys } from "./inventory.tsx"
+import { productOptionsQueryKeys } from "./product-options.tsx"
 import { useInfiniteList } from "../use-infinite-list.tsx"
 
 const PRODUCTS_QUERY_KEY = "products" as const
@@ -21,72 +22,6 @@ export const productsQueryKeys = queryKeysFactory(PRODUCTS_QUERY_KEY)
 const VARIANTS_QUERY_KEY = "product_variants" as const
 export const variantsQueryKeys = queryKeysFactory(VARIANTS_QUERY_KEY)
 
-const OPTIONS_QUERY_KEY = "product_options" as const
-export const optionsQueryKeys = queryKeysFactory(OPTIONS_QUERY_KEY)
-
-export const useCreateProductOption = (
-  productId: string,
-  options?: UseMutationOptions<any, FetchError, any>
-) => {
-  return useMutation({
-    mutationFn: (payload: HttpTypes.AdminCreateProductOption) =>
-      sdk.admin.product.createOption(productId, payload),
-    onSuccess: (data: any, variables: any, context: any) => {
-      queryClient.invalidateQueries({ queryKey: optionsQueryKeys.lists() })
-      queryClient.invalidateQueries({
-        queryKey: productsQueryKeys.detail(productId),
-      })
-      options?.onSuccess?.(data, variables, context)
-    },
-    ...options,
-  })
-}
-
-export const useUpdateProductOption = (
-  productId: string,
-  optionId: string,
-  options?: UseMutationOptions<any, FetchError, any>
-) => {
-  return useMutation({
-    mutationFn: (payload: HttpTypes.AdminUpdateProductOption) =>
-      sdk.admin.product.updateOption(productId, optionId, payload),
-    onSuccess: (data: any, variables: any, context: any) => {
-      queryClient.invalidateQueries({ queryKey: optionsQueryKeys.lists() })
-      queryClient.invalidateQueries({
-        queryKey: optionsQueryKeys.detail(optionId),
-      })
-      queryClient.invalidateQueries({
-        queryKey: productsQueryKeys.detail(productId),
-      })
-
-      options?.onSuccess?.(data, variables, context)
-    },
-    ...options,
-  })
-}
-
-export const useDeleteProductOption = (
-  productId: string,
-  optionId: string,
-  options?: UseMutationOptions<any, FetchError, void>
-) => {
-  return useMutation({
-    mutationFn: () => sdk.admin.product.deleteOption(productId, optionId),
-    onSuccess: (data: any, variables: any, context: any) => {
-      queryClient.invalidateQueries({ queryKey: optionsQueryKeys.lists() })
-      queryClient.invalidateQueries({
-        queryKey: optionsQueryKeys.detail(optionId),
-      })
-      queryClient.invalidateQueries({
-        queryKey: productsQueryKeys.detail(productId),
-      })
-
-      options?.onSuccess?.(data, variables, context)
-    },
-    ...options,
-  })
-}
-
 export const useProductVariant = (
   productId: string,
   variantId: string,
@@ -408,6 +343,31 @@ export const useDeleteProduct = (
   })
 }
 
+export const useLinkProductOptions = (
+  productId: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminProductResponse,
+    FetchError,
+    HttpTypes.AdminLinkProductOptions
+  >
+) => {
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.product.linkOptions(productId, payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({ queryKey: productsQueryKeys.lists() })
+      queryClient.invalidateQueries({
+        queryKey: productsQueryKeys.detail(productId),
+      })
+      queryClient.invalidateQueries({
+        queryKey: productOptionsQueryKeys.lists(),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
 export const useExportProducts = (
   query?: HttpTypes.AdminProductListParams,
   options?: UseMutationOptions<

package/src/hooks/api/translations.tsx

@@ -2,25 +2,16 @@ import { FetchError } from "@medusajs/js-sdk"
 import { HttpTypes } from "@medusajs/types"
 import {
   QueryKey,
+  useInfiniteQuery,
   UseInfiniteQueryOptions,
-  UseInfiniteQueryResult,
   useMutation,
   UseMutationOptions,
   useQuery,
   UseQueryOptions,
 } from "@tanstack/react-query"
 import { sdk } from "../../lib/client"
-import { queryKeysFactory } from "../../lib/query-key-factory"
 import { queryClient } from "../../lib/query-client"
-import { productsQueryKeys, useInfiniteProducts } from "./products"
-import {
-  productVariantQueryKeys,
-  useInfiniteVariants,
-} from "./product-variants"
-import { categoriesQueryKeys, useInfiniteCategories } from "./categories"
-import { collectionsQueryKeys, useInfiniteCollections } from "./collections"
-import { productTagsQueryKeys, useInfiniteProductTags } from "./tags"
-import { productTypesQueryKeys, useInfiniteProductTypes } from "./product-types"
+import { queryKeysFactory } from "../../lib/query-key-factory"
 
 const TRANSLATIONS_QUERY_KEY = "translations" as const
 export const translationsQueryKeys = queryKeysFactory(TRANSLATIONS_QUERY_KEY)
@@ -35,177 +26,77 @@ export const translationStatisticsQueryKeys = queryKeysFactory(
   TRANSLATION_STATISTICS_QUERY_KEY
 )
 
+const TRANSLATION_ENTITIES_QUERY_KEY = "translation_entities" as const
+export const translationEntitiesQueryKeys = queryKeysFactory(
+  TRANSLATION_ENTITIES_QUERY_KEY
+)
+
+const DEFAULT_PAGE_SIZE = 20
+
+/**
+ * Hook to fetch entities with their translatable fields and all translations.
+ * Uses the /admin/translations/entities endpoint which returns entities
+ * with all their translations for all locales.
+ *
+ * @param reference - The entity type (e.g., "product", "product_variant")
+ * @param referenceId - Optional ID(s) to filter specific entities
+ * @param options - React Query options
+ */
 export const useReferenceTranslations = (
   reference: string,
-  translatableFields: string[],
   referenceId?: string | string[],
   options?: Omit<
-    UseInfiniteQueryOptions<any, FetchError, any, any, QueryKey, number>,
+    UseInfiniteQueryOptions<
+      HttpTypes.AdminTranslationEntitiesResponse,
+      FetchError,
+      {
+        pages: HttpTypes.AdminTranslationEntitiesResponse[]
+        pageParams: number[]
+      },
+      HttpTypes.AdminTranslationEntitiesResponse,
+      QueryKey,
+      number
+    >,
     "queryFn" | "queryKey" | "initialPageParam" | "getNextPageParam"
   >
 ) => {
-  const referenceHookMap = new Map<
-    string,
-    () => Omit<UseInfiniteQueryResult<any, FetchError>, "data"> & {
-      data: {
-        translations: HttpTypes.AdminTranslation[]
-        references: (Record<string, any> & { id: string })[]
-        count: number
-      }
-    }
-  >([
-    [
-      "product",
-      () => {
-        const fields = translatableFields.concat(["translations.*"]).join(",")
-
-        const { data, ...rest } = useInfiniteProducts(
-          { fields, id: referenceId ?? [] },
-          options
-        )
-        const products = data?.pages.flatMap((page) => page.products) ?? []
-
-        return {
-          ...rest,
-          data: {
-            translations:
-              products?.flatMap((product) => product.translations ?? []) ?? [],
-            references: products ?? [],
-            count: data?.pages[0]?.count ?? 0,
-          },
-        }
-      },
-    ],
-    [
-      "product_variant",
-      () => {
-        const fields = translatableFields.concat(["translations.*"]).join(",")
-
-        const { data, ...rest } = useInfiniteVariants(
-          { id: referenceId ?? [], fields },
-          options
-        )
-        const variants = data?.pages.flatMap((page) => page.variants) ?? []
-
-        return {
-          ...rest,
-          data: {
-            translations:
-              variants?.flatMap((variant) => variant.translations ?? []) ?? [],
-            references: variants ?? [],
-            translatableFields,
-            count: data?.pages[0]?.count ?? 0,
-          },
-        }
-      },
-    ],
-    [
-      "product_category",
-      () => {
-        const fields = translatableFields.concat(["translations.*"]).join(",")
-
-        const { data, ...rest } = useInfiniteCategories(
-          { id: referenceId ?? [], fields },
-          options
-        )
-        const categories =
-          data?.pages.flatMap((page) => page.product_categories) ?? []
-
-        return {
-          ...rest,
-          data: {
-            translations:
-              categories?.flatMap((category) => category.translations ?? []) ??
-              [],
-            references: categories ?? [],
-            translatableFields,
-            count: data?.pages[0]?.count ?? 0,
-          },
-        }
-      },
-    ],
-    [
-      "product_collection",
-      () => {
-        const fields = translatableFields.concat(["translations.*"]).join(",")
-
-        const { data, ...rest } = useInfiniteCollections(
-          { id: referenceId ?? [], fields },
-          options
-        )
-        const collections =
-          data?.pages.flatMap((page) => page.collections) ?? []
-
-        return {
-          ...rest,
-          data: {
-            translations:
-              collections?.flatMap(
-                (collection) => collection.translations ?? []
-              ) ?? [],
-            references: collections ?? [],
-            translatableFields,
-            count: data?.pages[0]?.count ?? 0,
-          },
-        }
-      },
-    ],
-    [
-      "product_type",
-      () => {
-        const fields = translatableFields.concat(["translations.*"]).join(",")
-
-        const { data, ...rest } = useInfiniteProductTypes(
-          { id: referenceId ?? [], fields },
-          options
-        )
-        const product_types =
-          data?.pages.flatMap((page) => page.product_types) ?? []
-
-        return {
-          ...rest,
-          data: {
-            translations:
-              product_types?.flatMap((type) => type.translations ?? []) ?? [],
-            references: product_types ?? [],
-            count: data?.pages[0]?.count ?? 0,
-            translatableFields,
-          },
-        }
-      },
-    ],
-    [
-      "product_tag",
-      () => {
-        const fields = translatableFields.concat(["translations.*"]).join(",")
-
-        const { data, ...rest } = useInfiniteProductTags(
-          { id: referenceId ?? [], fields },
-          options
-        )
-        const product_tags =
-          data?.pages.flatMap((page) => page.product_tags) ?? []
+  const { data, ...rest } = useInfiniteQuery({
+    queryKey: translationEntitiesQueryKeys.list({
+      type: reference,
+      id: referenceId,
+    }),
+    queryFn: async ({ pageParam = 0 }) => {
+      return sdk.admin.translation.entities({
+        type: reference,
+        id: referenceId,
+        limit: DEFAULT_PAGE_SIZE,
+        offset: pageParam,
+      })
+    },
+    initialPageParam: 0,
+    getNextPageParam: (lastPage) => {
+      const nextOffset = lastPage.offset + lastPage.limit
+      return nextOffset < lastPage.count ? nextOffset : undefined
+    },
+    ...options,
+  })
 
-        return {
-          ...rest,
-          data: {
-            translations:
-              product_tags?.flatMap((tag) => tag.translations ?? []) ?? [],
-            references: product_tags ?? [],
-            translatableFields,
-            count: data?.pages[0]?.count ?? 0,
-          },
-        }
-      },
-    ],
-    // TODO: product option and option values
-  ])
-  const referenceHook = referenceHookMap.get(reference)
-  if (!referenceHook) {
-    throw new Error(`No hook found for reference type: ${reference}`)
+  const entitiesWithTranslations =
+    data?.pages.flatMap((page) => page.data) ?? []
+  const translations = entitiesWithTranslations.flatMap(
+    (entity) => entity.translations ?? []
+  )
+  const references = entitiesWithTranslations.map(
+    ({ translations: _, ...entity }) => entity
+  )
+  const count = data?.pages[0]?.count ?? 0
+
+  return {
+    references,
+    translations,
+    count,
+    ...rest,
   }
-  const { data, ...rest } = referenceHook()
-  return { ...data, ...rest }
 }
 
 export const useTranslations = (
@@ -237,30 +128,30 @@ export const useBatchTranslations = (
     HttpTypes.AdminBatchTranslations
   >
 ) => {
-  const referenceInvalidationKeysMap = new Map<string, QueryKey>([
-    ["product", productsQueryKeys.lists()],
-    ["product_variant", productVariantQueryKeys.lists()],
-    ["product_category", categoriesQueryKeys.lists()],
-    ["product_collection", collectionsQueryKeys.lists()],
-    ["product_type", productTypesQueryKeys.lists()],
-    ["product_tag", productTagsQueryKeys.lists()],
-  ])
-
-  return useMutation({
+  const mutation = useMutation({
     mutationFn: (payload: HttpTypes.AdminBatchTranslations) =>
       sdk.admin.translation.batch(payload),
-    onSuccess: (data, variables, context) => {
+    ...options,
+  })
+
+  /**
+   * Useful to call the invalidation separately from the batch request and await the refetch finishes.
+   */
+  const invalidateQueries = async () => {
+    await Promise.all([
       queryClient.invalidateQueries({
-        queryKey: referenceInvalidationKeysMap.get(reference),
-      })
+        queryKey: translationEntitiesQueryKeys.list({ type: reference }),
+      }),
       queryClient.invalidateQueries({
         queryKey: translationStatisticsQueryKeys.lists(),
-      })
+      }),
+    ])
+  }
 
-      options?.onSuccess?.(data, variables, context)
-    },
-    ...options,
-  })
+  return {
+    ...mutation,
+    invalidateQueries,
+  }
 }
 
 export const useTranslationSettings = (
@@ -284,6 +175,27 @@ export const useTranslationSettings = (
   return { ...data, ...rest }
 }
 
+export const useTranslationEntities = (
+  query: HttpTypes.AdminTranslationEntitiesParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminTranslationEntitiesResponse,
+      FetchError,
+      HttpTypes.AdminTranslationEntitiesResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryKey: translationEntitiesQueryKeys.list(query),
+    queryFn: () => sdk.admin.translation.entities(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
 export const useTranslationStatistics = (
   query?: HttpTypes.AdminTranslationStatisticsParams,
   options?: Omit<

package/src/hooks/table/columns/use-order-table-columns.tsx

@@ -9,6 +9,7 @@ import {
   DateCell,
   DateHeader,
 } from "../../../components/table/table-cells/common/date-cell"
+import { countries } from "../../../lib/data/countries"
 import { CountryCell } from "../../../components/table/table-cells/order/country-cell"
 import {
   CustomerCell,
@@ -101,10 +102,10 @@ export const useOrderTableColumns = (props: UseOrderTableColumnsProps) => {
             const isFullyRefunded = row.original.payment_status === "refunded"
             const total = !isFullyRefunded
               ? getValue()
-              : row.original.payment_collections.reduce(
+              : row.original.payment_collections?.reduce(
                   (acc, payCol) => acc + (payCol.refunded_amount ?? 0),
                   0
-                )
+                ) || 0
             const currencyCode = row.original.currency_code
 
             return (
@@ -121,7 +122,8 @@ export const useOrderTableColumns = (props: UseOrderTableColumnsProps) => {
       columnHelper.display({
         id: "actions",
         cell: ({ row }) => {
-          const country = row.original.shipping_address?.country
+          const countryCode = row.original.shipping_address?.country_code
+          const country = countries.find((c) => c.iso_2 === countryCode)
 
           return <CountryCell country={country} />
         },