@scayle/storefront-nuxt 7.36.3

package/dist/runtime/plugin/log.server.mjs

@@ -0,0 +1,11 @@
+import { defineNuxtPlugin } from "nuxt/app";
+export default defineNuxtPlugin((nuxtApp) => {
+  if (!nuxtApp.ssrContext) {
+    return;
+  }
+  const log = nuxtApp.ssrContext.event.context.$rpcContext.log;
+  const coreLog = log.space("sfc");
+  nuxtApp.provide("log", log);
+  nuxtApp.provide("coreLog", coreLog);
+  coreLog.debug("Attached server-side logger");
+});

package/dist/runtime/plugin/shop.d.ts

@@ -0,0 +1,8 @@
+declare const _default: import("nuxt/app").Plugin<{
+    currentShop: import("../../module").PublicShopConfig;
+    availableShops: import("../../module").PublicShopConfig[];
+}> & import("nuxt/app").ObjectPlugin<{
+    currentShop: import("../../module").PublicShopConfig;
+    availableShops: import("../../module").PublicShopConfig[];
+}>;
+export default _default;

package/dist/runtime/plugin/shop.mjs

@@ -0,0 +1,17 @@
+import { defineNuxtPlugin } from "nuxt/app";
+import { useCurrentShop } from "../composables/core/useCurrentShop.mjs";
+import { useAvailableShops } from "../composables/core/useAvailableShops.mjs";
+export default defineNuxtPlugin((nuxtApp) => {
+  const currentShop = useCurrentShop();
+  const availableShops = useAvailableShops();
+  if (process.server && nuxtApp.ssrContext) {
+    currentShop.value = nuxtApp.ssrContext.event.context.$currentShop;
+    availableShops.value = nuxtApp.ssrContext.event.context.$availableShops;
+  }
+  return {
+    provide: {
+      currentShop: currentShop.value,
+      availableShops: availableShops.value
+    }
+  };
+});

package/dist/runtime/rpc/rpcCall.d.ts

@@ -0,0 +1,9 @@
+import type { RpcContext, RpcMethodName, RpcMethodParameters, RpcMethodReturnType } from '@scayle/storefront-core';
+import type { NuxtApp } from 'nuxt/app';
+import type { PublicShopConfig } from '../../types/module';
+/**
+ * rpcCall can be used to invoke an RPC method either on the client or server
+ * It makes an HTTP request on the client and direct call on the server using $fetch
+ * https://nuxt.com/docs/api/utils/dollarfetch
+ */
+export declare const rpcCall: <N extends RpcMethodName, P extends RpcMethodParameters<N>, TResult extends Awaited<RpcMethodReturnType<N>>, TakesParameters = P extends RpcContext ? undefined : boolean>(nuxtApp: NuxtApp, method: N, shop: PublicShopConfig) => TakesParameters extends undefined ? () => Promise<TResult> : (params: P) => Promise<TResult>;

package/dist/runtime/rpc/rpcCall.mjs

@@ -0,0 +1,16 @@
+export const rpcCall = (nuxtApp, method, shop) => {
+  const fetch = nuxtApp.ssrContext?.event.$fetch ?? $fetch;
+  return async (params = void 0) => {
+    const data = await fetch(`${shop.apiBasePath ?? "/api"}/rpc/${method}`, {
+      // @ts-ignore
+      method: "POST",
+      body: {
+        payload: params
+      },
+      headers: {
+        "x-shop-id": shop.shopId + ""
+      }
+    });
+    return data;
+  };
+};

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

@@ -0,0 +1,12 @@
+import { RpcContext, Cache } from '@scayle/storefront-core';
+import type { PublicShopConfig } from '../../../module';
+declare module 'h3' {
+    interface H3EventContext {
+        $rpcContext: RpcContext;
+        $cache: Cache;
+        $currentShop: PublicShopConfig;
+        $availableShops: PublicShopConfig[];
+    }
+}
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void>>;
+export default _default;

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

