@scayle/storefront-nuxt 7.36.3

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

@@ -0,0 +1,123 @@
+import { errors as joseErrors, jwtVerify } from "jose";
+import { rpcMethods } from "@scayle/storefront-core";
+async function updateSession(event, data) {
+  const session = event.context.session;
+  Object.assign(session.data, data);
+  await session.save();
+}
+const updateUser = async (event, tokens) => {
+  const checkoutUrl = event.context.$rpcContext.checkout.url;
+  const shopId = event.context.$currentShop.shopId;
+  const user = await rpcMethods.fetchUser(
+    { accessToken: tokens.access_token, callback: "" },
+    {
+      checkoutUrl,
+      shopId
+    }
+  );
+  await updateSession(event, {
+    accessToken: tokens.access_token,
+    refreshToken: tokens.refresh_token,
+    user
+  });
+};
+const updateAccessTokenWithRefreshToken = async (event, sessionData, log) => {
+  if (!sessionData?.refreshToken) {
+    return false;
+  }
+  try {
+    const context = event.context.$rpcContext;
+    const updatedTokens = await rpcMethods.refreshAccessToken(context);
+    if (updatedTokens === null) {
+      await revokeTokensAndDestroySession(event, log);
+      return true;
+    }
+    try {
+      await updateUser(event, updatedTokens);
+      return true;
+    } catch (e) {
+      log.error("api/oauth/me", {
+        message: "fetching user failed",
+        error: e
+      });
+    }
+  } catch (e) {
+    log.error("v1/oauth/token", {
+      message: "refresh access token failed, so the local tokens were deleted",
+      error: e
+    });
+  }
+  return false;
+};
+const revokeTokensAndDestroySession = async (event, log) => {
+  log.debug("revokeTokensAndDestroySession");
+  const context = event.context.$rpcContext;
+  try {
+    await rpcMethods.oauthRevokeToken(context);
+  } catch (e) {
+    log.error("v1/oauth/tokens", {
+      message: "error when revoking an access token",
+      error: e
+    });
+  } finally {
+    await context.destroySession();
+  }
+};
+const updateSessionWithUser = async (event, sessionData, log) => {
+  try {
+    const checkoutUrl = event.context.$rpcContext.checkout.url;
+    const shopId = event.context.$currentShop.shopId;
+    const user = await rpcMethods.fetchUser(
+      { accessToken: sessionData.accessToken, callback: "" },
+      {
+        checkoutUrl,
+        shopId
+      }
+    );
+    await updateSession(event, {
+      user
+    });
+  } catch (e) {
+    log.error("api/oauth/me", {
+      message: "fetching user failed",
+      error: e
+    });
+  }
+};
+export async function useOauth(event, jwks) {
+  const context = event.context.$rpcContext;
+  const log = event.context.$rpcContext.log.space("core").space("session");
+  const sessionData = event.context.session.data;
+  log.debug("validating oauth");
+  if (!sessionData?.accessToken && !sessionData?.refreshToken) {
+    log.debug("no tokens saved on session; skipping validation");
+    return;
+  }
+  if (!sessionData?.accessToken) {
+    log.debug("destroying session");
+    await context.destroySession();
+    return;
+  }
+  try {
+    log.debug("validating existing session");
+    await jwtVerify(sessionData.accessToken, jwks, { clockTolerance: 5 });
+    if (!sessionData?.user) {
+      log.debug("updating user session");
+      await updateSessionWithUser(event, sessionData, log);
+    }
+    return;
+  } catch (e) {
+    log.debug("error validating session");
+    if (e instanceof joseErrors.JWTExpired) {
+      log.debug("token expired");
+      const wasTokenSuccessfullyRefreshed = await updateAccessTokenWithRefreshToken(event, sessionData, log);
+      if (wasTokenSuccessfullyRefreshed) {
+        log.debug("token successfully refreshed");
+        return;
+      }
+    }
+    log.error("Could not verify JWT", e);
+  }
+  log.debug("revoking token and destroying session");
+  await revokeTokensAndDestroySession(event, log);
+}

