@scayle/storefront-nuxt 7.82.1 → 7.83.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @scayle/storefront-nuxt
 
+## 7.83.0
+
+### Minor Changes
+
+- Deprecate `useQueryFilterState` in the `@scayle/storefront-nuxt` package
+
+## 7.82.2
+
+### Patch Changes
+
+- Fix types of `useBasket` composable
+- Fix types for more composables
+- Migrate from using `RpcContext.bapiClient` to using `RpcContext.sapiClient`
+- Updated dependencies
+  - @scayle/storefront-core@7.62.0
+
 ## 7.82.1
 
 ### Patch Changes

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-export { d as AdditionalShopConfig, A as AppKeys, B as BapiConfig, h as CheckoutEvent, C as CheckoutShopConfig, M as ModuleBaseOptions, i as ModulePublicRuntimeConfig, P as PublicShopConfig, R as RedisConfig, a as SessionConfig, e as ShopConfig, f as ShopConfigIndexed, c as StorageConfig, b as StorageEntity, S as StorageProvider, g as StorefrontConfig } from './shared/storefront-nuxt.ed010583.mjs';
+export { e as AdditionalShopConfig, A as AppKeys, B as BapiConfig, i as CheckoutEvent, C as CheckoutShopConfig, M as ModuleBaseOptions, j as ModulePublicRuntimeConfig, P as PublicShopConfig, R as RedisConfig, d as SapiConfig, a as SessionConfig, f as ShopConfig, g as ShopConfigIndexed, c as StorageConfig, b as StorageEntity, S as StorageProvider, h as StorefrontConfig } from './shared/storefront-nuxt.87331293.mjs';
 export { rpcCall } from './rpc.mjs';
 export * from '@scayle/storefront-core';
 export { LogLevel } from '@scayle/storefront-core';

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { d as AdditionalShopConfig, A as AppKeys, B as BapiConfig, h as CheckoutEvent, C as CheckoutShopConfig, M as ModuleBaseOptions, i as ModulePublicRuntimeConfig, P as PublicShopConfig, R as RedisConfig, a as SessionConfig, e as ShopConfig, f as ShopConfigIndexed, c as StorageConfig, b as StorageEntity, S as StorageProvider, g as StorefrontConfig } from './shared/storefront-nuxt.ed010583.js';
+export { e as AdditionalShopConfig, A as AppKeys, B as BapiConfig, i as CheckoutEvent, C as CheckoutShopConfig, M as ModuleBaseOptions, j as ModulePublicRuntimeConfig, P as PublicShopConfig, R as RedisConfig, d as SapiConfig, a as SessionConfig, f as ShopConfig, g as ShopConfigIndexed, c as StorageConfig, b as StorageEntity, S as StorageProvider, h as StorefrontConfig } from './shared/storefront-nuxt.87331293.js';
 export { rpcCall } from './rpc.js';
 export * from '@scayle/storefront-core';
 export { LogLevel } from '@scayle/storefront-core';

package/dist/module.d.mts

@@ -1,11 +1,11 @@
 import * as _nuxt_schema from '@nuxt/schema';
-import { M as ModuleBaseOptions } from './shared/storefront-nuxt.ed010583.mjs';
-export { d as AdditionalShopConfig, A as AppKeys, B as BapiConfig, h as CheckoutEvent, C as CheckoutShopConfig, i as ModulePublicRuntimeConfig, P as PublicShopConfig, R as RedisConfig, a as SessionConfig, e as ShopConfig, f as ShopConfigIndexed, c as StorageConfig, b as StorageEntity, S as StorageProvider, g as StorefrontConfig } from './shared/storefront-nuxt.ed010583.mjs';
+import { M as ModuleBaseOptions } from './shared/storefront-nuxt.87331293.mjs';
+export { e as AdditionalShopConfig, A as AppKeys, B as BapiConfig, i as CheckoutEvent, C as CheckoutShopConfig, j as ModulePublicRuntimeConfig, P as PublicShopConfig, R as RedisConfig, d as SapiConfig, a as SessionConfig, f as ShopConfig, g as ShopConfigIndexed, c as StorageConfig, b as StorageEntity, S as StorageProvider, h as StorefrontConfig } from './shared/storefront-nuxt.87331293.mjs';
 export { LogLevel } from '@scayle/storefront-core';
 import '@scayle/unstorage-compression-driver';
 import 'unstorage';
 import 'zod';
 
