@laioutr/app-shopware 0.14.4

package/dist/runtime/server/shopware-helper/resolveCheckout.d.ts

@@ -0,0 +1,39 @@
+import type { MintSessionHandoffParams } from './sessionHandoff.js';
+/** Outcome of the checkout handoff decision: a redirect target, or a fail-closed error. */
+export type CheckoutPlan = {
+    kind: 'redirect';
+    url: string;
+} | {
+    kind: 'error';
+    statusCode: number;
+    statusMessage: string;
+    cause?: unknown;
+};
+export interface ResolveCheckoutDeps {
+    config: {
+        endpoint: string;
+        accessToken: string;
+        storefrontUrl?: string;
+        checkoutLoginCallbackUrl?: string;
+        checkoutLogoutCallbackUrl?: string;
+    };
+    /** Shopware context token from the request cookie (absent for a shopper with no cart yet). */
+    contextToken: string | null | undefined;
+    /** Request origin used for the login/logout success callbacks. */
+    origin: string;
+    /** Injected minter (real: {@link mintSessionHandoffCode}) — keeps this decision logic pure/testable. */
+    mint: (params: MintSessionHandoffParams) => Promise<string>;
+}
+/**
+ * Decide where a checkout click should send the shopper. Fail-closed and free of I/O beyond the
+ * injected `mint` call, so the whole outcome matrix is unit-testable without an h3 event:
+ *
+ * - no context cookie (empty cart) → redirect to the laioutr frontend root, no mint;
+ * - no `storefrontUrl` (misconfig) → 500, no mint;
+ * - mint succeeds → redirect to `connect-session?code=…`;
+ * - mint throws (e.g. callback not allowlisted) → 502.
+ *
+ * The Shopware storefront is only ever navigated to for an actual checkout handoff — never as a
+ * fallback. No branch mutates the cart.
+ */
+export declare const resolveCheckout: (deps: ResolveCheckoutDeps) => Promise<CheckoutPlan>;

package/dist/runtime/server/shopware-helper/resolveCheckout.js

@@ -0,0 +1,24 @@
+import { buildConnectSessionUrl } from "./checkoutUrl.js";
+import { CHECKOUT_REDIRECT_ROUTE } from "../const/checkout.js";
+export const resolveCheckout = async (deps) => {
+  const { config, contextToken, origin, mint } = deps;
+  if (!contextToken) {
+    return { kind: "redirect", url: "/" };
+  }
+  if (!config.storefrontUrl) {
+    return { kind: "error", statusCode: 500, statusMessage: "Checkout is not configured" };
+  }
+  try {
+    const code = await mint({
+      endpoint: config.endpoint,
+      accessToken: config.accessToken,
+      contextToken,
+      loginSuccessCallback: config.checkoutLoginCallbackUrl ?? origin,
+      logoutSuccessCallback: config.checkoutLogoutCallbackUrl ?? origin,
+      redirectRoute: CHECKOUT_REDIRECT_ROUTE
+    });
+    return { kind: "redirect", url: buildConnectSessionUrl({ storefrontUrl: config.storefrontUrl, code }) };
+  } catch (cause) {
+    return { kind: "error", statusCode: 502, statusMessage: "Checkout handoff failed", cause };
+  }
+};

package/dist/runtime/server/shopware-helper/sessionHandoff.d.ts

