@scayle/storefront-nuxt 8.10.3 → 8.11.0

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @scayle/storefront-nuxt
 
+## 8.11.0
+
+### Minor Changes
+
+- Include `rpcCall` when building the context. This utility function can be used within RPC methods to invoke another RPC method.
+
+### Patch Changes
+
+**Dependencies**
+
+- Updated dependency to @scayle/unstorage-compression-driver@0.2.4
+- Updated dependency to @scayle/storefront-core@8.9.0
+
+## 8.10.4
+
+### Patch Changes
+
+- Updated dependency `@vercel/nft@0.29.1` to `@vercel/nft@0.29.2`
+
 ## 8.10.3
 
 ### Patch Changes

package/dist/module.json

@@ -1,6 +1,6 @@
 {
   "name": "@scayle/storefront-nuxt",
-  "version": "8.10.3",
+  "version": "8.11.0",
   "configKey": "storefront",
   "compatibility": {
     "nuxt": "^3.9.0"

package/dist/module.mjs

@@ -46,7 +46,7 @@ export default {
 }`;
 }
 const PACKAGE_NAME = "@scayle/storefront-nuxt";
-const PACKAGE_VERSION = "8.10.3";
+const PACKAGE_VERSION = "8.11.0";
 const logger = createConsola({
   fancy: true,
   formatOptions: {

package/dist/runtime/api/cacheAuth.d.ts

@@ -1,12 +1,27 @@
 import type { EventHandler } from 'h3';
 /**
- * Wrap an event handler protected by the authentication specified in `cache.auth`
- * @param handler
+ * Wraps an event handler with cache authentication.
+ *
+ * It takes an event handler and returns a new handler that is protected by
+ * basic authentication if cache authentication is configured in the runtime config (`cache.auth`).
+ * If cache authentication is not configured, the original handler is returned.
+ *
+ * @param handler The event handler to wrap.
+ *
+ * @returns The wrapped event handler.
  */
 export declare const eventHandlerWithCacheAuth: (handler: EventHandler) => EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
 /**
- * Wrap an event handler with basic auth
- * @param handler
- * @param auth
+ * Wraps an event handler with basic authentication.
+ *
+ * This function enhances a given event handler with basic authentication functionality.
+ * It checks for an Authorization header in the request and compares the decoded
+ * credentials with the provided authentication string. If the credentials match,
+ * the original handler is executed.
+ *
+ * @param handler The event handler to be wrapped.
+ * @param auth The authentication string in the format 'username:password'.
+ *
+ * @returns The wrapped and awaited event handler, else an authentication failure response is returned.
  */
 export declare const eventHandlerWithBasicAuth: (handler: EventHandler, auth: string) => EventHandler<import("h3").EventHandlerRequest, Promise<any>>;

package/dist/runtime/api/purgeAll.d.ts

@@ -1,2 +1,14 @@
+/**
+ * Purges the entire cache.
+ *
+ * This event handler purges all entries from the configured cache.
+ * It requires both `$rpcContext` and `$cache` to be present in the event context.
+ * If either is missing, it returns a 500 Internal Server Error.
+ * If the purge operation is successful, it returns a 200 OK with `{ success: true }`.
+ * If an error occurs during purging, it returns a 500 Internal Server Error with `{ success: false }`
+ * and logs the error using the logger provided by `$rpcContext`.
+ *
+ * @returns A promise that resolves to either an object indicating success or a `Response` object indicating an error.
+ */
 declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
 export default _default;

package/dist/runtime/api/purgeTags.d.ts

@@ -1,2 +1,16 @@
+/**
+ * Purges cache entries by tags.
+ *
+ * This event handler purges cache entries associated with the provided tags.
+ * It requires both `$rpcContext` and `$cache` to be present in the event context.
+ * If either is missing, it returns a 500 Internal Server Error.
+ * It reads an array of tags from the request body.
+ * If the body is empty or no tags are provided, it returns a 400 Bad Request.
+ * If the purge operation is successful, it returns 200 OK with `{ success: true }`.
+ * If an error occurs during the purge, it returns a 500 Internal Server Error with `{ success: false }`
+ * and logs the error using the logger provided by the `$rpcContext`.
+ *
+ * @returns A promise resolving to an object indicating success or a `Response` object with an error status.
+ */
 declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
 export default _default;

package/dist/runtime/api/rpcHandler.d.ts

@@ -1,21 +1,19 @@
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<string | true | string[] | import("@scayle/storefront-core").ShopUser | Response | import("@scayle/storefront-api").Product | import("@scayle/storefront-api").Product[] | {
-    count: number;
-} | {
-    filters: import("@scayle/storefront-api").FiltersEndpointResponseData;
-    unfilteredCount: number;
-} | {
-    products: import("@scayle/storefront-api").Product[];
-    pagination: {
-        current: number;
-        total: number;
-        perPage: number;
-        page: number;
-        first: number;
-        prev: number;
-        next: number;
-        last: number;
-    };
-} | {
+/**
+ * Generic event handler for RPC methods.
+ *
+ * It retrieves the RPC method name from the request path,
+ * reads the payload from the request body.
+ * It utilizes hooks provided by Nitro to allow for custom logic before,
+ * after, and in case of errors during RPC calls.
+ *
+ * @param event The H3 event object.
+ *
+ * @returns The result of the RPC call or a `Response` object with an error status.
+ */
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<string | true | string[] | import("@scayle/storefront-core").ShopUser | Response | import("@scayle/storefront-api").Product | import("@scayle/storefront-api").Product[] | import("@scayle/storefront-core").FetchProductsCountResponse | import("@scayle/storefront-core").FetchFiltersResponse | import("@scayle/storefront-core").FetchProductsByCategoryResponse | import("@scayle/storefront-api").Wishlist | {
+    accessToken: string;
+    checkoutJwt: string;
+} | import("@scayle/storefront-api").VariantDetail[] | {
     basket: import("@scayle/storefront-api").BasketResponseData<import("@scayle/storefront-api").Product, import("@scayle/storefront-api").Variant>;
 } | {
     readonly type: "success";
@@ -32,10 +30,7 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
     activeNode: import("@scayle/storefront-api").Category;
 } | import("@scayle/storefront-core").Order | import("@scayle/storefront-api").SearchV2SuggestionsEndpointResponseData | import("@scayle/storefront-api").SearchEntity | import("@scayle/storefront-api").ShopConfiguration | {
     user: import("@scayle/storefront-core").ShopUser | undefined;
-} | import("@scayle/storefront-api").Wishlist | import("@scayle/storefront-core").ShopUserAddress[] | {
-    accessToken: string;
-    checkoutJwt: string;
-} | import("@scayle/storefront-api").VariantDetail[] | import("@scayle/storefront-api").NavigationAllEndpointResponseData | import("@scayle/storefront-api").NavigationTree | {
+} | import("@scayle/storefront-core").ShopUserAddress[] | import("@scayle/storefront-api").NavigationAllEndpointResponseData | import("@scayle/storefront-api").NavigationTree | {
     success: true;
 } | {
     success: false;

package/dist/runtime/api/up.d.ts

@@ -1,3 +1,11 @@
+/**
+ * Health check endpoint.
+ *
+ * This simple endpoint returns a JSON object indicating that the service is up.
+ * It is typically used for monitoring and health checks.
+ *
+ * @returns An object with a status property set to 'up'.
+ */
 declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, {
     status: string;
 }>;

package/dist/runtime/cached.d.ts

@@ -1,2 +1,15 @@
 import { type Log, type CacheInterface } from '@scayle/storefront-core';
+/**
+ * Creates and returns a bound cached function.
+ *
+ * It initializes a new `Cached` instance with provided parameters and
+ * returns its `execute` method bound to the instance.
+ * This allows for easy use of the caching functionality provided by `@scayle/storefront-core`.
+ *
+ * @param $cache The cache interface instance.
+ * @param $log The logging instance.
+ * @param enabled Whether caching is enabled or not. Defaults to true if undefined.
+ *
+ * @returns A bound function that can be used to execute cached operations.
+ */
 export declare function getCachedFunction($cache: CacheInterface, $log: Log, enabled: boolean | undefined): <TArgs extends unknown[], TResult>(fn: (...args: TArgs) => Promise<TResult>, options?: import("@scayle/storefront-core").CacheOptions) => Awaited<(...args: TArgs) => Promise<TResult>>;

package/dist/runtime/campaignKey.d.ts

@@ -1,2 +1,20 @@
 import type { StorefrontAPIClient, CachedType, Log } from '@scayle/storefront-core';
+/**
+ * Fetches the key of the first active campaign.
+ *
+ * Retrieves campaigns from the Storefront API, filters for non-ended campaigns,
+ * sorts them, and returns the key of the first active one.
+ * The retrieved campaigns are cached for a specified duration.
+ *
+ * @see https://scayle.dev/en/user-guide/shops/promotions/discounts-and-offers/price-campaigns
+ * @see https://scayle.dev/en/api-guides/storefront-api/resources/campaigns/list-campaigns
+ *
+ * @param sapiClient The Storefront API client.
+ * @param cached The caching function.
+ * @param log The logging instance.
+ *
+ * @throws {Error} If fetching or processing campaigns fails.
+ *
+ * @returns The key of the first active campaign, or undefined if no active campaign is found or an error occurs.
+ */
 export declare const fetchCampaignKey: (sapiClient: StorefrontAPIClient, cached: CachedType, log: Log) => Promise<string | undefined>;

package/dist/runtime/composables/useCoreLog.d.ts

@@ -1 +1,14 @@
+/**
+ * Creates a logger instance with an `sfc` prefix.
+ *
+ * This composable provides a logging function specifically for storefront-nuxt internal operations.
+ * It wraps the generic `useLog` function and prefixes the provided subspace with `sfc` to distinguish
+ * storefront-nuxt logs from application logs. This aids in debugging and troubleshooting by clearly
+ * identifying the origin of log messages.
+ *
+ * @param subSpace The subspace for the logger. If provided, it will be prefixed with `sfc.`.
+ * If not provided, the subspace will be just `sfc`.
+ *
+ * @returns A logger instance.
+ */
 export declare function useCoreLog(subSpace: string): import("@scayle/storefront-core").Log;

package/dist/runtime/context.d.ts

@@ -4,6 +4,9 @@ import { type H3Event } from 'h3';
 import type { Log, RpcContext, Cache as CacheInterface } from '@scayle/storefront-core';
 import { StorefrontAPIClient } from '@scayle/storefront-core';
 import type { ShopConfig, StorefrontConfig } from '../module.js';
+/**
+ * Interface defining the options for the context builder.
+ */
 export interface ContextBuilderOptions {
     $cache: CacheInterface;
     $shopConfig: ShopConfig;
@@ -14,6 +17,28 @@ export interface ContextBuilderOptions {
     config: RuntimeConfig;
     event: H3Event;
 }
+/**
+ * Builds the RPC context.
+ *
+ * It builds the RPC context by gathering data from different sources like
+ * shop config, storefront config, session, etc.
+ * It initializes the SAPI client, caching function, and various context properties.
+ * It also sets up getters for IP, headers, user, access tokens,
+ * and functions for session management and user updates.
+ *
+ * @see https://scayle.dev/en/storefront-guide/developer-guide/basic-setup/rpc-methods#rpc-context
+ *
+ * @param context The context builder options.
+ * @param context.$cache The cache instance.
+ * @param context.$shopConfig The shop configuration.
+ * @param context.$storefront The storefront configuration.
+ * @param context.$log The log instance.
+ * @param context.config The runtime configuration.
+ * @param context.event The H3 event.
+ * @param context.session The session object.
+ *
+ * @returns The built RPC context.
+ */
 export declare const buildContext: (context: ContextBuilderOptions) => Promise<RpcContext>;
 declare module '@scayle/storefront-core' {
     interface AdditionalRpcContext {

package/dist/runtime/context.js

@@ -9,6 +9,8 @@ import {
 } from "@scayle/storefront-core/dist/utils/keys";
 import { useNitroApp } from "nitropack/runtime";
 import { getCachedFunction } from "./cached.js";
+import { getApiBasePath } from "./server/middleware/bootstrap-utils.js";
+import { unwrap } from "@scayle/storefront-core/dist/utils/response";
 import { fetchCampaignKey } from "./campaignKey.js";
 async function getWishlistKey(appKeys, session, $log, $shopConfig) {
   return session.data.user ? await generateWishlistKey({
@@ -28,6 +30,22 @@ async function getBasketKey(appKeys, session, $log, $shopConfig) {
     log: $log
   }) : session?.id;
 }
+function buildRpcCall(event, shopConfig, apiBasePath) {
+  const fetch = event.$fetch;
+  return async function rpcCall(method, params = void 0) {
+    const data = await fetch(`${apiBasePath}/rpc/${method}`, {
+      // @ts-expect-error Type '"POST"' is not assignable to type 'AvailableRouterMethod<`${string}/rpc/${N}`> | Uppercase<AvailableRouterMethod<`${string}/rpc/${N}`>> | undefined'.ts(2322)
+      method: "POST",
+      body: {
+        payload: params
+      },
+      headers: {
+        "x-shop-id": shopConfig.shopId.toString()
+      }
+    });
+    return await unwrap(data);
+  };
+}
 export const buildContext = async (context) => {
   const { $cache, $shopConfig, $storefront, $log, config, event, session } = context;
   const sapiConfig = $shopConfig.sapi ?? $storefront.sapi;
@@ -50,6 +68,11 @@ export const buildContext = async (context) => {
     $storefront.cache?.enabled
   );
   const { hooks } = useNitroApp();
+  const callRpc = buildRpcCall(
+    context.event,
+    $shopConfig,
+    getApiBasePath($storefront, "/")
+  );
   const rpcContext = {
     cached,
     sapiClient,
@@ -135,7 +158,8 @@ export const buildContext = async (context) => {
     updateTokens: session ? async (tokens) => {
       Object.assign(session.data, tokens);
       await session.save();
-    } : void 0
+    } : void 0,
+    callRpc
   };
   await hooks?.callHook("storefront:context:created", rpcContext);
   return rpcContext;

package/dist/runtime/createLog.d.ts

@@ -1,4 +1,20 @@
 import type { ConsolaInstance, ConsolaOptions } from 'consola';
 import type { LogLevel } from '../index.js';
 import { Log } from '@scayle/storefront-core';
+/**
+ * Creates a Consola log instance.
+ *
+ * It creates a new log instance using the provided `createConsola` function.
+ * It sets up a handler that formats log entries with the `space` and logs them
+ * using the consola instance.
+ *
+ * @see https://github.com/unjs/consola?tab=readme-ov-file#creating-a-new-instance
+ *
+ * @param createConsola Function to create a consola instance.
+ * @param createConsola.options Options for the consola instance.
+ * @param space The space for the log. Defaults to 'default-storefront'.
+ * @param level The log level.
+ *
+ * @returns The created Consola log instance.
+ */
 export default function createLog(createConsola: (options?: Partial<ConsolaOptions>) => ConsolaInstance, space: string | undefined, level: LogLevel): Log;

package/dist/runtime/handler.d.ts

@@ -1,8 +1,22 @@
 import type { RpcContext, RpcMethodName, RpcMethodParameters, RpcMethodReturnType } from '@scayle/storefront-core';
 /**
- * Handler for RPC methods
- * @param method
- * @param payload
- * @param rpcContext
+ * Handles RPC method calls, combining core RPC methods with custom Storefront RPC methods.
+ * This function acts as a central dispatcher for invoking RPC methods, determining
+ * whether the method takes parameters or not, and executing it accordingly.
+ * It additionally logs the execution time of each RPC call.
+ *
+ * @template N The RPC method name.
+ * @template P The RPC method parameters.
+ * @template TResult The awaited return type of the RPC method. This can include a `Response` object.
+ * @template TakesParameters A boolean indicating whether the method takes parameters (undefined if it doesn't).
+ * @template TParams The type of the parameters if the method takes any, otherwise null.
+ *
+ * @param method The name of the RPC method to call.
+ * @param payload The parameters for the RPC method (if any).
+ * @param rpcContext The RPC context object.
+ *
+ * @returns A Promise resolving to the result of the RPC call, which can be any valid return type or a `Response` object.
+ *
+ * @throws {Error} If the specified RPC method is not found.
  */
 export declare const handler: <N extends RpcMethodName, P extends RpcMethodParameters<N>, TResult extends Awaited<RpcMethodReturnType<N>>, TakesParameters = P extends RpcContext ? undefined : boolean, TParams = TakesParameters extends undefined ? null : P>(method: N, payload: TParams, rpcContext: RpcContext) => Promise<TResult | Response>;

package/dist/runtime/rpc/rpcCall.d.ts

@@ -2,8 +2,20 @@ import type { RpcContext, RpcMethodName, RpcMethodParameters, RpcMethodReturnTyp
 import type { NuxtApp } from 'nuxt/app';
 import type { PublicShopConfig } from '../../index.js';
 /**
- * rpcCall can be used to invoke an RPC method either on the client or server
- * It makes an HTTP request on the client and direct call on the server using $fetch
- * https://nuxt.com/docs/api/utils/dollarfetch
+ * Invokes an RPC method on the client or server.
+ * Uses an HTTP request on the client and a direct call on the server via `$fetch`.
+ *
+ * @see https://nuxt.com/docs/api/utils/dollarfetch
+ *
+ * @template N The RPC method name.
+ * @template P The RPC method parameters.
+ * @template TResult The unwrapped return type of the RPC method, excluding the Response type.
+ * @template TakesParameters A boolean indicating whether the method takes parameters (undefined if it doesn't).
+ *
+ * @param nuxtApp The Nuxt app instance.
+ * @param method The name of the RPC method to call.
+ * @param shop The public shop configuration.
+ *
+ * @returns A function that takes parameters (if required) and returns a Promise resolving to the result.
  */
 export declare const rpcCall: <N extends RpcMethodName, P extends RpcMethodParameters<N>, TResult extends Exclude<Awaited<RpcMethodReturnType<N>>, Response>, TakesParameters = P extends RpcContext ? undefined : boolean>(nuxtApp: NuxtApp, method: N, shop: PublicShopConfig) => TakesParameters extends undefined ? () => Promise<TResult> : (params: P) => Promise<TResult>;

package/dist/runtime/server/middleware/bootstrap-utils.d.ts

@@ -48,7 +48,7 @@ export declare const convertShopsToList: (shops: ShopConfig[] | ShopConfigIndexe
  *
  * @returns The API base path.
  */
-export declare function getApiBasePath(storefrontConfig: ModuleBaseOptions, baseUrl: string): string;
+export declare function getApiBasePath(storefrontConfig: Pick<ModuleBaseOptions, 'apiBasePath'>, baseUrl: string): string;
 /**
  * Retrieves the current shop configuration for a given request.
  *

package/dist/runtime/utils/promise.d.ts

@@ -1,9 +1,33 @@
 /**
- * This function accepts a Promise which has the same interface as its resolved value.
- * It returns a new Promise which extends the original Promise and the original Promise's resolve value
- * with all the properties in source.
- * @param promise
- * @param source
- * @returns
+ * Extends a Promise and its resolved value with properties from a source object.
+ *
+ * This effectively allows to treat a Promise as a regular object and
+ * extend it with custom properties, while maintaining its asynchronous behavior.
+ * These added properties are then available on the Promise itself as well as on its resolved value.
+ *
+ * @template T The type of the `Promise` and its resolved value. This should be an object type.
+ * @template U The type of the source object.
+ *
+ * @param promise The original Promise. The Promise's resolved value must have the same interface as the Promise itself.
+ * @param source The source object to merge with the Promise and its resolved value.
+ *
+ * @returns A new Promise with the properties of both the original Promise and the `source` object.
+ *          The resolved value of the new Promise also includes the merged properties.
+ *
+ * @example
+ * ```typescript
+ * const originalPromise = Promise.resolve({ initial: 'value' }) as { initial: string } & Promise<{ initial: string }>
+ * const sourceObject = { added: 'objectProperty' }
+ * const extendedPromise = extendPromise(originalPromise, sourceObject)
+ *
+ * // Access `added` property directly on the Promise:
+ * console.log(extendedPromise.added) // 'objectProperty'
+ *
+ * extendedPromise.then(result => {
+ *   // Access added property on the resolved value:
+ *   console.log(result.initial) // 'value'
+ *   console.log(result.added) // 'objectProperty'
+ * })
+ * ```
  */
 export declare function extendPromise<T extends object, U>(promise: T & Promise<T>, source: U): T & U & Promise<T & U>;

package/dist/runtime/utils/route.d.ts

@@ -1,2 +1,13 @@
 import type { LocationQuery } from 'vue-router';
+/**
+ * Retrieves the current page number from the Vue Router query object.
+ *
+ * This function attempts to extract the 'page' parameter from the provided `query` object.
+ * It handles cases where the 'page' parameter is a string and parses it as an integer.
+ * If the 'page' parameter is not a string or not present, it returns undefined.
+ *
+ * @param query The Vue Router query object.
+ *
+ * @returns The current page number as a number, or undefined if not found or invalid.
+ */
 export declare const getCurrentPage: (query: LocationQuery) => number | undefined;

package/dist/runtime/utils/seo.d.ts

@@ -12,4 +12,17 @@ import type { BreadcrumbItem } from '@scayle/storefront-core';
  * @returns The sanitized URL.
  */
 export declare const sanitizeCanonicalURL: (url: string, whitelistParams?: string[]) => string;
+/**
+ * Generates a BreadcrumbList schema for structured data based on an array of BreadcrumbItems.
+ *
+ * This function iterates through the provided `breadcrumbs` array and creates a
+ * `BreadcrumbList` object conforming to the schema.org specification.
+ * Each breadcrumb item is transformed into a `ListItem` with its position, name, and URL.
+ *
+ * @see https://schema.org/BreadcrumbList
+ *
+ * @param breadcrumbs An array of breadcrumb items used to generate the schema.
+ *
+ * @returns A BreadcrumbList schema object ready to be included in structured data.
+ */
 export declare const generateCategoryBreadcrumbSchema: (breadcrumbs: BreadcrumbItem[]) => WithContext<BreadcrumbList>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@scayle/storefront-nuxt",
   "type": "module",
-  "version": "8.10.3",
+  "version": "8.11.0",
   "description": "Nuxt integration for the SCAYLE Commerce Engine and Storefront API",
   "author": "SCAYLE Commerce Engine",
   "license": "MIT",
@@ -72,9 +72,9 @@
   "dependencies": {
     "@opentelemetry/api": "^1.9.0",
     "@scayle/h3-session": "0.6.0",
-    "@scayle/storefront-core": "8.8.0",
-    "@scayle/unstorage-compression-driver": "^0.2.3",
-    "@vercel/nft": "0.29.1",
+    "@scayle/storefront-core": "8.9.0",
+    "@scayle/unstorage-compression-driver": "^0.2.4",
+    "@vercel/nft": "0.29.2",
     "@vueuse/core": "12.7.0",
     "consola": "^3.2.3",
     "core-js": "^3.37.1",
@@ -95,12 +95,12 @@
     "@nuxt/kit": "3.14.1592",
     "@nuxt/module-builder": "0.8.4",
     "@nuxt/schema": "3.14.1592",
-    "@nuxt/test-utils": "3.15.4",
+    "@nuxt/test-utils": "3.17.0",
     "@scayle/eslint-config-storefront": "4.4.1",
     "@scayle/eslint-plugin-vue-composable": "0.2.1",
-    "@types/node": "22.13.4",
+    "@types/node": "22.13.5",
     "dprint": "0.49.0",
-    "eslint": "9.20.1",
+    "eslint": "9.21.0",
     "eslint-formatter-gitlab": "5.1.0",
     "fishery": "2.2.3",
     "h3": "1.15.0",
@@ -110,7 +110,7 @@
     "nuxt": "3.14.1592",
     "publint": "0.2.12",
     "typescript": "5.7.3",
-    "vue-tsc": "2.2.2",
+    "vue-tsc": "2.2.4",
     "vitest": "2.1.9"
   },
   "peerDependencies": {