@scayle/storefront-nuxt 8.15.1 → 8.16.0

package/CHANGELOG.md

@@ -1,5 +1,55 @@
 # @scayle/storefront-nuxt
 
+## 8.16.0
+
+### Minor Changes
+
+- [Redirects] Extend the redirects feature with a new option: `redirects.strategy`. This property can be set to two values: `before-request` and `on-missing`. When set to `before-request`, the server will check for potential redirects before processing each request. This is the current behavior and will also be used when no value is set. When `on-missing` is used, the server will check for redirects only if the response for the request is a 404.
+
+  To enable the new strategy, update your `nuxt.config.ts`.
+
+  ```ts
+  export default defineNuxtConfig({
+    runtimeConfig: {
+      storefront: {
+        redirects: {
+          enabled: true,
+          strategy: 'on-missing',
+        },
+      },
+    },
+  })
+  ```
+
+  Also, keep in mind that when this option is enabled, the redirect logic will only be executed when the request would otherwise result in a 404. There are three ways in which a 404 can occur.
+
+  1. No route found
+
+  If there is no matching route for the request's path, the framework will return a 404 response.
+
+  2. `Response` with 404 status
+
+  If the request handler returns a `Response` object with a `status` of 404, a 404 response will be returned to the client.
+
+  ```typescript
+  return new Response(null, { status: 404 })
+  ```
+
+  3. Thrown H3Error with 404 status
+
+  If the request handler throws an H3Error with a `statusCode` 404, a 404 response will be returned to the client.
+
+  ```typescript
+  import { createError } from 'h3'
+  throw createError({ statusCode: 404 })
+  ```
+
+### Patch Changes
+
+**@scayle/storefront-core v8.16.0**
+
+**Dependencies**
+
 ## 8.15.1
 
 ### Patch Changes
@@ -433,28 +483,28 @@
   **rpc-methods.ts**
 
   ```typescript
-  import type { RpcContext, RpcHandler } from "@scayle/storefront-nuxt";
+  import type { RpcContext, RpcHandler } from '@scayle/storefront-nuxt'
 
   export const foo: RpcHandler<string, number> = function testing(
     param: string,
-    _: RpcContext
+    _: RpcContext,
   ) {
-    return param.length;
-  };
+    return param.length
+  }
   ```
 
   **module.ts**
 
   ```typescript
   function setup() {
-    const resolver = createResolver(import.meta.url);
+    const resolver = createResolver(import.meta.url)
 
-    nuxt.hook("storefront:custom-rpc:extend", (customRpcImports) => {
+    nuxt.hook('storefront:custom-rpc:extend', (customRpcImports) => {
       customRpcImports.push({
-        source: resolver.resolve("./rpc-methods.ts"),
-        names: ["foo"],
-      });
-    });
+        source: resolver.resolve('./rpc-methods.ts'),
+        names: ['foo'],
+      })
+    })
   }
   ```
 
@@ -676,23 +726,23 @@
         storefront: {
           // ...
           redis: {
-            host: "localhost",
+            host: 'localhost',
             port: 6379,
-            prefix: "",
-            user: "",
-            password: "",
+            prefix: '',
+            user: '',
+            password: '',
             sslTransit: false,
           },
           // ...
           session: {
             // ...
-            provider: "redis",
+            provider: 'redis',
           },
         },
         // ...
       },
       // ...
-    });
+    })
     ```
 
   - _Current Unified Storage Approach (`nuxt.config.ts`):_
@@ -706,13 +756,13 @@
           // ...
           storage: {
             cache: {
-              driver: "redis",
-              host: "localhost",
+              driver: 'redis',
+              host: 'localhost',
               port: 6379,
             },
             session: {
-              driver: "redis",
-              host: "localhost",
+              driver: 'redis',
+              host: 'localhost',
               port: 6379,
             },
             // ...
@@ -722,7 +772,7 @@
         // ...
       },
       // ...
-    });
+    })
     ```
 
 - **\[💥 BREAKING\]** The composable `useSearch` has been replaced by `useStorefrontSearch`, consolidating and transitioning to SCAYLE Search v2.
@@ -789,9 +839,9 @@
 
     ```ts
     const { activeFilters, applyFilters, resetFilterUrl, productConditions } =
-      useQueryFilterState();
+      useQueryFilterState()
 
-    applyFilters({ brand: 23, sale: true, maxPrice: 100, minPrice: 0 });
+    applyFilters({ brand: 23, sale: true, maxPrice: 100, minPrice: 0 })
     ```
 
   - _Current Usage of `useFilter` and `useAppliedFilters`:_
@@ -804,20 +854,20 @@
       resetFilters,
       resetPriceFilter,
       resetFilter,
