@scayle/storefront-core 7.22.1

package/dist/helpers/sortingHelper.mjs

@@ -0,0 +1,66 @@
+import { APISortOption, APISortOrder } from "@aboutyou/backbone";
+import { pick } from "radash";
+import { SortName, SortQuery } from "../constants/sorting.mjs";
+const SORTING_VALUES = {
+  topSeller: {
+    by: APISortOption.Price,
+    direction: APISortOrder.Descending,
+    name: SortName.TOPSELLER,
+    query: SortQuery.TOPSELLER
+  },
+  dateNewest: {
+    by: APISortOption.DateAdded,
+    name: SortName.DATE_NEWEST,
+    query: SortQuery.DATE_NEWEST
+  },
+  priceDesc: {
+    by: APISortOption.Price,
+    direction: APISortOrder.Descending,
+    name: SortName.PRICE_DESC,
+    query: SortQuery.PRICE_DESC
+  },
+  priceAsc: {
+    by: APISortOption.Price,
+    direction: APISortOrder.Ascending,
+    name: SortName.PRICE_ASC,
+    query: SortQuery.PRICE_ASC
+  },
+  reductionDesc: {
+    by: APISortOption.Reduction,
+    direction: APISortOrder.Descending,
+    name: SortName.REDUCTION_DESC,
+    query: SortQuery.REDUCTION_DESC
+  },
+  reductionAsc: {
+    by: APISortOption.Reduction,
+    direction: APISortOrder.Ascending,
+    name: SortName.REDUCTION_ASC,
+    query: SortQuery.REDUCTION_ASC
+  }
+};
+export const getSortingValues = (options = [
+  "topSeller",
+  "dateNewest",
+  "priceDesc",
+  "priceAsc",
+  "reductionDesc",
+  "reductionAsc"
+]) => pick(SORTING_VALUES, options);
+export const getSortByValue = (query, defaultSort) => {
+  switch (query) {
+    case SortQuery.PRICE_DESC:
+      return SORTING_VALUES.priceDesc;
+    case SortQuery.PRICE_ASC:
+      return SORTING_VALUES.priceAsc;
+    case SortQuery.REDUCTION_DESC:
+      return SORTING_VALUES.reductionDesc;
+    case SortQuery.REDUCTION_ASC:
+      return SORTING_VALUES.reductionAsc;
+    case SortQuery.TOPSELLER:
+      return SORTING_VALUES.topSeller;
+    case SortQuery.DATE_NEWEST:
+      return SORTING_VALUES.dateNewest;
+    default:
+      return SORTING_VALUES[defaultSort || "dateNewest"];
+  }
+};

package/dist/helpers/stringHelpers.cjs

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.splitAndRemoveEmpty = void 0;
+const splitAndRemoveEmpty = (value, separator = "/") => value.split(separator).filter(string => string !== "");
+exports.splitAndRemoveEmpty = splitAndRemoveEmpty;

package/dist/helpers/stringHelpers.d.ts

@@ -0,0 +1,2 @@
+declare const splitAndRemoveEmpty: (value: string, separator?: string) => string[];
+export { splitAndRemoveEmpty };

package/dist/helpers/stringHelpers.mjs

@@ -0,0 +1,2 @@
+const splitAndRemoveEmpty = (value, separator = "/") => value.split(separator).filter((string) => string !== "");
+export { splitAndRemoveEmpty };

package/dist/index.cjs

