@anker-in/lib 1.0.0-beta.6 → 1.1.0-beta.1

package/src/cart/utils/autoFreeGift.ts

@@ -0,0 +1,297 @@
+import { AutoFreeGiftMainProduct, SpendMoneyType, RuleCondition, FormattedGift } from '../types/autoFreeGift'
+import { CUSTOMER_ATTRIBUTE_KEY } from '../../shopify/utils/const'
+import { atobID } from '../../shopify/utils/helper'
+import { UseScriptAutoFreeGiftResult } from '../hooks/feature/useScriptAutoFreeGift'
+import Cookies from 'js-cookie'
+import Decimal from 'decimal.js'
+import { Product } from '../../shopify/types'
+import { getQuery } from '../utils'
+
+export const getMatchedMainProductSubTotal = (
+  cartData: any,
+  variant_list: AutoFreeGiftMainProduct['variant_id_list'],
+  main_product: AutoFreeGiftMainProduct
+) => {
+  const isAllStoreVariant = main_product?.all_store_variant ?? false
+  const matchedList = cartData?.lineItems?.filter((line: any) => {
+    // 包含在主商品列表中
+    const { is_gift } = getDiscountEnvAttributeValue(line.customAttributes) // 获取折扣环境属性值
+    return isAllStoreVariant
+      ? !is_gift
+      : variant_list?.find((item: any) => {
+          return !is_gift && atobID(line.variantId) === item
+        })
+  })
+  return (
+    matchedList?.reduce((acc: number, line: any) => {
+      return (
+        acc +
+        (main_product?.spend_money_type === SpendMoneyType.ORIGIN_PRICE
+          ? Number(line.subtotalAmount) || 0
+          : Number(line.totalAmount) || 0)
+      )
+    }, 0) || 0 // 计算总金额
+  )
+}
+
+export const getDiscountEnvAttributeValue = (
+  // 函数接受一个名为 attributes 的参数，其类型为包含 key 和 value 字符串属性的对象数组，默认值为空数组
+  attributes: { key: string; value: string }[] = []
+) => {
+  // 在 attributes 数组中查找 key 值等于 CUSTOMER_ATTRIBUTE_KEY 的对象，并将其赋值给 attr 变量
+  const attr = attributes.find(attr => attr.key === CUSTOMER_ATTRIBUTE_KEY)
+  // 尝试解析 attr 对象的 value 属性为 JSON，如果解析失败或 attr 不存在，则返回一个空对象
+  return safeParseJson(attr?.value ?? '') ?? {}
+}
+
+export const safeParseJson = (str: string) => {
+  try {
+    return JSON.parse(str)
+  } catch (err) {
+    return {}
+  }
+}
+
+/**
+ * 检查 source 数组是否包含 requiredItems 数组中的所有元素。
+ * @param source - 源数据数组，例如用户的标签列表。
+ * @param requiredItems - 必须包含的项的数组。
+ * @returns boolean
+ */
+const containsAll = (source: string[], requiredItems: string[] = []): boolean => {
+  // 如果没有必须包含的项，则条件默认满足。
+  if (!requiredItems?.length) return true
+
+  const sourceSet = new Set(source)
+  // 检查每一个 requiredItem 是否都存在于 sourceSet 中。
+  return requiredItems.every(item => sourceSet.has(item))
+}
+
+/**
+ * 检查 source 数组是否不包含 forbiddenItems 数组中的任何元素。
+ * @param source - 源数据数组。
+ * @param forbiddenItems - 禁止包含的项的数组。
+ * @returns boolean
+ */
+const containsNone = (source: string[], forbiddenItems: string[] = []): boolean => {
+  // 如果没有禁止的项，则条件默认满足。
+  if (!forbiddenItems?.length) return true
+
+  const sourceSet = new Set(source)
+  // 只要在 sourceSet 中找到任何一个 forbiddenItem，条件就不满足。
+  return !forbiddenItems.some(item => sourceSet.has(item))
+}
+
+export function preCheck(rule_conditions: RuleCondition[], userTags: string[], currentDealsTypes: string[]): boolean {
+  // 1. 处理边界情况 (Guard Clauses)，保持不变
+  if (!Array.isArray(rule_conditions)) return false
+  if (rule_conditions.length === 0) return true
+
+  // 2. 使用 .some() 替代 for...of 循环和 break
+  // .some() 会在找到第一个满足条件的元素后立即返回 true，并停止遍历，
+  // 这完美地复刻了 for + break 的行为。
+  return rule_conditions.some(rule => {
+    // 检查标签条件是否满足
+    const tagsAreValid = containsAll(userTags, rule.with_user_tags) && containsNone(userTags, rule.without_user_tags)
+
+    // 检查URL参数条件是否满足
+    const paramsAreValid =
+      containsAll(currentDealsTypes, rule.with_special_url_params) &&
+      containsNone(currentDealsTypes, rule.without_special_url_params)
+
+    // 只有当两个条件都满足时，此规则才算匹配
+    return tagsAreValid && paramsAreValid
+  })
+}
+
+// 缓存上一次的结果，避免重复计算
+let formatScriptAutoFreeGiftCache: {
+  key: string
+  result: any[]
+} | null = null
+
+export const formatScriptAutoFreeGift = ({
+  scriptAutoFreeGiftResult,
+  gradient_gifts,
+  locale,
+}: {
+  scriptAutoFreeGiftResult: UseScriptAutoFreeGiftResult
+  gradient_gifts: any
+  locale: string
+}) => {
+  // 生成缓存键，用于判断输入是否发生变化
+  const cacheKey = JSON.stringify({
+    freeGiftLevel: scriptAutoFreeGiftResult?.freeGiftLevel
+      ? {
+          items:
+            scriptAutoFreeGiftResult.freeGiftLevel.giveawayProducts?.map(item => ({
+              handle: item.handle,
+              sku: item.sku,
+              quantity: 1,
+            })) || [],
+        }
+      : null,
+    giftProductsLength: scriptAutoFreeGiftResult?.giftProductsResult?.length || 0,
+    giftProductsIds: scriptAutoFreeGiftResult?.giftProductsResult?.map(p => p.id).sort() || [],
+    gradientGiftsId: gradient_gifts?.id || gradient_gifts?.name || '',
+    locale,
+  })
+
+  // 如果缓存存在且键相同，直接返回缓存结果
+  if (formatScriptAutoFreeGiftCache && formatScriptAutoFreeGiftCache.key === cacheKey) {
+    return formatScriptAutoFreeGiftCache.result
+  }
+
+  // 计算新结果
+  const result =
+    scriptAutoFreeGiftResult?.freeGiftLevel?.giveawayProducts
+      ?.filter(item => scriptAutoFreeGiftResult?.giftProductsResult?.some(product => product.handle === item.handle))
+      .map((item, index) => {
+        const product = scriptAutoFreeGiftResult?.giftProductsResult?.find(product => product.handle === item.handle)
+        const variant = product?.variants?.find((v: any) => v.sku === item.sku)
+
+        const query = getQuery()
+        const utmCampaign = Cookies.get('utm_campaign') || (query as any)?.utm_campaign
+        const addUTMFreeItem =
+          gradient_gifts.activityAvailableQuery && utmCampaign?.includes(gradient_gifts.activityAvailableQuery)
+
+        let points_subscribe = false
+        if (locale === 'au') {
+          const isPointsSubscribe = Cookies.get('points_subscribe')
+          points_subscribe = !!isPointsSubscribe
+        }
+
+        const customAttributes: { key: string; value: string }[] = [
+          {
+            key: '_giveaway_gradient_gifts',
+            value: '_giveaway_gradient_gifts',
+          },
+          ...(points_subscribe
+            ? [
+                { key: '_amount_upgrade_multiple', value: '1.2' },
+                { key: '_amount_upgrade_value', value: '40' },
+              ]
+            : []),
+          ...(addUTMFreeItem && gradient_gifts?.activityQroperty
+            ? [
+                {
+                  key: gradient_gifts.activityQroperty,
+                  value: gradient_gifts.activityQroperty,
+                },
+              ]
+            : []),
+        ]
+
+        const line = {
+          id: product?.id + '_' + index,
+          variantId: String(variant?.id),
+          productId: String(product?.id),
+          name: (product as any)?.name || (product as any)?.title || '',
+          quantity: 1,
+          discounts: [],
+          path: product?.handle || '',
+          variant: variant,
+          totalAmount: 0,
+          subtotalAmount: new Decimal(variant?.price || 0).toNumber(),
+          options: [],
+          discountAllocations: [],
+          product: product,
+          customAttributes,
+          freeGiftVariant: undefined,
+          relatedVariant: undefined,
+        } as any
+
+        return {
+          line,
+          isSoldOut: !variant?.availableForSale,
+        }
+      }) || []
+
+  // 缓存结果
+  formatScriptAutoFreeGiftCache = {
+    key: cacheKey,
+    result: result,
+  }
+
+  return result
+}
+
+// 缓存上一次的结果，避免重复计算
+let formatFunctionAutoFreeGiftCache: {
+  key: string
+  result: any[]
+} | null = null
+
+export const formatFunctionAutoFreeGift = ({
+  qualifyingGift,
+  giftProductsResult,
+  locale,
+}: {
+  locale: string
+  qualifyingGift?: FormattedGift | null
+  giftProductsResult?: Product[] | []
+}) => {
+  // 生成缓存键，用于判断输入是否发生变化
+  const cacheKey = JSON.stringify({
+    qualifyingGift: qualifyingGift
+      ? {
+          spend: qualifyingGift.tier?.spend_sum_money,
+          items:
+            qualifyingGift.itemsToAdd?.map(item => ({
+              variantId: item.variant.id,
+              handle: item.variant.handle,
+              sku: item.variant.sku,
+              quantity: item.quantity ?? 1,
+              attributes: item.attributes,
+            })) || [],
+        }
+      : null,
+    giftProductsLength: giftProductsResult?.length || 0,
+    giftProductsIds: giftProductsResult?.map(p => p.id).sort() || [],
+    locale,
+  })
+
+  // 如果缓存存在且键相同，直接返回缓存结果
+  if (formatFunctionAutoFreeGiftCache && formatFunctionAutoFreeGiftCache.key === cacheKey) {
+    return formatFunctionAutoFreeGiftCache.result
+  }
+
+  // 计算新结果
+  const result =
+    qualifyingGift?.itemsToAdd?.map((item, index) => {
+      const product = giftProductsResult?.find(product => product.handle === item.variant.handle)
+      const variant = product?.variants?.find(v => v.sku === item.variant.sku)
+      console.log('qualifyingGift variant', product, variant)
+
+        const line = {
+          id: product?.id + '_' + index,
+          variantId: String(variant?.id),
+          productId: String(product?.id),
+          name: (product as any)?.name || (product as any)?.title || '',
+          quantity: 1,
+          discounts: [],
+          path: product?.handle || '',
+          variant: variant,
+          totalAmount: 0,
+          subtotalAmount: new Decimal(variant?.price || 0).toNumber(),
+          options: [],
+          discountAllocations: [],
+          product: product,
+          customAttributes: item.attributes,
+          freeGiftVariant: undefined,
+          relatedVariant: undefined,
+        } as any
+      return {
+        line,
+        isSoldOut: !variant?.availableForSale,
+      }
+    }) || []
+
+  // 缓存结果
+  formatFunctionAutoFreeGiftCache = {
+    key: cacheKey,
+    result: result,
+  }
+
+  return result
+}