-    } = useFilter();
+    } = useFilter()
 
-    applyPriceFilter([0, 100]);
-    applyBooleanFilter("sale", true);
-    applyAttributeFilter("brand", 23);
+    applyPriceFilter([0, 100])
+    applyBooleanFilter('sale', true)
+    applyAttributeFilter('brand', 23)
 
-    const route = useRoute();
+    const route = useRoute()
     const {
       appliedFilter,
       appliedFiltersCount,
       appliedAttributeValues,
       appliedBooleanValues,
       areFiltersApplied,
-    } = useAppliedFilters(route);
+    } = useAppliedFilters(route)
     ```
 
 - **\[💥 BREAKING\]** The `getBadgeLabel` helper function has been removed, giving you more control over badge label display.
@@ -827,43 +877,43 @@
 
     ```ts
     const BadgeLabel = {
-      NEW: "new",
-      SOLD_OUT: "sold_out",
-      ONLINE_EXCLUSIVE: "online_exclusive",
-      SUSTAINABLE: "sustainable",
-      PREMIUM: "premium",
-      DEFAULT: "",
-    } as const;
+      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>>;
+      | 'isNew'
+      | 'isSoldOut'
+      | 'isOnlineOnly'
+      | 'isSustainable'
+      | 'isPremium'
+    type BadgeLabelParams = Partial<Record<BadgeLabelParamsKeys, boolean>>
 
     const getBadgeLabel = (params: BadgeLabelParams = {}): string => {
       if (!params) {
-        return BadgeLabel.DEFAULT;
+        return BadgeLabel.DEFAULT
       }
       const { isNew, isSoldOut, isOnlineOnly, isSustainable, isPremium } =
-        params;
+        params
 
       if (isNew) {
-        return BadgeLabel.NEW;
+        return BadgeLabel.NEW
       } else if (isSoldOut) {
-        return BadgeLabel.SOLD_OUT;
+        return BadgeLabel.SOLD_OUT
       } else if (isOnlineOnly) {
-        return BadgeLabel.ONLINE_EXCLUSIVE;
+        return BadgeLabel.ONLINE_EXCLUSIVE
       } else if (isSustainable) {
-        return BadgeLabel.SUSTAINABLE;
+        return BadgeLabel.SUSTAINABLE
       } else if (isPremium) {
-        return BadgeLabel.PREMIUM;
+        return BadgeLabel.PREMIUM
       } else {
-        return BadgeLabel.DEFAULT;
+        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.
@@ -887,7 +937,7 @@
         // ...
       },
       // ...
-    });
+    })
     ```
 
   - _Previous Environment Variables for Store Configuration:_
@@ -916,7 +966,7 @@
         // ...
       },
       // ...
-    });
+    })
     ```
 
   - _Current Environment Variables for Shops Configuration:_
@@ -936,8 +986,8 @@
     ```ts
     useProduct({
       // ...
-      key: "productKey",
-    });
+      key: 'productKey',
+    })
     ```
 
   - _Current `key` as dedicated composables argument:_
@@ -947,8 +997,8 @@
       {
         // ...
       },
-      "productKey"
-    );
+      '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.
@@ -965,27 +1015,27 @@
   - _Previous Usage of `handleIDPLoginCallback`:_
 
     ```ts
-    const { handleIDPLoginCallback } = await useIDP();
+    const { handleIDPLoginCallback } = await useIDP()
 
     watch(
       () => route.query,
       async (query) => {
         if (query.code && isString(query.code)) {
-          await handleIDPLoginCallback(query.code);
+          await handleIDPLoginCallback(query.code)
         }
       },
-      { immediate: true }
-    );
+      { immediate: true },
+    )
     ```
 
   - _Current Usage of `loginIDP`:_
 
     ```ts
-    const { loginIDP } = useAuthentication("login");
+    const { loginIDP } = useAuthentication('login')
 
     onMounted(async () => {
-      await loginIDP(props.code);
-    });
+      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.
@@ -995,17 +1045,17 @@
   - _Previous `useRpc` with `autoFetch`:_
 
     ```ts
-    useRpc("rpcMethod", key, params, { autoFetch: true });
+    useRpc('rpcMethod', key, params, { autoFetch: true })
 
-    useUser({ autoFetch: true });
+    useUser({ autoFetch: true })
     ```
 
   - _Current `useRpc` with `immediate`:_
 
     ```ts
-    useRpc("rpcMethod", key, params, { immediate: true });
+    useRpc('rpcMethod', key, params, { immediate: true })
 
