@laioutr/app-shopware 0.15.4 → 0.17.0

package/dist/runtime/server/orchestr-helper/requestedFields.js

@@ -1,47 +1,5 @@
 import { MediaIncludes } from "../const/includes.js";
 import { mergeIncludes } from "../shopware-helper/criteria.js";
-const addAssociation = (name, add, association = {}) => add ? { [name]: association } : {};
-export const resolveProductFields = async ({ loadVariants }, resolveCriteria) => {
-  const variantFields = loadVariants ? await resolveProductVariantFields(resolveCriteria) : void 0;
-  return resolveCriteria("product", {
-    associations: {
-      cover: { associations: { media: {} } },
-      media: { associations: { media: {} } },
-      ...addAssociation("children", loadVariants, variantFields ? { associations: variantFields.associations } : {})
-    },
-    includes: mergeIncludes(
-      {
-        product: [
-          "id",
-          "parentId",
-          "name",
-          "seoUrls",
-          "productNumber",
-          "ean",
-          "translated",
-          "manufacturer",
-          "description",
-          "cover",
-          "metaTitle",
-          "metaDescription",
-          "cover",
-          "media",
-          "minPurchase",
-          "purchaseSteps",
-          "maxPurchase",
-          "calculatedPrice",
-          "calculatedPrices",
-          "children",
-          "ratingAverage",
-          "productReviews"
-        ],
-        product_media: ["id", "mediaId", "media"],
-        media: MediaIncludes
-      },
-      variantFields?.includes ?? {}
-    )
-  });
-};
 export const resolveProductVariantFields = async (resolveCriteria) => resolveCriteria("product-variant", {
   associations: {
     cover: { associations: { media: {} } },
@@ -86,3 +44,57 @@ export const resolveProductVariantFields = async (resolveCriteria) => resolveCri
     property_group: ["id", "name", "translated"]
   }
 });
+export const resolveProductFields = async (resolveCriteria) => {
+  const variantFields = await resolveProductVariantFields(resolveCriteria);
+  return resolveCriteria("product", {
+    associations: {
+      cover: { associations: { media: {} } },
+      media: { associations: { media: {} } },
+      // Only the parent carries the configurator, which is what defines the option
+      // axes; `properties` on the same row are filterable facets and never do.
+      // `media` needs its own association: without it the option's swatch image is
+      // never returned, whatever the group's displayType claims.
+      configuratorSettings: { associations: { option: { associations: { group: {}, media: {} } } } },
+      // Only the variant projection's `includes` are merged below, never its
+      // associations, so the selected options need associating here too or the
+      // default variant reports none.
+      options: { associations: { group: {} } }
+    },
+    includes: mergeIncludes(
+      {
+        product: [
+          "id",
+          "parentId",
+          "name",
+          "seoUrls",
+          "productNumber",
+          "ean",
+          "translated",
+          "manufacturer",
+          "description",
+          "cover",
+          "metaTitle",
+          "metaDescription",
+          "cover",
+          "media",
+          "minPurchase",
+          "purchaseSteps",
+          "maxPurchase",
+          "calculatedPrice",
+          "calculatedPrices",
+          "ratingAverage",
+          "productReviews",
+          "configuratorSettings"
+        ],
+        product_media: ["id", "mediaId", "media"],
+        media: MediaIncludes,
+        product_configurator_setting: ["id", "optionId", "option", "position"],
+        // Merged with the variant projection's narrower list, which carries neither
+        // the swatch fields nor the ordering the configurator is authored in.
+        property_group_option: ["colorHexCode", "media", "position"],
+        property_group: ["displayType", "position"]
+      },
+      variantFields.includes
+    )
+  });
+};

package/dist/runtime/server/routes/checkout.js

@@ -1,5 +1,14 @@
 import { consola } from "consola";