package/dist/runtime/server/middleware/redirects.d.ts

@@ -0,0 +1,2 @@
+import { H3Event } from 'h3';
+export declare function useRedirects(event: H3Event): Promise<void>;

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

@@ -0,0 +1,86 @@
+import { sendRedirect, getRequestURL } from "h3";
+import { getRedirectLookupUrls, getTargetLocation } from "./redirects.utils.mjs";
+import { createCache } from "./cache.mjs";
+import { useRuntimeConfig } from "#imports";
+const REDIS_REDIRECT_PREFIX = ":REDIRECT";
+const REDIRECT_NOT_SET = "REDIRECT_NOT_SET";
+const REDIRECT_CACHE_TTL = 120;
+async function fetchRedirectWithCache(sourceUrl, bapiClient, redirectCache, log) {
+  const cachedResult = await redirectCache.get(sourceUrl);
+  if (cachedResult) {
+    if (cachedResult === REDIRECT_NOT_SET) {
+      return null;
+    }
+    return cachedResult;
+  }
+  log.debug("No cached result for redirect; querying BAPI");
+  let bapiResult;
+  try {
+    bapiResult = await bapiClient.redirects.post(sourceUrl);
+  } catch (error) {
+    log.error(`Error: Failed to fetch redirects ... ${error}`);
+    return null;
+  }
+  const isValidRedirect = (redirect) => {
+    return redirect && redirect?.source && redirect?.target && redirect.source !== redirect.target;
+  };
+  if (!bapiResult || !isValidRedirect(bapiResult)) {
+    await redirectCache.set(sourceUrl, REDIRECT_NOT_SET, REDIRECT_CACHE_TTL);
+    return null;
+  }
+  await redirectCache.set(
+    bapiResult.source,
+    {
+      target: bapiResult.target,
+      statusCode: bapiResult.statusCode
+    },
+    REDIRECT_CACHE_TTL
+  );
+  return bapiResult;
+}
+export async function useRedirects(event) {
+  const config = useRuntimeConfig();
+  const $storefrontConfig = config.storefront;
+  const options = $storefrontConfig.redirects;
+  const url = getRequestURL(event, {
+    xForwardedProto: true,
+    xForwardedHost: true
+  });
+  const currentShop = event.context.$currentShop;
+  const log = event.context.$rpcContext.log.space("sfc").space("redirects");
+  const redirectCache = createCache(
+    "redis",
+    currentShop.shopId + REDIS_REDIRECT_PREFIX,
+    log,
+    { redis: $storefrontConfig.redis }
+  );
+  const bapiClient = event.context.$rpcContext.bapiClient;
+  const queryParamWhitelist = new Set(options?.queryParamWhitelist ?? []);
+  log.debug(`Querying redirect for ${url.toString()}`);
+  const { relativeSourceUrl, absoluteSourceUrl } = getRedirectLookupUrls(
+    url,
+    queryParamWhitelist
+  );
+  const [relativeRedirect, absoluteRedirect] = await Promise.all([
+    fetchRedirectWithCache(relativeSourceUrl, bapiClient, redirectCache, log),
+    fetchRedirectWithCache(absoluteSourceUrl, bapiClient, redirectCache, log)
+  ]);
+  if (relativeRedirect && absoluteRedirect) {
+    log.info(`There are multiple valid redirects for: ${url.toString()}`);
+  }
+  const redirect = relativeRedirect ?? absoluteRedirect;
+  try {
+    if (redirect?.target) {
+      log.debug(`Redirecting to ${redirect.target}`);
+      await sendRedirect(
+        event,
+        getTargetLocation(url, redirect.target, queryParamWhitelist),
+        redirect.statusCode
+      );
+    } else {
+      log.debug(`No redirect found`);
+    }
+  } catch (error) {
+    log.error(`Error: Failed to execute redirect ... ${error}`);
+  }
+}