package/src/cart/utils/index.ts

@@ -0,0 +1,35 @@
+import { Attributes } from '../../shopify'
+
+export const isAttributesEqual = (oldAttributes: Attributes, newAttributes: Attributes) => {
+  // 比对两个数据是否完全相同
+  // 检查数组长度是否相同
+  if (oldAttributes?.length !== newAttributes?.length) {
+    return false
+  }
+
+  // 将数组转换为 Map 以便快速查找
+  const oldMap = new Map(oldAttributes.map(attr => [attr.key, attr.value]))
+  const newMap = new Map(newAttributes.map(attr => [attr.key, attr.value]))
+
+  // 检查所有 key 是否都存在且值相同
+  for (const [key, value] of newMap) {
+    if (!oldMap.has(key) || oldMap.get(key) !== value) {
+      return false
+    }
+  }
+
+  return true
+}
+
+export const getQuery = (): Record<string, string> => {
+  const url = typeof window !== 'undefined' ? window.location.search : '' //获取url中"?"符后的字串
+  const theRequest: Record<string, string> = {}
+  if (url.indexOf('?') != -1) {
+    const str = url.substr(1),
+      strs = str.split('&')
+    for (let i = 0; i < strs.length; i++) {
+      theRequest[strs[i].split('=')[0]] = decodeURIComponent(strs[i].split('=')[1])
+    }
+  }
+  return theRequest
+}