-declare const _default: _nuxt_schema.NuxtModule<ModuleBaseOptions>;
+declare const _default: _nuxt_schema.NuxtModule<Omit<ModuleBaseOptions, "sapi" | "bapi">>;
 
 export { ModuleBaseOptions, _default as default };

package/dist/module.d.ts

@@ -1,11 +1,11 @@
 import * as _nuxt_schema from '@nuxt/schema';
-import { M as ModuleBaseOptions } from './shared/storefront-nuxt.ed010583.js';
-export { d as AdditionalShopConfig, A as AppKeys, B as BapiConfig, h as CheckoutEvent, C as CheckoutShopConfig, i as ModulePublicRuntimeConfig, P as PublicShopConfig, R as RedisConfig, a as SessionConfig, e as ShopConfig, f as ShopConfigIndexed, c as StorageConfig, b as StorageEntity, S as StorageProvider, g as StorefrontConfig } from './shared/storefront-nuxt.ed010583.js';
+import { M as ModuleBaseOptions } from './shared/storefront-nuxt.87331293.js';
+export { e as AdditionalShopConfig, A as AppKeys, B as BapiConfig, i as CheckoutEvent, C as CheckoutShopConfig, j as ModulePublicRuntimeConfig, P as PublicShopConfig, R as RedisConfig, d as SapiConfig, a as SessionConfig, f as ShopConfig, g as ShopConfigIndexed, c as StorageConfig, b as StorageEntity, S as StorageProvider, h as StorefrontConfig } from './shared/storefront-nuxt.87331293.js';
 export { LogLevel } from '@scayle/storefront-core';
 import '@scayle/unstorage-compression-driver';
 import 'unstorage';
 import 'zod';
 
-declare const _default: _nuxt_schema.NuxtModule<ModuleBaseOptions>;
+declare const _default: _nuxt_schema.NuxtModule<Omit<ModuleBaseOptions, "sapi" | "bapi">>;
 
 export { ModuleBaseOptions, _default as default };

package/dist/module.json

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

package/dist/module.mjs