package/dist/runtime/server/middleware/redirects.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,66 @@
+import { describe, it, expect } from "vitest";
+import { getRedirectLookupUrls, getTargetLocation } from "./redirects.utils.mjs";
+describe("redirects module", () => {
+  describe("getRedirectLookupUrls", () => {
+    it("returns the relative and absolute URL", () => {
+      expect(
+        getRedirectLookupUrls(
+          new URL("https://demo.example/de/frauen/kleidung"),
+          /* @__PURE__ */ new Set()
+        )
+      ).to.eql({
+        relativeSourceUrl: "/de/frauen/kleidung",
+        absoluteSourceUrl: "https://demo.example/de/frauen/kleidung"
+      });
+    });
+    it("strips trailing slashes", () => {
+      expect(
+        getRedirectLookupUrls(new URL("https://demo.example/men/"), /* @__PURE__ */ new Set())
+      ).to.eql({
+        relativeSourceUrl: "/men",
+        absoluteSourceUrl: "https://demo.example/men"
+      });
+    });
+    it("strips query params", () => {
+      expect(
+        getRedirectLookupUrls(
+          new URL("https://demo.example/products?p=20&term=foo"),
+          /* @__PURE__ */ new Set()
+        )
+      ).to.eql({
+        relativeSourceUrl: "/products",
+        absoluteSourceUrl: "https://demo.example/products"
+      });
+    });
+    it("does not strip whitelisted query params", () => {
+      expect(
+        getRedirectLookupUrls(
+          new URL("https://demo.example/test/page/?foo=1&bar=10"),
+          /* @__PURE__ */ new Set(["bar"])
+        )
+      ).to.eql({
+        relativeSourceUrl: "/test/page?bar=10",
+        absoluteSourceUrl: "https://demo.example/test/page?bar=10"
+      });
+    });
+  });
+  describe("getTargetLocation", () => {
+    it("uses the source as the base for relative URLs", () => {
+      expect(
+        getTargetLocation(
+          new URL("http://demo.test/source/location"),
+          "/target"
+        )
+      ).to.eq("http://demo.test/target");
+    });
+    it("copies non-whitelisted query params from source", () => {
+      expect(
+        getTargetLocation(
+          new URL("http://demo.test/source?foo=10&bar=20"),
+          "/redirect",
+          /* @__PURE__ */ new Set(["foo"])
+        )
+      ).to.eq("http://demo.test/redirect?bar=20");
+    });
+  });
+});

package/dist/runtime/server/middleware/redirects.utils.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Get a normalized URL in absolute and relative forms for redirect lookup
+ * @param url
+ * @param queryParamWhitelist
+ */
+export declare function getRedirectLookupUrls(url: URL, queryParamWhitelist?: Set<string>): {
+    relativeSourceUrl: string;
+    absoluteSourceUrl: string;
+};
+/**
+ * Construct a URL string given a source URL and target redirect
+ * Query params are copied from source to target (if the params are not whitelisted)
+ * and source is used as the base URL if target is a relative redirect.
+ * @param source
+ * @param target
+ * @param queryParamWhitelist
+ */
+export declare function getTargetLocation(source: URL, target: string, queryParamWhitelist?: Set<string>): string;

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

@@ -0,0 +1,28 @@
+export function getRedirectLookupUrls(url, queryParamWhitelist) {
+  const incomingUrl = `${url.origin}${url.pathname}`;
+  const sourceUrlObject = new URL(
+    incomingUrl.endsWith("/") ? incomingUrl.slice(0, -1) : incomingUrl
+  );
+  if (queryParamWhitelist) {
+    for (const [key, value] of [...url.searchParams.entries()]) {
+      if (queryParamWhitelist.has(key)) {
+        sourceUrlObject.searchParams.append(key, value);
+      }
+    }
+  }
+  const relativeSourceUrl = decodeURI(
+    sourceUrlObject.toString().replace(sourceUrlObject.origin, "")
+  );
+  const absoluteSourceUrl = decodeURI(sourceUrlObject.toString());
+  return { relativeSourceUrl, absoluteSourceUrl };
+}
+export function getTargetLocation(source, target, queryParamWhitelist) {
+  const base = URL.canParse(target) ? target : source;
+  const targetUrl = new URL(target, base);
+  for (const [key, value] of source.searchParams.entries()) {
+    if (!queryParamWhitelist?.has(key) && !targetUrl.searchParams.has(key)) {
+      targetUrl.searchParams.append(key, value);
+    }
+  }
+  return decodeURI(targetUrl.toString());
+}

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

