@scayle/storefront-core 8.8.0 → 8.10.0

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

@@ -1,33 +1,93 @@
-import type { Category, ProductCategoryPropertyWith } from '../../types';
+import type { Category, ProductCategoryPropertyWith, RpcContext } from '../../types';
+/**
+ * Retrieves the root categories.
+ *
+ * This function uses the Storefront cache (`cached()`) with a `root-categories` key prefix to improve performance.
+ * Cached entries are returned if found; otherwise, data is fetched and cached.
+ *
+ * @param params The parameters for retrieving the root category.
+ * @param params.children The number of child categories to include.
+ * @param params.includeHidden Whether to include hidden categories.
+ * @param params.properties The properties to include for each category.
+ * @param context The RPC context.
+ *
+ * @returns The root categories and the active node (undefined).
+ */
 export declare const getRootCategories: ({ children, includeHidden, properties }: {
     children?: number;
     includeHidden?: true;
     properties?: ProductCategoryPropertyWith;
-}, { cached, sapiClient }: import("../../types").RpcContext) => Promise<{
+}, context: RpcContext) => Promise<{
     categories: Category[];
     activeNode: undefined;
 }>;
+/**
+ * Retrieves a category by its path.
+ *
+ * This function uses the Storefront cache (`cached()`) with a `getByPath-category-${sanitizedPath}` key prefix to improve performance.
+ * Cached entries are returned if found; otherwise, data is fetched and cached.
+ *
+ * @param params The parameters for retrieving a category by its path.
+ * @param params.path The path of the category.
+ * @param params.children The number of child categories to include, default to `1`.
+ * @param params.includeHidden Whether to include hidden categories.
+ * @param params.properties The properties to include for each category.
+ * @param context The RPC context.
+ *
+ * @returns The category or undefined if not found.
+ * It will return an `ErrorResponse` if an error occurs during the API call.
+ */
 export declare const getCategoryByPath: ({ path, children, includeHidden, properties }: {
     path: string;
     children?: number;
     includeHidden?: true;
     properties?: ProductCategoryPropertyWith;
-}, context: import("../../types").RpcContext) => Promise<Response | Category>;
+}, context: RpcContext) => Promise<Response | Category>;
+/**
+ * Retrieves categories by path.
+ *
+ * This function uses the Storefront cache (`cached()`) with a `getById-categories-${id}` key prefix to improve performance.
+ * Cached entries are returned if found; otherwise, data is fetched and cached.
+ *
+ * @param params The parameters for retrieving multiple categories by path.
+ * @param params.path The path of the categories.
+ * @param params.children The number of children categories to include, default o `1`.
+ * @param params.includeHidden Whether to include hidden categories.
+ * @param params.properties The properties to include for each category.
+ * @param context The RPC context.
+ *
+ * @returns The categories data.
+ */
 export declare const getCategoriesByPath: ({ path, children, includeHidden, properties }: {
     path: string;
     children?: number;
     includeHidden?: true;
     properties?: ProductCategoryPropertyWith;
-}, context: import("../../types").RpcContext) => Promise<{
+}, context: RpcContext) => Promise<{
     categories: Category[];
     activeNode: undefined;
 } | {
     categories: Category;
     activeNode: Category;
 }>;
+/**
+ * Retrieves a category by ID.
+ *
+ * This function uses the Storefront cache (`cached()`) with a `getById-categories-${id}` key prefix to improve performance.
+ * Cached entries are returned if found; otherwise, data is fetched and cached.
+ *
+ * @param params The parameters for retrieving a category by ID.
+ * @param params.id The category ID.
+ * @param params.children The number of child categories to include.
+ * @param params.includeHidden Whether to include hidden categories.
+ * @param params.properties The properties to include for each category.
+ * @param context The RPC context.
+ *
+ * @returns The category. It will return an `ErrorResponse` if category retrieval fails.
+ */
 export declare const getCategoryById: ({ id, children, includeHidden, properties }: {
     id: number;
     children?: number;
     includeHidden?: true;
     properties?: ProductCategoryPropertyWith;
-}, context: import("../../types").RpcContext) => Promise<Response | Category>;
+}, context: RpcContext) => Promise<Response | Category>;

package/dist/rpc/methods/categories.mjs