package/src/context/HeadlessProvider.tsx

@@ -0,0 +1,30 @@
+import { createContext, useContext, useMemo, ReactNode } from 'react'
+
+import { HeadlessConfig } from './config'
+
+const HeadlessContext = createContext<HeadlessConfig | null>(null)
+
+interface HeadlessProviderProps {
+  children: ReactNode
+  headlessConfig: HeadlessConfig
+}
+
+export const HeadlessProvider = ({ children, headlessConfig }: HeadlessProviderProps): JSX.Element => {
+  const contextValue = useMemo((): HeadlessConfig => {
+    if (!headlessConfig) {
+      throw new Error(`No site configuration or headless configuration found`)
+    }
+
+    return headlessConfig
+  }, [headlessConfig])
+
+  return <HeadlessContext.Provider value={contextValue}>{children}</HeadlessContext.Provider>
+}
+
+export const useHeadlessContext = (): HeadlessConfig => {
+  const context = useContext(HeadlessContext)
+  if (!context) {
+    throw new Error('useHeadlessContext must be used within a HeadlessProvider')
+  }
+  return context || ({} as HeadlessConfig)
+}

package/src/context/config.ts

@@ -0,0 +1,10 @@
+export type HeadlessConfig = {
+  storefrontToken: string
+  storeDomain: string
+  locale: string
+  comboMetafieldsNamespace: string
+  cartIdCookieName: string
+  brand: string
+  appName: string
+  passportUrl: string
+}