@@ -0,0 +1,85 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  rpcMethods: true
+};
+exports.rpcMethods = void 0;
+var rpcMethods = _interopRequireWildcard(require("./rpc/methods/index.cjs"));
+exports.rpcMethods = rpcMethods;
+var _errors = require("./errors/index.cjs");
+Object.keys(_errors).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _errors[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _errors[key];
+    }
+  });
+});
+var _utils = require("./utils/index.cjs");
+Object.keys(_utils).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _utils[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _utils[key];
+    }
+  });
+});
+var _constants = require("./constants/index.cjs");
+Object.keys(_constants).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _constants[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _constants[key];
+    }
+  });
+});
+var _cache = require("./cache/index.cjs");
+Object.keys(_cache).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _cache[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _cache[key];
+    }
+  });
+});
+var _helpers = require("./helpers/index.cjs");
+Object.keys(_helpers).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _helpers[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _helpers[key];
+    }
+  });
+});
+var _types = require("./types/index.cjs");
+Object.keys(_types).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _types[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _types[key];
+    }
+  });
+});
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+import * as rpcMethods from './rpc/methods';
+export { rpcMethods };
+export * from './errors';
+export * from './utils';
+export * from './constants';
+export * from './cache';
+export * from './helpers';
+export * from './types';
+type RpcMethodsCore = typeof rpcMethods;
+export interface RpcMethodsStorefrontInternal {
+}
+export type RpcMethods = {
+    [Key in keyof RpcMethodsCore | keyof RpcMethodsStorefrontInternal]: Key extends keyof RpcMethodsStorefrontInternal ? RpcMethodsStorefrontInternal[Key] : Key extends keyof RpcMethodsCore ? RpcMethodsCore[Key] : never;
+};
+type Resolve<T> = T extends T ? T : never;
+export type RpcMethodName = Resolve<keyof RpcMethods>;
+export type RpcMethod<N extends RpcMethodName> = RpcMethods[N];
+export type RpcMethodParameters<N extends RpcMethodName> = Parameters<RpcMethod<N>>[0];
+export type RpcMethodReturnType<N extends RpcMethodName> = ReturnType<RpcMethod<N>>;

package/dist/index.mjs

@@ -0,0 +1,8 @@
+import * as rpcMethods from "./rpc/methods/index.mjs";
+export { rpcMethods };
+export * from "./errors/index.mjs";
+export * from "./utils/index.mjs";
+export * from "./constants/index.mjs";
+export * from "./cache/index.mjs";
+export * from "./helpers/index.mjs";
+export * from "./types/index.mjs";

package/dist/rpc/methods/basket/basket.cjs