-    useUser({ immediate: true });
+    useUser({ immediate: true })
     ```
 
 - **\[💥 BREAKING\]** The attribute `isCmsPreview` has been removed from `RpcContext`.
@@ -1025,18 +1075,18 @@
       getSearchSuggestions,
       fetching,
       ...searchData
-    } = useStorefrontSearch(searchQuery, { key });
+    } = useStorefrontSearch(searchQuery, { key })
 
-    fetching.value; // true or false
+    fetching.value // true or false
     ```
 
   - _Current `useStorefrontSearch` returning `status`:_
 
     ```ts
     const { data, resolveSearch, getSearchSuggestions, status, ...searchData } =
-      useStorefrontSearch(searchQuery, {}, key);
+      useStorefrontSearch(searchQuery, {}, key)
 
-    status.value; // 'idle', 'pending', 'error' or 'success'
+    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.
@@ -1061,7 +1111,7 @@
         // ...
       },
       // ...
-    });
+    })
     ```
 
   - _Current `enableDefaultGetCachedDataOverride`in `nuxt.config.ts`:_
@@ -1086,7 +1136,7 @@
         // ...
       },
       // ...
-    });
+    })
     ```
 
 - **\[💥 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).
@@ -1108,7 +1158,7 @@
     function myCustomRpc() {
       // ...
 
-      throw new BaseError(404);
+      throw new BaseError(404)
     }
     ```
 
@@ -1118,7 +1168,7 @@
     function myCustomRpc() {
       // ...
 
-      return new Response(null, { status: 404 });
+      return new Response(null, { status: 404 })
     }
     ```
 

package/dist/module.json

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

package/dist/module.mjs

@@ -53,7 +53,7 @@ export default {
 }`;
 }
 const PACKAGE_NAME = "@scayle/storefront-nuxt";