@@ -0,0 +1,5 @@
+import { NuxtError } from 'nuxt/app';
+import { FetchError } from 'ofetch';
+import { parseErrorData } from '../error/handler';
+declare const handleError: (error: FetchError | Error | unknown, additionalData?: unknown) => NuxtError;
+export { handleError, parseErrorData };

package/dist/runtime/utils/error.mjs

@@ -0,0 +1,7 @@
+import { createError } from "nuxt/app";
+import { parseErrorData, resolveError } from "../error/handler.mjs";
+const handleError = (error, additionalData) => {
+  const data = resolveError(error, additionalData);
+  return createError(data);
+};
+export { handleError, parseErrorData };

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

@@ -0,0 +1,11 @@
+type BaseOptions = {
+    locale: string;
+    currencyFractionDigits?: number;
+};
+type FormatOptions = BaseOptions;
+type ToCurrencyOptions = BaseOptions & {
+    currency: string;
+};
+export declare const toCurrency: (value: number, options?: ToCurrencyOptions) => string;
+export declare const formatPrice: (value: number, formatOptions?: FormatOptions) => string;
+export {};

package/dist/runtime/utils/price.mjs

@@ -0,0 +1,32 @@
+import { getDefaultFractionDigits } from "@scayle/storefront-core";
+import { useCurrentShop } from "../composables/core/useCurrentShop.mjs";
+export const toCurrency = (value, options) => {
+  const currentShop = useCurrentShop();
+  const {
+    locale = currentShop.value.locale,
+    currency = currentShop.value.currency,
+    currencyFractionDigits = currentShop.value.currencyFractionDigits
+  } = options || {};
+  const minimumFractionDigits = getDefaultFractionDigits(locale, currency);
+  return (value / 100).toLocaleString(locale, {
+    style: "currency",
+    ...currencyFractionDigits && {
+      minimumFractionDigits: Math.min(
+        minimumFractionDigits,
+        currencyFractionDigits
+      )
+    },
+    maximumFractionDigits: currencyFractionDigits,
+    currency
+  });
+};
+export const formatPrice = (value, formatOptions) => {
+  const currentShop = useCurrentShop();
+  const {
+    locale = currentShop.value.locale,
+    currencyFractionDigits = currentShop.value.currencyFractionDigits
+  } = formatOptions || {};
+  return (value / 100).toLocaleString(locale, {
+    minimumFractionDigits: currencyFractionDigits
+  });
+};

package/dist/runtime/utils/price.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/utils/price.test.mjs