@@ -0,0 +1,27 @@
+export interface MintSessionHandoffParams {
+    /** Store-API base URL, e.g. `https://shop.example.com/store-api`. */
+    endpoint: string;
+    /** Sales-channel access key (sent as the `sw-access-key` header). */
+    accessToken: string;
+    /** Context token to hand off (sent as the `sw-context-token` header). */
+    contextToken: string;
+    /** Allowlist-validated URL the storefront returns to after a login inside checkout. */
+    loginSuccessCallback: string;
+    /** Allowlist-validated URL the storefront returns to after a logout inside checkout. */
+    logoutSuccessCallback: string;
+    /** Internal Shopware route the handoff lands on after redeem. */
+    redirectRoute: string;
+}
+/**
+ * Mint a single-use session-handoff code against the `LaioutrConnector` plugin's
+ * `POST /store-api/laioutr/session-handoff` endpoint.
+ *
+ * Called server-to-server: laioutr holds both the sales-channel access key and the
+ * shopper's `sw-context-token` (http-only cookie), so the raw token never reaches
+ * the browser. The returned code is opaque, single-use, and expires in ~60s.
+ *
+ * @throws with the plugin's rejection reason when the mint responds non-2xx or without a `code`.
+ *   A `400 "Callback domain is not allowed"` means the callback origin is not in the plugin's
+ *   `callbackDomainWildcard` allowlist.
+ */
+export declare const mintSessionHandoffCode: (params: MintSessionHandoffParams) => Promise<string>;

package/dist/runtime/server/shopware-helper/sessionHandoff.js

@@ -0,0 +1,29 @@
+const describeMintError = (err) => {
+  const e = err;
+  const apiError = e?.data?.errors?.[0];
+  return apiError?.detail ?? apiError?.title ?? e?.data?.message ?? e?.message ?? "unknown error";
+};
+export const mintSessionHandoffCode = async (params) => {
+  const base = params.endpoint.replace(/\/+$/, "");
+  let res;
+  try {
+    res = await $fetch(`${base}/laioutr/session-handoff`, {
+      method: "POST",
+      headers: {
+        "sw-access-key": params.accessToken,
+        "sw-context-token": params.contextToken
+      },
+      body: {
+        "login-success-callback": params.loginSuccessCallback,
+        "logout-success-callback": params.logoutSuccessCallback,
+        "redirect-route": params.redirectRoute
+      }
+    });
+  } catch (err) {
+    throw new Error(`session-handoff mint rejected: ${describeMintError(err)}`);
+  }
+  if (!res?.code) {
+    throw new Error("session-handoff mint returned no code");
+  }
+  return res.code;
+};

package/dist/runtime/server/shopware-helper/sortingMapper.d.ts

@@ -0,0 +1,3 @@
+import type { components } from '../types/storeApiTypes.js';
+import type { AvailableSorting } from '@laioutr-core/orchestr/types';
+export declare const mapShopwareSortingToOrchestr: (sortings: components["schemas"]["ProductListingResult"]["availableSortings"]) => AvailableSorting[];

package/dist/runtime/server/shopware-helper/sortingMapper.js

@@ -0,0 +1,7 @@
+export const mapShopwareSortingToOrchestr = (sortings) => {
+  const sortedSortings = [...sortings].sort((a, b) => a.priority - b.priority);
+  return sortedSortings.map((sorting) => ({
+    key: sorting.key,
+    label: sorting.translated.label
+  }));
+};

package/dist/runtime/server/shopware-helper/storeApiPageFetcher.d.ts

@@ -0,0 +1,20 @@
+import type { PageIndexEntry } from '@laioutr-core/core-types/orchestr';
+/** Shopware's store API caps `limit` at MAX_LIMIT; a larger value is rejected with a 400. */
+export declare const SHOPWARE_MAX_LIMIT = 100;
+/**
+ * Build the page-fetch closure `paginate` drives for a store-API list endpoint paged by number.
+ *
+ * Takes a read thunk rather than an endpoint name so the caller keeps the client's per-operation
+ * typing, and stays free of `#imports` so it remains unit-testable — the handler owns `paginate`.
+ */
+export declare const storeApiPageFetcher: <TItem>(readPage: (args: {
+    page: number;
+    limit: number;
+}) => Promise<{
+    elements?: TItem[];
+}>, toEntry: (item: TItem) => PageIndexEntry, batchSize: number) => ({ cursor }: {
+    cursor: string | undefined;
+}) => Promise<{
+    entries: PageIndexEntry[];
+    nextCursor: string | undefined;
+}>;

package/dist/runtime/server/shopware-helper/storeApiPageFetcher.js