@@ -0,0 +1,183 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.removeItemFromBasket = exports.mergeBaskets = exports.getBasket = exports.clearBasket = exports.addItemsToBasket = exports.addItemToBasket = void 0;
+var _errors = require("../../../errors/index.cjs");
+var _constants = require("../../../constants/index.cjs");
+var _user = require("../../../utils/user.cjs");
+const BAPI_ERROR_NAME = "BAPI ERROR";
+function getWithParams(params, context) {
+  return params.with ?? context.withParams?.basket ?? _constants.MIN_WITH_PARAMS_BASKET;
+}
+const addItemToBasket = async function addItemToBasket2({
+  variantId,
+  promotionId,
+  quantity,
+  displayData,
+  customData,
+  existingItemHandling = _constants.ExistingItemHandling.AddQuantityToExisting,
+  itemGroup,
+  with: _with
+}, context) {
+  const {
+    campaignKey,
+    bapiClient,
+    basketKey
+  } = context;
+  const resolvedWith = getWithParams({
+    with: _with
+  }, context);
+  const result = await bapiClient.basket.addOrUpdateItems(basketKey, [{
+    variantId,
+    quantity,
+    params: {
+      promotionId,
+      campaignKey,
+      displayData,
+      pricePromotionKey: resolvedWith?.pricePromotionKey || "",
+      customData,
+      itemGroup,
+      with: resolvedWith,
+      includeItemsWithoutProductData: resolvedWith?.includeItemsWithoutProductData
+    }
+  }], {
+    skipAvailabilityCheck: false
+  }, {
+    existingItemHandling
+  });
+  if (result.type === "success") {
+    return result.basket;
+  } else {
+    const {
+      message,
+      statusCode
+    } = parseBasketError(result);
+    context.log.error("Adding item to basket failed", {
+      message,
+      statusCode
+    });
+    throw new _errors.BAPIError(BAPI_ERROR_NAME, statusCode, message, "addItemToBasket:bapiClient.basket.addOrUpdateItems");
+  }
+};
+exports.addItemToBasket = addItemToBasket;
+const addItemsToBasket = async function addItemsToBasket2(params, context) {
+  const {
+    campaignKey,
+    bapiClient,
+    basketKey
+  } = context;
+  const resolvedWith = getWithParams(params, context);
+  const itemsToBeAddedOrUpdated = params.items.map(item => ({
+    variantId: item.variantId,
+    quantity: item.quantity,
+    params: {
+      promotionId: item.promotionId,
+      campaignKey,
+      displayData: item.displayData,
+      pricePromotionKey: resolvedWith?.pricePromotionKey || "",
+      customData: item.customData,
+      with: resolvedWith,
+      includeItemsWithoutProductData: item.includeItemsWithoutProductData ?? resolvedWith?.includeItemsWithoutProductData,
+      itemGroup: item.itemGroup ?? void 0
+    }
+  }));
+  const result = await bapiClient.basket.addOrUpdateItems(basketKey, itemsToBeAddedOrUpdated, {
+    skipAvailabilityCheck: false,
+    includeItemsWithoutProductData: resolvedWith?.includeItemsWithoutProductData
+  }, {
+    existingItemHandling: params.existingItemHandling || _constants.ExistingItemHandling.AddQuantityToExisting,
+    considerItemGroupForUniqueness: Boolean(params.considerItemGroupForUniqueness ?? null)
+  });
+  if (result.type === "success") {
+    return result.basket;
+  } else {
+    const {
+      statusCode,
+      message
+    } = parseBasketError(result);
+    context.log.error("Adding one or more items to basket failed", {
+      statusCode,
+      message
+    });
+    throw new _errors.BAPIError(BAPI_ERROR_NAME, statusCode, message, "addItemsToBasket:bapiClient.basket.addOrUpdateItems");
+  }
+};
+exports.addItemsToBasket = addItemsToBasket;
+const getBasket = async function getBasket2(options, context) {
+  const {
+    bapiClient,
+    campaignKey,
+    basketKey
+  } = context;
+  const resolvedWith = getWithParams({
+    with: options
+  }, context);
+  const response = await bapiClient.basket.get(basketKey, {
+    with: resolvedWith,
+    campaignKey,
+    includeItemsWithoutProductData: resolvedWith.includeItemsWithoutProductData
+  });
+  if (response.type === "failure") {
+    const {
+      statusCode,
+      message
+    } = parseBasketError(response);
+    throw new _errors.BAPIError(BAPI_ERROR_NAME, statusCode, message, "bapiClient.basket.get");
+  }
+  return response.basket;
+};
+exports.getBasket = getBasket;
+const removeItemFromBasket = async function removeItemFromBasket2(options, context) {
+  const {
+    bapiClient,
+    campaignKey,
+    basketKey
+  } = context;
+  const resolvedWith = getWithParams(options, context);
+  return await bapiClient.basket.deleteItem(basketKey, options.itemKey, {
+    with: resolvedWith,
+    campaignKey,
+    includeItemsWithoutProductData: resolvedWith?.includeItemsWithoutProductData
+  });
+};
+exports.removeItemFromBasket = removeItemFromBasket;
+const clearBasket = async function clearBasket2(context) {
+  const basket = await getBasket({}, context);
+  await Promise.all(basket.items.map(async item => {
+    await removeItemFromBasket({
+      itemKey: item.key
+    }, context);
+  }));
+  context.log.debug("The basket has been cleared");
+  return true;
+};
+exports.clearBasket = clearBasket;
+const mergeBaskets = async function mergeBaskets2({
+  fromBasketKey,
+  toBasketKey,
+  with: _with
+}, context) {
+  const resolvedWith = getWithParams({
+    with: _with
+  }, context);
+  return await (0, _user.mergeBaskets)(fromBasketKey, toBasketKey, resolvedWith, context);
+};
+exports.mergeBaskets = mergeBaskets;
+function parseBasketError(response) {
+  if (response.type === "failure") {
+    const parsedError = {
+      message: "",
+      statusCode: 500
+    };
+    if ("statusCode" in response) {
+      parsedError.statusCode = response.statusCode;
+    } else {
+      const [error] = response.errors;
+      parsedError.message = response.errors?.map(error2 => `${error2.operation !== "delete" ? error2.kind + ":" : ""}${error2.operation}:${error2.variantId} - ${error2.message}`).join(" | ");
+      parsedError.statusCode = error.statusCode;
+    }
+    return parsedError;
+  }
+}

package/dist/rpc/methods/basket/basket.d.ts

@@ -0,0 +1,23 @@
+import { AddOrUpdateItemType, BasketResponseData, BasketWithOptions, Product, Variant, RpcHandler } from '../../../types';
+import { ExistingItemHandling } from '../../../constants';
+export declare const addItemToBasket: RpcHandler<AddOrUpdateItemType & {
+    existingItemHandling?: ExistingItemHandling;
+    with?: BasketWithOptions;
+}, BasketResponseData<Product, Variant>>;
+export declare const addItemsToBasket: RpcHandler<{
+    items: AddOrUpdateItemType[];
+    existingItemHandling: ExistingItemHandling;
+    with?: BasketWithOptions;
+    considerItemGroupForUniqueness?: boolean;
+}, BasketResponseData<Product, Variant>>;
+export declare const getBasket: RpcHandler<BasketWithOptions | undefined, BasketResponseData<Product, Variant>>;
+export declare const removeItemFromBasket: RpcHandler<{
+    itemKey: string;
+    with?: BasketWithOptions;
+}, BasketResponseData<Product, Variant>>;
+export declare const clearBasket: RpcHandler<boolean>;
+export declare const mergeBaskets: RpcHandler<{
+    fromBasketKey: string;
+    toBasketKey: string;
+    with?: BasketWithOptions;
+}, any>;