@@ -0,0 +1,83 @@
+import { describe, it, expect, vi } from "vitest";
+import { ref } from "vue";
+import { toCurrency, formatPrice } from "./price.mjs";
+describe("Price utils", () => {
+  vi.mock("../composables/core/useCurrentShop", () => ({
+    useCurrentShop: () => ref({
+      locale: "de-DE",
+      currency: "EUR",
+      currencyFractionDigits: 2
+    })
+  }));
+  describe("toCurrency", () => {
+    it("should return value with EUR currency", () => {
+      const options = {
+        locale: "de-DE",
+        currency: "EUR",
+        currencyFractionDigits: 2
+      };
+      const currency = toCurrency(200, options);
+      expect(currency).be.eq("2,00\xA0\u20AC");
+    });
+    it("should return value with EUR currency with default options", () => {
+      const currency = toCurrency(200);
+      expect(currency).be.eq("2,00\xA0\u20AC");
+    });
+    it("should return value with EUR currency with default options", () => {
+      const currency = toCurrency(200);
+      expect(currency).be.eq("2,00\xA0\u20AC");
+    });
+    it("should return value with USD currency", () => {
+      const options = {
+        locale: "de-DE",
+        currency: "USD",
+        currencyFractionDigits: 2
+      };
+      const currency = toCurrency(200, options);
+      expect(currency).be.eq("2,00\xA0$");
+    });
+    it("should return value with one fraction digit", () => {
+      const options = {
+        locale: "de-DE",
+        currency: "USD",
+        currencyFractionDigits: 1
+      };
+      const currency = toCurrency(200, options);
+      expect(currency).be.eq("2,0\xA0$");
+    });
+    it("should return value with two fraction digits if no fraction digits set", () => {
+      const options = {
+        locale: "de-DE",
+        currency: "USD"
+      };
+      const currency = toCurrency(200, options);
+      expect(currency).be.eq("2,00\xA0$");
+    });
+    it("should return value properly formatted for en-US locale", () => {
+      const options = {
+        locale: "en-US",
+        currency: "USD"
+      };
+      const currency = toCurrency(200, options);
+      expect(currency).be.eq("$2.00");
+    });
+  });
+  describe("formatPrice", () => {
+    it("should return formatted price with two fraction digits", () => {
+      const options = {
+        locale: "en-US",
+        currencyFractionDigits: 2
+      };
+      const price = formatPrice(200, options);
+      expect(price).be.eq("2.00");
+    });
+    it("should return formatted price with one fraction digits", () => {
+      const options = {
+        locale: "en-US",
+        currencyFractionDigits: 1
+      };
+      const price = formatPrice(200, options);
+      expect(price).be.eq("2.0");
+    });
+  });
+});

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

@@ -0,0 +1,2 @@
+import type { LocationQuery } from 'vue-router';
+export declare const getCurrentPage: (query: LocationQuery) => number | undefined;

package/dist/runtime/utils/route.mjs

@@ -0,0 +1,3 @@
+export const getCurrentPage = (query) => {
+  return typeof query.page === "string" ? parseInt(query.page, 10) : void 0;
+};

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

@@ -0,0 +1 @@
+export {};

package/dist/runtime/utils/route.test.mjs

@@ -0,0 +1,15 @@
+import { describe, it, expect } from "vitest";
+import { getCurrentPage } from "./route.mjs";
+describe("getCurrentPage", () => {
+  it("should return parsed current page", () => {
+    const page = getCurrentPage({ page: "20" });
+    expect(page).be.equal(20);
+  });
+  it("should return undefined if page does not exist inside the query", () => {
+    const page = getCurrentPage({});
+    expect(page).be.equal(void 0);
+  });
+  it("should return undefined if page is not a string", () => {
+    expect(getCurrentPage({ page: ["1", "2"] })).toBe(void 0);
+  });
+});

package/dist/shared/storefront-nuxt.9548700f.d.mts