@@ -0,0 +1,10 @@
+export const SHOPWARE_MAX_LIMIT = 100;
+export const storeApiPageFetcher = (readPage, toEntry, batchSize) => async ({ cursor }) => {
+  const page = cursor ? Number(cursor) : 1;
+  const elements = (await readPage({ page, limit: batchSize })).elements ?? [];
+  return {
+    entries: elements.map(toEntry),
+    // A short page ends the walk; an enumeration that divides exactly costs one extra empty read.
+    nextCursor: elements.length < batchSize ? void 0 : String(page + 1)
+  };
+};

package/dist/runtime/server/shopware-helper/swTranslated.d.ts

@@ -0,0 +1,7 @@
+export declare const swTranslatedRaw: (rawEntity: any, key: PropertyKey) => any;
+type SwTranslatable = {
+    translated?: any;
+};
+type SwTranslatableKeys<TEntity extends SwTranslatable> = keyof Exclude<TEntity['translated'], undefined>;
+export declare function swTranslated<TEntity extends SwTranslatable, TKey extends SwTranslatableKeys<TEntity> & keyof TEntity>(rawEntity: TEntity | undefined, key: TKey & keyof TEntity): TEntity[TKey];
+export {};

package/dist/runtime/server/shopware-helper/swTranslated.js

@@ -0,0 +1,4 @@
+export const swTranslatedRaw = (rawEntity, key) => rawEntity?.translated?.[key] ?? rawEntity?.[key];
+export function swTranslated(rawEntity, key) {
+  return swTranslatedRaw(rawEntity, key);
+}

package/dist/runtime/server/shopware-helper/system/getCurrentSystemEntities.d.ts

@@ -0,0 +1,20 @@
+import { SwSystemEntities } from './getSystemEntities.js';
+import { ClientEnv } from '@laioutr-core/orchestr/types';
+export declare const getCurrentSystemEntities: (systemIds: SwSystemEntities, clientEnv: ClientEnv) => {
+    locale: {
+        id: string;
+        languageId: string;
+        iso: string;
+    };
+    currency: {
+        id: string;
+        name: string;
+        iso: string;
+    };
+    country: {
+        id: string;
+        iso: string | undefined;
+        iso3: string | undefined;
+        name: string;
+    };
+};

package/dist/runtime/server/shopware-helper/system/getCurrentSystemEntities.js

@@ -0,0 +1,39 @@
+const findBestLocale = (swLocales, clientLocale) => {
+  if (swLocales.length === 0) {
+    throw new Error("No locales available");
+  }
+  const normalizeLocale = (locale) => locale.replace("_", "-").toLowerCase();
+  const normalizedClientLocale = normalizeLocale(clientLocale);
+  const normalizedSwLocales = swLocales.map((locale) => ({
+    ...locale,
+    iso: normalizeLocale(locale.iso)
+  }));
+  const exactMatch = normalizedSwLocales.find((locale) => locale.iso === normalizedClientLocale);
+  if (exactMatch) {
+    return swLocales.find((locale) => locale.id === exactMatch.id);
+  }
+  const clientLanguage = normalizedClientLocale.split("-")[0];
+  const languageMatch = normalizedSwLocales.find((locale) => {
+    const swLanguage = locale.iso.split("-")[0];
+    return swLanguage === clientLanguage;
+  });
+  if (languageMatch) {
+    return swLocales.find((locale) => locale.id === languageMatch.id);
+  }
+  const englishMatch = normalizedSwLocales.find((locale) => locale.iso.startsWith("en"));
+  if (englishMatch) {
+    return swLocales.find((locale) => locale.id === englishMatch.id);
+  }
+  return swLocales[0];
+};
+export const getCurrentSystemEntities = (systemIds, clientEnv) => {
+  const clientLocale = new Intl.Locale(clientEnv.locale);
+  const locale = findBestLocale(systemIds.locales, clientEnv.locale);
+  const currency = systemIds.currencies.find((currency2) => currency2.iso === clientEnv.currency) ?? systemIds.currencies[0];
+  const country = systemIds.countries.find((country2) => country2.iso === clientLocale.region) ?? systemIds.countries[0];
+  return {
+    locale,
+    currency,
+    country
+  };
+};