package/dist/rpc/methods/basket/basket.mjs

@@ -0,0 +1,181 @@
+import { BAPIError } from "../../../errors/index.mjs";
+import {
+  ExistingItemHandling,
+  MIN_WITH_PARAMS_BASKET
+} from "../../../constants/index.mjs";
+import { mergeBaskets as mergeBasketFunction } from "../../../utils/user.mjs";
+const BAPI_ERROR_NAME = "BAPI ERROR";
+function getWithParams(params, context) {
+  return params.with ?? context.withParams?.basket ?? MIN_WITH_PARAMS_BASKET;
+}
+export const addItemToBasket = async function addItemToBasket2({
+  variantId,
+  promotionId,
+  quantity,
+  displayData,
+  customData,
+  existingItemHandling = ExistingItemHandling.AddQuantityToExisting,
+  itemGroup,
+  with: _with
+}, context) {
+  const { campaignKey, bapiClient, basketKey } = context;
+  const resolvedWith = getWithParams(
+    { with: _with },
+    context
+  );
+  const result = await bapiClient.basket.addOrUpdateItems(
+    basketKey,
+    [
+      {
+        variantId,
+        quantity,
+        params: {
+          promotionId,
+          campaignKey,
+          displayData,
+          pricePromotionKey: resolvedWith?.pricePromotionKey || "",
+          customData,
+          itemGroup,
+          with: resolvedWith,
+          includeItemsWithoutProductData: resolvedWith?.includeItemsWithoutProductData
+        }
+      }
+    ],
+    {
+      skipAvailabilityCheck: false
+    },
+    {
+      existingItemHandling
+    }
+  );
+  if (result.type === "success") {
+    return result.basket;
+  } else {
+    const { message, statusCode } = parseBasketError(result);
+    context.log.error("Adding item to basket failed", { message, statusCode });
+    throw new BAPIError(
+      BAPI_ERROR_NAME,
+      statusCode,
+      message,
+      "addItemToBasket:bapiClient.basket.addOrUpdateItems"
+    );
+  }
+};
+export const addItemsToBasket = async function addItemsToBasket2(params, context) {
+  const { campaignKey, bapiClient, basketKey } = context;
+  const resolvedWith = getWithParams(params, context);
+  const itemsToBeAddedOrUpdated = params.items.map((item) => ({
+    variantId: item.variantId,
+    quantity: item.quantity,
+    params: {
+      promotionId: item.promotionId,
+      campaignKey,
+      displayData: item.displayData,
+      pricePromotionKey: resolvedWith?.pricePromotionKey || "",
+      customData: item.customData,
+      with: resolvedWith,
+      includeItemsWithoutProductData: item.includeItemsWithoutProductData ?? resolvedWith?.includeItemsWithoutProductData,
+      itemGroup: item.itemGroup ?? void 0
+    }
+  }));
+  const result = await bapiClient.basket.addOrUpdateItems(
+    basketKey,
+    itemsToBeAddedOrUpdated,
+    {
+      skipAvailabilityCheck: false,
+      includeItemsWithoutProductData: resolvedWith?.includeItemsWithoutProductData
+    },
+    {
+      existingItemHandling: params.existingItemHandling || ExistingItemHandling.AddQuantityToExisting,
+      considerItemGroupForUniqueness: Boolean(
+        params.considerItemGroupForUniqueness ?? null
+      )
+    }
+  );
+  if (result.type === "success") {
+    return result.basket;
+  } else {
+    const { statusCode, message } = parseBasketError(result);
+    context.log.error("Adding one or more items to basket failed", {
+      statusCode,
+      message
+    });
+    throw new BAPIError(
+      BAPI_ERROR_NAME,
+      statusCode,
+      message,
+      "addItemsToBasket:bapiClient.basket.addOrUpdateItems"
+    );
+  }
+};
+export const getBasket = async function getBasket2(options, context) {
+  const { bapiClient, campaignKey, basketKey } = context;
+  const resolvedWith = getWithParams(
+    { with: options },
+    context
+  );
+  const response = await bapiClient.basket.get(basketKey, {
+    with: resolvedWith,
+    campaignKey,
+    includeItemsWithoutProductData: resolvedWith.includeItemsWithoutProductData
+  });
+  if (response.type === "failure") {
+    const { statusCode, message } = parseBasketError(response);
+    throw new BAPIError(
+      BAPI_ERROR_NAME,
+      statusCode,
+      message,
+      "bapiClient.basket.get"
+    );
+  }
+  return response.basket;
+};
+export const removeItemFromBasket = async function removeItemFromBasket2(options, context) {
+  const { bapiClient, campaignKey, basketKey } = context;
+  const resolvedWith = getWithParams(options, context);
+  return await bapiClient.basket.deleteItem(basketKey, options.itemKey, {
+    with: resolvedWith,
+    campaignKey,
+    includeItemsWithoutProductData: resolvedWith?.includeItemsWithoutProductData
+  });
+};
+export const clearBasket = async function clearBasket2(context) {
+  const basket = await getBasket({}, context);
+  await Promise.all(
+    basket.items.map(async (item) => {
+      await removeItemFromBasket({ itemKey: item.key }, context);
+    })
+  );
+  context.log.debug("The basket has been cleared");
+  return true;
+};
+export const mergeBaskets = async function mergeBaskets2({ fromBasketKey, toBasketKey, with: _with }, context) {
+  const resolvedWith = getWithParams(
+    { with: _with },
+    context
+  );
+  return await mergeBasketFunction(
+    fromBasketKey,
+    toBasketKey,
+    resolvedWith,
+    context
+  );
+};
+function parseBasketError(response) {
+  if (response.type === "failure") {
+    const parsedError = {
+      message: "",
+      statusCode: 500
+    };
+    if ("statusCode" in response) {
+      parsedError.statusCode = response.statusCode;
+    } else {
+      const [error] = response.errors;
+      parsedError.message = response.errors?.map(
+        (error2) => `${error2.operation !== "delete" ? error2.kind + ":" : ""}${error2.operation}:${error2.variantId} - ${error2.message}`
+      ).join(" | ");
+      parsedError.statusCode = error.statusCode;
+    }
+    return parsedError;
+  }
+}

