@scayle/storefront-nuxt 7.95.3 → 8.0.0

package/CHANGELOG.md

@@ -1,5 +1,489 @@
 # @scayle/storefront-nuxt
 
+## 8.0.0
+
+### Major Changes
+
+- **\[💥 BREAKING\]** Removed deprecated `transformLegacyConfig` function in favor of the new unified `storefront.storage` configuration system.
+  Legacy configuration options `provider` and `redis` configuration are no longer supported and have been deprecated since Storefront Boilerplate v1.0.0-rc.05.
+
+  You'll need to migrate your existing storage settings to the new `storefront.storage` format.
+  Check the [SCAYLE Resource Center](https://scayle.dev/en/storefront-guide/developer-guide/basic-setup/introduction#storage) for more details.
+
+  - _No Longer Supported: Legacy Storage Setup in (`nuxt.config.ts`):_
+
+    ```ts
+    export default defineNuxtConfig({
+      // ...
+      runtimeConfig: {
+        // ...
+        storefront: {
+          // ...
+          redis: {
+            host: 'localhost',
+            port: 6379,
+            prefix: '',
+            user: '',
+            password: '',
+            sslTransit: false,
+          },
+          // ...
+          session: {
+            // ...
+            provider: 'redis',
+          },
+        },
+        // ...
+      },
+      // ...
+    })
+    ```
+
+  - _Current Unified Storage Approach (`nuxt.config.ts`):_
+
+    ```ts
+    export default defineNuxtConfig({
+      // ...
+      runtimeConfig: {
+        // ...
+        storefront: {
+          // ...
+          storage: {
+            cache: {
+              driver: 'redis',
+              host: 'localhost',
+              port: 6379,
+            },
+            session: {
+              driver: 'redis',
+              host: 'localhost',
+              port: 6379,
+            },
+            // ...
+          },
+          // ...
+        },
+        // ...
+      },
+      // ...
+    })
+    ```
+
+- **\[💥 BREAKING\]** The composable `useSearch` has been replaced by `useStorefrontSearch`, consolidating and transitioning to SCAYLE Search v2.
+
+  - _Previous Usage of `useSearch`:_
+
+    ```ts
+    const { search, data } = useSearch({ params: { with: ...}, key: 'search' })
+
+    search({term: 'searchTerm', slug: 'slug', productLimit: 10})
+    ```
+
+  - _Current Usage of `useStorefrontSearch`:_
+
+    ```ts
+    const searchTerm = ref()
+
+    const { data, resolveSearch } = useStorefrontSearch(searchTerm, { categoryId: ..., with: { ... } }, 'search')
+    //data contains search suggestions
+
+    resolveSearch()
+    //data contains search results
+    ```
+
+- **\[💥 BREAKING\]** The previous use of the `useFacet` composable for category-related product listings was overly complex and difficult to customize. To simplify things, dedicated composables are being introduced:
+
+  - `useProductsByCategory`: Replaces `useFacet` for fetching products within a specific category.
+  - `useFilters` or `useProductListFilters`: Provide focused filter management capabilities.
+
+  - _Previous Usage of `useFacet`:_
+
+    ```ts
+    const {products, category, filters, ...} = useFacet()
+    ```
+
+  - _Current Usage of dedicated Category-Specific Composables:_
+
+    ```ts
+    const { data: category } = useCategoryById({
+      params: {
+        id,
+        children: 0,
+        properties: { withName: ['sale'] },
+      },
+    }, 'current-category-id')
+
+    const {
+      products,
+      pagination,
+      fetching,
+      totalProductsCount,
+      paginationOffset,
+    } = useProductsByCategory(currentCategoryId, route)
+
+    const { availableFilters } = useFilters({
+      ...
+    });
+    ```
+
+- **\[💥 BREAKING\]** We've renamed the `useNavigationTree` composable to `useNavigationTreeById` for better clarity. Its functionality, parameters and return values stay identical.
+- **\[💥 BREAKING\]** The composable `useQueryFilterState` has been superseded by the `useFilter` and `useAppliedFilters` (part of `@scayle/storefront-product-listing`) composables.
+
+  - _Previous Usage of `useQueryFilterState`:_
+
+    ```ts
+    const { activeFilters, applyFilters, resetFilterUrl, productConditions } =
+      useQueryFilterState()
+
+    applyFilters({ brand: 23, sale: true, maxPrice: 100, minPrice: 0 })
+    ```
+
+  - _Current Usage of `useFilter` and `useAppliedFilters`:_
+
+    ```ts
+    const {
+      applyPriceFilter,
+      applyBooleanFilter,
+      applyAttributeFilter,
+      resetFilters,
+      resetPriceFilter,
+      resetFilter,
+    } = useFilter()
+
+    applyPriceFilter([0, 100])
+    applyBooleanFilter('sale', true)
+    applyAttributeFilter('brand', 23)
+
+    const route = useRoute()
+    const {
+      appliedFilter,
+      appliedFiltersCount,
+      appliedAttributeValues,
+      appliedBooleanValues,
+      areFiltersApplied,
+    } = useAppliedFilters(route)
+    ```
+
+- **\[💥 BREAKING\]** The `getBadgeLabel` helper function has been removed, giving you more control over badge label display.
+
+  - **Note:** This change doesn't affect projects using SCAYLE Storefront Boilerplate v1.0 or later.
+  - For applications based on older versions or using `getBadgeLabel`, you can refer to the previous implementation below:
+
+    ```ts
+    const BadgeLabel = {
+      NEW: 'new',
+      SOLD_OUT: 'sold_out',
+      ONLINE_EXCLUSIVE: 'online_exclusive',
+      SUSTAINABLE: 'sustainable',
+      PREMIUM: 'premium',
+      DEFAULT: '',
+    } as const
+
+    type BadgeLabelParamsKeys =
+      | 'isNew'
+      | 'isSoldOut'
+      | 'isOnlineOnly'
+      | 'isSustainable'
+      | 'isPremium'
+    type BadgeLabelParams = Partial<Record<BadgeLabelParamsKeys, boolean>>
+
+    const getBadgeLabel = (params: BadgeLabelParams = {}): string => {
+      if (!params) {
+        return BadgeLabel.DEFAULT
+      }
+      const { isNew, isSoldOut, isOnlineOnly, isSustainable, isPremium } =
+        params
+
+      if (isNew) {
+        return BadgeLabel.NEW
+      } else if (isSoldOut) {
+        return BadgeLabel.SOLD_OUT
+      } else if (isOnlineOnly) {
+        return BadgeLabel.ONLINE_EXCLUSIVE
+      } else if (isSustainable) {
+        return BadgeLabel.SUSTAINABLE
+      } else if (isPremium) {
+        return BadgeLabel.PREMIUM
+      } else {
+        return BadgeLabel.DEFAULT
+      }
+    }
+    ```
+
+- **\[💥 BREAKING\]** The `store` option in the module configuration has been removed. `œscayle/storefront-nuxt@7.84.0` introduced the `shops` option as a replacement, but maintained backward compatibility with the `store` option. Going forward, configuring shops must be done using the `shops` keyword.
+
+  - For more information, please refer to the [documentation](https://scayle.dev/en/storefront-guide/developer-guide/basic-setup/introduction#shops).
+  - **NOTE:** These changes might impact your environment variables used for deployments. Please check your infrastructure and deployment setup and adapt accordingly!
+  - _Previous Store Configuration in `nuxt.config.ts`:_
+
+    ```ts
+    export default defineNuxtConfig({
+      // ...
+      runtimeConfig: {
+        // ...
+        storefront: {
+          // ...
+          store: {
+            // ...
+          },
+          // ...
+        },
+        // ...
+      },
+      // ...
+    })
+    ```
+
+  - _Previous Environment Variables for Store Configuration:_
+
+    ```env
+    NUXT_STOREFRONT_STORE_{UNIQUE_IDENTIFIER}_CHECKOUT_USER=''
+    NUXT_STOREFRONT_STORE_{UNIQUE_IDENTIFIER}_CHECKOUT_TOKEN=''
+    NUXT_STOREFRONT_STORE_{UNIQUE_IDENTIFIER}_CHECKOUT_SECRET=''
+    NUXT_STOREFRONT_STORE_{UNIQUE_IDENTIFIER}_CHECKOUT_HOST=''
+    ```
+
+  - _Current Shops Configuration in `nuxt.config.ts`:_
+
+    ```ts
+    export default defineNuxtConfig({
+      // ...
+      runtimeConfig: {
+        // ...
+        storefront: {
+          // ...
+          shops: {
+            // ...
+          },
+          // ...
+        },
+        // ...
+      },
+      // ...
+    })
+    ```
+
+  - _Current Environment Variables for Shops Configuration:_
+
+    ```env
+    NUXT_STOREFRONT_SHOPS_{UNIQUE_IDENTIFIER}_CHECKOUT_USER=''
+    NUXT_STOREFRONT_SHOPS_{UNIQUE_IDENTIFIER}_CHECKOUT_TOKEN=''
+    NUXT_STOREFRONT_SHOPS_{UNIQUE_IDENTIFIER}_CHECKOUT_SECRET=''
+    NUXT_STOREFRONT_SHOPS_{UNIQUE_IDENTIFIER}_CHECKOUT_HOST=''
+    ```
+
+- **\[💥 BREAKING\]** To better align with the current Nuxt 3 architecture make key handling more explicit, we've simplified how you interact with the key parameter in RPC composables from version 8 onwards.
+  Instead of placing the key within the composable's options object, you'll now provide it as the second argument when calling the composable.
+
+  - _Previous `key` as options parameter:_
+
+    ```ts
+    useProduct({
+      // ...
+      key: 'productKey',
+    })
+    ```
+
+  - _Current `key` as dedicated composables argument:_
+
+    ```ts
+    useProduct(
+      {
+        // ...
+      },
+      'productKey',
+    )
+    ```
+
+- **\[💥 BREAKING\]** Introducing a new feature flag `storefront.legacy.enableSessionMigration` to control the automatic migration of legacy session data, set to `false` by default. Starting with `@scayle/storefront-nuxt@7.68.0` Storefront uses unique session cookie names for each shop, simplifying implementation and enhancing stability.
+  Instead of relying on the Path attribute, each shop receives a distinct cookie name. This change is internal and should not require code modifications.
+
+  - _Cookie format before `@scayle/storefront-nuxt@7.68.0`:_
+    - `Set-Cookie: $session=s:fa3746f9-88c8-4065-a6c9-0c7bee473dd8.pSoaN6Q7iFHHyWKE7s9gQAqdDzGb9fS8a478P7PHLxw; Path=/de`
+  - _Cookie format after `@scayle/storefront-nuxt@7.68.0`:_
+    - `Set-Cookie: $session-1001=s:fa3746f9-88c8-4065-a6c9-0c7bee473dd8.pSoaN6Q7iFHHyWKE7s9gQAqdDzGb9fS8a478P7PHLxw; Path=/`
+  - **NOTE:** Upgrading directly to this version from a version prior to `@scayle/storefront-nuxt@7.68.0` without enabling the `storefront.legacy.enableSessionMigration` feature flag will lead to loss of user sessions. Ensure version `@scayle/storefront-nuxt@7.68.0` or higher has been deployed in production for a period exceeding the configured session TTL before upgrading to this version. This ensures all legacy sessions have been migrated. Consult the updated documentation for details on the cookie format changes and migration procedures.
+
+- **\[💥 BREAKING\]** We've optimized the way Identity Provider (IDP) logins are handled. Instead of using the `handleIDPLoginCallback` RPC method, which has been removed, from the `useIDP` composable, you'll now use the `loginIDP` function, which has been moved to the `useAuthentication` composable. This change consolidates IDP login functionality within `useAuthentication` for a more unified approach.
+
+  - _Previous Usage of `handleIDPLoginCallback`:_
+
+    ```ts
+    const { handleIDPLoginCallback } = await useIDP()
+
+    watch(
+      () => route.query,
+      async (query) => {
+        if (query.code && isString(query.code)) {
+          await handleIDPLoginCallback(query.code)
+        }
+      },
+      { immediate: true },
+    )
+    ```
+
+  - _Current Usage of `loginIDP`:_
+
+    ```ts
+    const { loginIDP } = useAuthentication('login')
+
+    onMounted(async () => {
+      await loginIDP(props.code)
+    })
+    ```
+
+- **\[🧹 NON-BREAKING\]** Addressed various type resolution errors that were present when using the `@scayle/storefront-nuxt` package with different Node.js versions and module systems. These errors manifested as internal resolution errors or ESM dynamic import only warnings. With this fix, the package now more consistently resolves types correctly across Node.js 16 (CJS and ESM), and bundlers, ensuring a smoother developer experience.
+- **\[💥 BREAKING\]** The `useBasket` composable now gracefully handles cases where adding items to the basket results in a smaller quantity being added than originally requested by checking against `AddToBasketFailureKind`.
+- **\[💥 BREAKING\]** The deprecated `autoFetch` option of `useRpc` has been removed in favor of the `immediate` option. This also applies to all data fetching composables provided by `@scayle/storefront-nuxt`.
+
+  - _Previous `useRpc` with `autoFetch`:_
+
+    ```ts
+    useRpc('rpcMethod', key, params, { autoFetch: true })
+
+    useUser({ autoFetch: true })
+    ```
+
+  - _Current `useRpc` with `immediate`:_
+
+    ```ts
+    useRpc('rpcMethod', key, params, { immediate: true })
+
+    useUser({ immediate: true })
+    ```
+
+- **\[💥 BREAKING\]** The attribute `isCmsPreview` has been removed from `RpcContext`.
+- **\[💥 BREAKING\]** The attribute `storeCampaignKeyword` has been removed from `RpcContext`.
+
+  - The `campaignKey` is now automatically determined by fetching campaign data through the Storefront API client by retrieving a list of all campaigns from the API. It then narrows down the list by filtering for campaigns that are still active, ensuring any returned campaign is currently running. These active campaigns are then sorted by their start date, ensuring chronological order. Finally, it iterates through the sorted campaigns to find the first one that is currently active, returning its key as an identifier. If no active campaign is found or an error occurs, it returns nothing.
+  - The `storeCampaignKeyword` is also no longer used to determine the active campaign key. The functionality to run only certain campaigns for specific countries is now supported through the SCAYLE Panel out of the box.
+
+- **\[💥 BREAKING\]** The composable `useStorefrontSearch` is now consistent with `useRpc` return values. The `fetching` boolean is replaced by `status` with states `idle`, `pending`, `error` or `success`.
+
+  - _Previous `useStorefrontSearch` returning `fetching`:_
+
+    ```ts
+    const {
+      data,
+      resolveSearch,
+      getSearchSuggestions,
+      fetching,
+      ...searchData
+    } = useStorefrontSearch(searchQuery, { key })
+
+    fetching.value // true or false
+    ```
+
+  - _Current `useStorefrontSearch` returning `status`:_
+
+    ```ts
+    const { data, resolveSearch, getSearchSuggestions, status, ...searchData } =
+      useStorefrontSearch(searchQuery, {}, key)
+
+    status.value // 'idle', 'pending', 'error' or 'success'
+    ```
+
+- **\[💥 BREAKING\]** We've simplified composable caching and clarified the control you have over shared state behavior. The configuration option `disableDefaultGetCachedDataOverride` has been replaced with `legacy.enableDefaultGetCachedDataOverride`, and its logic has been reversed. Now, when `legacy.enableDefaultGetCachedDataOverride` is not set or set to `false`, the default behavior maintains the shared state functionality of `useRpc`, where multiple calls with the same key use the same cached data. Setting the option to `true` bypasses this shared caching, providing data isolation between calls. To maintain your existing caching behavior, simply change the value of `disableDefaultGetCachedDataOverride` to its opposite in your `nuxt.config.ts` file.
+
+  Old config
+
+  - _Previous `disableDefaultGetCachedDataOverride` in `nuxt.config.ts`:_
+
+    ```ts
+    export default defineNuxtConfig({
+      // ...
+      runtimeConfig: {
+        // ...
+        public: {
+          // ...
+          storefront: {
+            // ...
+            disableDefaultGetCachedDataOverride: false,
+          },
+          // ...
+        },
+        // ...
+      },
+      // ...
+    })
+    ```
+
+  - _Current `enableDefaultGetCachedDataOverride`in `nuxt.config.ts`:_
+
+    ```ts
+    export default defineNuxtConfig({
+      // ...
+      runtimeConfig: {
+        // ...
+        public: {
+          // ...
+          storefront: {
+            // ...
+            legacy: {
+              // ...
+              enableDefaultGetCachedDataOverride: true,
+            },
+            // ...
+          },
+          // ...
+        },
+        // ...
+      },
+      // ...
+    })
+    ```
+
+- **\[💥 BREAKING\]** The `useRpc` composable has been updated to provide a more modern and robust data fetching experience, aligning its interface with the current and underlying [Nuxt 3 `useAsyncData`.](https://nuxt.com/docs/api/composables/use-async-data#return-values).
+  The separate `fetch` function has been replaced with a single, intuitive `refresh` function that can be used to refresh the data returned by the `handler` function.
+  Additionally, the boolean `pending` flag has been superseded by a more informative `status` return value, offering greater insight into the fetching lifecycle with possible states: `idle`, `pending`, `success`, and `error`.
+  These changes enhance the developer experience and provide greater clarity and control over data fetching operations within components.
+
+  - **NOTE:** This update not only impacts the `useRpc` composable directly, but also extends to other RPC composables relying on it, such as `useProducts` and `useCategories`!
+
+- **\[💥 BREAKING\]** Removed special handling for `BAPIError` and `BaseError` thrown in RPC methods. These custom `Error` classes were previously used in RPC methods to allow customizing the status code and message of errors.
+  However, they have been deprecated since January 2024 when the preferred approach was changed to return the native `Response` object. This provides performance benefits by limiting the transformations necessary in the response pipeline, and aligns `@scayle/storefront-nuxt` with web standards. It also simplifies the implementation and means `@scayle/storefront-nuxt` no longer needs to be aware of third-party libraries used and their possible errors.
+  In this release, the legacy special handling for `BAPIError` and `BaseError` has been removed. Now they will be treated like any other `Error`. If they are thrown uncaught during the execution of an RPC method, a 500 status code will be used in the response. They have also been removed from `@scayle/storefront-nuxt`.
+  For most users, this change will have no impact as the core RPC methods have been updated for some time. However, if you have custom RPC methods you should review their implementation.
+  In order to have an RPC method use a specific status code, it should return a `Response` object.
+
+  - _Previous Usage with `BaseError`:_
+
+    ```ts
+    function myCustomRpc() {
+      // ...
+
+      throw new BaseError(404)
+    }
+    ```
+
+  - _Current Usage with `Response` object and `status` code:_
+
+    ```ts
+    function myCustomRpc() {
+      // ...
+
+      return new Response(null, { status: 404 })
+    }
+    ```
+
+- **\[💥 BREAKING\]** We've updated how API routes are structured in multi-shop environments using path-based selection (`path` or `path_except_default`). Instead of being nested under each shop's specific path, all API routes will now be mounted globally under a single path, which defaults to `/api`. This means the option to customize the `apiBasePath` on a per-shop basis has been removed. This change promotes consistency and makes API route management more straightforward.
+- **\[💥 BREAKING\]** The methods `getBasket`, `removeItemFromBasket`, `addItemsToBasket`, and `addItemToBasket` have been updated. Instead of returning the basket object directly, the basket will now be accessible as a property within the response body. Furthermore, errors occurring during`addItemToBasket` and `addItemsToBasket` will from now on return HTTP 400. The error kind can be identified by checking the `error` property of the response.
+
+### Patch Changes
+
+- Updated dependency `@vueuse/core@11.3.0` to `@vueuse/core@12.0.0`
+  **Dependencies**
+
+- Updated dependency to @scayle/storefront-core@8.0.0
+
+## 7.95.4
+
+### Patch Changes
+
+**Dependencies**
+
+- Updated dependency to @scayle/storefront-core@7.69.3
+
 ## 7.95.3
 
 ### Patch Changes

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-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.80aa5060.mjs';
+export { d as AdditionalShopConfig, A as AppKeys, h as CheckoutEvent, C as CheckoutShopConfig, M as ModuleBaseOptions, i as ModulePublicRuntimeConfig, P as PublicShopConfig, c as SapiConfig, S as SessionConfig, e as ShopConfig, f as ShopConfigIndexed, b as StorageConfig, a as StorageEntity, g as StorefrontConfig } from './shared/storefront-nuxt.a816664e.mjs';
 export { rpcCall } from '../dist/runtime/rpc/rpcCall.js';
 export { extendPromise } from '../dist/runtime/utils/promise.js';
 export * from '../dist/runtime/utils/seo.js';

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-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.80aa5060.js';
+export { d as AdditionalShopConfig, A as AppKeys, h as CheckoutEvent, C as CheckoutShopConfig, M as ModuleBaseOptions, i as ModulePublicRuntimeConfig, P as PublicShopConfig, c as SapiConfig, S as SessionConfig, e as ShopConfig, f as ShopConfigIndexed, b as StorageConfig, a as StorageEntity, g as StorefrontConfig } from './shared/storefront-nuxt.a816664e.js';
 export { rpcCall } from '../dist/runtime/rpc/rpcCall.js';
 export { extendPromise } from '../dist/runtime/utils/promise.js';
 export * from '../dist/runtime/utils/seo.js';

package/dist/module.d.mts

@@ -1,6 +1,6 @@
 import * as _nuxt_schema from '@nuxt/schema';
-import { M as ModuleBaseOptions } from './shared/storefront-nuxt.80aa5060.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.80aa5060.mjs';
+import { M as ModuleBaseOptions } from './shared/storefront-nuxt.a816664e.mjs';
+export { d as AdditionalShopConfig, A as AppKeys, h as CheckoutEvent, C as CheckoutShopConfig, i as ModulePublicRuntimeConfig, P as PublicShopConfig, c as SapiConfig, S as SessionConfig, e as ShopConfig, f as ShopConfigIndexed, b as StorageConfig, a as StorageEntity, g as StorefrontConfig } from './shared/storefront-nuxt.a816664e.mjs';
 export { LogLevel } from '@scayle/storefront-core';
 import '@scayle/unstorage-compression-driver';
 import 'unstorage';

package/dist/module.d.ts

@@ -1,6 +1,6 @@
 import * as _nuxt_schema from '@nuxt/schema';
-import { M as ModuleBaseOptions } from './shared/storefront-nuxt.80aa5060.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.80aa5060.js';
+import { M as ModuleBaseOptions } from './shared/storefront-nuxt.a816664e.js';
+export { d as AdditionalShopConfig, A as AppKeys, h as CheckoutEvent, C as CheckoutShopConfig, i as ModulePublicRuntimeConfig, P as PublicShopConfig, c as SapiConfig, S as SessionConfig, e as ShopConfig, f as ShopConfigIndexed, b as StorageConfig, a as StorageEntity, g as StorefrontConfig } from './shared/storefront-nuxt.a816664e.js';
 export { LogLevel } from '@scayle/storefront-core';
 import '@scayle/unstorage-compression-driver';
 import 'unstorage';

package/dist/module.json

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

package/dist/module.mjs

@@ -12,10 +12,7 @@ function stringToBoolean(value, defaultValue = false) {
 function getUsedDrivers(options) {
   const drivers = /* @__PURE__ */ new Set();
   drivers.add("memory");
-  const shops = ("shops" in options ? options.shops : options.stores) ?? {};
-  if (options.redis || Object.values(shops).some((shop) => shop.redis)) {
-    drivers.add("redis");
-  }
+  const shops = options.shops ?? {};
   const addDriver = (config) => {
     if (config?.cache?.driver) {
       drivers.add(config.cache.driver);
@@ -48,7 +45,7 @@ export default {
 }`;
 }
 const PACKAGE_NAME = "@scayle/storefront-nuxt";
-const PACKAGE_VERSION = "7.95.3";
+const PACKAGE_VERSION = "8.0.0";
 const logger = createConsola({
   fancy: true,
   formatOptions: {
@@ -100,6 +97,9 @@ const module = defineNuxtModule({
       basketKey: "basket_{shopId}_{userId}",
       hashAlgorithm: "sha256"
     },
+    legacy: {
+      enableSessionMigration: false
+    },
     internalAccessHeader: ""
   },
   setup(options, nuxt) {
@@ -176,7 +176,7 @@ Missing RPC Overrides: ${Array.from(overridenRPCMethodNames).map((name) => `'${n
       });
     }
     const shops = convertShopsToList(
-      ("shops" in nuxt.options.runtimeConfig.storefront ? nuxt.options.runtimeConfig.storefront.shops : nuxt.options.runtimeConfig.storefront.stores) ?? {}
+      nuxt.options.runtimeConfig.storefront.shops ?? {}
     );
     const shopSelector = nuxt.options.runtimeConfig.storefront.shopSelector;
     if (shopSelector === "path" || shopSelector === "path_or_default") {

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

@@ -1,4 +1,4 @@
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<string | true | import("@scayle/storefront-core").ShopUser | string[] | import("@scayle/storefront-api").Product | import("@scayle/storefront-api").Product[] | {
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<string | true | import("@scayle/storefront-core").ShopUser | string[] | Response | import("@scayle/storefront-api").Product | import("@scayle/storefront-api").Product[] | {
     count: number;
 } | {
     filters: import("@scayle/storefront-api").FiltersEndpointResponseData;
@@ -15,9 +15,7 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
         next: number;
         last: number;
     };
-} | import("@scayle/storefront-api").BasketResponseData<import("@scayle/storefront-api").Product, import("@scayle/storefront-api").Variant> | {
-    type: "failure";
-    statusCode: number;
+} | {
     basket: import("@scayle/storefront-api").BasketResponseData<import("@scayle/storefront-api").Product, import("@scayle/storefront-api").Variant>;
 } | {
     readonly type: "success";
@@ -32,9 +30,9 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
 } | import("@scayle/storefront-api").Category | {
     categories: import("@scayle/storefront-api").Category;
     activeNode: import("@scayle/storefront-api").Category;
-} | import("@scayle/storefront-core").Order | import("@scayle/storefront-api").TypeaheadSuggestionsEndpointResponseData | import("@scayle/storefront-api").SearchV2SuggestionsEndpointResponseData | import("@scayle/storefront-api").SearchEntity | import("@scayle/storefront-api").ShopConfiguration | {
+} | 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 | Response | import("@scayle/storefront-core").ShopUserAddress[] | {
+} | 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 | {

package/dist/runtime/campaignKey.d.ts

@@ -1,6 +1,5 @@
 import type { StorefrontAPIClient, CachedType, Campaign, Log } from '@scayle/storefront-core';
 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: (sapiClient: StorefrontAPIClient, cached: CachedType, storeCampaignKeyword: string | undefined, log: Log) => Promise<string | undefined>;
+export declare const fetchCampaignKey: (sapiClient: StorefrontAPIClient, cached: CachedType, log: Log) => Promise<string | undefined>;

package/dist/runtime/campaignKey.js

@@ -12,26 +12,20 @@ export const isCampaignActive = (campaign) => {
 export const campaignHasNotEnded = (campaign) => {
   return new Date(campaign.end_at).getTime() > Date.now();
 };
-export const campaignKeyMatchesKeyword = (campaign, keyword) => {
-  if (!keyword) {
-    return true;
-  }
-  return campaign.key.toLowerCase().startsWith(keyword.toLowerCase());
-};
 export const sortCampaignsByDateAscending = (a, b) => {
   return new Date(a.start_at).getTime() - new Date(b.start_at).getTime();
 };
-export const fetchCampaignKey = async (sapiClient, cached, storeCampaignKeyword, log) => {
+export const fetchCampaignKey = async (sapiClient, cached, log) => {
   try {
     const { campaigns } = await cached(async () => {
       const { entities } = await sapiClient.campaigns.get();
       return {
         campaigns: entities.filter((campaign) => {
-          return campaignHasNotEnded(campaign) && campaignKeyMatchesKeyword(campaign, storeCampaignKeyword);
+          return campaignHasNotEnded(campaign);
         }).sort(sortCampaignsByDateAscending)
       };
     }, {
-      cacheKeyPrefix: storeCampaignKeyword ? `fetch-campaignKey-${storeCampaignKeyword}` : "fetch-campaignKey",
+      cacheKeyPrefix: "fetch-campaignKey",
       ttl: 5 * 60
     })();
     return campaigns.find(isCampaignActive)?.key;

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

@@ -1,8 +1,6 @@
 import type { MaybeRefOrGetter } from 'vue';
-import type { RpcMethodParameters, RpcMethodReturnType } from '@scayle/storefront-core';
+import type { RpcMethodParameters } from '@scayle/storefront-core';
 import { type UseRpcReturn } from '../core/useRpc.js';
-type UseIDPBaseReturn = Pick<Awaited<UseRpcReturn<'getExternalIdpRedirect'>>, 'data' | 'error' | 'status' | 'fetch' | 'fetching' | 'refresh'> & {
-    handleIDPLoginCallback: (params: RpcMethodParameters<'handleIDPLoginCallback'>) => RpcMethodReturnType<'handleIDPLoginCallback'>;
-};
+type UseIDPBaseReturn = Pick<Awaited<UseRpcReturn<'getExternalIdpRedirect'>>, 'data' | 'error' | 'status' | 'refresh'>;
 export declare function useIDP(params?: MaybeRefOrGetter<RpcMethodParameters<'getExternalIdpRedirect'>>, key?: string): UseIDPBaseReturn & Promise<UseIDPBaseReturn>;
 export {};