@scayle/storefront-nuxt 8.61.1 → 8.61.2

package/dist/module.json

@@ -1,6 +1,6 @@
 {
   "name": "@scayle/storefront-nuxt",
-  "version": "8.61.1",
+  "version": "8.61.2",
   "configKey": "storefront",
   "compatibility": {
     "nuxt": ">=3.13"

package/dist/module.mjs

@@ -1,11 +1,14 @@
 import { existsSync } from 'node:fs';
-import { defineNuxtModule, createResolver, addServerTemplate, addTypeTemplate, extendViteConfig, addTemplate, updateTemplates, addPlugin, addImportsDir } from '@nuxt/kit';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { defineNuxtModule, createResolver, addServerTemplate, addTypeTemplate, extendViteConfig, addTemplate, updateTemplates, addPlugin, addImportsDir, runWithNuxtContext, resolvePath } from '@nuxt/kit';
 import { rpcMethods } from '@scayle/storefront-core';
 import { defu } from 'defu';
 import { genExport, genImport, genSafeVariableName } from 'knitwork';
 import { builtinDrivers } from 'unstorage';
 import { createConsola } from 'consola';
 import { nodeFileTrace } from '@vercel/nft';
+import { createJiti } from 'jiti';
 import { getApiBasePath } from '../dist/runtime/server/middleware/bootstrap-utils.js';
 export * from '../dist/runtime/types/module.js';
 
@@ -54,7 +57,7 @@ export default {
 }`;
 }
 const PACKAGE_NAME = "@scayle/storefront-nuxt";
-const PACKAGE_VERSION = "8.61.1";
+const PACKAGE_VERSION = "8.61.2";
 const logger = createConsola({
   fancy: true,
   formatOptions: {
@@ -69,9 +72,7 @@ const logger = createConsola({
   // This assertion avoids the typescript error
 });
 function createRpcMethodIndex(customRpcImports) {
-  return `${customRpcImports.map(({ source, names }) => genExport(source, names)).join(
-    "\n"
-  )}
+  return `${customRpcImports.map(({ source, names }) => genExport(source, names)).join("\n")}
 export {}`;
 }
 function createRpcMethodTypeDeclaration(customRpcImports) {
@@ -79,7 +80,9 @@ function createRpcMethodTypeDeclaration(customRpcImports) {
     type RpcMethodsCustomType = {
       ${customRpcImports.reduce(
     (lines, { source, names }) => lines.concat(
-      names.map((name) => `${name}: typeof import('${source}')['${name}'],`).join("\n")
+      names.map(
+        (name) => `${name}: typeof import('${source}')['${name}'],`
+      ).join("\n")
     ),
     []
   ).join("\n")}
@@ -105,7 +108,60 @@ function readHttpMethod(handler) {
   }
   return DEFAULT_RPC_HTTP_METHOD;
 }
-async function buildRpcHttpMethodManifest(customRpcImports, coreHandlers) {
+function getNuxtStringAliases(nuxt) {
+  const out = {};
+  for (const [specifier, target] of Object.entries(nuxt.options.alias)) {
+    if (typeof target === "string") {
+      out[specifier] = target;
+    }
+  }
+  return out;
+}
+function sortAliasRecordByLongestSpecifierFirst(map) {
+  return Object.fromEntries(
+    Object.entries(map).sort((a, b) => b[0].length - a[0].length)
+  );
+}
+async function resolveAliasChain(target, resolveOpts) {
+  let current = target;
+  for (let i = 0; i < 10; i++) {
+    const next = await resolvePath(current, resolveOpts);
+    if (next === current) {
+      return next;
+    }
+    current = next;
+  }
+  logger.warn(`Alias chain for ${target} resolved to ${current} but maximum depth of 10 was reached`);
+  return current;
+}
+async function buildResolvedNuxtAliasMap(nuxt) {
+  return runWithNuxtContext(nuxt, async () => {
+    const alias = getNuxtStringAliases(nuxt);
+    const resolveOpts = {
+      cwd: nuxt.options.rootDir,
+      alias,
+      virtual: true,
+      fallbackToOriginal: true
+    };
+    const resolved = {};
+    for (const [specifier, target] of Object.entries(alias)) {
+      try {
+        resolved[specifier] = await resolveAliasChain(target, resolveOpts);
+      } catch {
+        resolved[specifier] = target;
+      }
+    }
+    return sortAliasRecordByLongestSpecifierFirst(resolved);
+  });
+}
+function getJitiParentUrlForNuxtApp(nuxt) {
+  const pkg = join(nuxt.options.rootDir, "package.json");
+  if (existsSync(pkg)) {
+    return pathToFileURL(pkg).href;
+  }
+  return pathToFileURL(join(nuxt.options.rootDir, ".")).href;
+}
+async function buildRpcHttpMethodManifest(customRpcImports, coreHandlers, nuxt) {
   const manifest = {};
   for (const [name, handler] of Object.entries(coreHandlers)) {
     manifest[name] = readHttpMethod(handler);
@@ -113,10 +169,13 @@ async function buildRpcHttpMethodManifest(customRpcImports, coreHandlers) {
   if (customRpcImports.length === 0) {
     return manifest;
   }
+  const jiti = createJiti(getJitiParentUrlForNuxtApp(nuxt), {
+    alias: await buildResolvedNuxtAliasMap(nuxt)
+  });
   for (const { source, names } of customRpcImports) {
     let loadedModule;
     try {
-      loadedModule = await import(source);
+      loadedModule = await jiti.import(source);
     } catch (error) {
       logger.warn(
         `Failed to load custom RPC module '${source}' while inferring HTTP methods. Methods from this module will default to '${DEFAULT_RPC_HTTP_METHOD}'.`,
@@ -134,8 +193,8 @@ function createRpcHttpMethodsSource(manifest) {
 export const rpcHttpMethods = ${JSON.stringify(manifest, null, 2)}
 `;
 }
-async function nitroSetup(nitroConfig, config, moduleOptions) {
-  const { resolve, resolvePath } = createResolver(import.meta.url);
+async function nitroSetup(nitroConfig, config, moduleOptions, nuxt) {
+  const { resolve, resolvePath: resolvePath2 } = createResolver(import.meta.url);
   const {
     apiBasePath,
     customRpcImports,
@@ -144,33 +203,28 @@ async function nitroSetup(nitroConfig, config, moduleOptions) {
     rpcHttpMethodManifest,
     rpcHttpMethodsPath
   } = config;
+  const nuxtAliases = await buildResolvedNuxtAliasMap(nuxt);
   nitroConfig.replace = nitroConfig.replace || {};
   nitroConfig.replace["process.env.SFC_OMIT_MD5"] = stringToBoolean(
     process.env.SFC_OMIT_MD5
   );
   nitroConfig.replace.__sfc_version = PACKAGE_VERSION;
   nitroConfig.alias = {
-    ...nitroConfig.alias,
+    ...nuxtAliases,
+    ...nitroConfig.alias ?? {},
     "#virtual/rpcHttpMethods": rpcHttpMethodsPath
   };
   nitroConfig.virtual = {
     ...nitroConfig.virtual,
-    "#virtual/storage-drivers": createVirtualDriverImport(
-      usedDrivers
-    ),
-    "#virtual/customRpcMethods": createRpcMethodIndex(
-      customRpcImports
-    )
+    "#virtual/storage-drivers": createVirtualDriverImport(usedDrivers),
+    "#virtual/customRpcMethods": createRpcMethodIndex(customRpcImports)
   };
   nitroConfig.handlers = nitroConfig.handlers ?? [];
   nitroConfig.handlers.unshift({
     middleware: true,
     handler: resolve("./runtime/server/middleware/bootstrap")
   });
-  const allRpcNames = customRpcImports.reduce(
-    (acc, { names }) => acc.concat(names),
-    []
-  ).concat(coreMethodNames);
+  const allRpcNames = customRpcImports.reduce((acc, { names }) => acc.concat(names), []).concat(coreMethodNames);
   for (const methodName of allRpcNames) {
     const httpMethod = rpcHttpMethodManifest[methodName] ?? DEFAULT_RPC_HTTP_METHOD;
     nitroConfig.handlers.push({
@@ -203,9 +257,7 @@ async function nitroSetup(nitroConfig, config, moduleOptions) {
       resolve("./runtime/nitro/plugins/nitroLegacyStorageConfig")
     );
   }
-  nitroConfig.plugins.push(
-    resolve("./runtime/nitro/plugins/internalFetch")
-  );
+  nitroConfig.plugins.push(resolve("./runtime/nitro/plugins/internalFetch"));
   if (stringToBoolean(process.env.SFC_PLUGIN_CONFIG_VALIDATION_ENABLED, true)) {
     logger.debug("Installing config validation plugin");
     nitroConfig.plugins.push(
@@ -233,14 +285,12 @@ async function nitroSetup(nitroConfig, config, moduleOptions) {
     );
   }
   const base = resolve(`./`);
-  const handlerPaths = nitroConfig.handlers.filter(
-    (h) => h?.handler && h?.handler.startsWith(base)
-  ).map((h) => h?.handler);
+  const handlerPaths = nitroConfig.handlers.filter((h) => h?.handler && h?.handler.startsWith(base)).map((h) => h?.handler);
   const pluginPaths = nitroConfig.plugins.filter(
     (p) => p && p?.startsWith(base)
   );
   const runtimeEntries = await Promise.all(
-    [...handlerPaths, ...pluginPaths].map((p) => resolvePath(p))
+    [...handlerPaths, ...pluginPaths].map((p) => resolvePath2(p))
   );
   const trace = await nodeFileTrace(runtimeEntries, { base });
   const tracedImports = [...trace.fileList].map((p) => resolve(p));
@@ -300,7 +350,7 @@ const module$1 = defineNuxtModule({
   },
   async setup(options, nuxt) {
     const { resolve } = createResolver(import.meta.url);
-    const { resolve: appResolve, resolvePath } = createResolver(
+    const { resolve: appResolve, resolvePath: resolvePath2 } = createResolver(
       nuxt.options.rootDir
     );
     addServerTemplate({
@@ -401,7 +451,7 @@ const module$1 = defineNuxtModule({
           (name) => !storefrontRpcMethodNames.includes(name)
         );
       });
-      const rpcDir = await resolvePath(
+      const rpcDir = await resolvePath2(
         appResolve(options.rpcDir ?? "./rpcMethods")
       );
       if (existsSync(rpcDir)) {
@@ -420,7 +470,8 @@ const module$1 = defineNuxtModule({
       );
       rpcHttpMethodManifest = await buildRpcHttpMethodManifest(
         customRpcImports,
-        rpcMethods
+        rpcMethods,
+        nuxt
       );
       const rpcHttpMethodsSource = createRpcHttpMethodsSource(
         rpcHttpMethodManifest
@@ -461,14 +512,19 @@ const module$1 = defineNuxtModule({
         export {}`
     });
     nuxt.hooks.hook("nitro:config", async (nitroConfig) => {
-      await nitroSetup(nitroConfig, {
-        apiBasePath,
-        customRpcImports,
-        coreMethodNames: [...rpcMethodNames],
-        usedDrivers: getUsedDrivers(nuxt.options.runtimeConfig.storefront),
-        rpcHttpMethodManifest,
-        rpcHttpMethodsPath
-      }, nuxt.options.runtimeConfig.storefront);
+      await nitroSetup(
+        nitroConfig,
+        {
+          apiBasePath,
+          customRpcImports,
+          coreMethodNames: [...rpcMethodNames],
+          usedDrivers: getUsedDrivers(nuxt.options.runtimeConfig.storefront),
+          rpcHttpMethodManifest,
+          rpcHttpMethodsPath
+        },
+        nuxt.options.runtimeConfig.storefront,
+        nuxt
+      );
     });
     nuxt.hooks.hook("nitro:init", async (nitro) => {
       await nitroPostInit(nuxt.options.runtimeConfig.storefront, nitro);

package/dist/runtime/api/rpcHandler.js

@@ -23,10 +23,7 @@ export default defineEventHandler(async (event) => {
       status: HttpStatusCode.INTERNAL_SERVER_ERROR
     });
   }
-  const tracer = trace.getTracer(
-    "storefront-nuxt",
-    "__sfc_version"
-  );
+  const tracer = trace.getTracer("storefront-nuxt", "__sfc_version");
   const pathComponents = event.path.split("?")[0].split("/");
   const method = pathComponents[pathComponents.length - 1];
   const httpMethod = rpcHttpMethods[method] ?? DEFAULT_RPC_HTTP_METHOD;

package/dist/runtime/cached.js

@@ -1,10 +1,5 @@
 import { Cached } from "@scayle/storefront-core";
 export function getCachedFunction($cache, $log, enabled) {
-  const cached = new Cached(
-    $cache,
-    $log,
-    "",
-    enabled ?? true
-  );
+  const cached = new Cached($cache, $log, "", enabled ?? true);
   return cached.execute.bind(cached);
 }

package/dist/runtime/campaignKey.js

@@ -5,22 +5,22 @@ import {
 } from "@scayle/storefront-core";
 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);
-        }).sort(sortCampaignsByDateAscending)
-      };
-    }, {
-      cacheKeyPrefix: "fetch-campaignKey",
-      ttl: 5 * 60
-    })();
+    const { campaigns } = await cached(
+      async () => {
+        const { entities } = await sapiClient.campaigns.get();
+        return {
+          campaigns: entities.filter((campaign) => {
+            return campaignHasNotEnded(campaign);
+          }).sort(sortCampaignsByDateAscending)
+        };
+      },
+      {
+        cacheKeyPrefix: "fetch-campaignKey",
+        ttl: 5 * 60
+      }
+    )();
     return campaigns.find(isCampaignActive)?.key;
   } catch (error) {
-    log.error(
-      "Failed to get or process the campaigns from SAPI.",
-      error
-    );
+    log.error("Failed to get or process the campaigns from SAPI.", error);
   }
 };

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

@@ -6,17 +6,15 @@ export function useIDP(params = {}, key) {
     key ?? "useIDP",
     params
   );
-  const {
-    data,
-    error,
-    refresh,
-    status
-  } = useRpcPromise;
-  return extendPromise(useRpcPromise.then(() => ({})), {
-    data,
-    fetch,
-    error,
-    refresh,
-    status
-  });
+  const { data, error, refresh, status } = useRpcPromise;
+  return extendPromise(
+    useRpcPromise.then(() => ({})),
+    {
+      data,
+      fetch,
+      error,
+      refresh,
+      status
+    }
+  );
 }

package/dist/runtime/composables/core/useSession.js

@@ -7,9 +7,7 @@ export function useSession() {
     refreshToken: useRpcCall("refreshAccessToken"),
     revokeToken: useRpcCall("oauthRevokeToken"),
     forgetPassword: useRpcCall("oauthForgetPassword"),
-    resetPasswordByHash: useRpcCall(
-      "updatePasswordByHash"
-    ),
+    resetPasswordByHash: useRpcCall("updatePasswordByHash"),
     loginWithIDP: useRpcCall("handleIDPLoginCallback")
   };
 }