@@ -65,7 +65,7 @@ export default {
 }`;
 }
 const PACKAGE_NAME = "@scayle/storefront-nuxt";
-const PACKAGE_VERSION = "7.82.1";
+const PACKAGE_VERSION = "7.83.0";
 const logger = createConsola({
   fancy: true,
   formatOptions: {
@@ -98,10 +98,6 @@ const module = defineNuxtModule({
       // if we set maxAge explicitly to undefined `useRuntimeConfig` will set it default to '' which leads to no sessions not being saved
       // maxAge: undefined,
     },
-    bapi: {
-      host: "",
-      token: ""
-    },
     shopSelector: "domain",
     stores: {},
     oauth: {

package/dist/rpc.d.mts

@@ -1,6 +1,6 @@
 import { RpcMethodName, RpcMethodParameters, RpcMethodReturnType, RpcContext } from '@scayle/storefront-core';
 import { NuxtApp } from 'nuxt/app';
-import { P as PublicShopConfig } from './shared/storefront-nuxt.ed010583.mjs';
+import { P as PublicShopConfig } from './shared/storefront-nuxt.87331293.mjs';
 import '@scayle/unstorage-compression-driver';
 import 'unstorage';
 import 'zod';

package/dist/rpc.d.ts

@@ -1,6 +1,6 @@
 import { RpcMethodName, RpcMethodParameters, RpcMethodReturnType, RpcContext } from '@scayle/storefront-core';
 import { NuxtApp } from 'nuxt/app';
-import { P as PublicShopConfig } from './shared/storefront-nuxt.ed010583.js';
+import { P as PublicShopConfig } from './shared/storefront-nuxt.87331293.js';
 import '@scayle/unstorage-compression-driver';
 import 'unstorage';
 import 'zod';

package/dist/runtime/campaignKey.d.ts

@@ -3,4 +3,4 @@ export declare const isCampaignActive: (campaign?: Campaign) => boolean;
 export declare const campaignHasNotEnded: (campaign: Campaign) => boolean;
 export declare const campaignKeyMatchesKeyword: (campaign: Campaign, keyword?: string) => boolean;
 export declare const sortCampaignsByDateAscending: (a: Campaign, b: Campaign) => number;
-export declare const fetchCampaignKey: (bapiClient: StorefrontAPIClient, cached: CachedType, storeCampaignKeyword: string | undefined, log: Log) => Promise<string | undefined>;
+export declare const fetchCampaignKey: (sapiClient: StorefrontAPIClient, cached: CachedType, storeCampaignKeyword: string | undefined, log: Log) => Promise<string | undefined>;

package/dist/runtime/campaignKey.mjs

@@ -21,10 +21,10 @@ export const campaignKeyMatchesKeyword = (campaign, keyword) => {
 export const sortCampaignsByDateAscending = (a, b) => {
   return new Date(a.start_at).getTime() - new Date(b.start_at).getTime();
 };
-export const fetchCampaignKey = async (bapiClient, cached, storeCampaignKeyword, log) => {
+export const fetchCampaignKey = async (sapiClient, cached, storeCampaignKeyword, log) => {
   try {
     const { campaigns } = await cached(async () => {
-      const { entities } = await bapiClient.campaigns.get();
+      const { entities } = await sapiClient.campaigns.get();
       return {
         campaigns: entities.filter((campaign) => {
           return campaignHasNotEnded(campaign) && campaignKeyMatchesKeyword(campaign, storeCampaignKeyword);

package/dist/runtime/composables/core/useIDP.d.ts

@@ -1,22 +1,28 @@
 import { type MaybeRefOrGetter } from 'vue';
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-export declare function useIDP(params?: MaybeRefOrGetter<RpcMethodParameters<'getExternalIdpRedirect'>>, key?: string): import("nuxt/dist/app/composables/asyncData")._AsyncData<{
-    [k: string]: string;
-}, any> & {
-    fetching: import("vue").Ref<boolean>;
+export declare function useIDP(params?: MaybeRefOrGetter<RpcMethodParameters<'getExternalIdpRedirect'>>, key?: string): {
+    data: import("vue").Ref<{
+        [k: string]: string;
+    }>;
     fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
-} & {
+    fetching: import("vue").Ref<boolean>;
+    error: import("vue").Ref<any>;
+    refresh: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
+    status: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus>;
     handleIDPLoginCallback: (params: string | {
         code: string;
     }) => Promise<{
         message: string;
     }>;
-} & Promise<import("nuxt/dist/app/composables/asyncData")._AsyncData<{
-    [k: string]: string;
-}, any> & {
-    fetching: import("vue").Ref<boolean>;
+} & Promise<{
+    data: import("vue").Ref<{
+        [k: string]: string;
+    }>;
     fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
-} & {
+    fetching: import("vue").Ref<boolean>;
+    error: import("vue").Ref<any>;
+    refresh: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
+    status: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus>;
     handleIDPLoginCallback: (params: string | {
         code: string;
     }) => Promise<{

package/dist/runtime/composables/core/useIDP.mjs

@@ -12,12 +12,26 @@ export function useIDP(params = {}, key) {
     key ?? "useIDP",
     params
   );
+  const {
+    data,
+    fetch,
+    fetching,
+    error,
+    refresh,
+    status
+  } = useRpcPromise;
   const handleIDPLoginCallback = rpcCall(
     nuxtApp,
     "handleIDPLoginCallback",
     toValue(shop)
   );
-  return extendPromise(useRpcPromise, {
+  return extendPromise(useRpcPromise.then(() => ({})), {
+    data,
+    fetch,
+    fetching,
+    error,
+    refresh,
+    status,
     // TODO: Deprecate the property here and remove it with the next major release
     handleIDPLoginCallback
   });

package/dist/runtime/composables/storefront/useCategories.d.ts

@@ -7,27 +7,33 @@ type Options = Partial<{
     /** @deprecated use the second argument of the composable to define the key */
     key: string;
 }>;
-export declare function useCategories({ params, options, key: _key, }?: Options, key?: string): import("nuxt/dist/app/composables/asyncData")._AsyncData<{
-    categories: import("@scayle/storefront-api").Category[];
-    activeNode: undefined;
-} | {
-    categories: import("@scayle/storefront-api").Category;
-    activeNode: import("@scayle/storefront-api").Category;
-}, any> & {
-    fetching: import("vue").Ref<boolean>;
+export declare function useCategories({ params, options, key: _key, }?: Options, key?: string): {
+    data: import("vue").Ref<{
+        categories: import("@scayle/storefront-api").Category[];
+        activeNode: undefined;
+    } | {
+        categories: import("@scayle/storefront-api").Category;
+        activeNode: import("@scayle/storefront-api").Category;
+    }>;
+    error: import("vue").Ref<any>;
+    status: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus>;
     fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
-} & {
-    getCategoryById: (id: number, includeHidden?: true) => Promise<import("@scayle/storefront-api").Category>;
-} & Promise<import("nuxt/dist/app/composables/asyncData")._AsyncData<{
-    categories: import("@scayle/storefront-api").Category[];
-    activeNode: undefined;
-} | {
-    categories: import("@scayle/storefront-api").Category;
-    activeNode: import("@scayle/storefront-api").Category;
-}, any> & {
     fetching: import("vue").Ref<boolean>;
+    refresh: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
+    getCategoryById: (id: number, includeHidden?: true) => Promise<import("@scayle/storefront-api").Category>;
+} & Promise<{
+    data: import("vue").Ref<{
+        categories: import("@scayle/storefront-api").Category[];
+        activeNode: undefined;
+    } | {
+        categories: import("@scayle/storefront-api").Category;
+        activeNode: import("@scayle/storefront-api").Category;
+    }>;
+    error: import("vue").Ref<any>;
+    status: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus>;
     fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
-} & {
+    fetching: import("vue").Ref<boolean>;
+    refresh: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
     getCategoryById: (id: number, includeHidden?: true) => Promise<import("@scayle/storefront-api").Category>;
 }>;
 export {};

package/dist/runtime/composables/storefront/useCategories.mjs

@@ -21,7 +21,21 @@ export function useCategories({
     "getCategoryById",
     currentShop.value ?? void 0
   );
-  return extendPromise(useRpcPromise, {
+  const {
+    data,
+    error,
+    status,
+    fetch,
+    fetching,
+    refresh
+  } = useRpcPromise;
+  return extendPromise(useRpcPromise.then(() => ({})), {
+    data,
+    error,
+    status,
+    fetch,
+    fetching,
+    refresh,
     getCategoryById: (id, includeHidden) => getCategoryById({ id, includeHidden })
   });
 }

package/dist/runtime/composables/storefront/useOrder.d.ts

@@ -1,6 +1,6 @@
 import type { RpcMethodParameters, Order } from '@scayle/storefront-core';
 import type { RpcOptions } from '../core/useRpc';
-import type { MaybeRefOrGetter } from '#imports';
+import type { Ref, MaybeRefOrGetter } from 'vue';
 type Options = Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getOrderById'>>;
     options: RpcOptions;
@@ -11,10 +11,7 @@ export declare function useOrder<P = {
     [k: string]: unknown;
 }, V = {
     [k: string]: unknown;
-}>({ params, options, key: _key }?: Options, key?: string): import("nuxt/dist/app/composables/asyncData")._AsyncData<Order, any> & {
-    fetching: import("vue").Ref<boolean>;
-    fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
-} & {
+}>({ params, options, key: _key }?: Options, key?: string): {
     data: Ref<Order & {
         items?: ({
             id?: import("@scayle/storefront-core").UniqueNumericIdentifierOfTheItem;
@@ -85,10 +82,12 @@ export declare function useOrder<P = {
             variant: V;
         })[];
     }>;
-} & Promise<import("nuxt/dist/app/composables/asyncData")._AsyncData<Order, any> & {
-    fetching: import("vue").Ref<boolean>;
     fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
-} & {
+    fetching: Ref<boolean>;
+    error: Ref<any>;
+    refresh: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
+    status: Ref<import("nuxt/app").AsyncDataRequestStatus>;
+} & Promise<{
     data: Ref<Order & {
         items?: ({
             id?: import("@scayle/storefront-core").UniqueNumericIdentifierOfTheItem;
@@ -159,5 +158,10 @@ export declare function useOrder<P = {
             variant: V;
         })[];
     }>;
+    fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
+    fetching: Ref<boolean>;
+    error: Ref<any>;
+    refresh: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
+    status: Ref<import("nuxt/app").AsyncDataRequestStatus>;
 }>;
 export {};

package/dist/runtime/composables/storefront/useOrder.mjs

@@ -7,8 +7,21 @@ export function useOrder({ params, options, key: _key } = {}, key) {
     params,
     options
   );
-  const _data = promise.data;
-  return extendPromise(promise, {
-    data: _data
+  const {
+    data,
+    fetch,
+    fetching,
+    error,
+    refresh,
+    status
+  } = promise;
+  const _data = data;
+  return extendPromise(promise.then(() => ({})), {
+    data: _data,
+    fetch,
+    fetching,
+    error,
+    refresh,
+    status
   });
 }

package/dist/runtime/composables/storefront/useOrderConfirmation.d.ts

@@ -1,6 +1,6 @@
 import type { RpcMethodParameters, Order } from '@scayle/storefront-core';
 import type { RpcOptions } from '../core/useRpc';
-import type { MaybeRefOrGetter } from '#imports';
+import type { Ref, MaybeRefOrGetter } from 'vue';
 type Options = Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getOrderDataByCbd'>>;
     options: RpcOptions;
@@ -11,10 +11,12 @@ export declare function useOrderConfirmation<P = {
     [k: string]: unknown;
 }, V = {
     [k: string]: unknown;
-}>({ params, options, key: _key }?: Options, key?: string): import("nuxt/dist/app/composables/asyncData")._AsyncData<Order | undefined, any> & {
-    fetching: import("vue").Ref<boolean>;
+}>({ params, options, key: _key }?: Options, key?: string): {
     fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
-} & {
+    fetching: Ref<boolean>;
+    error: Ref<any>;
+    refresh: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
+    status: Ref<import("nuxt/app").AsyncDataRequestStatus>;
     data: Ref<Order & {
         items?: ({
             id?: import("@scayle/storefront-core").UniqueNumericIdentifierOfTheItem;
@@ -85,10 +87,12 @@ export declare function useOrderConfirmation<P = {
             variant: V;
         })[];
     }>;
-} & Promise<import("nuxt/dist/app/composables/asyncData")._AsyncData<Order | undefined, any> & {
-    fetching: import("vue").Ref<boolean>;
+} & Promise<{
     fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
-} & {
+    fetching: Ref<boolean>;
+    error: Ref<any>;
+    refresh: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
+    status: Ref<import("nuxt/app").AsyncDataRequestStatus>;
     data: Ref<Order & {
         items?: ({
             id?: import("@scayle/storefront-core").UniqueNumericIdentifierOfTheItem;

package/dist/runtime/composables/storefront/useOrderConfirmation.mjs

@@ -7,8 +7,21 @@ export function useOrderConfirmation({ params, options, key: _key } = {}, key) {
     params,
     options
   );
-  const _data = promise.data;
-  return extendPromise(promise, {
+  const {
+    data,
+    fetch,
+    fetching,
+    error,
+    refresh,
+    status
+  } = promise;
+  const _data = data;
+  return extendPromise(promise.then(() => ({})), {
+    fetch,
+    fetching,
+    error,
+    refresh,
+    status,
     data: _data
   });
 }

package/dist/runtime/composables/storefront/useQueryFilterState.d.ts

@@ -1,7 +1,8 @@
-import type { FilterParams, SortingValueKey, TransformedFilter, Filter } from '@scayle/storefront-core';
+import { type FilterParams, type TransformedFilter, type Filter, type SortingValueKey } from '@scayle/storefront-core';
 type Options = {
     defaultSort?: SortingValueKey;
 };
+/** @deprecated The Storefront Boilerplate contains a `useQueryFilterState` composable you can use instead. **/
 export declare function useQueryFilterState(options?: Options): {
     activeFilters: import("vue").ComputedRef<Filter>;
     applyFilters: (filter?: Filter, scrollToTop?: boolean) => Promise<void>;

package/dist/runtime/composables/storefront/useQueryFilterState.mjs

@@ -1,10 +1,10 @@
 import { isEmpty, isEqual } from "radash";
 import {
-  getSortByValue,
   isFilterActive,
   transformToWhereCondition,
   serializeFilters,
-  deserializeFilters
+  deserializeFilters,
+  getSortByValue
 } from "@scayle/storefront-core";
 import { computed } from "vue";
 import { getCurrentPage } from "../../utils/route.mjs";

package/dist/runtime/context.d.ts

@@ -2,6 +2,7 @@ import type { Session } from '@scayle/h3-session';
 import type { RuntimeConfig } from '@nuxt/schema';
 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';
 export interface ContextBuilderOptions {
     $cache: CacheInterface;
@@ -14,3 +15,8 @@ export interface ContextBuilderOptions {
     event: H3Event;
 }
 export declare const buildContext: (context: ContextBuilderOptions) => Promise<RpcContext>;
+declare module '@scayle/storefront-core' {
+    interface AdditionalRpcContext {
+        sapiClient: StorefrontAPIClient;
+    }
+}

package/dist/runtime/context.mjs

@@ -80,22 +80,23 @@ async function sessionProperties(context) {
 }
 export const buildContext = async (context) => {
   const { $cache, $shopConfig, $storefront, $log, config, event } = context;
-  const bapiConfig = $shopConfig.bapi ?? $storefront.bapi;
+  const sapiConfig = $shopConfig.sapi ?? $shopConfig.bapi ?? $storefront.sapi ?? $storefront.bapi;
   const appKeys = $shopConfig.appKeys ?? $storefront.appKeys;
   const idpConfig = $shopConfig.idp ?? $storefront.idp;
-  const bapiClient = new StorefrontAPIClient({
-    host: bapiConfig.host,
+  const sapiClient = new StorefrontAPIClient({
+    host: sapiConfig.host,
     shopId: $shopConfig.shopId,
     auth: {
       type: "token",
-      token: bapiConfig.token
+      token: sapiConfig.token
     }
   });
   const cached = new Cached($cache, $log, "", $storefront.cache?.enabled ?? true).execute;
   const { hooks } = useNitroApp();
   const baseContext = {
     cached,
-    bapiClient,
+    bapiClient: sapiClient,
+    sapiClient,
     auth: {
       resetPasswordUrl: $shopConfig.auth?.resetPasswordUrl
     },
@@ -136,7 +137,7 @@ export const buildContext = async (context) => {
     withParams: $storefront.withParams,
     storeCampaignKeyword: $shopConfig.storeCampaignKeyword,
     campaignKey: await fetchCampaignKey(
-      bapiClient,
+      sapiClient,
       cached,
       $shopConfig.storeCampaignKeyword,
       $log

package/dist/runtime/server/middleware/redirects.mjs

@@ -13,10 +13,10 @@ async function fetchRedirectWithCache(sourceUrl, storefrontAPIClient, redirectCa
     }
     return cachedResult;
   }
-  log.debug("No cached result for redirect; querying BAPI");
-  let bapiResult;
+  log.debug("No cached result for redirect; querying SAPI");
+  let sapiResult;
   try {
-    bapiResult = await storefrontAPIClient.redirects.post(sourceUrl);
+    sapiResult = await storefrontAPIClient.redirects.post(sourceUrl);
   } catch (error) {
     log.error(
       `Error: Failed to fetch redirects ... ${error} for sourceURL: ${sourceUrl}`
@@ -26,19 +26,19 @@ async function fetchRedirectWithCache(sourceUrl, storefrontAPIClient, redirectCa
   const isValidRedirect = (redirect) => {
     return redirect && redirect?.source && redirect?.target && redirect.source !== redirect.target;
   };
-  if (!bapiResult || !isValidRedirect(bapiResult)) {
+  if (!sapiResult || !isValidRedirect(sapiResult)) {
     await redirectCache.set(sourceUrl, REDIRECT_NOT_SET, REDIRECT_CACHE_TTL);
     return null;
   }
   await redirectCache.set(
-    bapiResult.source,
+    sapiResult.source,
     {
-      target: bapiResult.target,
-      statusCode: bapiResult.statusCode
+      target: sapiResult.target,
+      statusCode: sapiResult.statusCode
     },
     REDIRECT_CACHE_TTL
   );
-  return bapiResult;
+  return sapiResult;
 }
 export async function useRedirects(event) {
   const config = useRuntimeConfig();
@@ -54,7 +54,7 @@ export async function useRedirects(event) {
     shopCache.storage,
     shopCache.prefix + REDIS_REDIRECT_PREFIX
   );
-  const bapiClient = event.context.$rpcContext.bapiClient;
+  const sapiClient = event.context.$rpcContext.sapiClient;
   const queryParamWhitelist = new Set(options?.queryParamWhitelist ?? []);
   log.debug(`Querying redirect for ${url.toString()}`);
   const { relativeSourceUrl, absoluteSourceUrl } = getRedirectLookupUrls(
@@ -62,8 +62,8 @@ export async function useRedirects(event) {
     queryParamWhitelist
   );
   const [relativeRedirect, absoluteRedirect] = await Promise.all([
-    fetchRedirectWithCache(relativeSourceUrl, bapiClient, redirectCache, log),
-    fetchRedirectWithCache(absoluteSourceUrl, bapiClient, redirectCache, log)
+    fetchRedirectWithCache(relativeSourceUrl, sapiClient, redirectCache, log),
+    fetchRedirectWithCache(absoluteSourceUrl, sapiClient, redirectCache, log)
   ]);
   if (relativeRedirect && absoluteRedirect) {
     log.info(`There are multiple valid redirects for: ${url.toString()}`);