package/dist/runtime/server/shopware-helper/system/getSystemEntities.d.ts

@@ -0,0 +1,31 @@
+import { StorefrontClient } from '../../types/shopware.js';
+export type SwSystemEntities = Awaited<ReturnType<typeof getSystemEntities>>;
+export type SwSystemLocale = SwSystemEntities['locales'][number];
+/**
+ * Shopware wants us to send ids for certain system entities.
+ * This function fetches all of the relevant ones and returns them aggregated for further use.
+ */
+export declare const getSystemEntities: (client: StorefrontClient) => Promise<{
+    currencies: {
+        id: string;
+        name: string;
+        iso: string;
+    }[];
+    salutations: {
+        id: string;
+        key: string;
+        displayName: string;
+    }[];
+    countries: {
+        id: string;
+        iso: string | undefined;
+        iso3: string | undefined;
+        name: string;
+    }[];
+    locales: {
+        id: string;
+        languageId: string;
+        iso: string;
+    }[];
+}>;
+export declare const getCachedSystemEntities: (client: StorefrontClient) => Promise<any>;

package/dist/runtime/server/shopware-helper/system/getSystemEntities.js

@@ -0,0 +1,47 @@
+import { useRuntimeConfig, useUserlandCache } from "#imports";
+import { swTranslated } from "../swTranslated.js";
+export const getSystemEntities = async (client) => {
+  const rawCurrencies = await client.invoke("readCurrency post /currency");
+  const currencies = rawCurrencies.data.map((currency) => ({
+    id: currency.id,
+    name: swTranslated(currency, "name"),
+    iso: swTranslated(currency, "isoCode")
+  }));
+  const rawSalutations = await client.invoke("readSalutation post /salutation");
+  const salutations = rawSalutations.data.elements?.map((salutation) => ({
+    id: salutation.id,
+    key: salutation.salutationKey,
+    displayName: swTranslated(salutation, "displayName")
+  })) ?? [];
+  const rawCountries = await client.invoke("readCountry post /country");
+  const countries = rawCountries.data.elements?.map((country) => ({
+    id: country.id,
+    iso: country.iso,
+    iso3: country.iso3,
+    name: swTranslated(country, "name")
+  })) ?? [];
+  const rawLanguages = await client.invoke("readLanguages post /language");
+  const locales = rawLanguages.data.elements?.map((language) => ({
+    id: language.localeId,
+    languageId: language.id,
+    iso: swTranslated(language.locale, "code") ?? swTranslated(language.translationCode, "code")
+  })) ?? [];
+  return {
+    currencies,
+    salutations,
+    countries,
+    locales
+  };
+};
+const SYSTEM_ENTITIES_TTL = 60 * 60 * 24;
+export const getCachedSystemEntities = async (client) => {
+  const accessToken = useRuntimeConfig()["@laioutr/app-shopware"].accessToken;
+  const cache = useUserlandCache(`shopware:${accessToken}:system-entities`);
+  const cachedSystemEntities = await cache.getItem("default");
+  if (cachedSystemEntities) {
+    return cachedSystemEntities;
+  }
+  const systemEntities = await getSystemEntities(client);
+  await cache.setItem("default", systemEntities, { ttl: SYSTEM_ENTITIES_TTL });
+  return systemEntities;
+};

package/dist/runtime/server/shopware-helper/useSeoResolver.d.ts

@@ -0,0 +1,11 @@
+import { StorefrontClient } from '../types/shopware.js';
+type SeoUrlType = 'product' | 'category';
+interface SeoEntry {
+    type: SeoUrlType;
+    id: string;
+    matchedPath: string;
+}
+export declare const useSeoResolver: (storefrontClient: StorefrontClient) => {
+    resolve: (type: SeoUrlType, slug: string) => Promise<SeoEntry | undefined>;
+};
+export {};