package/src/context/index.ts

@@ -0,0 +1,2 @@
+export * from './HeadlessProvider'
+export * from './config'

package/src/index.ts

@@ -0,0 +1,9 @@
+export * from './context'
+
+export * from './shopify'
+
+export * from './cart'
+
+export * from './utils'
+
+export * from './registration'

package/src/registration/hooks/index.ts

@@ -0,0 +1,3 @@
+export * from './useSendEmailValidation'
+export * from './useEmailValidation'
+export * from './useSubscriptions'

package/src/registration/hooks/useEmailValidation.ts

@@ -0,0 +1,28 @@
+import useSWRMutation, { SWRMutationConfiguration } from 'swr/mutation'
+import { useHeadlessContext } from '../../context'
+import { fetcher } from '../../utils'
+
+export const useEmailValidation = (
+  config?: SWRMutationConfiguration<
+    any,
+    { type: 'responseError'; data: any; response: any },
+    string,
+    { token: string; code: string }
+  >
+) => {
+  const { locale } = useHeadlessContext()
+  return useSWRMutation(
+    'emailValidation',
+    (_, { arg: { token, code } }: { arg: { token: string; code: string } }) => {
+      return fetcher({
+        url: `/identity/users/email_validation`,
+        method: 'POST',
+        body: { activation_code: token, verify_code: code },
+        action: 'account',
+        needRecaptcha: true,
+        locale,
+      })
+    },
+    config
+  )
+}

package/src/registration/hooks/useSendEmailValidation.ts

@@ -0,0 +1,21 @@
+import useSWRMutation, { type SWRMutationResponse } from 'swr/mutation'
+import { useHeadlessContext } from '../../context'
+import { fetcher } from '../../utils'
+
+// data 参数会被 stringify 后放入到邮件链接参数中
+export type RequestData = { email: string; data: any }
+
+export function useSendEmailValidation(): SWRMutationResponse<any, any, string, { email: string } & any> {
+  const { appName, locale } = useHeadlessContext()
+
+  return useSWRMutation('send-email-validation', (_, { arg: { email, ...rest } }: { arg: RequestData }) =>
+    fetcher({
+      locale,
+      url: '/api/multipass/account/users/send_validation_email',
+      method: 'POST',
+      body: { email: email, app: appName, ...rest },
+      needRecaptcha: true,
+      action: 'verifyAccount',
+    })
+  )
+}

package/src/registration/hooks/useSubscriptions.ts