@@ -1,6 +1,7 @@
 import { splitAndRemoveEmpty } from "../../helpers/index.mjs";
 import { mapSAPIFetchErrorToResponse } from "../../utils/sapi.mjs";
-export const getRootCategories = async function getRootCategories2({ children = 1, includeHidden, properties }, { cached, sapiClient }) {
+export const getRootCategories = async function getRootCategories2({ children = 1, includeHidden, properties }, context) {
+  const { cached, sapiClient } = context;
   const result = await cached(sapiClient.categories.getRoots, {
     cacheKeyPrefix: "root-categories"
   })({

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

@@ -1,5 +1,15 @@
 import { ErrorResponse } from '../../errors';
 import type { Order, RpcContext } from '../../types';
+/**
+ * Retrieves order data using a CBD token.
+ *
+ * @param params The parameters for retrieving order data.
+ * @param params.cbdToken The CBD token used for authentication and order identification.
+ * @param context The RPC context.
+ *
+ * @returns The order data. It will return an `ErrorResponse` alternatively if
+ * the CBD token is invalid, expired, or if an error occurs during the order retrieval.
+ */
 export declare const getOrderDataByCbd: ({ cbdToken }: {
     cbdToken: string;
 }, context: RpcContext) => Promise<ErrorResponse | Order>;

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

@@ -1,15 +1,54 @@
-import { ErrorResponse } from '../../../errors';
-import type { RpcContext } from '../../../types';
+import type { RpcHandler } from '../../../types';
+/**
+ * Representation of the payload for the JWT used in the checkout process.
+ * This is used to supplement checkout-related information, such as voucher codes,
+ * custom data, preferred collection point, and selected carrier.
+ * This allows pre-filling checkout information and ensures data integrity.
+ */
 interface CheckoutJwtPayload {
+    /**
+     * The voucher code.
+     */
     voucher?: string;
+    /**
+     * Arbitrary custom data associated with the checkout process.  This can be used to store
+     * any additional information relevant to the checkout.
+     */
     customData?: Record<string, unknown>;
+    /**
+     * The preferred collection point.
+     */
     preferredCollectionPoint?: {
+        /**
+         * The collection point Id.
+         */
         id: number;
+        /**
+         * The collection point type.
+         */
         type: string;
     };
+    /**
+     * The selected carrier.
+     */
     carrier?: string;
 }
-export declare const getCheckoutToken: (jwtPayload: CheckoutJwtPayload | undefined, context: RpcContext) => Promise<ErrorResponse | {
+/**
+ * Generates a checkout token, which includes a refreshed access token and
+ * a JWT containing checkout information.
+ *
+ * The generated JWT is signed with a secret and includes information from the
+ * provided `jwtPayload`, along with the `basketId` and `campaignKey`.
+ * It is used to pre-fill checkout details and maintain data integrity during
+ * the checkout process.
+ *
+ * @param jwtPayload The payload for the JWT. Provides checkout-related data to embed within the token.
+ * @param context The RPC context.
+ *
+ * @returns An object containing the access token and checkout JWT.
+ * It will return an `ErrorResponse` if no session is found, no access token is present.
+ */
+export declare const getCheckoutToken: RpcHandler<CheckoutJwtPayload | undefined, {
     accessToken: string;
     checkoutJwt: string;
 }>;

package/dist/rpc/methods/checkout/checkout.mjs

@@ -3,7 +3,6 @@ import { hasSession } from "../../../types/index.mjs";
 import { ErrorResponse } from "../../../errors/index.mjs";
 import { HttpStatusCode, HttpStatusMessage } from "../../../constants/index.mjs";
 import { getAccessToken } from "../user.mjs";
-import { getCampaignKey } from "../campaign.mjs";
 export const getCheckoutToken = async function getCheckoutToken2(jwtPayload = {}, context) {
   if (!hasSession(context)) {
     return new ErrorResponse(
@@ -29,7 +28,7 @@ export const getCheckoutToken = async function getCheckoutToken2(jwtPayload = {}
   const secret = new TextEncoder().encode(context.checkout.secret);
   const now = /* @__PURE__ */ new Date();
   const { voucher, customData, preferredCollectionPoint, carrier } = jwtPayload;
-  const campaignKey = await getCampaignKey(context);
+  const campaignKey = await context.callRpc?.("getCampaignKey");
   const checkoutJwt = await new SignJWT({
     voucher,
     customData,
@@ -37,7 +36,7 @@ export const getCheckoutToken = async function getCheckoutToken2(jwtPayload = {}
     carrier,
     basketId: context.basketKey,
     campaignKey
-  }).setIssuedAt(now).setNotBefore(now).setExpirationTime("1h").setIssuer(`${"@scayle/storefront-core"}@${"8.8.0"}`).setProtectedHeader({ alg: "HS256", typ: "JWT" }).sign(secret);
+  }).setIssuedAt(now).setNotBefore(now).setExpirationTime("1h").setIssuer(`${"@scayle/storefront-core"}@${"8.10.0"}`).setProtectedHeader({ alg: "HS256", typ: "JWT" }).sign(secret);
   return {
     accessToken: refreshedAccessToken,
     checkoutJwt

package/dist/rpc/methods/checkout/order.d.ts

@@ -1,5 +1,17 @@
 import { ErrorResponse } from '../../../errors';
 import type { Order } from '../../../types';
+/**
+ * Retrieves an order by its ID.
+ *
+ * @param params The parameters for retrieving an order by its ID.
+ * @param params.orderId The ID of the order to retrieve.
+ * @param context The RPC context.
+ *
+ * @returns The order details if found. It will return an `ErrorResponse` alternatively
+ * if the order ID is invalid, no access token is present,
+ * the order does not belong to the current user, the order is not found,
+ * or an unknown error occurs.
+ */
 export declare const getOrderById: ({ orderId }: {
     orderId: number;
 }, context: import("../../../types").RpcContext) => Promise<ErrorResponse | Order>;

package/dist/rpc/methods/checkout/shopUser.d.ts

@@ -1,8 +1,28 @@
 import { ErrorResponse } from '../../../errors';
 import type { ShopUser, UpdatePasswordParams } from '../../../types';
+/**
+ * Updates the shop user.
+ *
+ * @param payload The payload containing partial user data to update.
+ * @param context The RPC context.
+ *
+ * @returns The updated user. It will return an `ErrorResponse` alternatively
+ * if updating user information fails.
+ */
 export declare const updateShopUser: (payload: Partial<ShopUser>, context: import("../../../types").RpcContext) => Promise<ErrorResponse | {
     user: ShopUser;
 }>;
+/**
+ * Updates the user's password.
+ *
+ * @param payload The payload with old and new password.
+ * @param payload.oldPassword The current password.
+ * @param payload.newPassword The new password.
+ * @param context The RPC context.
+ *
+ * @returns The user object (or undefined if an error occurs and shopUser is undefined).
+ * It will return an `ErrorResponse` if updating the password fails.
+ */
 export declare const updatePassword: ({ oldPassword, newPassword }: UpdatePasswordParams, context: import("../../../types").RpcContext) => Promise<ErrorResponse | {
     user: ShopUser | undefined;
 }>;

package/dist/rpc/methods/checkout/shopUserAddresses.d.ts

@@ -1,3 +1,10 @@
 import type { ShopUserAddress } from '../../../types';
+/**
+ * Retrieves the shop user addresses.
+ *
+ * @param context The RPC context.
+ *
+ * @returns The shop user addresses.
+ */
 declare const getShopUserAddresses: (context: import("../../../types").RpcContext) => Promise<ShopUserAddress[]>;
 export { getShopUserAddresses };

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

@@ -1,6 +1,33 @@
 import type { NavigationAllEndpointResponseData, NavigationTree } from '@scayle/storefront-api';
 import type { FetchNavigationTreeByIdParams, FetchNavigationTreeByNameParams, FetchNavigationTreesParams } from '../../types';
 import { ErrorResponse } from '../../errors';
+/**
+ * Fetches all navigation trees.
+ *
+ * This function uses the Storefront cache (`cached()`) with a `getAll-navigation-trees` key prefix to improve performance.
+ * Cached entries are returned if found; otherwise, data is fetched and cached.
+ *
+ * @param params The parameters for retrieving all navigation tress.
+ * @param params.params The parameters for fetching navigation trees.
+ * @param context The RPC context.
+ *
+ * @returns The navigation trees data. It will return an `ErrorResponse`
+ * if an error occurs during fetching.
+ */
 export declare const fetchAllNavigationTrees: ({ params }: FetchNavigationTreesParams, { sapiClient: { navigation }, cached }: import("../../types").RpcContext) => Promise<NavigationAllEndpointResponseData>;
+/**
+ * Fetches a navigation tree by its ID.
+ *
+ * This function uses the Storefront cache (`cached()`) with a `getById-navigation-trees-${treeId}` key prefix to improve performance.
+ * Cached entries are returned if found; otherwise, data is fetched and cached.
+ *
+ * @param params The parameters for retrieving a navigation tree by its ID.
+ * @param params.treeId The ID of the navigation tree.
+ * @param params.params The parameters for fetching navigation trees.
+ * @param context The RPC context.
+ *
+ * @returns The navigation tree data. It will return an `ErrorResponse`
+ * if an error occurs during fetching.
+ */
 export declare const fetchNavigationTreeById: ({ treeId, params }: FetchNavigationTreeByIdParams, { sapiClient: { navigation }, cached }: import("../../types").RpcContext) => Promise<NavigationTree>;
 export declare const fetchNavigationTreeByName: ({ treeName, params }: FetchNavigationTreeByNameParams, { sapiClient: { navigation }, cached }: import("../../types").RpcContext) => Promise<ErrorResponse | NavigationTree>;

package/dist/rpc/methods/oauth/idp.d.ts

@@ -1,10 +1,34 @@
 import { ErrorResponse } from '../../../errors';
 import type { RpcContext } from '../../../types';
+/**
+ * Retrieves external IDP redirect URLs.
+ *
+ * @see https://scayle.dev/en/storefront-guide/developer-guide/basic-setup/authentication#overview
+ *
+ * @param params The parameters for retrieving the external IDP redirect.
+ * @param params.queryParams Optional query parameters to include in the redirect URLs.
+ * @param context The RPC context.
+ *
+ * @returns A record mapping IDP keys to their corresponding redirect URLs,
+ * or an ErrorResponse if an error occurs. It will return an `ErrorResponse`
+ * if JWT signing fails or another unexpected error occurs.
+ */
 export declare const getExternalIdpRedirect: ({ queryParams }: {
     queryParams?: Record<string, string>;
 }, context: RpcContext) => Promise<ErrorResponse | {
     [k: string]: string;
 }>;
+/**
+ * Handles the IDP login callback.
+ *
+ * @see https://scayle.dev/en/storefront-guide/developer-guide/basic-setup/authentication#overview
+ *
+ * @param payload The payload containing the authorization code.
+ * @param payload.code The authorization code.
+ * @param context The RPC context.
+ *
+ * @returns A success message, or an `ErrorResponse` an error during login occurs.
+ */
 export declare const handleIDPLoginCallback: (payload: {
     code: string;
 }, context: RpcContext) => Promise<ErrorResponse | {

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

@@ -1,14 +1,17 @@
-import type { FiltersEndpointResponseData } from '@scayle/storefront-api';
-import type { FetchFiltersParams, FetchProductParams, FetchProductsByCategoryParams, FetchProductsByIdsParams, FetchProductsByReferenceKeysParams, FetchProductsCountParams, Product, RpcContext } from '../../types';
-import { ErrorResponse } from '../../errors';
-/**
- * For functions which accept either a category path or category ID,
- * this function can resolve the ID which is necessary for the calling
- * the Storefront APIs.
- * @param context
- * @param params
- * @returns A object with `category` and `categoryId` properties.
- *  If no `category` was provided in the params, it will be undefined or '/'
+import type { FetchFiltersParams, FetchFiltersResponse, FetchProductParams, FetchProductsByCategoryParams, FetchProductsByCategoryResponse, FetchProductsByIdsParams, FetchProductsByReferenceKeysParams, FetchProductsCountParams, FetchProductsCountResponse, Product, RpcContext, RpcHandler } from '../../types';
+/**
+ * Resolves the category ID from provided parameters.
+ * This function handles cases where either a category path or ID is provided.
+ *
+ * This function uses the Storefront cache (`cached()`) with a `getById-navigation-trees-${treeId}` key prefix to improve performance.
+ * Cached entries are returned if found; otherwise, data is fetched and cached.
+ *
+ * @param context The RPC context.
+ * @param params The parameters for resolving a category ID from provides params.
+ * @param params.category The category path.
+ * @param params.categoryId The category ID.
+ *
+ * @returns A Promise resolving to an object with `category` (path) and `categoryId` properties.
  */
 export declare function resolveCategoryIdFromParams(context: RpcContext, params: {
     category?: string;
@@ -20,32 +23,153 @@ export declare function resolveCategoryIdFromParams(context: RpcContext, params:
     category: string | undefined;
     categoryId: number | undefined;
 }>;
-export declare const getProductById: (options: FetchProductParams, context: RpcContext) => Promise<Response | Product>;
-export declare const getProductsByIds: (options: FetchProductsByIdsParams, context: RpcContext) => Promise<Response | Product[]>;
-export declare const getProductsByReferenceKeys: (options: FetchProductsByReferenceKeysParams, context: RpcContext) => Promise<Response | Product[]>;
-export declare const getProductsCount: (params: FetchProductsCountParams, context: RpcContext) => Promise<(string[] & ErrorResponse) | {
-    count: number;
-}>;
-export declare const fetchAllFiltersForCategory: ({ includedFilters, category }: {
+/**
+ * Retrieves a product by its ID.
+ *
+ * This function uses the Storefront cache (`cached()`) with a `getById-product-${options.id}` key prefix to improve performance.
+ * Cached entries are returned if found; otherwise, data is fetched and cached.
+ *
+ * @param options The options for retrieving a single product by its ID.
+ * @param options.id The ID of the product.
+ * @param options.with Fields to include in the response.
+ * @param options.pricePromotionKey Price promotion key.
+ * @param options.includeSellableForFree Whether to include sellable for free products.
+ * @param context The RPC context.
+ *
+ * @returns A Promise resolving to the product data. It will return a
+ * `ErrorResponse` alternatively If the product retrieval fails.
+ */
+export declare const getProductById: RpcHandler<FetchProductParams, Product>;
+/**
+ * Retrieves multiple products by their IDs.
+ *
+ * This function uses the Storefront cache (`cached()`) with a `getByIds-products` key prefix to improve performance.
+ * Cached entries are returned if found; otherwise, data is fetched and cached.
+ *
+ * @param options The options for retrieving multiple products by their IDs.
+ * @param options.ids An array of product IDs.
+ * @param options.with Fields to include in the response.
+ * @param options.pricePromotionKey Price promotion key.
+ * @param context The RPC context.
+ *
+ * @returns A Promise resolving to an array of product data.
+ * It will return an `ErrorResponse` if the product retrieval fails.
+ */
+export declare const getProductsByIds: RpcHandler<FetchProductsByIdsParams, Product[]>;
+/**
+ * Retrieves products by their reference keys.
+ *
+ * This function uses the Storefront cache (`cached()`) with a `getByReferenceKeys-products` key prefix to improve performance.
+ * Cached entries are returned if found; otherwise, data is fetched and cached.
+ *
+ * @param options The options for retrieving products.
+ * @param options.referenceKeys An array of product reference keys.
+ * @param options.with The fields to include in the response.
+ * @param options.pricePromotionKey The price promotion key.
+ * @param context The RPC context.
+ *
+ * @returns A Promise that resolves with an array of products.
+ * It will return an `ErrorResponse` if the Storefront API request fails.
+ */
+export declare const getProductsByReferenceKeys: RpcHandler<FetchProductsByReferenceKeysParams, Product[]>;
+/**
+ * Retrieves the count of products matching the provided parameters.
+ *
+ * This function uses the Storefront cache (`cached()`) with a `products-query` key prefix to improve performance.
+ * Cached entries are returned if found; otherwise, data is fetched and cached.
+ *
+ * @param params The parameters for retrieving the product count.
+ * @param params.categoryId ID of the category.
+ * @param params.category Path of the category.
+ * @param params.includedFilters Filters to include.
+ * @param params.where Search criteria.
+ * @param params.where.minPrice Minimum price.
+ * @param params.where.maxPrice Maximum price.
+ * @param params.where.term Search term.
+ * @param params.where.attributes Attributes for filtering.
+ * @param params.where.whitelistAttributes Whitelisted attributes for filtering.
+ * @param params.where.disableFuzziness Whether to disable fuzzy search.
+ * @param params.includeSoldOut Whether to include sold out products.
+ * @param params.includeSellableForFree Whether to include products sellable for free.
+ * @param params.orFiltersOperator Whether to use the OR operator for filters.
+ * @param context The RPC context.
+ *
+ * @returns A Promise that resolves with the product count.
+ */
+export declare const getProductsCount: RpcHandler<FetchProductsCountParams, FetchProductsCountResponse>;
+/**
+ * Fetches all filters for a given category.
+ *
+ * This function uses the Storefront cache (`cached()`) with a `filters-for-category-${category.id}` key prefix to improve performance.
+ * Cached entries are returned if found; otherwise, data is fetched and cached.
+ *
+ * @param params The parameters for fetching filters for a category.
+ * @param params.includedFilters An array of filter slugs to include.
+ * @param params.category Category data.
+ * @param context The RPC context.
+ *
+ * @returns A Promise resolving to an array of filter slugs.
+ *
+ * @throws Will throw an error if fetching filters fails.
+ */
+export declare const fetchAllFiltersForCategory: RpcHandler<{
     includedFilters?: string[];
     category: {
         id?: number;
     };
-}, context: RpcContext) => Promise<string[]>;
-export declare const getFilters: (params: FetchFiltersParams, context: RpcContext) => Promise<(string[] & ErrorResponse) | {
-    filters: FiltersEndpointResponseData;
-    unfilteredCount: number;
-}>;
-export declare const getProductsByCategory: (params: FetchProductsByCategoryParams, context: RpcContext) => Promise<(string[] & ErrorResponse) | {
-    products: Product[];
-    pagination: {
-        current: number;
-        total: number;
-        perPage: number;
-        page: number;
-        first: number;
-        prev: number;
-        next: number;
-        last: number;
-    };
-}>;
+}, string[]>;
+/**
+ * Retrieves filters and product count for a given category.
+ *
+ * This function uses the Storefront cache (`cached()`) with a `get-filters-${categoryId}` and `products-query-category-${categoryId}` key prefix to improve performance.
+ * Cached entries are returned if found; otherwise, data is fetched and cached.
+ *
+ * @param params The parameters for fetching filters.
+ * @param params.includedFilters An array of included filters.
+ * @param params.where The where clause for filtering.
+ * @param params.where.minPrice Minimum price.
+ * @param params.where.maxPrice Maximum price.
+ * @param params.where.term Search term.
+ * @param params.where.attributes Attributes for filtering.
+ * @param params.where.whitelistAttributes Whitelisted attributes.
+ * @param params.where.disableFuzziness Whether to disable fuzziness.
+ * @param params.includeSoldOut Whether to include sold out products.
+ * @param params.includeSellableForFree Whether to include products sellable for free.
+ * @param params.orFiltersOperator The operator for OR filters.
+ * @param context The RPC context.
+ *
+ * @returns An object containing the filters and unfiltered count.
+ */
+export declare const getFilters: RpcHandler<FetchFiltersParams, FetchFiltersResponse>;
+/**
+ * Retrieves products by category.
+ *
+ * This function uses the Storefront cache (`cached()`) with a `products-query-category-${categoryId}` key prefix to improve performance.
+ * Cached entries are returned if found; otherwise, data is fetched and cached.
+ *
+ * @param params The parameters for fetching products.
+ * @param params.includedFilters An array of included filters.
+ * @param params.cache Cache options.
+ * @param params.cache.ttl Time to live for the cache.
+ * @param params.cache.cacheKeyPrefix Cache key prefix.
+ * @param params.with The 'with' parameter for including additional data.
+ * @param params.perPage Number of products per page.
+ * @param params.page Page number.
+ * @param params.where The where clause for filtering.
+ * @param params.where.minPrice Minimum price.
+ * @param params.where.maxPrice Maximum price.
+ * @param params.where.term Search term.
+ * @param params.where.attributes Attributes for filtering.
+ * @param params.where.whitelistAttributes Whitelisted attributes.
+ * @param params.where.disableFuzziness Whether to disable fuzziness.
+ * @param params.sort Sorting criteria.
+ * @param params.pricePromotionKey Price promotion key.
+ * @param params.includeSellableForFree Whether to include products sellable for free.
+ * @param params.includeSoldOut Whether to include sold out products.
+ * @param params.orFiltersOperator The operator for OR filters.
+ * @param params.trackSearchAnalyticsEvent Whether to track search analytics event.
+ * @param context The RPC context.
+ *
+ * @returns An object containing the products and pagination information.
+ */
+export declare const getProductsByCategory: RpcHandler<FetchProductsByCategoryParams, FetchProductsByCategoryResponse>;

package/dist/rpc/methods/products.mjs

@@ -4,7 +4,6 @@ import { MINUTE } from "../../cache/index.mjs";
 import { unwrap } from "../../utils/response.mjs";
 import { mapSAPIFetchErrorToResponse } from "../../utils/sapi.mjs";
 import { ErrorResponse } from "../../errors/index.mjs";
-import { getCampaignKey } from "./campaign.mjs";
 const MAX_PER_PAGE = 100;
 const sanitizeAttributesForSAPI = ({
   attributes,
@@ -25,9 +24,7 @@ export async function resolveCategoryIdFromParams(context, params) {
     category = params.category;
     const result = await context.cached(
       context.sapiClient.categories.getByPath,
-      {
-        cacheKeyPrefix: `getByPath-categories-${category}`
-      }
+      { cacheKeyPrefix: `getByPath-categories-${category}` }
     )(splitAndRemoveEmpty(category));
     categoryId = result.id;
   } else {
@@ -37,7 +34,7 @@ export async function resolveCategoryIdFromParams(context, params) {
 }
 export const getProductById = async function getProductById2(options, context) {
   const { sapiClient, cached, withParams } = context;
-  const campaignKey = await getCampaignKey(context);
+  const campaignKey = await context.callRpc?.("getCampaignKey");
   return await cached(
     mapSAPIFetchErrorToResponse(sapiClient.products.getById),
     {
@@ -53,7 +50,7 @@ export const getProductById = async function getProductById2(options, context) {
 };
 export const getProductsByIds = async function getProductsByIds2(options, context) {
   const { sapiClient, cached, withParams } = context;
-  const campaignKey = await getCampaignKey(context);
+  const campaignKey = await context.callRpc?.("getCampaignKey");
   return await cached(
     mapSAPIFetchErrorToResponse(sapiClient.products.getByIds),
     {
@@ -68,7 +65,7 @@ export const getProductsByIds = async function getProductsByIds2(options, contex
 };
 export const getProductsByReferenceKeys = async function getProductsByReferenceKeys2(options, context) {
   const { sapiClient, cached, withParams } = context;
-  const campaignKey = await getCampaignKey(context);
+  const campaignKey = await context.callRpc?.("getCampaignKey");
   return await cached(
     mapSAPIFetchErrorToResponse(sapiClient.products.getByReferenceKeys),
     {
@@ -90,7 +87,7 @@ export const getProductsCount = async function getProductsCount2(params, context
     orFiltersOperator = void 0
   } = params;
   const { cached, sapiClient } = context;
-  const campaignKey = await getCampaignKey(context);
+  const campaignKey = await context.callRpc?.("getCampaignKey");
   const { categoryId } = await resolveCategoryIdFromParams(context, params);
   const response = await getSanitizedAttributes(
     context,
@@ -131,7 +128,7 @@ export const getProductsCount = async function getProductsCount2(params, context
 };
 export const fetchAllFiltersForCategory = async function fetchAllFiltersForCategory2({ includedFilters = [], category }, context) {
   const { cached, sapiClient } = context;
-  const campaignKey = await getCampaignKey(context);
+  const campaignKey = await context.callRpc?.("getCampaignKey");
   const fetchAndMapFiltersToSlugs = async () => {
     const filtersFromSAPI = await cached(sapiClient.filters.get)({
       where: { categoryId: category.id },
@@ -173,7 +170,7 @@ export const getFilters = async function getFilters2(params, context) {
     orFiltersOperator
   } = params;
   const { cached, sapiClient } = context;
-  const campaignKey = await getCampaignKey(context);
+  const campaignKey = await context.callRpc?.("getCampaignKey");
   const { category, categoryId } = await resolveCategoryIdFromParams(
     context,
     params
@@ -253,7 +250,7 @@ export const getProductsByCategory = async function getProductsByCategory2(param
     trackSearchAnalyticsEvent = void 0
   } = params;
   const { cached, sapiClient } = context;
-  const campaignKey = await getCampaignKey(context);
+  const campaignKey = await context.callRpc?.("getCampaignKey");
   const { category, categoryId } = await resolveCategoryIdFromParams(
     context,
     params