@@ -0,0 +1,188 @@
+import { defineEventHandler, getRequestURL } from "h3";
+import { createConsola } from "consola";
+import { createRemoteJWKSet, decodeJwt } from "jose";
+import { randomUUID } from "uncrypto";
+import redisDriver from "unstorage/drivers/redis";
+import memoryDriver from "unstorage/drivers/memory";
+import { createStorage } from "unstorage";
+import {
+  useSession,
+  UnstorageSessionStore
+} from "@scayle/h3-session";
+import { buildContext } from "../../context.mjs";
+import createLog from "../../createLog.mjs";
+import {
+  convertStoresToList,
+  getCurrentShopForRequest,
+  getPublicShopData
+} from "./bootstrap.utils.mjs";
+import { useOauth } from "./oauth.mjs";
+import { useRedirects } from "./redirects.mjs";
+import { createCache } from "./cache.mjs";
+import { useRuntimeConfig } from "#imports";
+const getShopConfig = (event, config) => {
+  const storefrontConfig = config.storefront;
+  const $shopConfig = getCurrentShopForRequest(
+    event,
+    storefrontConfig
+  );
+  return $shopConfig;
+};
+const memoryStorage = memoryDriver();
+function createSessionStore(sessionConfig, redisConfig, log) {
+  const ioredisConfig = {
+    ..."user" in redisConfig && {
+      username: redisConfig.user
+    },
+    ..."password" in redisConfig && {
+      password: redisConfig.password
+    },
+    host: redisConfig.host,
+    port: redisConfig.port,
+    db: 1,
+    tls: redisConfig.sslTransit ? {} : void 0
+  };
+  if (sessionConfig.provider === "memory") {
+    log.warn("Creating in-memory session storage");
+    log.warn("In-memory storage should not be used in production");
+    return new UnstorageSessionStore(
+      createStorage({
+        driver: memoryStorage
+      })
+    );
+  }
+  log.debug(
+    `Creating redis session storage. host: ${ioredisConfig.host} port: ${ioredisConfig.port} db: ${ioredisConfig.db} tls: ${ioredisConfig.tls}`
+  );
+  return new UnstorageSessionStore(
+    createStorage({
+      driver: redisDriver(ioredisConfig)
+    }),
+    {
+      ttl: sessionConfig?.maxAge ?? 60 * 60 * 24
+    }
+  );
+}
+async function handleOauth(event, storefrontConfig, log) {
+  if (!storefrontConfig.oauth.apiHost) {
+    log.error("oauth.apiHost must be set in the module options.");
+    return false;
+  }
+  if (!storefrontConfig.oauth.clientId) {
+    log.error("oauth.clientId must be set in the module options.");
+    return false;
+  }
+  if (!storefrontConfig.oauth.clientSecret) {
+    log.error("oauth.clientSecret must be set in the module options.");
+    return false;
+  }
+  const authURL = storefrontConfig.oauth.apiHost;
+  const JWKS = createRemoteJWKSet(new URL("/.well-known/jwks.json", authURL), {
+    cacheMaxAge: 5 * 60 * 1e3
+    // Cache Keys for 5 minutes.
+  });
+  await useOauth(event, JWKS);
+}
+async function bootstrap(event, log, url, $shopConfig, $storefrontConfig, apiBasePath) {
+  const bootstrapLog = log.space("bootstrap");
+  bootstrapLog.debug("Bootstrapping request: ", url.toString());
+  const redisConfig = $shopConfig.redis ?? $storefrontConfig.redis;
+  const $cache = createCache(
+    $storefrontConfig.cache?.provider ?? "redis",
+    String($shopConfig.shopId),
+    bootstrapLog,
+    { redis: redisConfig }
+  );
+  const sessionDefaults = {
+    maxAge: void 0,
+    cookieName: "$session",
+    secret: "current-secret",
+    sameSite: "none"
+  };
+  const sessionConfig = {
+    ...sessionDefaults,
+    ...$storefrontConfig.session,
+    ...$shopConfig.sessionConfig
+  };
+  const sessionStorage = createSessionStore(sessionConfig, redisConfig, log);
+  const generateSessionId = (event2) => {
+    let userId;
+    if (event2?.context.session?.data?.accessToken) {
+      const payload = decodeJwt(event2?.context.session?.data?.accessToken);
+      userId = payload.customerId;
+    }
+    return userId ? `${userId}:${randomUUID()}` : randomUUID();
+  };
+  bootstrapLog.debug("Attaching session to request");
+  await useSession(event, {
+    ...sessionConfig,
+    store: sessionStorage,
+    // @ts-ignore
+    genid: generateSessionId,
+    saveUninitialized: true,
+    cookie: {
+      maxAge: sessionConfig?.maxAge,
+      // secure: sessionConfig.isHttps, TODO
+      sameSite: sessionConfig.sameSite,
+      domain: sessionConfig?.domain
+    },
+    name: sessionConfig?.cookieName ?? "$session",
+    secret: sessionConfig?.secret ?? "current-secret"
+  });
+  event.context.$currentShop = getPublicShopData(
+    $shopConfig,
+    $shopConfig.shopId,
+    apiBasePath,
+    $storefrontConfig.publicShopData
+  );
+  event.context.$availableShops = convertStoresToList($storefrontConfig.stores).filter((store) => store.isEnabled !== false).map(
+    (config) => getPublicShopData(
+      config,
+      $shopConfig.shopId,
+      apiBasePath,
+      $storefrontConfig.publicShopData
+    )
+  );
+  event.context.$cache = $cache;
+  bootstrapLog.debug("Building context for request");
+  event.context.$rpcContext = await buildContext({
+    $cache,
+    $shopConfig,
+    $storefront: $storefrontConfig,
+    $log: log,
+    sessionId: event.context.sessionId,
+    session: event.context.session
+  });
+}
+export default defineEventHandler(async (event) => {
+  try {
+    const url = getRequestURL(event);
+    if (url.pathname.startsWith("/__nuxt")) {
+      return;
+    }
+    const config = useRuntimeConfig();
+    const $storefrontConfig = config.storefront;
+    const $shopConfig = getShopConfig(event, config);
+    const apiBasePath = $shopConfig.apiBasePath || $storefrontConfig.apiBasePath || "/api";
+    if (url.pathname === `${apiBasePath}/up`) {
+      return;
+    }
+    const log = createLog(createConsola, $storefrontConfig.log.name);
+    if (!event.context.$rpcContext) {
+      await bootstrap(
+        event,
+        log,
+        url,
+        $shopConfig,
+        $storefrontConfig,
+        apiBasePath
+      );
+    }
+    if ($storefrontConfig.redirects?.enabled && !url.pathname.startsWith(apiBasePath)) {
+      await useRedirects(event);
+    }
+    await handleOauth(event, $storefrontConfig, log);
+  } catch (e) {
+    console.error(e);
+  }
+});

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