@@ -0,0 +1,161 @@
+import { HashAlgorithm, WithParams, ShopUser } from '@scayle/storefront-core';
+
+type StorageProvider = 'memory' | 'redis';
+type CheckoutShopConfig = {
+    host: string;
+    token: string;
+    secret: string;
+    user: string;
+    /**
+     * The number of seconds that a CBD token should be considered valid since issued
+     */
+    cbdExpiration?: number;
+};
+/**
+ * Options to configure how the storefront core manages sessions
+ */
+type SessionConfig = Partial<{
+    /**
+     * The name used for the session cookie
+     */
+    cookieName: string;
+    /**
+     * The sameSite policy to use for the session cookie
+     */
+    sameSite: 'none' | 'lax' | 'strict';
+    /**
+     * The default maxAge (in seconds) set on the session cookie and default TTL for session store
+     */
+    maxAge: number;
+    /**
+     * The secret used for signing session cookies. If an array is passed, the last
+     * value is used for signing new cookies, but all values are used to verify cookies.
+     */
+    secret: string | string[];
+    /**
+     * Controls the domain option on the session cookie
+     */
+    domain: string;
+    /**
+     * The provider to use for the persistent storage.
+     */
+    provider: StorageProvider;
+}>;
+interface CacheConfig {
+    provider?: StorageProvider;
+    auth?: {
+        username: string;
+        password: string;
+    };
+    ssr?: {};
+    enabled?: boolean;
+}
+type RedisConfig = {
+    port?: number;
+    host?: string;
+    prefix?: string;
+    sslTransit?: boolean;
+} | {
+    port?: number;
+    host?: string;
+    prefix?: string;
+    sslTransit?: boolean;
+    user: string;
+    password: string;
+};
+interface BapiConfig {
+    host: string;
+    token: string;
+}
+interface AppKeys {
+    wishlistKey: string;
+    basketKey: string;
+    hashAlgorithm: HashAlgorithm;
+}
+interface RedirectsConfig {
+    enabled: boolean;
+    queryParamWhitelist?: string[];
+}
+interface OauthConfig {
+    apiHost: string;
+    clientId: string;
+    clientSecret: string;
+}
+type AuthenticationConfig = {
+    redirect: {
+        home: string;
+        logout: string;
+    };
+};
+interface AdditionalShopConfig {
+}
+interface ShopConfig extends AdditionalShopConfig {
+    shopId: number;
+    domain: string;
+    path?: string;
+    locale: string;
+    apiBasePath?: string;
+    currency: string;
+    currencyFractionDigits?: number;
+    storeCampaignKeyword?: string;
+    isEnabled?: boolean;
+    checkout: CheckoutShopConfig;
+    sessionConfig?: SessionConfig;
+    auth: {
+        resetPasswordUrl: string;
+    };
+    redis?: RedisConfig;
+    bapi?: BapiConfig;
+    appKeys?: AppKeys;
+}
+type ShopConfigIndexed = Record<string, ShopConfig>;
+interface PublicShopConfig extends Pick<ShopConfig, 'shopId' | 'domain' | 'path' | 'locale' | 'currency' | 'currencyFractionDigits'> {
+    checkout: Pick<CheckoutShopConfig, 'host'>;
+    apiBasePath: string;
+}
+interface StorefrontConfig {
+    session?: SessionConfig;
+    bapi: BapiConfig;
+    redis: RedisConfig;
+    auth: AuthenticationConfig;
+    oauth: OauthConfig;
+    appKeys: AppKeys;
+    apiBasePath?: string;
+    cache?: CacheConfig;
+    publicShopData?: (keyof AdditionalShopConfig)[];
+    withParams?: WithParams;
+}
+type ModuleOptions = StorefrontConfig & {
+    shopSelector: 'domain' | 'path';
+    stores: ShopConfigIndexed;
+    rpcDir?: string;
+    rpcMethodNames?: string[];
+    log: {
+        name: string;
+    };
+    redirects?: RedirectsConfig;
+};
+interface CheckoutEvent {
+    action?: 'authenticated';
+    type?: 'tracking';
+    user: ShopUser;
+    accessToken: string;
+    event?: {
+        event: 'login' | 'add_to_cart' | 'remove_from_cart';
+        status: 'successful' | 'error';
+    };
+}
+declare module '@nuxt/schema' {
+    interface RuntimeConfig {
+        storefront: ModuleOptions;
+    }
+    interface PublicRuntimeConfig {
+        imageBaseUrl: string;
+        log: {
+            name: string;
+        };
+        auth: AuthenticationConfig;
+    }
+}
+
+export type { AppKeys as A, BapiConfig as B, CheckoutShopConfig as C, ModuleOptions as M, OauthConfig as O, PublicShopConfig as P, RedisConfig as R, StorageProvider as S, SessionConfig as a, CacheConfig as b, RedirectsConfig as c, AuthenticationConfig as d, AdditionalShopConfig as e, ShopConfig as f, ShopConfigIndexed as g, StorefrontConfig as h, CheckoutEvent as i };