@medusajs/dashboard 2.12.3-preview-20251217120154 → 2.12.3-snapshot-20251216185234

package/src/hooks/api/collections.tsx

@@ -1,7 +1,9 @@
 import { FetchError } from "@medusajs/js-sdk"
 import { FindParams, HttpTypes, PaginatedResponse } from "@medusajs/types"
 import {
+  InfiniteData,
   QueryKey,
+  UseInfiniteQueryOptions,
   UseMutationOptions,
   UseQueryOptions,
   useMutation,
@@ -11,6 +13,7 @@ import { sdk } from "../../lib/client"
 import { queryClient } from "../../lib/query-client"
 import { queryKeysFactory } from "../../lib/query-key-factory"
 import { productsQueryKeys } from "./products"
+import { useInfiniteList } from "../use-infinite-list"
 
 const COLLECTION_QUERY_KEY = "collections" as const
 export const collectionsQueryKeys = queryKeysFactory(COLLECTION_QUERY_KEY)
@@ -57,6 +60,34 @@ export const useCollections = (
   return { ...data, ...rest }
 }
 
+export const useInfiniteCollections = (
+  query?: Omit<HttpTypes.AdminCollectionListParams, "offset" | "limit"> & {
+    limit?: number
+  },
+  options?: Omit<
+    UseInfiniteQueryOptions<
+      HttpTypes.AdminCollectionListResponse,
+      FetchError,
+      InfiniteData<HttpTypes.AdminCollectionListResponse, number>,
+      HttpTypes.AdminCollectionListResponse,
+      QueryKey,
+      number
+    >,
+    "queryFn" | "queryKey" | "initialPageParam" | "getNextPageParam"
+  >
+) => {
+  return useInfiniteList<
+    HttpTypes.AdminCollectionListResponse,
+    HttpTypes.AdminCollectionListParams,
+    FetchError,
+    QueryKey
+  >({
+    queryKey: (params) => collectionsQueryKeys.list(params),
+    queryFn: (params) => sdk.admin.productCollection.list(params),
+    query,
+    options,
+  })
+}
 export const useUpdateCollection = (
   id: string,
   options?: UseMutationOptions<

package/src/hooks/api/index.ts

@@ -34,6 +34,7 @@ export * from "./store"
 export * from "./tags"
 export * from "./tax-rates"
 export * from "./tax-regions"
+export * from "./translations"
 export * from "./users"
 export * from "./views"
 export * from "./workflow-executions"

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

@@ -1,7 +1,9 @@
 import { FetchError } from "@medusajs/js-sdk"
 import { HttpTypes } from "@medusajs/types"
 import {
+  InfiniteData,
   QueryKey,
+  UseInfiniteQueryOptions,
   UseMutationOptions,
   UseQueryOptions,
   useMutation,
@@ -10,6 +12,7 @@ import {
 import { sdk } from "../../lib/client"
 import { queryClient } from "../../lib/query-client"
 import { queryKeysFactory } from "../../lib/query-key-factory"
+import { useInfiniteList } from "../use-infinite-list"
 
 const PRODUCT_TYPES_QUERY_KEY = "product_types" as const
 export const productTypesQueryKeys = queryKeysFactory(PRODUCT_TYPES_QUERY_KEY)
@@ -57,6 +60,35 @@ export const useProductTypes = (
   return { ...data, ...rest }
 }
 
+export const useInfiniteProductTypes = (
+  query?: Omit<HttpTypes.AdminProductTypeListParams, "offset" | "limit"> & {
+    limit?: number
+  },
+  options?: Omit<
+    UseInfiniteQueryOptions<
+      HttpTypes.AdminProductTypeListResponse,
+      FetchError,
+      InfiniteData<HttpTypes.AdminProductTypeListResponse, number>,
+      HttpTypes.AdminProductTypeListResponse,
+      QueryKey,
+      number
+    >,
+    "queryFn" | "queryKey" | "initialPageParam" | "getNextPageParam"
+  >
+) => {
+  return useInfiniteList<
+    HttpTypes.AdminProductTypeListResponse,
+    HttpTypes.AdminProductTypeListParams,
+    FetchError,
+    QueryKey
+  >({
+    queryKey: (params) => productTypesQueryKeys.list(params),
+    queryFn: (params) => sdk.admin.productType.list(params),
+    query,
+    options,
+  })
+}
+
 export const useCreateProductType = (
   options?: UseMutationOptions<
     HttpTypes.AdminProductTypeResponse,

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

@@ -1,7 +1,15 @@
-import { QueryKey, useQuery, UseQueryOptions } from "@tanstack/react-query"
+import {
+  QueryKey,
+  UseInfiniteQueryOptions,
+  useQuery,
+  UseQueryOptions,
+} from "@tanstack/react-query"
+import { InfiniteData } from "@tanstack/query-core"
 import { sdk } from "../../lib/client"
 import { queryKeysFactory } from "../../lib/query-key-factory"
 import { FetchError } from "@medusajs/js-sdk"
+import { HttpTypes } from "@medusajs/types"
+import { useInfiniteList } from "../use-infinite-list"
 
 const PRODUCT_VARIANT_QUERY_KEY = "product_variant" as const
 export const productVariantQueryKeys = queryKeysFactory(
@@ -9,9 +17,14 @@ export const productVariantQueryKeys = queryKeysFactory(
 )
 
 export const useVariants = (
-  query?: Record<string, any>,
+  query?: HttpTypes.AdminProductVariantParams,
   options?: Omit<
-    UseQueryOptions<any, FetchError, any, QueryKey>,
+    UseQueryOptions<
+      HttpTypes.AdminProductVariantListResponse,
+      FetchError,
+      HttpTypes.AdminProductVariantListResponse,
+      QueryKey
+    >,
     "queryFn" | "queryKey"
   >
 ) => {
@@ -23,3 +36,34 @@ export const useVariants = (
 
   return { ...data, ...rest }
 }
+
+export const useInfiniteVariants = (
+  query?: Omit<HttpTypes.AdminProductVariantParams, "offset" | "limit"> & {
+    limit?: number
+  },
+  options?: Omit<
+    UseInfiniteQueryOptions<
+      HttpTypes.AdminProductVariantListResponse,
+      FetchError,
+      InfiniteData<HttpTypes.AdminProductVariantListResponse, number>,
+      HttpTypes.AdminProductVariantListResponse,
+      QueryKey,
+      number
+    >,
+    "queryFn" | "queryKey" | "initialPageParam" | "getNextPageParam"
+  >
+) => {
+  return useInfiniteList<
+    HttpTypes.AdminProductVariantListResponse,
+    HttpTypes.AdminProductVariantParams,
+    FetchError,
+    QueryKey
+  >({
+    queryKey: (params) => productVariantQueryKeys.list(params),
+    queryFn: async (params) => {
+      return await sdk.admin.productVariant.list(params)
+    },
+    query,
+    options,
+  })
+}

package/src/hooks/api/products.tsx

@@ -2,15 +2,18 @@ import { FetchError } from "@medusajs/js-sdk"
 import { HttpTypes } from "@medusajs/types"
 import {
   QueryKey,
+  UseInfiniteQueryOptions,
   useMutation,
   UseMutationOptions,
   useQuery,
   UseQueryOptions,
 } from "@tanstack/react-query"
+import { InfiniteData } from "@tanstack/query-core"
 import { sdk } from "../../lib/client"
 import { queryClient } from "../../lib/query-client"
 import { queryKeysFactory } from "../../lib/query-key-factory"
 import { inventoryItemsQueryKeys } from "./inventory.tsx"
+import { useInfiniteList } from "../use-infinite-list.tsx"
 
 const PRODUCTS_QUERY_KEY = "products" as const
 export const productsQueryKeys = queryKeysFactory(PRODUCTS_QUERY_KEY)
@@ -310,6 +313,32 @@ export const useProducts = (
   return { ...data, ...rest }
 }
 
+export const useInfiniteProducts = (
+  query?: HttpTypes.AdminProductListParams,
+  options?: Omit<
+    UseInfiniteQueryOptions<
+      HttpTypes.AdminProductListResponse,
+      FetchError,
+      InfiniteData<HttpTypes.AdminProductListResponse, number>,
+      HttpTypes.AdminProductListResponse,
+      QueryKey,
+      number
+    >,
+    "queryFn" | "queryKey" | "initialPageParam" | "getNextPageParam"
+  >
+) => {
+  return useInfiniteList<
+    HttpTypes.AdminProductListResponse,
+    HttpTypes.AdminProductListParams,
+    FetchError,
+    QueryKey
+  >({
+    queryKey: (params) => productsQueryKeys.list(params),
+    queryFn: (params) => sdk.admin.product.list(params),
+    query,
+    options,
+  })
+}
 export const useCreateProduct = (
   options?: UseMutationOptions<
     HttpTypes.AdminProductResponse,

package/src/hooks/api/tags.tsx

@@ -1,7 +1,9 @@
 import { FetchError } from "@medusajs/js-sdk"
 import { HttpTypes } from "@medusajs/types"
 import {
+  InfiniteData,
   QueryKey,
+  UseInfiniteQueryOptions,
   UseMutationOptions,
   UseQueryOptions,
   useMutation,
@@ -10,6 +12,7 @@ import {
 import { sdk } from "../../lib/client"
 import { queryClient } from "../../lib/query-client"
 import { queryKeysFactory } from "../../lib/query-key-factory"
+import { useInfiniteList } from "../use-infinite-list"
 
 const TAGS_QUERY_KEY = "tags" as const
 export const productTagsQueryKeys = queryKeysFactory(TAGS_QUERY_KEY)
@@ -57,6 +60,35 @@ export const useProductTags = (
   return { ...data, ...rest }
 }
 
+export const useInfiniteProductTags = (
+  query?: Omit<HttpTypes.AdminProductTagListParams, "offset" | "limit"> & {
+    limit?: number
+  },
+  options?: Omit<
+    UseInfiniteQueryOptions<
+      HttpTypes.AdminProductTagListResponse,
+      FetchError,
+      InfiniteData<HttpTypes.AdminProductTagListResponse, number>,
+      HttpTypes.AdminProductTagListResponse,
+      QueryKey,
+      number
+    >,
+    "queryFn" | "queryKey" | "initialPageParam" | "getNextPageParam"
+  >
+) => {
+  return useInfiniteList<
+    HttpTypes.AdminProductTagListResponse,
+    HttpTypes.AdminProductTagListParams,
+    FetchError,
+    QueryKey
+  >({
+    queryKey: (params) => productTagsQueryKeys.list(params),
+    queryFn: (params) => sdk.admin.productTag.list(params),
+    query,
+    options,
+  })
+}
+
 export const useCreateProductTag = (
   query?: HttpTypes.AdminProductTagParams,
   options?: UseMutationOptions<

package/src/hooks/api/translations.tsx

@@ -0,0 +1,306 @@
+import { FetchError } from "@medusajs/js-sdk"
+import { HttpTypes } from "@medusajs/types"
+import {
+  QueryKey,
+  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"
+
+const TRANSLATIONS_QUERY_KEY = "translations" as const
+export const translationsQueryKeys = queryKeysFactory(TRANSLATIONS_QUERY_KEY)
+
+const TRANSLATION_SETTINGS_QUERY_KEY = "translation_settings" as const
+export const translationSettingsQueryKeys = queryKeysFactory(
+  TRANSLATION_SETTINGS_QUERY_KEY
+)
+
+const TRANSLATION_STATISTICS_QUERY_KEY = "translation_statistics" as const
+export const translationStatisticsQueryKeys = queryKeysFactory(
+  TRANSLATION_STATISTICS_QUERY_KEY
+)
+
+export const useReferenceTranslations = (
+  reference: string,
+  translatableFields: string[],
+  referenceId?: string | string[],
+  options?: Omit<
+    UseInfiniteQueryOptions<any, FetchError, any, any, 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) ?? []
+
+        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 { data, ...rest } = referenceHook()
+  return { ...data, ...rest }
+}
+
+export const useTranslations = (
+  query?: HttpTypes.AdminTranslationsListParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminTranslationsListResponse,
+      FetchError,
+      HttpTypes.AdminTranslationsListResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryKey: translationsQueryKeys.list(query),
+    queryFn: () => sdk.admin.translation.list(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useBatchTranslations = (
+  reference: string,
+  options?: UseMutationOptions<
+    HttpTypes.AdminTranslationsBatchResponse,
+    FetchError,
+    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({
+    mutationFn: (payload: HttpTypes.AdminBatchTranslations) =>
+      sdk.admin.translation.batch(payload),
+    onSuccess: (data, variables, context) => {
+      queryClient.invalidateQueries({
+        queryKey: referenceInvalidationKeysMap.get(reference),
+      })
+      queryClient.invalidateQueries({
+        queryKey: translationStatisticsQueryKeys.lists(),
+      })
+
+      options?.onSuccess?.(data, variables, context)
+    },
+    ...options,
+  })
+}
+
+export const useTranslationSettings = (
+  query?: HttpTypes.AdminTranslationSettingsParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminTranslationSettingsResponse,
+      FetchError,
+      HttpTypes.AdminTranslationSettingsResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryKey: translationSettingsQueryKeys.list(query),
+    queryFn: () => sdk.admin.translation.settings(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}
+
+export const useTranslationStatistics = (
+  query?: HttpTypes.AdminTranslationStatisticsParams,
+  options?: Omit<
+    UseQueryOptions<
+      HttpTypes.AdminTranslationStatisticsResponse,
+      FetchError,
+      HttpTypes.AdminTranslationStatisticsResponse,
+      QueryKey
+    >,
+    "queryFn" | "queryKey"
+  >
+) => {
+  const { data, ...rest } = useQuery({
+    queryKey: translationStatisticsQueryKeys.list(query),
+    queryFn: () => sdk.admin.translation.statistics(query),
+    ...options,
+  })
+
+  return { ...data, ...rest }
+}

package/src/hooks/use-infinite-list.tsx

@@ -0,0 +1,92 @@
+import { FetchError } from "@medusajs/js-sdk"
+import { PaginatedResponse } from "@medusajs/types"
+import {
+  QueryKey,
+  UseInfiniteQueryOptions,
+  InfiniteData,
+  useInfiniteQuery,
+} from "@tanstack/react-query"
+
+/**
+ * Generic hook for infinite queries with pagination support.
+ *
+ * @template TResponse - The response type that must include count, offset, and limit
+ * @template TParams - The query parameters type (offset and limit will be handled internally)
+ * @template TError - The error type (defaults to FetchError)
+ * @template TQueryKey - The query key type (defaults to QueryKey)
+ *
+ * @param config - Configuration object
+ * @param config.queryKey - Function or array that generates the query key
+ * @param config.queryFn - Function that fetches data with offset and limit
+ * @param config.query - Query parameters (offset is ignored, limit is optional)
+ * @param config.options - Additional options for useInfiniteQuery
+ *
+ * @example
+ * ```ts
+ * const { data, fetchNextPage, hasNextPage } = useInfiniteList({
+ *   queryKey: (params) => productVariantQueryKeys.list(params),
+ *   queryFn: async (params) => sdk.admin.productVariant.list(params),
+ *   query: { status: "published" },
+ * })
+ * ```
+ */
+export const useInfiniteList = <
+  TResponse extends PaginatedResponse<unknown>,
+  TParams extends { offset?: number; limit?: number } = {
+    offset?: number
+    limit?: number
+  },
+  TError = FetchError,
+  TQueryKey extends QueryKey = QueryKey
+>({
+  queryKey,
+  queryFn,
+  query,
+  options,
+}: {
+  queryKey: ((params: Omit<TParams, "limit">) => TQueryKey) | TQueryKey
+  queryFn: (params: TParams) => Promise<TResponse>
+  query?: TParams
+  options?: Omit<
+    UseInfiniteQueryOptions<
+      TResponse,
+      TError,
+      InfiniteData<TResponse, number>,
+      TResponse,
+      TQueryKey,
+      number
+    >,
+    "queryKey" | "queryFn" | "initialPageParam" | "getNextPageParam"
+  >
+}) => {
+  const { limit = 50, offset: _, ..._query } = query ?? {}
+  const resolvedQueryKey =
+    typeof queryKey === "function"
+      ? queryKey(_query as Omit<TParams, "limit">)
+      : queryKey
+  const infiniteQueryKey =
+    resolvedQueryKey[resolvedQueryKey.length - 1] === "__infinite"
+      ? resolvedQueryKey
+      : ([...resolvedQueryKey, "__infinite"] as unknown as TQueryKey)
+
+  return useInfiniteQuery<
+    TResponse,
+    TError,
+    InfiniteData<TResponse, number>,
+    TQueryKey,
+    number
+  >({
+    // Infinite queries must not share the exact same queryKey as non-infinite queries,
+    // since the cached data shape differs (InfiniteData<T> vs T).
+    queryKey: infiniteQueryKey,
+    queryFn: ({ pageParam = 0 }) => {
+      return queryFn({ ..._query, limit, offset: pageParam } as TParams)
+    },
+    initialPageParam: 0,
+    getNextPageParam: (lastPage) => {
+      const moreItemsExist = lastPage.count > lastPage.offset + lastPage.limit
+      return moreItemsExist ? lastPage.offset + lastPage.limit : undefined
+    },
+    ...options,
+  })
+}