@@ -0,0 +1,36 @@
+import useSWR, { SWRResponse } from 'swr'
+
+import { useHeadlessContext } from '../../context'
+import { fetcher } from '../../utils'
+
+export interface Subscription {
+  preference: {
+    subscribe: boolean
+    brand: string
+  }[]
+}
+
+export type SubscriptionApiResponse = { data: Subscription }
+export type FetchSubscriptionResponse = SWRResponse<Subscription>
+
+export function useSubscriptions({ email }: { email?: string }): FetchSubscriptionResponse {
+  const { locale } = useHeadlessContext()
+
+  const { data, ...rest } = useSWR<SubscriptionApiResponse>(
+    email ? ['/api/multipass/account/subscriptions', email] : null,
+    async ([url, email]) =>
+      fetcher({
+        method: 'GET',
+        url,
+        body: {
+          email,
+        },
+        action: 'login',
+        locale,
+        headers: {},
+        type: '',
+      })
+  )
+
+  return { data: data?.data, ...rest } as unknown as FetchSubscriptionResponse
+}

package/src/registration/index.ts

@@ -0,0 +1,2 @@
+
+export * from './hooks'

package/src/shopify/fetchers/add-cart-lines.ts

@@ -0,0 +1,53 @@
+import { CartLinesAddPayload, MutationCartLinesAddArgs } from '../gql'
+import { addCartLinesMutation } from '../mutations/add-cart-lines'
+import type { Cart } from '../types/cart'
+import { ShopifyFetcher } from '../types/fetcher'
+import { fetchGraphqlApi } from '../utils/fetch-graphql-api'
+import { normalizeCart } from '../utils/normalize'
+import { ShopifyConfig } from '../types/config'
+import { Optional } from '../types/type-helper'
+/**
+ * Adds cart lines to the Shopify cart.
+ *
+ * @param options - The options for adding cart lines.
+ * @param config - The store configuration.
+ * @returns The updated cart or undefined if the cart could not be updated.
+ */
+export const addCartLines: ShopifyFetcher<Cart | undefined, MutationCartLinesAddArgs> = async function ({
+  options,
+  config,
+}: {
+  options: MutationCartLinesAddArgs
+  config: ShopifyConfig
+}) {
+  const { data } = await fetchGraphqlApi<
+    { cartLinesAdd: CartLinesAddPayload },
+    Optional<MutationCartLinesAddArgs, 'cartId'>
+  >({
+    query: addCartLinesMutation,
+    variables: {
+      cartId: options.cartId,
+      lines: options.lines,
+    },
+    config,
+  })
+
+  if (data?.cartLinesAdd?.userErrors?.length) {
+    const errors = data.cartLinesAdd.userErrors
+    const quantityError = errors.find(error => error.field?.includes('quantity'))
+    if (quantityError) {
+      // The quantity of the line item is invalid.
+      return Promise.reject(quantityError)
+    } else {
+      throw new Error(JSON.stringify(data?.cartLinesAdd?.userErrors))
+    }
+  }
+
+  const cart = data?.cartLinesAdd?.cart
+
+  if (cart) {
+    return normalizeCart(cart, '')
+  } else {
+    return undefined
+  }
+}

package/src/shopify/fetchers/create-cart.ts

@@ -0,0 +1,43 @@
+import { CartCreatePayload, CartInput } from '../gql'
+import { createCartMutation } from '../mutations/create-cart'
+import type { Cart } from '../types/cart'
+import { ShopifyFetcher } from '../types/fetcher'
+import { fetchGraphqlApi } from '../utils/fetch-graphql-api'
+import { normalizeCart } from '../utils/normalize'
+import { GetCartMetafieldQueryRoot } from './get-cart'
+import { constructMetafieldIdentifiersQueryParams } from '../utils/helper'
+
+/**
+ * Creates a cart using the Shopify API.
+ *
+ * @param options - The options for the cart.
+ * @param config - The store configuration.
+ * @returns The created cart or undefined if the cart creation fails.
+ */
+export const createCart: ShopifyFetcher<Cart | undefined, CartInput, GetCartMetafieldQueryRoot> = async function ({
+  options,
+  config,
+}) {
+  const { comboMetafieldsNamespace, metafieldIdentifiers, ...rest } = options
+  if (!rest.lines?.length) {
+    throw new Error('Invalid input used for this operation: Miss lines')
+  }
+  const { data } = await fetchGraphqlApi<{ cartCreate: CartCreatePayload }, CartInput>({
+    query: createCartMutation,
+    variables: {
+      ...rest,
+      ...(metafieldIdentifiers && {
+        ...constructMetafieldIdentifiersQueryParams(metafieldIdentifiers, comboMetafieldsNamespace),
+      }),
+    },
+    config,
+  })
+
+  const cart = data?.cartCreate?.cart
+
+  if (cart) {
+    return normalizeCart(cart, comboMetafieldsNamespace)
+  } else {
+    return undefined
+  }
+}