package/dist/rpc/methods/brands.cjs

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getBrands = exports.getBrandById = void 0;
+const MAX_PER_PAGE = 100;
+const getBrands = async function getBrands2({
+  pagination
+}, {
+  bapiClient,
+  cached
+}) {
+  return await cached(bapiClient.brands.get, {
+    cacheKeyPrefix: "getBrands"
+  })({
+    pagination: {
+      page: pagination?.page,
+      perPage: pagination?.perPage ? Math.min(pagination.perPage, MAX_PER_PAGE) : void 0
+    }
+  });
+};
+exports.getBrands = getBrands;
+const getBrandById = async function getBrandById2({
+  brandId
+}, {
+  bapiClient,
+  cached
+}) {
+  return await cached(bapiClient.brands.getById, {
+    cacheKeyPrefix: `getBrandById-${brandId}`
+  })(brandId);
+};
+exports.getBrandById = getBrandById;

package/dist/rpc/methods/brands.d.ts

@@ -0,0 +1,5 @@
+import { Brand, BrandsEndpointRequestParameters, BrandsEndpointResponseData, RpcHandler } from '../../types';
+export declare const getBrands: RpcHandler<BrandsEndpointRequestParameters, BrandsEndpointResponseData>;
+export declare const getBrandById: RpcHandler<{
+    brandId: number;
+}, Brand>;

package/dist/rpc/methods/brands.mjs

@@ -0,0 +1,16 @@
+const MAX_PER_PAGE = 100;
+export const getBrands = async function getBrands2({ pagination }, { bapiClient, cached }) {
+  return await cached(bapiClient.brands.get, {
+    cacheKeyPrefix: "getBrands"
+  })({
+    pagination: {
+      page: pagination?.page,
+      perPage: pagination?.perPage ? Math.min(pagination.perPage, MAX_PER_PAGE) : void 0
+    }
+  });
+};
+export const getBrandById = async function getBrandById2({ brandId }, { bapiClient, cached }) {
+  return await cached(bapiClient.brands.getById, {
+    cacheKeyPrefix: `getBrandById-${brandId}`
+  })(brandId);
+};