@@ -0,0 +1,6 @@
+declare module '../../../module' {
+    interface AdditionalShopConfig {
+        paymentProviders: string[];
+    }
+}
+export {};

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

@@ -0,0 +1,277 @@
+import { describe, it, expect } from "vitest";
+import { createRequest, createResponse } from "node-mocks-http";
+import { createEvent } from "h3";
+import { getCurrentShopForRequest, getPublicShopData } from "./bootstrap.utils.mjs";
+const DOMAIN_DE = "de.scayle.example";
+const DOMAIN_AT = "at.scayle.example";
+const DOMAIN_US = "us.scayle.example";
+const CHECKOUT_HOST = "https://checkout.scayle.cloud";
+const baseShop = {
+  appKeys: {
+    wishlistKey: "wishlist_{shopId}_{userId}",
+    basketKey: "basket_{shopId}_{userId}",
+    hashAlgorithm: "sha256"
+  },
+  auth: {
+    resetPasswordUrl: ""
+  },
+  domain: "demo.test",
+  paymentProviders: [],
+  checkout: {
+    host: CHECKOUT_HOST,
+    token: "",
+    secret: "",
+    user: ""
+  }
+};
+describe("getCurrentShopForRequest", () => {
+  it("respects the x-shop-id header", () => {
+    const req = createRequest({
+      url: "/api/getProducts",
+      headers: {
+        "x-shop-id": "1002"
+      }
+    });
+    const moduleOptions = {
+      shopSelector: "domain",
+      stores: {
+        DE_DE: {
+          ...baseShop,
+          shopId: 1001,
+          domain: DOMAIN_DE,
+          locale: "de-DE",
+          currency: "EUR"
+        },
+        DE_AT: {
+          ...baseShop,
+          shopId: 1002,
+          domain: DOMAIN_AT,
+          locale: "de-AT",
+          currency: "EUR"
+        },
+        DE_US: {
+          ...baseShop,
+          shopId: 1003,
+          domain: DOMAIN_US,
+          locale: "en-US",
+          currency: "USD"
+        }
+      }
+    };
+    const shop = getCurrentShopForRequest(
+      createEvent(req, createResponse()),
+      moduleOptions
+    );
+    expect(shop.shopId).to.eq(1002);
+  });
+  it("falls back to the path when shopSelector = path", () => {
+    const moduleOptions = {
+      shopSelector: "path",
+      stores: {
+        DE_DE: {
+          ...baseShop,
+          shopId: 1001,
+          path: "de",
+          locale: "de-DE",
+          currency: "EUR"
+        },
+        DE_AT: {
+          ...baseShop,
+          shopId: 1002,
+          path: "at",
+          locale: "de-AT",
+          currency: "EUR"
+        },
+        EN_US: {
+          ...baseShop,
+          shopId: 1003,
+          path: "foobar",
+          locale: "en-US",
+          currency: "USD"
+        },
+        DE_CH: {
+          ...baseShop,
+          shopId: 1004,
+          path: "de-ch",
+          locale: "de-CH",
+          currency: "CHF"
+        }
+      }
+    };
+    expect(
+      getCurrentShopForRequest(
+        createEvent(
+          createRequest({
+            url: "https://de.scayle.example/foobar/men/shirts"
+          }),
+          createResponse()
+        ),
+        moduleOptions
+      ).shopId
+    ).to.eq(1003);
+    expect(
+      getCurrentShopForRequest(
+        createEvent(
+          createRequest({
+            url: "/foobar/men/shirts"
+          }),
+          createResponse()
+        ),
+        moduleOptions
+      ).shopId
+    ).to.eq(1003);
+    expect(
+      getCurrentShopForRequest(
+        createEvent(
+          createRequest({
+            url: "https://de.scayle.example/at/men/shirts"
+          }),
+          createResponse()
+        ),
+        moduleOptions
+      ).shopId
+    ).to.eq(1002);
+    expect(
+      getCurrentShopForRequest(
+        createEvent(
+          createRequest({
+            url: "https://de.scayle.example/de-ch/men/shirts"
+          }),
+          createResponse()
+        ),
+        moduleOptions
+      ).shopId
+    ).to.eq(1004);
+  });
+  it("falls back to the domain when shopSelector = domain", () => {
+    const req = createRequest({
+      url: "https://de.scayle.example/at/frauen"
+    });
+    const moduleOptions = {
+      shopSelector: "domain",
+      stores: {
+        DE_DE: {
+          ...baseShop,
+          shopId: 1001,
+          domain: DOMAIN_DE,
+          locale: "de-DE",
+          currency: "EUR"
+        },
+        DE_AT: {
+          ...baseShop,
+          shopId: 1002,
+          domain: DOMAIN_AT,
+          locale: "de-AT",
+          currency: "EUR"
+        },
+        EN_US: {
+          ...baseShop,
+          shopId: 1003,
+          domain: DOMAIN_US,
+          locale: "en-US",
+          currency: "USD"
+        }
+      }
+    };
+    const shop = getCurrentShopForRequest(
+      createEvent(req, createResponse()),
+      moduleOptions
+    );
+    expect(shop.shopId).to.eq(1001);
+  });
+  it("falls back to the first shop when there is no match", () => {
+    const req = createRequest({
+      url: "https://de.scayle.example/foobar/men/shirts",
+      headers: {
+        "x-shop-id": "1005"
+      }
+    });
+    const moduleOptions = {
+      shopSelector: "domain",
+      stores: {
+        DE_DE: {
+          ...baseShop,
+          shopId: 1001,
+          domain: DOMAIN_DE,
+          locale: "de-DE",
+          currency: "EUR"
+        },
+        DE_AT: {
+          ...baseShop,
+          shopId: 1002,
+          domain: DOMAIN_AT,
+          locale: "de-AT",
+          currency: "EUR"
+        },
+        EN_US: {
+          ...baseShop,
+          shopId: 1003,
+          domain: DOMAIN_US,
+          locale: "en-US",
+          currency: "USD"
+        }
+      }
+    };
+    const shop = getCurrentShopForRequest(
+      createEvent(req, createResponse()),
+      moduleOptions
+    );
+    expect(shop.shopId).to.eq(1001);
+  });
+});
+describe("getPublicShopData", () => {
+  it("excludes checkout secrets from the public shop data", () => {
+    const shopConfig = {
+      ...baseShop,
+      shopId: 1003,
+      domain: DOMAIN_US,
+      path: "en",
+      locale: "en-US",
+      currency: "USD"
+    };
+    expect(getPublicShopData(shopConfig, 1003, "/api")).to.eql({
+      shopId: 1003,
+      domain: DOMAIN_US,
+      path: "en",
+      locale: "en-US",
+      currency: "USD",
+      isActive: true,
+      checkout: {
+        host: CHECKOUT_HOST
+      },
+      apiBasePath: "/api"
+    });
+  });
+  it("includes additional shop data for keys in storefront.publicShopData", () => {
+    const shopConfig = {
+      ...baseShop,
+      shopId: 1003,
+      domain: DOMAIN_US,
+      path: "en",
+      locale: "en-US",
+      currency: "USD",
+      paymentProviders: ["visa", "klarna"],
+      checkout: {
+        host: CHECKOUT_HOST,
+        token: "",
+        secret: "",
+        user: ""
+      }
+    };
+    expect(
+      getPublicShopData(shopConfig, 1003, "/api", ["paymentProviders"])
+    ).to.eql({
+      shopId: 1003,
+      domain: DOMAIN_US,
+      path: "en",
+      locale: "en-US",
+      currency: "USD",
+      paymentProviders: ["visa", "klarna"],
+      isActive: true,
+      checkout: {
+        host: CHECKOUT_HOST
+      },
+      apiBasePath: "/api"
+    });
+  });
+});

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

