@scayle/storefront-core 8.6.1 → 8.7.1

package/dist/index.d.ts

@@ -6,15 +6,63 @@ export * from './constants';
 export * from './cache';
 export * from './helpers';
 export * from './types';
+/**
+ * Core RPC methods available within `@scayle/storefront-core`.
+ */
 type RpcMethodsCore = typeof rpcMethods;
+/**
+ * Interface for extending RPC methods within `@scayle/storefront-core`. Allows custom RPC methods
+ * to be added to the SCAYLE Storefront application by extending this interface.
+ *
+ * @example
+ * ```typescript
+ * // nuxt.config.ts
+ * import * as customRpcMethods from './rpc'
+ * declare module '@scayle/storefront-core' {
+ *   export interface RpcMethodsStorefrontInternal extends typeof customRpcMethods {}
+ * }
+ * ```
+ */
 export interface RpcMethodsStorefrontInternal {
 }
+/**
+ * Combined RPC methods, merging core methods with SCAYLE Storefront application extensions.
+ * Extensions from `@scayle/storefront-core` take precedence in case of naming conflicts.
+ */
 export type RpcMethods = {
     [Key in keyof RpcMethodsCore | keyof RpcMethodsStorefrontInternal]: Key extends keyof RpcMethodsStorefrontInternal ? RpcMethodsStorefrontInternal[Key] : Key extends keyof RpcMethodsCore ? RpcMethodsCore[Key] : never;
 };
+/**
+ * Type alias representing the name of an RPC method.  This uses a
+ * resolution technique to avoid inlining method names in compiled
+ * type declarations, which is essential for supporting dynamically
+ * added RPC methods from the SCAYLE Storefront application.
+ *
+ * @see https://github.com/microsoft/TypeScript/pull/42149#issuecomment-865385560
+ * @
+ * Without this workaround, the signature to `rpcCall` looks something like
+ * `rpcCall(m: 'addItemToBasket' | 'addItemToWishlist'...)`.
+ * But we need it to look like `rpcCall(m: RpcMethodName)` in order to include
+ * RPC methods added by the SCAYLE Storefront application.
+ */
 type Resolve<T> = T extends T ? T : never;
 export type RpcMethodName = Resolve<keyof RpcMethods>;
+/**
+ * Describes the type of a specific RPC method by its name.
+ *
+ * @template N The name of the RPC method.
+ */
 export type RpcMethod<N extends RpcMethodName> = RpcMethods[N];
+/**
+ * Describes the type of the parameters for a specific RPC method.
+ *
+ * @template N The name of the RPC method.
+ */
 export type RpcMethodParameters<N extends RpcMethodName> = Parameters<RpcMethod<N>>[0];
+/**
+ * Describes the return type of a specific RPC method.
+ *
+ * @template N The name of the RPC method.
+ */
 export type RpcMethodReturnType<N extends RpcMethodName> = ReturnType<RpcMethod<N>>;
 export { ExistingItemHandling, AddToBasketFailureKind, UpdateBasketItemFailureKind, AddToWishlistFailureKind, PromotionEffectType, FilterTypes, APISortOption, APISortOrder, type ProductSortConfig, } from '@scayle/storefront-api';

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