package/dist/runtime/server/shopware-helper/useSeoResolver.js

@@ -0,0 +1,70 @@
+import { extractShopwareId, isShopwareId } from "./isShopwareId.js";
+import { isSlugMatchingSeoPath } from "./mappers/slugMapper.js";
+import { useUserlandCache } from "#imports";
+const typeToRouteNames = {
+  product: ["frontend.detail.page"],
+  category: ["frontend.navigation.page", "frontend.landing.page"]
+};
+const SEO_ENTRY_TTL = 60 * 60 * 24;
+export const useSeoResolver = (storefrontClient) => {
+  const cache = useUserlandCache("shopware/seo-urls");
+  const resolve = async (type, slug) => {
+    const languageId = storefrontClient.defaultHeaders["sw-language-id"] ?? "default";
+    const cacheKey = `${languageId}:${type}-${slug}`;
+    const cachedSlug = await cache.getItem(cacheKey);
+    if (cachedSlug) {
+      return cachedSlug;
+    }
+    const shopwareId = extractShopwareId(slug);
+    if (shopwareId) {
+      return {
+        type,
+        id: shopwareId,
+        matchedPath: slug
+      };
+    }
+    const response = await storefrontClient.invoke("readSeoUrl post /seo-url", {
+      body: {
+        filter: [
+          {
+            type: "multi",
+            operator: "and",
+            queries: [
+              {
+                type: "multi",
+                operator: "or",
+                queries: [
+                  { field: "seoPathInfo", type: "contains", value: slug },
+                  { field: "seoPathInfo", type: "equals", value: slug }
+                ]
+              },
+              { field: "routeName", type: "equalsAny", value: typeToRouteNames[type] }
+            ]
+          }
+        ]
+      }
+    });
+    const exactMatch = response.data.elements.find((element) => element.seoPathInfo === slug);
+    const bestMatch = exactMatch ?? response.data.elements.find((element) => isSlugMatchingSeoPath(slug, element.seoPathInfo));
+    if (!bestMatch && isShopwareId(slug)) {
+      return {
+        type,
+        id: slug,
+        matchedPath: slug
+      };
+    }
+    if (!bestMatch) {
+      return void 0;
+    }
+    const entry = {
+      type,
+      id: bestMatch.foreignKey,
+      matchedPath: bestMatch.seoPathInfo
+    };
+    await cache.setItem(cacheKey, entry, { ttl: SEO_ENTRY_TTL });
+    return entry;
+  };
+  return {
+    resolve
+  };
+};

package/dist/runtime/server/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../../.nuxt/tsconfig.server.json"
+}

package/dist/runtime/server/types/shopware.d.ts

@@ -0,0 +1,29 @@
+import { createAPIClient } from '@shopware/api-client';
+import type { components, operations } from './storeApiTypes.js';
+export type ShopwareProduct = components['schemas']['Product'];
+export type ShopwareProductReview = components['schemas']['ProductReview'];
+export type ShopwareCategory = components['schemas']['Category'];
+export type ShopwareFilters = components['schemas']['Filters'];
+export type ShopwareManufacturer = components['schemas']['ProductManufacturer'];
+export type ShopwareSeoUrl = components['schemas']['SeoUrl'];
+export type StorefrontClient = ReturnType<typeof createAPIClient<operations>>;
+export type ShopwareIncludesQuery = components['schemas']['Include'];
+export type ShopwareAssociationsQuery = components['schemas']['Association'];
+export type WithSeoUrl = {
+    seoUrls?: ShopwareSeoUrl[];
+};
+export type ShopwareExtensions = {
+    extensions?: {
+        completionResult?: Record<string, string>;
+        multiSuggestResult?: {
+            suggestResults?: {
+                product_manufacturer?: {
+                    elements: Record<string, ShopwareManufacturer>;
+                };
+                category?: {
+                    elements: Record<string, ShopwareCategory>;
+                };
+            };
+        };
+    };
+};