@@ -0,0 +1,7 @@
+import { H3Event } from 'h3';
+import type { ModuleOptions, PublicShopConfig, ShopConfig, ShopConfigIndexed } from '../../../module';
+export declare const convertStoresToList: (stores: ShopConfig[] | ShopConfigIndexed) => ShopConfig[];
+export declare function getCurrentShopForRequest(event: H3Event, config: Pick<ModuleOptions, 'stores' | 'shopSelector'>): ShopConfig;
+export declare function getPublicShopData(data: ShopConfig, currentShopId: number, apiBasePath: string, publicShopData?: (keyof ShopConfig)[]): PublicShopConfig & {
+    isActive: boolean;
+};

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

@@ -0,0 +1,59 @@
+import { getRequestHeaders, getRequestHost } from "h3";
+import { isArray, listify } from "radash";
+const getStoreByDomain = (event, stores) => {
+  const host = getRequestHost(event, { xForwardedHost: true });
+  return stores.find((s) => s.domain === host);
+};
+const getStoreByPath = (event, stores) => {
+  if (!event.path) {
+    return;
+  }
+  const url = new URL(
+    event.path,
+    `https://${getRequestHost(event, { xForwardedHost: true })}`
+  );
+  const prefix = url.pathname.split("/")[1];
+  return stores.find((shop) => prefix === shop.path);
+};
+export const convertStoresToList = (stores) => {
+  if (isArray(stores)) {
+    return stores;
+  }
+  return listify(stores, (_key, value) => ({ ...value }));
+};
+export function getCurrentShopForRequest(event, config) {
+  let $shopConfig;
+  const { shopSelector, stores } = config;
+  const storesList = convertStoresToList(stores);
+  const headers = getRequestHeaders(event);
+  const shopId = headers["x-shop-id"];
+  if (shopId) {
+    $shopConfig = storesList.find((s) => s.shopId === Number(shopId));
+  } else if (shopSelector === "domain") {
+    $shopConfig = getStoreByDomain(event, storesList);
+  } else if (shopSelector === "path") {
+    $shopConfig = getStoreByPath(event, storesList);
+  }
+  $shopConfig = $shopConfig || storesList[0];
+  if (!$shopConfig) {
+    throw new Error("Could not find shop config");
+  }
+  return $shopConfig;
+}
+export function getPublicShopData(data, currentShopId, apiBasePath, publicShopData = []) {
+  const additionalShopData = {};
+  publicShopData.forEach((key) => additionalShopData[key] = data[key]);
+  return {
+    domain: data.domain,
+    path: data.path,
+    locale: data.locale,
+    shopId: data.shopId,
+    currency: data.currency,
+    isActive: data.shopId === currentShopId,
+    checkout: {
+      host: data.checkout.host
+    },
+    apiBasePath,
+    ...additionalShopData
+  };
+}

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