@@ -35,7 +35,7 @@ export const getCheckoutToken = async function getCheckoutToken2(jwtPayload = {}
     carrier,
     basketId: context.basketKey,
     campaignKey: context.campaignKey
-  }).setIssuedAt(now).setNotBefore(now).setExpirationTime("1h").setIssuer(`${"@scayle/storefront-core"}@${"8.6.1"}`).setProtectedHeader({ alg: "HS256", typ: "JWT" }).sign(secret);
+  }).setIssuedAt(now).setNotBefore(now).setExpirationTime("1h").setIssuer(`${"@scayle/storefront-core"}@${"8.7.1"}`).setProtectedHeader({ alg: "HS256", typ: "JWT" }).sign(secret);
   return {
     accessToken: refreshedAccessToken,
     checkoutJwt

package/dist/test/factories/index.d.ts

@@ -1 +1,2 @@
 export * from '@scayle/storefront-api/dist/test/factories';
+export * from './user';

package/dist/test/factories/index.mjs

@@ -1 +1,2 @@
 export * from "@scayle/storefront-api/dist/test/factories";
+export * from "./user.mjs";

package/dist/test/factories/user.d.ts

@@ -0,0 +1,3 @@
+import { Factory } from 'fishery';
+import type { ShopUser } from '../../types';
+export declare const userFactory: Factory<ShopUser, any, ShopUser>;

package/dist/test/factories/user.mjs

@@ -0,0 +1,16 @@
+import { Factory } from "fishery";
+export const userFactory = Factory.define(() => ({
+  id: 1,
+  app_id: 1,
+  completed_orders: 0,
+  createdAt: "2024-12-12T09:08:06+01:00",
+  updatedAt: "2025-02-14T07:29:05+01:00",
+  email: "user@example.org",
+  firstName: "John",
+  lastName: "Neil",
+  gender: "n",
+  publicKey: "test-public-key",
+  referenceKey: "test-ref-key",
+  isGuest: false,
+  isReturningCustomer: false
+}));

package/dist/types/api/context.d.ts

@@ -75,7 +75,7 @@ export type RpcContext = {
     sapiClient: StorefrontAPIClient;
     cached: CachedType;
     shopId: number;
-    domain: string;
+    domain?: string;
     withParams?: WithParams;
     campaignKey?: string;
     destroySessionsForUserId: (userId: number, sessionsToKeep?: string[]) => Promise<void>;

package/dist/utils/basket.d.ts

@@ -1,2 +1,25 @@
 import type { AddOrUpdateItemError } from '@scayle/storefront-api';
+/**
+ * Checks if all basket add/update errors indicate that items were added with reduced quantity.
+ * This function helps determine if a basket operation partially succeeded, meaning some items were added but with a lower quantity than requested.
+ *
+ * @param errors An array of `AddOrUpdateItemError` objects, typically returned from a basket add/update operation.
+ * @returns `true` if all errors indicate reduced quantity, `false` otherwise (including when the `errors` array is empty, null, or undefined).
+ *
+ * @example
+ * ```typescript
+ * const errors: AddOrUpdateItemError[] = [
+ *   { operation: 'add', kind: AddToBasketFailureKind.ITEM_ADDED_WITH_REDUCED_QUANTITY, variantId: 123 },
+ *   { operation: 'update', kind: UpdateBasketItemFailureKind.ITEM_ADDED_WITH_REDUCED_QUANTITY, variantId: 456 },
+ * ]
+ *
+ * const allReducedQuantity = wasAddedWithReducedQuantity(errors) // true
+ *
+ * const noErrors = wasAddedWithReducedQuantity() // false
+ *
+ * const otherErrors = wasAddedWithReducedQuantity([
+ *   { operation: 'add', kind: AddToBasketFailureKind.ITEM_NOT_FOUND, variantId: 789 },
+ * ]) // false
+ * ```
+ */
 export declare const wasAddedWithReducedQuantity: (errors?: AddOrUpdateItemError[]) => boolean;

package/dist/utils/fetch.d.ts

@@ -1,6 +1,25 @@
 /**
- * A custom Error type for errors that occur in a fetch() request
- * Contains the Response object from the request, and optionally the response data
+ * A custom Error type for errors that occur during a `fetch()` request.
+ * Includes the `Response` object and optional response data for more detailed error analysis.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const response = await fetch('/some/url')
+ *
+ *   if (!response.ok) {
+ *      const data = await response.json(); // Attempt to parse JSON error data
+ *      throw new FetchError(response, data)
+ *   }
+ *   // ... process successful response
+ * } catch (error) {
+ *   if (error instanceof FetchError) {
+ *     console.error("Fetch error:", error.message, error.response.status, error.data)
+ *   } else {
+ *     console.error("Other error:", error)
+ *   }
+ * }
+ * ```
  */
 export declare class FetchError extends Error {
     response: Response;

package/dist/utils/hash.d.ts

@@ -1,8 +1,75 @@
+/**
+ * Calculates the MD5 hash of a string.
+ * Uses `CryptoJS` for MD5 calculation.  Throws an error if MD5 support is omitted in the build.
+ *
+ * @see https://cryptojs.gitbook.io/docs/
+ *
+ * @param value The string to hash.
+ *
+ * @returns A Promise that resolves with the MD5 hash as a hex string.
+ *
+ * @throws {Error} If SFC is built without MD5 support (SFC_OMIT_MD5 environment variable is set).
+ */
 export declare const md5: (value: string) => Promise<any>;
+/**
+ * Calculates the SHA256 hash of a string.
+ *
+ * @param value The input string.
+ *
+ * @returns A Promise that resolves with the SHA256 hash as a hexadecimal string.
+ */
 export declare const sha256: (value: string) => Promise<string>;
+/**
+ * Calculates the HMAC (Hash-based Message Authentication Code) of a string.
+ *
+ * @param value The input string (message).
+ * @param secret The secret key.
+ * @param algorithm The hashing algorithm to use (e.g., 'SHA-256'). Defaults to 'SHA-256'.
+ *
+ * @returns A Promise that resolves with the HMAC as a hexadecimal string.
+ */
 export declare const hmac: (value: string, secret: string, algorithm?: string) => Promise<string>;
+/**
+ * Encodes a string to Base64. Works in both Node.js and browser environments.
+ *
+ * @param string The string to encode.
+ *
+ * @returns The Base64 encoded string.
+ */
 export declare const encodeBase64: (string: string) => string;
+/**
+ * Decodes a Base64 encoded string. Works in both Node.js and browser environments.
+ *
+ * @param string The Base64 encoded string.
+ *
+ * @returns The decoded string.
+ */
 export declare const decodeBase64: (string: string) => string;
+/**
+ * Verifies an order success token by comparing its signature with an expected signature.
+ *
+ * @template T The type of the parsed payload.
+ *
+ * @param token The token to verify.
+ * @param secret The secret key used to generate the signature.
+ *
+ * @returns A Promise resolving to the parsed token payload if the signature is valid, or undefined otherwise.
+ */
 export declare const verifyOrderSuccessToken: <T = unknown>(token: string, secret: string) => Promise<T | undefined>;
+/**
+ * Builds a hash payload by stringifying and Base64 encoding a given payload.
+ *
+ * @param payload The payload to hash.
+ *
+ * @returns The Base64 encoded hash payload.
+ */
 export declare const buildHashPayload: (payload: unknown) => string;
+/**
+ * Builds a signature for a given payload hash and secret.
+ *
+ * @param payloadHash The hash of the payload.
+ * @param secret The secret key.
+ *
+ * @returns A Promise resolving to the Base64 encoded signature.
+ */
 export declare const buildSignature: (payloadHash: string, secret: string) => Promise<string>;

package/dist/utils/hash.mjs

@@ -56,10 +56,10 @@ export const decodeBase64 = (string) => {
 export const verifyOrderSuccessToken = async (token, secret) => {
   const [encodedPayload, signature] = token.split(".", 2);
   const expectedSignature = encodeBase64(await hmac(encodedPayload, secret));
-  if (expectedSignature === signature) {
-    return JSON.parse(decodeBase64(encodedPayload));
+  if (expectedSignature !== signature) {
+    return;
   }
-  return void 0;
+  return JSON.parse(decodeBase64(encodedPayload));
 };
 export const buildHashPayload = (payload) => encodeBase64(JSON.stringify(payload));
 export const buildSignature = async (payloadHash, secret) => encodeBase64(await hmac(payloadHash, secret));

package/dist/utils/keys.d.ts

@@ -1,6 +1,20 @@
 import type { Log } from '..';
 import { HashAlgorithm } from '../constants/hash';
+/**
+ * Generates a key based on a template, shop ID, user ID, and optional hash algorithm.
+ *
+ * @param params The required asynchronous function parameters.
+ * @param params.keyName Deprecated and unused value to specify the name of a key.
+ * @param params.keyTemplate The template string for the key, which can include placeholders for `shopId` and `userId`.
+ * @param params.hashAlgorithm The hash algorithm to use (MD5, SHA256, or none). Defaults to SHA256.
+ * @param params.shopId The shop ID.
+ * @param params.userId The user ID.
+ * @param params.log Optional logger instance.
+ *
+ * @returns A Promise resolving to the generated key.
+ */
 export declare const generateKey: ({ keyTemplate, hashAlgorithm, shopId, userId, log, }: {
+    /** @deprecated */
     keyName?: string;
     keyTemplate: string;
     hashAlgorithm: HashAlgorithm;
@@ -8,6 +22,18 @@ export declare const generateKey: ({ keyTemplate, hashAlgorithm, shopId, userId,
     userId: string;
     log?: Log;
 }) => Promise<string>;
+/**
+ * Generates a wishlist key.
+ *
+ * @param params The required asynchronous function parameters.
+ * @param params.keyTemplate The template string for the key.
+ * @param params.hashAlgorithm The hash algorithm to use. Defaults to SHA256.
+ * @param params.shopId The shop ID.
+ * @param params.userId The user ID.
+ * @param params.log Optional logger instance.
+ *
+ * @returns A Promise resolving to the generated wishlist key.
+ */
 export declare const generateWishlistKey: ({ keyTemplate, hashAlgorithm, shopId, userId, log, }: {
     keyTemplate: string;
     hashAlgorithm: HashAlgorithm;
@@ -15,6 +41,18 @@ export declare const generateWishlistKey: ({ keyTemplate, hashAlgorithm, shopId,
     userId: string;
     log?: Log;
 }) => Promise<string>;
+/**
+ * Generates a basket key.
+ *
+ * @param params The required asynchronous function parameters.
+ * @param params.keyTemplate The template string for the key.
+ * @param params.hashAlgorithm The hash algorithm to use. Defaults to SHA256.
+ * @param params.shopId The shop ID.
+ * @param params.userId The user ID.
+ * @param params.log Optional logger instance.
+ *
+ * @returns A Promise resolving to the generated basket key.
+ */
 export declare const generateBasketKey: ({ keyTemplate, hashAlgorithm, shopId, userId, log, }: {
     keyTemplate: string;
     hashAlgorithm: HashAlgorithm;

package/dist/utils/log.d.ts

@@ -1,43 +1,112 @@
+/**
+ * Represents a log level.
+ */
 export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+/**
+ * Represents a single log entry.
+ */
 export interface LogEntry {
     level: LogLevel;
     space: string;
     message: string;
     data?: object;
 }
+/**
+ * A function that handles log entries.
+ *
+ * @param entry The log entry to handle.
+ */
 export type LogHandler = (entry: LogEntry) => void;
+/**
+ * Options for configuring the logger.
+ */
 export interface LogOptions {
     handler?: LogHandler;
     space: string;
 }
 /**
- * This log provides a way to log messages to a custom log handler (in a serial manner).
- * If no handler is provided, it will log to the console.
+ * A logger that provides structured logging with namespaces.
+ * Supports custom log handlers or if no handler is provided, logging to the console.
  */
 export declare class Log {
+    /**
+     * The default log instance, logging to the console with the `global` namespace.
+     */
     static readonly default: Log;
     _handler?: LogHandler;
     _space: string;
     _type: string;
+    /**
+     * Creates a new Log instance.
+     *
+     * @param options Options for the logger.
+     */
     constructor(options?: LogOptions);
+    /**
+     * Logs a debug message.
+     *
+     * @param message The debug message.
+     * @param data Optional additional data.
+     */
     debug(message: string, data?: any): void;
+    /**
+     * Logs an informational message.
+     *
+     * @param message The informational message.
+     * @param data Optional additional data.
+     */
     info(message: string, data?: any): void;
+    /**
+     * Logs a warning message.
+     *
+     * @param message The warning message.
+     * @param data Optional additional data.
+     */
     warn(message: string, data?: any): void;
+    /**
+     * Logs an error message.
+     *
+     * @param message The error message or an Error object.
+     * @param data Optional additional data.
+     */
     error(message: string | Error, data?: any): void;
+    /**
+     * Writes a log entry.
+     *
+     * @param level The log level.
+     * @param message The log message.
+     * @param data Optional additional data.
+     */
     write(level: LogLevel, message: string, data?: any): void;
     /**
-     * Create a new sub-space.
-     * All spaces are being separated by a dot. E.g. `global.api` and `global.api.getUser`
-     * @param subSpace The name of the sub-space in camel-case (e.g. `api` and `api.getUser`)
+     * Creates a new Log instance with a sub-namespace.
+     * Namespaces are separated by dots (e.g., "global.api.getUser").
+     *
+     * @param subSpace The sub-namespace to add in camel-case (e.g. `api` and `api.getUser`)
+     *
+     * @returns A new Log instance with the updated namespace.
      */
     space(subSpace: string): Log;
     /**
-     * Measure the time of a function.
+     * Measures the execution time of an asynchronous function and logs a debug message.
+     *
+     * @param message A message to include in the log output.
+     * @param func The asynchronous function to time.
+     *
+     * @returns A Promise that resolves with the result of the timed function.
      */
     time(message: string, func: () => any): Promise<any>;
     /**
-     * Attach the log to the request object: `req.$log`.
-     * This function should be called in a server middleware before storefront-core is initialized.
+     * Attaches the log instance to a request object.
+     * This is typically used in server middleware.
+     *
+     * @param req The request object.
+     * @param log The Log instance to attach.
+     *
+     * @example
+     * Log.attachToRequest(req, new Log({ space: 'myModule' }))
+     *
+     * @deprecated
      */
     static attachToRequest(req: any, log: Log): void;
 }

package/dist/utils/log.mjs

@@ -1,4 +1,7 @@
 export class Log {
+  /**
+   * The default log instance, logging to the console with the `global` namespace.
+   */
   static default = new this({
     space: "global",
     handler: consoleLogHandler
@@ -6,19 +9,48 @@ export class Log {
   _handler;
   _space;
   _type = "log";
+  /**
+   * Creates a new Log instance.
+   *
+   * @param options Options for the logger.
+   */
   constructor(options) {
     this._handler = options?.handler || Log.default._handler;
     this._space = options?.space || Log.default._space;
   }
+  /**
+   * Logs a debug message.
+   *
+   * @param message The debug message.
+   * @param data Optional additional data.
+   */
   debug(message, data) {
     this.write("debug", message, data);
   }
+  /**
+   * Logs an informational message.
+   *
+   * @param message The informational message.
+   * @param data Optional additional data.
+   */
   info(message, data) {
     this.write("info", message, data);
   }
+  /**
+   * Logs a warning message.
+   *
+   * @param message The warning message.
+   * @param data Optional additional data.
+   */
   warn(message, data) {
     this.write("warn", message, data);
   }
+  /**
+   * Logs an error message.
+   *
+   * @param message The error message or an Error object.
+   * @param data Optional additional data.
+   */
   error(message, data) {
     const error = message instanceof Error ? message : null;
     if (error) {
@@ -29,6 +61,13 @@ export class Log {
     }
     this.write("error", error?.message ?? message, data);
   }
+  /**
+   * Writes a log entry.
+   *
+   * @param level The log level.
+   * @param message The log message.
+   * @param data Optional additional data.
+   */
   write(level, message, data) {
     if (typeof data !== "undefined") {
       data = typeof data !== "object" ? { data } : data;
@@ -41,9 +80,12 @@ export class Log {
     }
   }
   /**
-   * Create a new sub-space.
-   * All spaces are being separated by a dot. E.g. `global.api` and `global.api.getUser`
-   * @param subSpace The name of the sub-space in camel-case (e.g. `api` and `api.getUser`)
+   * Creates a new Log instance with a sub-namespace.
+   * Namespaces are separated by dots (e.g., "global.api.getUser").
+   *
+   * @param subSpace The sub-namespace to add in camel-case (e.g. `api` and `api.getUser`)
+   *
+   * @returns A new Log instance with the updated namespace.
    */
   space(subSpace) {
     return new Log({
@@ -52,7 +94,12 @@ export class Log {
     });
   }
   /**
-   * Measure the time of a function.
+   * Measures the execution time of an asynchronous function and logs a debug message.
+   *
+   * @param message A message to include in the log output.
+   * @param func The asynchronous function to time.
+   *
+   * @returns A Promise that resolves with the result of the timed function.
    */
   async time(message, func) {
     const start = Date.now();
@@ -62,8 +109,16 @@ export class Log {
     return result;
   }
   /**
-   * Attach the log to the request object: `req.$log`.
-   * This function should be called in a server middleware before storefront-core is initialized.
+   * Attaches the log instance to a request object.
+   * This is typically used in server middleware.
+   *
+   * @param req The request object.
+   * @param log The Log instance to attach.
+   *
+   * @example
+   * Log.attachToRequest(req, new Log({ space: 'myModule' }))
+   *
+   * @deprecated
    */
   static attachToRequest(req, log) {
     req.$log = log;

package/dist/utils/response.d.ts

@@ -1,6 +1,11 @@
 /**
- * Unwrap a possible response into its body
- * @param res
- * @returns unwrapped response
+ * Unwraps a value that might be a `Response` object or a direct value. If it's a `Response`,
+ * it parses the JSON body and returns it; otherwise, it returns the value directly.
+ *
+ * @template T The expected type of the unwrapped value.
+ *
+ * @param res The value to unwrap, which can be a `Promise`, `Response`, or a direct value.
+ *
+ * @returns A Promise resolving to the unwrapped value.
  */
 export declare function unwrap<T>(res: Promise<Response | T> | Response | T): Promise<T>;

package/dist/utils/sapi.d.ts

@@ -1,5 +1,13 @@
 /**
- * Wrap a SAPI API function, catching any SAPI FetchErrors thrown
- * and translating them to a Response return
+ * Wraps a SAPI API function, catching SAPI FetchErrors and converting them to a structured Response.
+ * This allows handling SAPI errors in a consistent way, returning a JSON response with status information.
+ *
+ * @template T The type of the SAPI API function.
+ *
+ * @param func The SAPI API function to wrap.
+ *
+ * @returns A wrapped function that returns a Promise resolving to either the original function's result or a JSON Response representing the error.
+ *
+ * @throws Re-throws any error that is not an instance of FetchError.
  */
 export declare function mapSAPIFetchErrorToResponse<T extends (...args: any) => any>(func: T): (...args: Parameters<T>) => Promise<Awaited<ReturnType<T>> | Response>;

package/dist/utils/timeout.d.ts

@@ -1,2 +1,20 @@
+/**
+ * Pauses execution for a specified number of milliseconds.
+ *
+ * @param ms The number of milliseconds to wait.
+ *
+ * @returns A Promise that resolves after the specified delay.
+ */
 export declare const wait: (ms: number) => Promise<unknown>;
+/**
+ * Wraps a promise with a timeout. Rejects the promise if it doesn't resolve within the given time.
+ *
+ * @template T The type of the promise's resolved value.
+ * @param ms The timeout duration in milliseconds.
+ * @param promise The promise to wrap.
+ *
+ * @returns A new promise that resolves or rejects based on the original promise or the timeout.
+ *
+ * @throws {Error} If the promise times out.  The error message will be "timeout".
+ */
 export declare const timeout: <T>(ms: number, promise: Promise<T>) => Promise<T>;

package/dist/utils/user.d.ts

@@ -1,4 +1,15 @@
 import type { BasketWithOptions, RpcContext } from '../types';
+/**
+ * Merges two baskets. Adds the items from the `fromBasketKey` basket to the `toBasketKey` basket
+ * and then clears the `fromBasketKey` basket. Handles existing items by adding quantities.
+ *
+ * @param fromBasketKey The key of the source basket.
+ * @param toBasketKey The key of the destination basket.
+ * @param withOptions Options for retrieving basket data (including custom and order data).
+ * @param context The RPC context.
+ *
+ * @returns The merged basket.
+ */
 export declare const mergeBaskets: (fromBasketKey: string, toBasketKey: string, withOptions: BasketWithOptions & {
     orderCustomData?: Record<string, unknown>;
 }, context: RpcContext) => Promise<{
@@ -13,4 +24,15 @@ export declare const mergeBaskets: (fromBasketKey: string, toBasketKey: string,
     readonly basket: import("@scayle/storefront-api").BasketResponseData<import("@scayle/storefront-api").Product, import("@scayle/storefront-api").Variant>;
     readonly errors: import("@scayle/storefront-api").AddOrUpdateItemError[];
 } | undefined>;
+/**
+ * Merges two wishlists.  Adds the items from the `fromWishlistKey` wishlist to the `toWishlistKey` wishlist
+ * and then clears the `fromWishlistKey` wishlist.
+ *
+ * @param fromWishlistKey The key of the source wishlist.
+ * @param toWishlistKey The key of the destination wishlist.
+ * @param withOptions Options for retrieving wishlist data.
+ * @param context The RPC context.
+ *
+ * @returns Nothing (resolves when the merge operation is complete).
+ */
 export declare const mergeWishlists: (fromWishlistKey: string, toWishlistKey: string, withOptions: BasketWithOptions, context: RpcContext) => Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scayle/storefront-core",
-  "version": "8.6.1",
+  "version": "8.7.1",
   "description": "Collection of essential utilities to work with the Storefront API",
   "author": "SCAYLE Commerce Engine",
   "license": "MIT",