-import { createError, defineEventHandler, getCookie, getRequestURL, sendRedirect, useRuntimeConfig } from "#imports";
+import {
+  createError,
+  defineEventHandler,
+  getCookie,
+  getQuery,
+  getRequestURL,
+  sendRedirect,
+  useRuntimeConfig
+} from "#imports";
+import { RETRY_ORDER_QUERY_KEY } from "../const/checkout.js";
 import { CONTEXT_TOKEN_COOKIE } from "../const/cookieKeys.js";
 import { bootstrapGuestContextToken } from "../shopware-helper/bootstrapContextToken.js";
 import { persistContextToken } from "../shopware-helper/persistContextToken.js";
@@ -17,10 +26,12 @@ export default defineEventHandler(async (event) => {
       log.error("Failed to bootstrap a guest context token", cause);
     }
   }
+  const retryOrderId = getQuery(event)[RETRY_ORDER_QUERY_KEY];
   const plan = await resolveCheckout({
     config,
     contextToken,
     origin: getRequestURL(event).origin,
+    retryOrderId: typeof retryOrderId === "string" ? retryOrderId : null,
     mint: mintSessionHandoffCode
   });
   if (plan.kind === "error") {

package/dist/runtime/server/routes/order-handoff.post.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Mint a single-use session-handoff code for the embedded checkout's top-level order submit.
+ *
+ * The confirm form targets `_top` so redirect-based payment providers are never framed, and
+ * the storefront route it posts to redeems this code to install a session in the top-level
+ * cookie jar before forwarding to Shopware's order endpoint. Codes expire in about a minute,
+ * so the section re-mints while the shopper sits on the confirm page rather than once on load.
+ *
+ * The shopper reaches confirm through the checkout handoff, which bootstraps a context token
+ * when none exists — so a missing cookie here means the session was lost, not that the
+ * shopper is new. Fail rather than mint against a fresh guest cart the order would not match.
+ */
+declare const _default: any;
+export default _default;

package/dist/runtime/server/routes/order-handoff.post.js

@@ -0,0 +1,33 @@
+import { consola } from "consola";
+import { createError, defineEventHandler, getCookie, getRequestURL, readBody, useRuntimeConfig } from "#imports";
+import { CHECKOUT_REDIRECT_ROUTE } from "../const/checkout.js";
+import { CONTEXT_TOKEN_COOKIE } from "../const/cookieKeys.js";
+import { mintSessionHandoffCode } from "../shopware-helper/sessionHandoff.js";
+const log = consola.withTag("shopware/order-handoff");
+export default defineEventHandler(async (event) => {
+  const config = useRuntimeConfig()["@laioutr/app-shopware"];
+  const contextToken = getCookie(event, CONTEXT_TOKEN_COOKIE);
+  if (!contextToken) {
+    throw createError({ statusCode: 409, statusMessage: "No cart context to hand off" });
+  }
+  const origin = getRequestURL(event).origin;
+  const body = await readBody(event).catch(() => ({}));
+  const finishUrl = typeof body?.finishUrl === "string" ? body.finishUrl : void 0;
+  const checkoutUrl = typeof body?.checkoutUrl === "string" ? body.checkoutUrl : void 0;
+  try {
+    const code = await mintSessionHandoffCode({
+      endpoint: config.endpoint,
+      accessToken: config.accessToken,
+      contextToken,
+      loginSuccessCallback: config.checkoutLoginCallbackUrl ?? origin,
+      logoutSuccessCallback: config.checkoutLogoutCallbackUrl ?? origin,
+      redirectRoute: CHECKOUT_REDIRECT_ROUTE,
+      finishSuccessCallback: finishUrl,
+      checkoutCallback: checkoutUrl
+    });
+    return { code };
+  } catch (cause) {
+    log.error("Failed to mint an order handoff code", cause);
+    throw createError({ statusCode: 502, statusMessage: "Order handoff mint failed" });
+  }
+});

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

@@ -1,9 +1,10 @@
 import type { ResolveCriteria } from '../types/criteria.js';
 import { StorefrontClient } from '../types/shopware.js';
-export declare const fetchAllProducts: (storefrontClient: StorefrontClient, { productIds, loadVariants, resolveCriteria }: {
+export declare const fetchAllProducts: (storefrontClient: StorefrontClient, { productIds, loadVariants, resolveCriteria, maxLimit, }: {
     productIds: string[];
     loadVariants: boolean;
     resolveCriteria: ResolveCriteria;
+    maxLimit: number;
 }) => Promise<{
     active?: boolean;
     apiAlias: "product";

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

@@ -1,17 +1,45 @@
 import { toRequestCriteria } from "./criteria.js";
-import { resolveProductFields } from "../orchestr-helper/requestedFields.js";
-export const fetchAllProducts = async (storefrontClient, { productIds, loadVariants, resolveCriteria }) => {
+import { resolveProductFields, resolveProductVariantFields } from "../orchestr-helper/requestedFields.js";
+const readVariants = async (storefrontClient, { parentIds, resolveCriteria, maxLimit }) => {
+  const criteria = await resolveProductVariantFields(resolveCriteria);
+  const variants = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (let page = 1; ; page++) {
+    const response = await storefrontClient.invoke("readProduct post /product", {
+      body: {
+        page,
+        limit: maxLimit,
+        filter: [{ type: "equalsAny", field: "parentId", value: parentIds }],
+        ...toRequestCriteria(criteria)
+      }
+    });
+    const elements = response.data.elements ?? [];
+    const fresh = elements.filter((element) => element.id && !seen.has(element.id));
+    for (const element of fresh) seen.add(element.id);
+    variants.push(...fresh);
+    if (elements.length < maxLimit || fresh.length === 0) break;
+  }
+  return variants;
+};
+export const fetchAllProducts = async (storefrontClient, {
+  productIds,
+  loadVariants,
+  resolveCriteria,
+  maxLimit
+}) => {
   if (productIds.length === 0) {
     return [];
   }
-  const criteria = await resolveProductFields({ loadVariants }, resolveCriteria);
-  const response = await storefrontClient.invoke("readProduct post /product", {
-    body: {
-      ids: productIds,
-      ...toRequestCriteria(criteria)
-    }
-  });
+  const criteria = await resolveProductFields(resolveCriteria);
+  const [response, variants] = await Promise.all([
+    storefrontClient.invoke("readProduct post /product", {
+      body: {
+        ids: productIds,
+        ...toRequestCriteria(criteria)
+      }
+    }),
+    loadVariants ? readVariants(storefrontClient, { parentIds: productIds, resolveCriteria, maxLimit }) : []
+  ]);
   const products = response.data.elements ?? [];
-  const all = [...products.flatMap((product) => product.children ?? []), ...products];
-  return all;
+  return [...variants, ...products];
 };

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

@@ -0,0 +1,23 @@
+import type { ShopwareProduct } from '../types/shopware.js';
+import type { Swatch } from '@laioutr-core/core-types/common';
+/**
+ * The option axes a product offers, read from its configurator.
+ *
+ * The configurator is what defines a variant; `properties` on the same product are
+ * filterable facets and never do. Only the parent carries it, so this must be given
+ * the parent row rather than the variant the rest of the projection reads from.
+ *
+ * Per-value stock and a per-value variant id are deliberately absent: both would
+ * mean loading every child variant, which is the cost this component exists to
+ * avoid. A consumer that needs them falls back to the variants link.
+ */
+export declare const mapProductOptionGroups: (product: Pick<ShopwareProduct, "configuratorSettings">) => {
+    groups: {
+        name: string;
+        wellKnownName: import("@laioutr-core/canonical-types/entity/product-variant").WellKnownOptionName | undefined;
+        values: {
+            value: string;
+            swatch: Swatch | undefined;
+        }[];
+    }[];
+};

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

@@ -0,0 +1,37 @@
+import { mapMedia } from "./mediaMapper.js";
+import { swTranslated } from "./swTranslated.js";
+import { guessWellKnownName } from "./wellKnownOptionName.js";
+const byPosition = (a, b) => (a.position ?? 0) - (b.position ?? 0);
+const bySettingThenOption = (a, b) => (a.position ?? 0) - (b.position ?? 0) || (a.option.position ?? 0) - (b.option.position ?? 0);
+const mapSwatch = (option) => {
+  const hex = swTranslated(option, "colorHexCode") ?? option.colorHexCode;
+  if (hex) return ["color", hex];
+  const media = option.media ? mapMedia(option.media) : void 0;
+  return media?.type === "image" ? ["image", media] : void 0;
+};
+export const mapProductOptionGroups = (product) => {
+  const settings = (product.configuratorSettings ?? []).filter((setting) => !!setting.option);
+  const groups = /* @__PURE__ */ new Map();
+  for (const setting of settings) {
+    const group = setting.option.group;
+    const key = group?.id ?? swTranslated(group, "name") ?? "";
+    const existing = groups.get(key);
+    if (existing) {
+      existing.settings.push(setting);
+      continue;
+    }
+    groups.set(key, { name: swTranslated(group, "name") ?? "", position: group?.position ?? 0, settings: [setting] });
+  }
+  return {
+    groups: [...groups.values()].sort(byPosition).map((group) => ({
+      name: group.name,
+      wellKnownName: guessWellKnownName(group.name),
+      // The merchant's configurator order, which is what keeps a size run out of
+      // alphabetical order.
+      values: [...group.settings].sort(bySettingThenOption).map((setting) => ({
+        value: swTranslated(setting.option, "name") ?? "",
+        swatch: mapSwatch(setting.option)
+      }))
+    }))
+  };
+};

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

@@ -21,6 +21,8 @@ export interface ResolveCheckoutDeps {
     contextToken: string | null | undefined;
     /** Request origin used for the login/logout success callbacks. */
     origin: string;
+    /** Order to retry payment for, from the storefront's `retry-order` bounce. */
+    retryOrderId?: string | null;
     /** Injected minter (real: {@link mintSessionHandoffCode}) — keeps this decision logic pure/testable. */
     mint: (params: MintSessionHandoffParams) => Promise<string>;
 }

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

@@ -1,7 +1,7 @@
 import { buildConnectSessionUrl } from "./checkoutUrl.js";
-import { CHECKOUT_REDIRECT_ROUTE } from "../const/checkout.js";
+import { CHECKOUT_REDIRECT_ROUTE, CHECKOUT_RETRY_ROUTE, RETRY_FRAME_MARKER_KEY } from "../const/checkout.js";
 export const resolveCheckout = async (deps) => {
-  const { config, contextToken, origin, mint } = deps;
+  const { config, contextToken, origin, retryOrderId, mint } = deps;
   if (!contextToken) {
     return { kind: "redirect", url: "/" };
   }
@@ -15,7 +15,8 @@ export const resolveCheckout = async (deps) => {
       contextToken,
       loginSuccessCallback: config.checkoutLoginCallbackUrl ?? origin,
       logoutSuccessCallback: config.checkoutLogoutCallbackUrl ?? origin,
-      redirectRoute: CHECKOUT_REDIRECT_ROUTE
+      redirectRoute: retryOrderId ? CHECKOUT_RETRY_ROUTE : CHECKOUT_REDIRECT_ROUTE,
+      ...retryOrderId ? { redirectRouteParams: { orderId: retryOrderId, [RETRY_FRAME_MARKER_KEY]: "1" } } : {}
     });
     return { kind: "redirect", url: buildConnectSessionUrl({ storefrontUrl: config.storefrontUrl, code }) };
   } catch (cause) {

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

@@ -11,6 +11,12 @@ export interface MintSessionHandoffParams {
     logoutSuccessCallback: string;
     /** Internal Shopware route the handoff lands on after redeem. */
     redirectRoute: string;
+    /** Absolute URL of the laioutr page shown after a completed order. */
+    finishSuccessCallback?: string;
+    /** Absolute URL of the laioutr checkout page, used to re-frame a payment retry. */
+    checkoutCallback?: string;
+    /** Parameters for `redirectRoute`; the retry route is keyed by `orderId`. */
+    redirectRouteParams?: Record<string, string>;
 }
 /**
  * Mint a single-use session-handoff code against the `LaioutrConnector` plugin's

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

@@ -13,10 +13,15 @@ export const mintSessionHandoffCode = async (params) => {
         "sw-access-key": params.accessToken,
         "sw-context-token": params.contextToken
       },
+      // Undefined keys are omitted rather than sent as null, so a plugin build that predates
+      // the return trip still accepts the call.
       body: {
         "login-success-callback": params.loginSuccessCallback,
         "logout-success-callback": params.logoutSuccessCallback,
-        "redirect-route": params.redirectRoute
+        "redirect-route": params.redirectRoute,
+        ...params.finishSuccessCallback ? { "finish-success-callback": params.finishSuccessCallback } : {},
+        ...params.checkoutCallback ? { "checkout-callback": params.checkoutCallback } : {},
+        ...params.redirectRouteParams ? { "redirect-route-params": params.redirectRouteParams } : {}
       }
     });
   } catch (err) {

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

@@ -0,0 +1,2 @@
+import type { WellKnownOptionName } from '@laioutr-core/canonical-types/entity/product-variant';
+export declare const guessWellKnownName: (name: string) => WellKnownOptionName | undefined;

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

@@ -0,0 +1,278 @@
+const OPTION_NAME_ALIASES = {
+  color: [
+    "color",
+    // en (US), es
+    "colour",
+    // en (GB)
+    "farbe",
+    // de
+    "farbton",
+    // de — shade rather than colour, and a real axis name in the wild
+    "kleur",
+    // nl
+    "couleur",
+    // fr
+    "colore",
+    // it
+    "cor",
+    // pt
+    "kolor",
+    // pl
+    "barva",
+    // cs, sl
+    "farba",
+    // sk
+    "boja",
+    // hr
+    "sz\xEDn",
+    // hu
+    "culoare",
+    // ro
+    "\u0446\u0432\u044F\u0442",
+    // bg
+    "\u03C7\u03C1\u03CE\u03BC\u03B1",
+    // el
+    "f\xE4rg",
+    // sv
+    "farve",
+    // da
+    "farge",
+    // no
+    "v\xE4ri",
+    // fi
+    "litur",
+    // is
+    "v\xE4rv",
+    // et
+    "kr\u0101sa",
+    // lv
+    "spalva",
+    // lt
+    "renk",
+    // tr
+    "\u8272",
+    // ja
+    "\u30AB\u30E9\u30FC",
+    // ja
+    "\uC0C9\uC0C1",
+    // ko
+    "\uCEEC\uB7EC",
+    // ko
+    "\u989C\u8272",
+    // zh-Hans
+    "\u984F\u8272"
+    // zh-Hant
+  ],
+  size: [
+    "size",
+    // en
+    "gr\xF6\xDFe",
+    // de
+    "groesse",
+    // de, ASCII transliteration — "oe" survives diacritic folding
+    "maat",
+    // nl
+    "grootte",
+    // nl
+    "taille",
+    // fr
+    "pointure",
+    // fr, footwear
+    "taglia",
+    // it
+    "misura",
+    // it
+    "talla",
+    // es
+    "tama\xF1o",
+    // es
+    "tamanho",
+    // pt
+    "rozmiar",
+    // pl
+    "velikost",
+    // cs, sl
+    "ve\u013Ekos\u0165",
+    // sk
+    "veli\u010Dina",
+    // hr
+    "m\xE9ret",
+    // hu
+    "m\u0103rime",
+    // ro
+    "\u0440\u0430\u0437\u043C\u0435\u0440",
+    // bg
+    "\u03BC\u03AD\u03B3\u03B5\u03B8\u03BF\u03C2",
+    // el
+    "storlek",
+    // sv
+    "st\xF8rrelse",
+    // da, no
+    "koko",
+    // fi
+    "st\xE6r\xF0",
+    // is
+    "suurus",
+    // et
+    "izm\u0113rs",
+    // lv
+    "dydis",
+    // lt
+    "beden",
+    // tr
+    "\u30B5\u30A4\u30BA",
+    // ja
+    "\uC0AC\uC774\uC988",
+    // ko
+    "\uD06C\uAE30",
+    // ko
+    "\u5C3A\u5BF8",
+    // zh
+    "\u5C3A\u7801",
+    // zh-Hans
+    "\u5C3A\u78BC"
+    // zh-Hant
+  ],
+  material: [
+    "material",
+    // en, de, es, pt, ro, sv, sl, and cs/sk `materiál` once folded
+    "materiaal",
+    // nl
+    "mati\xE8re",
+    // fr
+    "mat\xE9riau",
+    // fr
+    "materiale",
+    // it, da, no
+    "materia\u0142",
+    // pl
+    "materijal",
+    // hr
+    "anyag",
+    // hu
+    "\u043C\u0430\u0442\u0435\u0440\u0438\u0430\u043B",
+    // bg
+    "\u03C5\u03BB\u03B9\u03BA\u03CC",
+    // el
+    "materiaali",
+    // fi
+    "efni",
+    // is
+    "materjal",
+    // et
+    "materi\u0101ls",
+    // lv
+    "med\u017Eiaga",
+    // lt
+    "malzeme",
+    // tr
+    "\u7D20\u6750",
+    // ja
+    "\u6750\u8CEA",
+    // ja, zh-Hant
+    "\uC18C\uC7AC",
+    // ko
+    "\uC7AC\uC9C8",
+    // ko
+    "\u6750\u6599",
+    // zh
+    "\u6750\u8D28"
+    // zh-Hans
+  ],
+  style: [
+    "style",
+    // en, fr
+    "stil",
+    // de, sv, da, no, hr, tr
+    "stijl",
+    // nl
+    "stile",
+    // it
+    "estilo",
+    // es, pt
+    "styl",
+    // pl, cs, and sk `štýl` once folded
+    "slog",
+    // sl
+    "st\xEDlus",
+    // hu
+    "\u0441\u0442\u0438\u043B",
+    // bg
+    "\u03C3\u03C4\u03C5\u03BB",
+    // el
+    "tyyli",
+    // fi
+    "st\xEDll",
+    // is
+    "stiil",
+    // et
+    "stils",
+    // lv
+    "stilius",
+    // lt
+    "\u30B9\u30BF\u30A4\u30EB",
+    // ja
+    "\uC2A4\uD0C0\uC77C",
+    // ko
+    "\u6B3E\u5F0F"
+    // zh
+  ],
+  type: [
+    "type",
+    // en, nl, fr, da, no
+    "typ",
+    // de, pl, cs, sk, sv
+    "tipo",
+    // it, es, pt
+    "tip",
+    // sl, hr, tr
+    "vrsta",
+    // sl, hr
+    "rodzaj",
+    // pl
+    "t\xEDpus",
+    // hu
+    "\u0442\u0438\u043F",
+    // bg
+    "\u03C4\u03CD\u03C0\u03BF\u03C2",
+    // el
+    "tyyppi",
+    // fi
+    "tegund",
+    // is
+    "t\xFC\xFCp",
+    // et
+    "veids",
+    // lv
+    "tipas",
+    // lt
+    "\u30BF\u30A4\u30D7",
+    // ja
+    "\u7A2E\u985E",
+    // ja
+    "\uC720\uD615",
+    // ko
+    "\uD0C0\uC785",
+    // ko
+    "\u7C7B\u578B",
+    // zh-Hans
+    "\u985E\u578B"
+    // zh-Hant
+  ]
+};
+const normalizeOptionName = (name) => name.trim().toLowerCase().replace(/ß/g, "ss").normalize("NFD").replace(/\p{M}/gu, "");
+const OPTION_NAME_LOOKUP = new Map(
+  Object.entries(OPTION_NAME_ALIASES).flatMap(
+    ([wellKnownName, aliases]) => aliases.map((alias) => [normalizeOptionName(alias), wellKnownName])
+  )
+);
+export const guessWellKnownName = (name) => {
+  const normalized = normalizeOptionName(name);
+  const exact = OPTION_NAME_LOOKUP.get(normalized);
+  if (exact) return exact;
+  for (const token of normalized.split(/[^\p{L}\p{N}]+/u)) {
+    const match = OPTION_NAME_LOOKUP.get(token);
+    if (match) return match;
+  }
+  return void 0;
+};