package/dist/runtime/composables/core/useUser.js

@@ -10,25 +10,16 @@ export function useUser(options = {}) {
   const updateUserRpc = useRpcCall("updateShopUser");
   const updatePasswordRpc = useRpcCall("updatePassword");
   const refreshUserRpc = useRpcCall("refreshUser");
-  const {
-    immediate = true,
-    lazy = false,
-    key = "useUser"
-  } = options;
-  const asyncDataPromise = useRpc(
-    "getUser",
-    key,
-    void 0,
-    {
-      immediate,
-      lazy,
-      server: false,
-      dedupe: "defer",
-      getCachedData: (cacheKey) => {
-        return toValue(nuxtApp._asyncData[cacheKey]?.data) ?? void 0;
-      }
+  const { immediate = true, lazy = false, key = "useUser" } = options;
+  const asyncDataPromise = useRpc("getUser", key, void 0, {
+    immediate,
+    lazy,
+    server: false,
+    dedupe: "defer",
+    getCachedData: (cacheKey) => {
+      return toValue(nuxtApp._asyncData[cacheKey]?.data) ?? void 0;
     }
-  );
+  });
   const { data, refresh, error, status } = asyncDataPromise;
   const updateUser = async (payload) => {
     log.debug("Update user");
@@ -53,16 +44,19 @@ export function useUser(options = {}) {
     log.debug("Refresh user");
     data.value = await refreshUserRpc();
   };
-  return extendPromise(asyncDataPromise.then(() => ({})), {
-    user,
-    isLoggedIn,
-    customerType,
-    refresh,
-    fetch,
-    forceRefresh,
-    updateUser,
-    updatePassword,
-    error,
-    status
-  });
+  return extendPromise(
+    asyncDataPromise.then(() => ({})),
+    {
+      user,
+      isLoggedIn,
+      customerType,
+      refresh,
+      fetch,
+      forceRefresh,
+      updateUser,
+      updatePassword,
+      error,
+      status
+    }
+  );
 }

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

@@ -80,5 +80,5 @@ type UseBasketBaseReturn = Omit<Awaited<UseRpcReturn<'getBasket'>>, 'data'> & {
  *
  * @throws {Error} If an item cannot be found during removal or if an item is added with a reduced quantity.  Also throws FetchError if RPC calls fail.
  */
-export declare function useBasket({ params, }?: UseBasketOptions, key?: UseRpcCacheKey): UseBasketBaseReturn & Promise<UseBasketBaseReturn>;
+export declare function useBasket({ params }?: UseBasketOptions, key?: UseRpcCacheKey): UseBasketBaseReturn & Promise<UseBasketBaseReturn>;
 export {};

package/dist/runtime/composables/storefront/useBasket.js

@@ -10,9 +10,7 @@ import { useRpc } from "../core/useRpc.js";
 import { useRpcCall } from "../core/useRpcCall.js";
 import { toValue, computed } from "vue";
 import { FetchError } from "ofetch";
-export function useBasket({
-  params
-} = {}, key = "useBasket") {
+export function useBasket({ params } = {}, key = "useBasket") {
   const addItemToBasketRpc = useRpcCall("addItemToBasket");
   const addItemsToBasketRpc = useRpcCall("addItemsToBasket");
   const updateBasketItemRpc = useRpcCall("updateBasketItem");
@@ -40,12 +38,7 @@ export function useBasket({
       return toValue(nuxtApp._asyncData[cacheKey]?.data) ?? void 0;
     }
   });
-  const {
-    data,
-    error,
-    refresh,
-    status
-  } = asyncData;
+  const { data, error, refresh, status } = asyncData;
   const handleBasketError = (basketErrors) => {
     if (wasAddedWithReducedQuantity(basketErrors)) {
       throw new Error("Item was added with reduced quantity", {
@@ -54,9 +47,7 @@ export function useBasket({
     }
   };
   const handleFetchError = (error2) => {
-    if (error2 instanceof FetchError && isAddOrUpdateItemError(
-      error2.data.errors?.[0]
-    ) && error2.data.errors?.[0].operation !== "delete") {
+    if (error2 instanceof FetchError && isAddOrUpdateItemError(error2.data.errors?.[0]) && error2.data.errors?.[0].operation !== "delete") {
       throw new Error(error2.message, {
         cause: error2.data.errors?.[0].kind
       });
@@ -164,42 +155,38 @@ export function useBasket({
   const products = computed(
     () => data.value?.items.map((item) => item.product) || []
   );
-  const count = computed(
-    () => {
-      return data.value?.items?.reduce((prev, current) => {
-        if (current.itemGroup?.id && !current.itemGroup.isMainItem) {
-          return prev;
-        }
-        return prev + current.quantity;
-      }, 0);
-    }
-  );
-  const countWithoutSoldOutItems = computed(
-    () => {
-      const mainItemQuantities = /* @__PURE__ */ new Map();
-      const soldOutItemGroups = /* @__PURE__ */ new Set();
-      let count2 = (data.value?.items ?? []).reduce((prev, current) => {
-        if (current.itemGroup?.id) {
-          if (current.itemGroup.isMainItem) {
-            mainItemQuantities.set(current.itemGroup.id, current.quantity);
-          } else {
-            if (current.product.isSoldOut && current.itemGroup.isRequired) {
-              soldOutItemGroups.add(current.itemGroup.id);
-            }
-            return prev;
+  const count = computed(() => {
+    return data.value?.items?.reduce((prev, current) => {
+      if (current.itemGroup?.id && !current.itemGroup.isMainItem) {
+        return prev;
+      }
+      return prev + current.quantity;
+    }, 0);
+  });
+  const countWithoutSoldOutItems = computed(() => {
+    const mainItemQuantities = /* @__PURE__ */ new Map();
+    const soldOutItemGroups = /* @__PURE__ */ new Set();
+    let count2 = (data.value?.items ?? []).reduce((prev, current) => {
+      if (current.itemGroup?.id) {
+        if (current.itemGroup.isMainItem) {
+          mainItemQuantities.set(current.itemGroup.id, current.quantity);
+        } else {
+          if (current.product.isSoldOut && current.itemGroup.isRequired) {
+            soldOutItemGroups.add(current.itemGroup.id);
           }
-        }
-        if (current.product.isSoldOut) {
           return prev;
         }
-        return prev + current.quantity;
-      }, 0);
-      soldOutItemGroups.forEach((itemGroupId) => {
-        count2 -= mainItemQuantities.get(itemGroupId) || 0;
-      });
-      return count2;
-    }
-  );
+      }
+      if (current.product.isSoldOut) {
+        return prev;
+      }
+      return prev + current.quantity;
+    }, 0);
+    soldOutItemGroups.forEach((itemGroupId) => {
+      count2 -= mainItemQuantities.get(itemGroupId) || 0;
+    });
+    return count2;
+  });
   const items = computed(() => data.value?.items);
   const cost = computed(() => data.value?.cost);
   const basketKey = computed(() => data.value?.key);

package/dist/runtime/composables/storefront/useBrand.js

@@ -3,10 +3,5 @@ export function useBrand({
   params,
   options
 } = {}, key = "useBrand") {
-  return useRpc(
-    "getBrandById",
-    key,
-    params,
-    options
-  );
+  return useRpc("getBrandById", key, params, options);
 }

package/dist/runtime/composables/storefront/useBrands.js

@@ -3,10 +3,5 @@ export function useBrands({
   params,
   options
 } = {}, key = "useBrands") {
-  return useRpc(
-    "getBrands",
-    key,
-    params,
-    options
-  );
+  return useRpc("getBrands", key, params, options);
 }

package/dist/runtime/composables/storefront/useCampaign.js

@@ -2,10 +2,5 @@ import { useRpc } from "../core/useRpc.js";
 export function useCampaign({
   options
 } = {}, key = "useCampaign") {
-  return useRpc(
-    "getCampaign",
-    key,
-    void 0,
-    options
-  );
+  return useRpc("getCampaign", key, void 0, options);
 }

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

@@ -5,24 +5,17 @@ export function useCategories({
   params,
   options
 } = {}, key = "useCategories") {
-  const useRpcPromise = useRpc(
-    "getCategoriesByPath",
-    key,
-    params,
-    options
-  );
+  const useRpcPromise = useRpc("getCategoriesByPath", key, params, options);
   const getCategoryById = useRpcCall("getCategoryById");
-  const {
-    data,
-    error,
-    status,
-    refresh
-  } = useRpcPromise;
-  return extendPromise(useRpcPromise.then(() => ({})), {
-    data,
-    error,
-    status,
-    refresh,
-    getCategoryById: (id, includeHidden) => getCategoryById({ id, includeHidden })
-  });
+  const { data, error, status, refresh } = useRpcPromise;
+  return extendPromise(
+    useRpcPromise.then(() => ({})),
+    {
+      data,
+      error,
+      status,
+      refresh,
+      getCategoryById: (id, includeHidden) => getCategoryById({ id, includeHidden })
+    }
+  );
 }

package/dist/runtime/composables/storefront/useCategoryById.js

@@ -3,10 +3,5 @@ export function useCategoryById({
   params,
   options
 } = {}, key = "useCategoryById") {
-  return useRpc(
-    "getCategoryById",
-    key,
-    params,
-    options
-  );
+  return useRpc("getCategoryById", key, params, options);
 }

package/dist/runtime/composables/storefront/useCategoryByPath.js

@@ -3,10 +3,5 @@ export function useCategoryByPath({
   params,
   options
 }, key = "useCategoryByPath") {
-  return useRpc(
-    "getCategoryByPath",
-    key,
-    params,
-    options
-  );
+  return useRpc("getCategoryByPath", key, params, options);
 }