-const PACKAGE_VERSION = "8.15.1";
+const PACKAGE_VERSION = "8.16.0";
 const logger = createConsola({
   fancy: true,
   formatOptions: {
@@ -137,6 +137,7 @@ async function nitroSetup(nitroConfig, config) {
   });
   nitroConfig.plugins = nitroConfig.plugins ?? [];
   nitroConfig.plugins.push(resolve("./runtime/nitro/plugins/nitroLogger"));
+  nitroConfig.plugins.push(resolve("./runtime/nitro/plugins/redirectOnError"));
   nitroConfig.plugins.push(
     resolve("./runtime/nitro/plugins/nitroRuntimeStorageConfig")
   );

package/dist/runtime/nitro/plugins/redirectOnError.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Nitro plugin to handle redirecting on errors
+ *
+ * @param nitroApp The nitro app instance.
+ *
+ * @see https://nitro.build/guide/configuration#runtime-configuration
+ * @see https://nitro.build/guide/plugins
+ */
+declare const _default: import("nitropack").NitroAppPlugin;
+export default _default;

package/dist/runtime/nitro/plugins/redirectOnError.js

@@ -0,0 +1,24 @@
+import { defineNitroPlugin } from "nitropack/runtime/plugin";
+import { useRuntimeConfig } from "#imports";
+import { useRedirects } from "../../server/middleware/redirects.js";
+import { HttpStatusCode } from "@scayle/storefront-core";
+import { getResponseStatus } from "h3";
+export default defineNitroPlugin((nitroApp) => {
+  const config = useRuntimeConfig();
+  if (config.storefront.redirects?.enabled && config.storefront.redirects?.strategy === "on-missing") {
+    const originalErrorHandler = nitroApp.h3App.options.onError;
+    nitroApp.h3App.options.onError = async (error, event) => {
+      if (error.statusCode === HttpStatusCode.NOT_FOUND) {
+        await useRedirects(event);
+      }
+      if (originalErrorHandler) {
+        await originalErrorHandler(error, event);
+      }
+    };
+    nitroApp.hooks.hook("beforeResponse", async (event) => {
+      if (getResponseStatus(event) === HttpStatusCode.NOT_FOUND) {
+        await useRedirects(event);
+      }
+    });
+  }
+});

package/dist/runtime/server/middleware/bootstrap.js

@@ -202,7 +202,7 @@ export default defineEventHandler(async (event) => {
       }
     );
   }
-  if ($storefrontConfig.redirects?.enabled && !path.startsWith(apiBasePath) && originalPath !== joinURL(config.app.baseURL, "/__nuxt_error")) {
+  if ($storefrontConfig.redirects?.enabled && (!$storefrontConfig.redirects?.strategy || $storefrontConfig.redirects?.strategy === "before-request") && !path.startsWith(apiBasePath) && originalPath !== joinURL(config.app.baseURL, "/__nuxt_error")) {
     await tracer.startActiveSpan(
       `storefront-nuxt.middleware/redirects`,
       {},

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

@@ -4,12 +4,15 @@ import { type BuiltinDriverName } from 'unstorage';
 export declare const RedirectsSchema: z.ZodObject<{
     enabled: z.ZodBoolean;
     queryParamWhitelist: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    strategy: z.ZodOptional<z.ZodEnum<["before-request", "on-missing"]>>;
 }, "strip", z.ZodTypeAny, {
     enabled: boolean;
     queryParamWhitelist?: string[] | undefined;
+    strategy?: "before-request" | "on-missing" | undefined;
 }, {
     enabled: boolean;
     queryParamWhitelist?: string[] | undefined;
+    strategy?: "before-request" | "on-missing" | undefined;
 }>;
 declare const SessionSchema: z.ZodObject<{
     /**
@@ -1063,12 +1066,15 @@ export declare const RuntimeConfigSchema: z.ZodObject<{
         redirects: z.ZodOptional<z.ZodObject<{
             enabled: z.ZodBoolean;
             queryParamWhitelist: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            strategy: z.ZodOptional<z.ZodEnum<["before-request", "on-missing"]>>;
         }, "strip", z.ZodTypeAny, {
             enabled: boolean;
             queryParamWhitelist?: string[] | undefined;
+            strategy?: "before-request" | "on-missing" | undefined;
         }, {
             enabled: boolean;
             queryParamWhitelist?: string[] | undefined;
+            strategy?: "before-request" | "on-missing" | undefined;
         }>>;
         shops: z.ZodRecord<z.ZodString, z.ZodObject<{
             idp: z.ZodOptional<z.ZodObject<{
@@ -1587,6 +1593,7 @@ export declare const RuntimeConfigSchema: z.ZodObject<{
         redirects?: {
             enabled: boolean;
             queryParamWhitelist?: string[] | undefined;
+            strategy?: "before-request" | "on-missing" | undefined;
         } | undefined;
     }, {
         shopSelector: "domain" | "path" | "path_or_default";
@@ -1671,6 +1678,7 @@ export declare const RuntimeConfigSchema: z.ZodObject<{
         redirects?: {
             enabled: boolean;
             queryParamWhitelist?: string[] | undefined;
+            strategy?: "before-request" | "on-missing" | undefined;
         } | undefined;
     }>, z.ZodObject<{
         session: z.ZodOptional<z.ZodObject<{
@@ -2259,6 +2267,7 @@ export declare const RuntimeConfigSchema: z.ZodObject<{
         redirects?: {
             enabled: boolean;
             queryParamWhitelist?: string[] | undefined;
+            strategy?: "before-request" | "on-missing" | undefined;
         } | undefined;
     } & {
         oauth: {
@@ -2432,6 +2441,7 @@ export declare const RuntimeConfigSchema: z.ZodObject<{
         redirects?: {
             enabled: boolean;
             queryParamWhitelist?: string[] | undefined;
+            strategy?: "before-request" | "on-missing" | undefined;
         } | undefined;
     } & {
         oauth: {

package/dist/runtime/utils/zodSchema.js

@@ -2,7 +2,8 @@ import { z } from "zod";
 import { builtinDrivers } from "unstorage";
 export const RedirectsSchema = z.object({
   enabled: z.boolean(),
-  queryParamWhitelist: z.array(z.string()).optional()
+  queryParamWhitelist: z.array(z.string()).optional(),
+  strategy: z.enum(["before-request", "on-missing"]).optional()
 });
 const SessionSchema = z.object({
   /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@scayle/storefront-nuxt",
   "type": "module",
-  "version": "8.15.1",
+  "version": "8.16.0",
   "description": "Nuxt integration for the SCAYLE Commerce Engine and Storefront API",
   "author": "SCAYLE Commerce Engine",
   "license": "MIT",
@@ -81,7 +81,7 @@
   "dependencies": {
     "@opentelemetry/api": "^1.9.0",
     "@scayle/h3-session": "0.6.0",
-    "@scayle/storefront-core": "8.15.1",
+    "@scayle/storefront-core": "8.16.0",
     "@scayle/unstorage-compression-driver": "^0.2.4",
     "@vercel/nft": "0.29.2",
     "@vueuse/core": "13.0.0",
@@ -109,7 +109,7 @@
     "@scayle/eslint-config-storefront": "4.5.0",
     "@scayle/eslint-plugin-vue-composable": "0.2.1",
     "@scayle/unstorage-scayle-kv-driver": "0.1.1",
-    "@types/node": "22.13.16",
+    "@types/node": "22.14.0",
     "dprint": "0.49.1",
     "eslint-formatter-gitlab": "5.1.0",
     "eslint": "9.23.0",