@@ -0,0 +1,12 @@
+import { Cache as CacheInterface, Log } from '@scayle/storefront-core';
+import { RedisConfig, StorageProvider } from '../../../types/module';
+/**
+ * Create an unstorage-backed cache interface
+ * @param provider
+ * @param prefix
+ * @param log
+ * @param options
+ */
+export declare function createCache(provider: StorageProvider, prefix: string, log: Log, options?: {
+    redis?: RedisConfig;
+}): CacheInterface;

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

@@ -0,0 +1,44 @@
+import redisDriver from "unstorage/drivers/redis";
+import memoryDriver from "unstorage/drivers/memory";
+import { UnstorageCache } from "@scayle/storefront-core/dist/cache/providers/unstorage";
+import { createStorage } from "unstorage";
+const memoryStorage = memoryDriver();
+export function createCache(provider, prefix, log, options) {
+  if (provider === "memory") {
+    log.warn("Creating in-memory redirect cache");
+    log.warn("In-memory storage should not be used in production");
+    return new UnstorageCache(
+      createStorage({
+        driver: memoryStorage
+      }),
+      prefix
+    );
+  }
+  if (provider === "redis") {
+    const redisConfig = options?.redis;
+    if (!redisConfig) {
+      throw Error("options.redis must be specified for the redis provider");
+    }
+    const ioredisConfig = {
+      ..."user" in redisConfig && {
+        username: redisConfig.user
+      },
+      ..."password" in redisConfig && {
+        password: redisConfig.password
+      },
+      host: redisConfig.host,
+      port: redisConfig.port,
+      tls: redisConfig.sslTransit ? {} : void 0
+    };
+    log.debug(
+      `Creating redis redirect cache. host: ${ioredisConfig.host} port: ${ioredisConfig.port} db: ${ioredisConfig.db} tls: ${ioredisConfig.tls}`
+    );
+    return new UnstorageCache(
+      createStorage({
+        driver: redisDriver(ioredisConfig)
+      }),
+      prefix
+    );
+  }
+  throw Error("Unknown cache provider");
+}

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

@@ -0,0 +1,3 @@
+import { H3Event } from 'h3';
+import { JWTVerifyGetKey } from 'jose';
+export declare function useOauth(event: H3Event, jwks: JWTVerifyGetKey): Promise<void>;