@laioutr/app-shopware 0.15.4 → 0.17.0

package/dist/module.json

@@ -1,6 +1,6 @@
 {
   "name": "@laioutr/app-shopware",
-  "version": "0.15.4",
+  "version": "0.17.0",
   "configKey": "@laioutr/app-shopware",
   "builder": {
     "@nuxt/module-builder": "1.0.1",

package/dist/module.mjs

@@ -1,10 +1,10 @@
 import { defineNuxtModule, createResolver, addServerHandler, addPlugin, installModule } from '@nuxt/kit';
 import { defu } from 'defu';
-import { CHECKOUT_ENDPOINT_PATH, ADOPT_SESSION_ENDPOINT_PATH } from '../dist/runtime/server/const/checkout.js';
+import { CHECKOUT_ENDPOINT_PATH, ADOPT_SESSION_ENDPOINT_PATH, ORDER_HANDOFF_ENDPOINT_PATH } from '../dist/runtime/server/const/checkout.js';
 import { registerLaioutrApp } from '@laioutr-core/kit';
 
 const name = "@laioutr/app-shopware";
-const version = "0.15.4";
+const version = "0.17.0";
 
 const module$1 = defineNuxtModule({
   meta: {
@@ -36,6 +36,11 @@ const module$1 = defineNuxtModule({
       method: "post",
       handler: resolveRuntimeModule("./server/routes/adopt-session.post")
     });
+    addServerHandler({
+      route: ORDER_HANDOFF_ENDPOINT_PATH,
+      method: "post",
+      handler: resolveRuntimeModule("./server/routes/order-handoff.post")
+    });
     await registerLaioutrApp({
       name,
       version,

package/dist/runtime/app/components/ShopwareEmbedFrame.d.vue.ts

@@ -1,14 +1,24 @@
-declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+type __VLS_Props = {
+    /** Absolute URL of the page a completed order lands on. */
+    finishUrl?: string;
+    /** Absolute URL of this checkout page, used to re-frame a failed payment's retry. */
+    checkoutUrl?: string;
+    /** Order whose payment failed, re-framed on the storefront's order-edit page. */
+    retryOrderId?: string;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {
+    refreshHandoff: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "checkout-finish": (orderId: string) => any;
     "auth-changed": (payload: {
         from: string;
         code?: string;
     }) => any;
-}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     "onCheckout-finish"?: ((orderId: string) => any) | undefined;
     "onAuth-changed"?: ((payload: {
         from: string;
         code?: string;
     }) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 export default _default;

package/dist/runtime/app/components/ShopwareEmbedFrame.vue

@@ -1,21 +1,56 @@
 <script setup>
-import { computed, ref, useRuntimeConfig } from "#imports";
-import { CHECKOUT_ENDPOINT_PATH } from "../../shared/const/checkout";
+import { computed, onBeforeUnmount, ref, useRuntimeConfig } from "#imports";
+import {
+  CHECKOUT_CONFIRM_ROUTE,
+  CHECKOUT_ENDPOINT_PATH,
+  CHECKOUT_RETRY_ROUTE,
+  ORDER_HANDOFF_ENDPOINT_PATH,
+  RETRY_ORDER_QUERY_KEY
+} from "../../shared/const/checkout";
 import { useShopwareEmbedBridge } from "../composables/useShopwareEmbedBridge";
+import { createOrderHandoffRefresher } from "../lib/createOrderHandoffRefresher";
 const emit = defineEmits(["checkout-finish", "auth-changed"]);
+const props = defineProps({
+  finishUrl: { type: String, required: false },
+  checkoutUrl: { type: String, required: false },
+  retryOrderId: { type: String, required: false }
+});
 const storefrontOrigin = computed(() => useRuntimeConfig().public["@laioutr/app-shopware"]?.storefrontOrigin ?? "");
 const frameRef = ref(null);
 const height = ref();
 const loaded = ref(false);
+const handoff = createOrderHandoffRefresher({
+  mint: async () => {
+    try {
+      const response = await $fetch(ORDER_HANDOFF_ENDPOINT_PATH, {
+        method: "POST",
+        body: { finishUrl: props.finishUrl, checkoutUrl: props.checkoutUrl }
+      });
+      return response.code;
+    } catch {
+      return null;
+    }
+  },
+  deliver: (code) => sendOrderHandoff(code)
+});
 let hasShownFramePage = false;
-const onFramePageLoaded = () => {
+let handoffActive = false;
+const onFramePageLoaded = (payload) => {
   loaded.value = true;
+  const canReturn = Boolean(props.finishUrl) || payload.returnFallback;
+  const submitsAnOrder = payload.route === CHECKOUT_CONFIRM_ROUTE || payload.route === CHECKOUT_RETRY_ROUTE;
+  handoffActive = submitsAnOrder && canReturn;
+  if (handoffActive) {
+    handoff.start();
+  } else {
+    handoff.stop();
+  }
   if (hasShownFramePage) {
     window.scrollTo({ top: 0, left: 0 });
   }
   hasShownFramePage = true;
 };
-const { sendInit } = useShopwareEmbedBridge(frameRef, {
+const { sendInit, sendOrderHandoff } = useShopwareEmbedBridge(frameRef, {
   storefrontOrigin: storefrontOrigin.value,
   onResize: (value) => height.value = value,
   onPageLoaded: onFramePageLoaded,
@@ -23,10 +58,18 @@ const { sendInit } = useShopwareEmbedBridge(frameRef, {
   onAuthChanged: (payload) => emit("auth-changed", payload)
   // laioutr:pw-recovery is received but unused in v1.
 });
+const refreshHandoff = () => {
+  if (handoffActive) handoff.start();
+};
+defineExpose({ refreshHandoff });
+onBeforeUnmount(() => handoff.stop());
 const onFrameLoad = () => {
   loaded.value = true;
   sendInit();
 };
+const frameSrc = computed(
+  () => props.retryOrderId ? `${CHECKOUT_ENDPOINT_PATH}?${RETRY_ORDER_QUERY_KEY}=${encodeURIComponent(props.retryOrderId)}` : CHECKOUT_ENDPOINT_PATH
+);
 const frameStyle = computed(() => ({ height: height.value ? `${height.value}px` : "600px" }));
 </script>
 
@@ -42,7 +85,7 @@ const frameStyle = computed(() => ({ height: height.value ? `${height.value}px`
       </div>
       <iframe
         ref="frameRef"
-        :src="CHECKOUT_ENDPOINT_PATH"
+        :src="frameSrc"
         title="Checkout"
         class="shopware-embed-frame__iframe"
         :style="frameStyle"

package/dist/runtime/app/components/ShopwareEmbedFrame.vue.d.ts

@@ -1,14 +1,24 @@
-declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+type __VLS_Props = {
+    /** Absolute URL of the page a completed order lands on. */
+    finishUrl?: string;
+    /** Absolute URL of this checkout page, used to re-frame a failed payment's retry. */
+    checkoutUrl?: string;
+    /** Order whose payment failed, re-framed on the storefront's order-edit page. */
+    retryOrderId?: string;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {
+    refreshHandoff: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "checkout-finish": (orderId: string) => any;
     "auth-changed": (payload: {
         from: string;
         code?: string;
     }) => any;
-}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     "onCheckout-finish"?: ((orderId: string) => any) | undefined;
     "onAuth-changed"?: ((payload: {
         from: string;
         code?: string;
     }) => any) | undefined;
-}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 export default _default;

package/dist/runtime/app/composables/useShopwareEmbedBridge.d.ts

@@ -17,8 +17,10 @@ export type UseShopwareEmbedBridgeOptions = {
  *
  * Returns `sendInit` — call it on the iframe's `load` event to proactively complete the
  * handshake, since the plugin's one-shot `ready` can fire before this listener attaches
- * (the SSR iframe loads before Vue hydrates).
+ * (the SSR iframe loads before Vue hydrates) — and `sendOrderHandoff`, which hands the
+ * storefront a freshly minted code for its top-level order submit.
  */
 export declare const useShopwareEmbedBridge: (frameRef: Ref<HTMLIFrameElement | null>, options: UseShopwareEmbedBridgeOptions) => {
     sendInit: () => void;
+    sendOrderHandoff: (code: string) => void;
 };

package/dist/runtime/app/composables/useShopwareEmbedBridge.js

@@ -1,11 +1,15 @@
 import { onBeforeUnmount, onMounted } from "vue";
-import { buildInitMessage } from "../const/bridge.js";
+import {
+  buildInitMessage,
+  buildOrderHandoffMessage
+} from "../const/bridge.js";
 import { createBridgeHandler } from "../lib/createBridgeHandler.js";
 export const useShopwareEmbedBridge = (frameRef, options) => {
-  const { handleMessage, sendInit } = createBridgeHandler({
+  const { handleMessage, sendInit, sendOrderHandoff } = createBridgeHandler({
     getFrameWindow: () => frameRef.value?.contentWindow ?? null,
     storefrontOrigin: options.storefrontOrigin,
     postInit: (frameWindow, targetOrigin) => frameWindow.postMessage(buildInitMessage(), targetOrigin),
+    postOrderHandoff: (frameWindow, targetOrigin, code) => frameWindow.postMessage(buildOrderHandoffMessage(code), targetOrigin),
     onResize: options.onResize,
     onPageLoaded: options.onPageLoaded,
     onCheckoutFinish: options.onCheckoutFinish,
@@ -18,5 +22,5 @@ export const useShopwareEmbedBridge = (frameRef, options) => {
     sendInit();
   });
   onBeforeUnmount(() => window.removeEventListener("message", listener));
-  return { sendInit };
+  return { sendInit, sendOrderHandoff };
 };

package/dist/runtime/app/const/bridge.d.ts

@@ -10,6 +10,15 @@ export declare const BRIDGE_SOURCE = "laioutr-shopware";
 export declare const BRIDGE_VERSION = 1;
 /** Handshake reply this (parent) frame posts to pin the storefront origin. */
 export declare const BRIDGE_INIT_TYPE = "laioutr:init";
+/**
+ * Message this (parent) frame posts to hand the storefront a fresh single-use handoff code.
+ *
+ * The storefront's confirm form submits into the top-level window, which carries no storefront
+ * session of its own when the two sit on different registrable domains. The code travels in the
+ * form so the storefront can install one before the order is placed. Codes expire in about a
+ * minute, so this is posted repeatedly while the frame sits on the confirm page.
+ */
+export declare const BRIDGE_ORDER_HANDOFF_TYPE = "laioutr:order-handoff";
 /** Messages the storefront bridge sends to this (parent) frame. */
 export type BridgeInboundMessage = {
     type: 'laioutr:ready';
@@ -26,6 +35,8 @@ export type BridgeInboundMessage = {
         route: string | null;
         navigationId: string | null;
         salesChannelId: string | null;
+        /** Whether the storefront has a configured return URL of its own to fall back on. */
+        returnFallback: boolean;
     };
 } | {
     type: 'laioutr:checkout-finish';
@@ -61,3 +72,12 @@ export declare const buildInitMessage: () => {
     type: string;
     payload: {};
 };
+/** A freshly minted handoff code, posted to the pinned storefront origin. */
+export declare const buildOrderHandoffMessage: (code: string) => {
+    source: string;
+    version: number;
+    type: string;
+    payload: {
+        code: string;
+    };
+};

package/dist/runtime/app/const/bridge.js

@@ -1,9 +1,16 @@
 export const BRIDGE_SOURCE = "laioutr-shopware";
 export const BRIDGE_VERSION = 1;
 export const BRIDGE_INIT_TYPE = "laioutr:init";
+export const BRIDGE_ORDER_HANDOFF_TYPE = "laioutr:order-handoff";
 export const buildInitMessage = () => ({
   source: BRIDGE_SOURCE,
   version: BRIDGE_VERSION,
   type: BRIDGE_INIT_TYPE,
   payload: {}
 });
+export const buildOrderHandoffMessage = (code) => ({
+  source: BRIDGE_SOURCE,
+  version: BRIDGE_VERSION,
+  type: BRIDGE_ORDER_HANDOFF_TYPE,
+  payload: { code }
+});

package/dist/runtime/app/lib/createBridgeHandler.d.ts

@@ -12,6 +12,8 @@ export type CreateBridgeHandlerOptions = {
     storefrontOrigin: string;
     /** Post the contentless handshake reply to the (validated) origin. */
     postInit: (frameWindow: Window, targetOrigin: string) => void;
+    /** Post a freshly minted order-handoff code to the (validated) origin. */
+    postOrderHandoff: (frameWindow: Window, targetOrigin: string, code: string) => void;
     onResize?: (height: number) => void;
     onPageLoaded?: (payload: BridgePageLoadedPayload) => void;
     onCheckoutFinish?: (orderId: string) => void;
@@ -41,4 +43,5 @@ export type CreateBridgeHandlerOptions = {
 export declare const createBridgeHandler: (options: CreateBridgeHandlerOptions) => {
     handleMessage: (event: BridgeMessageEvent) => void;
     sendInit: () => void;
+    sendOrderHandoff: (code: string) => void;
 };

package/dist/runtime/app/lib/createBridgeHandler.js

@@ -7,6 +7,12 @@ export const createBridgeHandler = (options) => {
       options.postInit(frameWindow, options.storefrontOrigin);
     }
   };
+  const sendOrderHandoff = (code) => {
+    const frameWindow = options.getFrameWindow();
+    if (frameWindow && options.storefrontOrigin) {
+      options.postOrderHandoff(frameWindow, options.storefrontOrigin, code);
+    }
+  };
   const handleMessage = (event) => {
     const frameWindow = options.getFrameWindow();
     if (!frameWindow || event.source !== frameWindow) return;
@@ -36,5 +42,5 @@ export const createBridgeHandler = (options) => {
         message;
     }
   };
-  return { handleMessage, sendInit };
+  return { handleMessage, sendInit, sendOrderHandoff };
 };

package/dist/runtime/app/lib/createOrderHandoffRefresher.d.ts

@@ -0,0 +1,24 @@
+export type CreateOrderHandoffRefresherOptions = {
+    /** Mint a fresh single-use code, or resolve `null` when the mint failed. */
+    mint: () => Promise<string | null>;
+    /** Hand a freshly minted code to the storefront frame. */
+    deliver: (code: string) => void;
+    /** Overrides the re-mint cadence; must stay under the storefront's code lifetime. */
+    intervalMs?: number;
+};
+/**
+ * Keeps a fresh order-handoff code in the storefront frame for as long as the shopper sits on
+ * the confirm page.
+ *
+ * A code cannot be minted at submit time: minting is a round trip, and awaiting it inside the
+ * click handler outlives the transient user activation the top-level form submit depends on.
+ * Minting once on page load does not work either, since a shopper reading the terms outlives
+ * the code. So mint on a cadence and let the frame hold the newest one.
+ *
+ * Failures are swallowed by design — the frame keeps the previous code, and leaves the form
+ * submitting in-frame if it never received one.
+ */
+export declare const createOrderHandoffRefresher: (options: CreateOrderHandoffRefresherOptions) => {
+    start: () => void;
+    stop: () => void;
+};

package/dist/runtime/app/lib/createOrderHandoffRefresher.js

@@ -0,0 +1,21 @@
+const DEFAULT_INTERVAL_MS = 4e4;
+export const createOrderHandoffRefresher = (options) => {
+  let timer = null;
+  const tick = () => {
+    options.mint().then((code) => {
+      if (code) options.deliver(code);
+    }).catch(() => {
+    });
+  };
+  const stop = () => {
+    if (!timer) return;
+    clearInterval(timer);
+    timer = null;
+  };
+  const start = () => {
+    stop();
+    tick();
+    timer = setInterval(tick, options.intervalMs ?? DEFAULT_INTERVAL_MS);
+  };
+  return { start, stop };
+};

package/dist/runtime/app/lib/parseBridgeMessage.js

@@ -20,7 +20,8 @@ export const parseBridgeMessage = (data) => {
           path: payload.path,
           route: typeof payload.route === "string" ? payload.route : null,
           navigationId: typeof payload.navigationId === "string" ? payload.navigationId : null,
-          salesChannelId: typeof payload.salesChannelId === "string" ? payload.salesChannelId : null
+          salesChannelId: typeof payload.salesChannelId === "string" ? payload.salesChannelId : null,
+          returnFallback: payload.returnFallback === true
         }
       } : null;
     case "laioutr:auth-changed":

package/dist/runtime/app/sections/SectionShopwareCheckout.vue

@@ -16,6 +16,12 @@ export const definition = defineSection({
           name: "finishLink",
           label: "Order Confirmation Page",
           description: "If set, the customer is redirected here after completing an order, with the order id appended as ?order=. If left empty, Shopware\u2019s own order confirmation page is shown inside the checkout frame instead."
+        },
+        {
+          type: "link",
+          name: "checkoutLink",
+          label: "Checkout Page",
+          description: "The page this section sits on. Used to bring the customer back here when a payment fails or is cancelled, so they can choose another method without leaving the site."
         }
       ]
     }
@@ -24,21 +30,53 @@ export const definition = defineSection({
 </script>
 
 <script setup>
-import { defineSection, definitionToProps, linkResolver, navigateTo, refreshNuxtData } from "#imports";
-import { ADOPT_SESSION_ENDPOINT_PATH } from "../../shared/const/checkout";
+import {
+  computed,
+  defineSection,
+  definitionToProps,
+  linkResolver,
+  navigateTo,
+  ref,
+  refreshNuxtData,
+  useRoute
+} from "#imports";
+import { ADOPT_SESSION_ENDPOINT_PATH, RETRY_ORDER_QUERY_KEY } from "../../shared/const/checkout";
 import ShopwareEmbedFrame from "../components/ShopwareEmbedFrame.vue";
 const props = defineProps(definitionToProps(definition));
+const route = useRoute();
+const frame = ref(null);
+const toAbsolute = (path) => import.meta.client ? new URL(path, window.location.origin).href : path;
+const finishUrl = computed(() => props.finishLink ? toAbsolute(linkResolver.resolve(props.finishLink)) : void 0);
+const checkoutUrl = computed(
+  () => props.checkoutLink ? toAbsolute(linkResolver.resolve(props.checkoutLink)) : void 0
+);
+const retryOrderId = computed(() => {
+  const value = route.query[RETRY_ORDER_QUERY_KEY];
+  return typeof value === "string" ? value : void 0;
+});
 const onCheckoutFinish = async (orderId) => {
   if (!props.finishLink) return;
   const path = linkResolver.resolve(props.finishLink);
   await navigateTo({ path, query: { order: orderId } });
 };
 const onAuthChanged = async (payload) => {
-  await $fetch(ADOPT_SESSION_ENDPOINT_PATH, { method: "POST", body: { code: payload.code } });
+  try {
+    await $fetch(ADOPT_SESSION_ENDPOINT_PATH, { method: "POST", body: { code: payload.code } });
+  } catch (cause) {
+    console.warn("[app-shopware] could not adopt the storefront session", cause);
+  }
   await refreshNuxtData();
+  frame.value?.refreshHandoff();
 };
 </script>
 
 <template>
-  <ShopwareEmbedFrame @checkout-finish="onCheckoutFinish" @auth-changed="onAuthChanged" />
+  <ShopwareEmbedFrame
+    ref="frame"
+    :finish-url="finishUrl"
+    :checkout-url="checkoutUrl"
+    :retry-order-id="retryOrderId"
+    @checkout-finish="onCheckoutFinish"
+    @auth-changed="onAuthChanged"
+  />
 </template>

package/dist/runtime/server/const/checkout.d.ts

@@ -1,4 +1,4 @@
-export { ADOPT_SESSION_ENDPOINT_PATH, CHECKOUT_ENDPOINT_PATH } from '../../shared/const/checkout.js';
+export { ADOPT_SESSION_ENDPOINT_PATH, CHECKOUT_ENDPOINT_PATH, CHECKOUT_RETRY_ROUTE, ORDER_HANDOFF_ENDPOINT_PATH, RETRY_FRAME_MARKER_KEY, RETRY_ORDER_QUERY_KEY, } from '../../shared/const/checkout.js';
 /**
  * Internal Shopware route the handoff lands on after the storefront session adopts
  * the cart context. Resolved server-side by the `LaioutrConnector` plugin's

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

@@ -1,2 +1,10 @@
-export { ADOPT_SESSION_ENDPOINT_PATH, CHECKOUT_ENDPOINT_PATH } from "../../shared/const/checkout.js";
-export const CHECKOUT_REDIRECT_ROUTE = "frontend.checkout.confirm.page";
+import { CHECKOUT_CONFIRM_ROUTE } from "../../shared/const/checkout.js";
+export {
+  ADOPT_SESSION_ENDPOINT_PATH,
+  CHECKOUT_ENDPOINT_PATH,
+  CHECKOUT_RETRY_ROUTE,
+  ORDER_HANDOFF_ENDPOINT_PATH,
+  RETRY_FRAME_MARKER_KEY,
+  RETRY_ORDER_QUERY_KEY
+} from "../../shared/const/checkout.js";
+export const CHECKOUT_REDIRECT_ROUTE = CHECKOUT_CONFIRM_ROUTE;

package/dist/runtime/server/orchestr/product/base.resolver.js

@@ -6,6 +6,7 @@ import {
   ProductFlags,
   ProductInfo,
   ProductMedia,
+  ProductOptionGroups,
   ProductPrices,
   ProductRating,
   ProductSeo
@@ -16,6 +17,7 @@ import { defineShopwareComponentResolver } from "../../middleware/defineShopware
 import { fetchAllProducts } from "../../shopware-helper/fetchAllProductVariants.js";
 import { entitySlug } from "../../shopware-helper/mappers/slugMapper.js";
 import { mapMedia } from "../../shopware-helper/mediaMapper.js";
+import { mapProductOptionGroups } from "../../shopware-helper/optionGroupsMapper.js";
 import { swTranslated } from "../../shopware-helper/swTranslated.js";
 export default defineShopwareComponentResolver({
   label: "Shopware Product Connector",
@@ -29,6 +31,7 @@ export default defineShopwareComponentResolver({
     ProductSeo,
     ProductDescription,
     ProductDefaultVariant,
+    ProductOptionGroups,
     ProductRating
   ],
   resolve: async ({ entityIds, context, $entity, passthrough }) => {
@@ -40,7 +43,8 @@ export default defineShopwareComponentResolver({
       const response = await fetchAllProducts(context.storefrontClient, {
         productIds: missingIds,
         loadVariants: false,
-        resolveCriteria: context.resolveCriteria
+        resolveCriteria: context.resolveCriteria,
+        maxLimit: context.settings.maxLimit
       });
       loadedVariants.push(...response);
     }
@@ -64,8 +68,15 @@ export default defineShopwareComponentResolver({
           slug: entitySlug(rawProduct)
         },
         defaultVariant: {
-          id: rawVariant.id
+          id: rawVariant.id,
+          sku: rawVariant.productNumber ?? void 0,
+          // Typed locally because the resolver hands `rawVariant` back as `any`.
+          options: rawVariant.options?.map((option) => swTranslated(option, "name") ?? "").filter(Boolean),
+          status: rawVariant.available ? "inStock" : "outOfStock"
         },
+        // The configurator hangs off the parent, never the variant the rest of this
+        // projection reads from.
+        optionGroups: mapProductOptionGroups(rawProduct),
         info: {
           cover: mappedCover,
           shortDescription: swTranslated(rawProduct, "description") || swTranslated(rawVariant, "description"),
@@ -119,6 +130,11 @@ export default defineShopwareComponentResolver({
     components: {
       prices: {
         ttl: "15 minutes"
+      },
+      // Half of it is stock-derived, so it decays like prices rather than living for
+      // the resolver's full day. `optionGroups` needs no override: nothing in it is.
+      defaultVariant: {
+        ttl: "15 minutes"
       }
     }
   }

package/dist/runtime/server/orchestr/product/variants.link.js

@@ -6,16 +6,18 @@ export default defineShopwareLink(ProductVariantsLink, async ({ entityIds, conte
   const allVariants = passthrough.get(productVariantsToken) ?? await fetchAllProducts(context.storefrontClient, {
     productIds: entityIds,
     loadVariants: true,
-    resolveCriteria: context.resolveCriteria
+    resolveCriteria: context.resolveCriteria,
+    maxLimit: context.settings.maxLimit
   });
   passthrough.set(productVariantsToken, allVariants);
   return {
     links: entityIds.map((productId) => {
-      const product = allVariants.find((variant) => variant.id === productId);
+      const variants = allVariants.filter((variant) => variant.parentId === productId);
       return {
         sourceId: productId,
-        // A products children are its variants. If it has no children, it is a single variant product.
-        targetIds: product?.children && product?.children.length > 0 ? product?.children.map((child) => child.id) : [productId]
+        // A product's variants are the children this sales channel sells. With none of its own, the
+        // product is its single variant.
+        targetIds: variants.length > 0 ? variants.map((variant) => variant.id) : [productId]
       };
     })
   };

package/dist/runtime/server/orchestr/product-variant/base.resolver.js

@@ -15,6 +15,7 @@ import { resolveProductVariantFields } from "../../orchestr-helper/requestedFiel
 import { toRequestCriteria } from "../../shopware-helper/criteria.js";
 import { mapMedia } from "../../shopware-helper/mediaMapper.js";
 import { swTranslated } from "../../shopware-helper/swTranslated.js";
+import { guessWellKnownName } from "../../shopware-helper/wellKnownOptionName.js";
 export default defineShopwareComponentResolver({
   entityType: "ProductVariant",
   label: "Shopware Product Variant Connector",
@@ -119,10 +120,14 @@ export default defineShopwareComponentResolver({
             required: true
           }),
           options: () => ({
-            selected: entity.options?.map((option) => ({
-              name: swTranslated(option.group, "name") ?? swTranslated(option, "name") ?? "Unknown Property",
-              value: swTranslated(option, "name") ?? swTranslated(option, "option") ?? "Unknown Value"
-            })) ?? []
+            selected: entity.options?.map((option) => {
+              const name = swTranslated(option.group, "name") ?? swTranslated(option, "name") ?? "Unknown Property";
+              return {
+                name,
+                wellKnownName: guessWellKnownName(name),
+                value: swTranslated(option, "name") ?? swTranslated(option, "option") ?? "Unknown Value"
+              };
+            }) ?? []
           })
         })
       )

package/dist/runtime/server/orchestr-helper/requestedFields.d.ts

@@ -1,5 +1,3 @@
 import type { ResolveCriteria, ShopwareCriteria } from '../types/criteria.js';
-export declare const resolveProductFields: ({ loadVariants }: {
-    loadVariants: boolean;
-}, resolveCriteria: ResolveCriteria) => Promise<ShopwareCriteria>;
 export declare const resolveProductVariantFields: (resolveCriteria: ResolveCriteria) => Promise<ShopwareCriteria>;
+export declare const resolveProductFields: (resolveCriteria: ResolveCriteria) => Promise<ShopwareCriteria>;