package/src/shopify/fetchers/get-cart.ts

@@ -0,0 +1,48 @@
+import { Cart, GetCartQueryVariables } from '../gql'
+import type { Cart as ExportCart } from '../types/cart'
+import {
+  HasMetafieldQueryRoot,
+  metafieldIdentifiersGroup,
+  ShopifyFetcher,
+  ShopifyFetcherVariables,
+} from '../types/fetcher'
+import { fetchGraphqlApi } from '../utils/fetch-graphql-api'
+import { normalizeCart } from '../utils/normalize'
+import { getCartQuery } from '../queries/get-cart'
+import { constructMetafieldIdentifiersQueryParams } from '../utils/helper'
+
+export type GetCartMetafieldQueryRoot = HasMetafieldQueryRoot.Product | HasMetafieldQueryRoot.Variant
+
+export type GetCartReq = {
+  cartId: string
+} & metafieldIdentifiersGroup<GetCartMetafieldQueryRoot>
+
+/**
+ * Fetches the cart from Shopify.
+ *
+ * @param options - The options for fetching the cart.
+ * @param config - The store configuration.
+ * @returns The fetched cart or undefined if not found.
+ */
+export const getCart: ShopifyFetcher<ExportCart | undefined, GetCartQueryVariables, GetCartMetafieldQueryRoot> =
+  async function ({ options, config }) {
+    const { comboMetafieldsNamespace: metafieldsNamespace, metafieldIdentifiers, cartId } = options
+
+    if (!cartId) {
+      throw new Error('Invalid input used for this operation: Miss cartId')
+    }
+
+    const { data } = await fetchGraphqlApi<
+      { cart: Cart },
+      ShopifyFetcherVariables<GetCartQueryVariables, GetCartMetafieldQueryRoot>
+    >({
+      query: getCartQuery,
+      variables: {
+        cartId,
+        ...constructMetafieldIdentifiersQueryParams(metafieldIdentifiers, metafieldsNamespace),
+      },
+      config,
+    })
+
+    return normalizeCart(data.cart, metafieldsNamespace)
+  }

package/src/shopify/fetchers/get-products-by-handles.ts

@@ -0,0 +1,48 @@
+import { getProductsByHandlesQuery } from '../queries/get-product-by-handles'
+import { fetchGraphqlApi } from '../utils/fetch-graphql-api'
+import { constructMetafieldIdentifiersQueryParams } from '../utils/helper'
+import { normalizeProduct } from '../utils/normalize/product'
+import { Product as ShopifyProduct } from '../gql'
+import { HasMetafieldQueryRoot, ShopifyFetcher, ShopifyFetcherVariables } from '../types/fetcher'
+import { Product } from '../types/product'
+
+export type GetProductsMetafieldQueryRoot = HasMetafieldQueryRoot.Product | HasMetafieldQueryRoot.Variant
+
+export type GetProductsByHandlesReq = {
+  handles: string[]
+}
+
+/**
+ * Gets products by their handles.
+ *
+ * @param options - The options for getting products.
+ * @param config - The store configuration.
+ * @returns An array of products.
+ */
+export const getProductsByHandles: ShopifyFetcher<
+  Product[],
+  GetProductsByHandlesReq,
+  GetProductsMetafieldQueryRoot
+> = async ({ options, config }) => {
+  const { handles, metafieldIdentifiers, comboMetafieldsNamespace } = options
+
+  if (!handles?.length) {
+    throw new Error('Handles are required')
+  }
+
+  const products = await fetchGraphqlApi<
+    Record<string, ShopifyProduct>,
+    ShopifyFetcherVariables<GetProductsByHandlesReq, GetProductsMetafieldQueryRoot>
+  >({
+    query: getProductsByHandlesQuery(handles),
+    variables: {
+      handles,
+      ...constructMetafieldIdentifiersQueryParams(metafieldIdentifiers, comboMetafieldsNamespace),
+    },
+    config,
+  })
+
+  return Object.values(products.data)
+    .filter(item => !!item)
+    .map(product => normalizeProduct(product, '')) as Product[]
+}