@laioutr/app-shopware 0.14.4

package/dist/runtime/server/orchestr/cart/cart-items.link.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/orchestr/cart/cart-items.link.js

@@ -0,0 +1,10 @@
+import { CartItemsLink } from "@laioutr-core/canonical-types/ecommerce";
+import { cartFragmentToken } from "../../const/passthroughTokens.js";
+import { defineShopwareLink } from "../../middleware/defineShopware.js";
+import { getCart } from "../../shopware-helper/getCart.js";
+export default defineShopwareLink(CartItemsLink, async ({ context, passthrough }) => {
+  const cart = passthrough.get(cartFragmentToken) ?? await getCart(context.storefrontClient);
+  passthrough.set(cartFragmentToken, cart);
+  const targetIds = (cart.lineItems ?? []).filter((li) => li.type === "product").map((li) => li.id);
+  return { links: [{ sourceId: cart.token ?? "", targetIds }] };
+});

package/dist/runtime/server/orchestr/cart/get-checkout-url.action.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Returns the stable, same-origin checkout URL. The single-use session-handoff code
+ * is minted server-side when the browser navigates to this route (see
+ * `server/routes/checkout.ts`), so the URL itself is safe to render and cache.
+ *
+ * This mirrors the `checkoutLink` on the Cart component resolver — both resolve to
+ * {@link CHECKOUT_ENDPOINT_PATH}.
+ */
+declare const _default: any;
+export default _default;

package/dist/runtime/server/orchestr/cart/get-checkout-url.action.js

@@ -0,0 +1,6 @@
+import { GetCheckoutUrlAction } from "@laioutr-core/canonical-types/ecommerce";
+import { CHECKOUT_ENDPOINT_PATH } from "../../const/checkout.js";
+import { defineShopwareAction } from "../../middleware/defineShopware.js";
+export default defineShopwareAction(GetCheckoutUrlAction, async () => ({
+  checkoutUrl: CHECKOUT_ENDPOINT_PATH
+}));

package/dist/runtime/server/orchestr/cart/get-current.query.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/orchestr/cart/get-current.query.js

@@ -0,0 +1,9 @@
+import { GetCurrentCartQuery } from "@laioutr-core/canonical-types/ecommerce";
+import { cartFragmentToken } from "../../const/passthroughTokens.js";
+import { defineShopwareQuery } from "../../middleware/defineShopware.js";
+import { getCart } from "../../shopware-helper/getCart.js";
+export default defineShopwareQuery(GetCurrentCartQuery, async ({ context, passthrough }) => {
+  const cart = passthrough.get(cartFragmentToken) ?? await getCart(context.storefrontClient);
+  passthrough.set(cartFragmentToken, cart);
+  return { id: cart.token ?? "" };
+});

package/dist/runtime/server/orchestr/cart/remove-items.action.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/orchestr/cart/remove-items.action.js

@@ -0,0 +1,14 @@
+import { CartRemoveItemsAction } from "@laioutr-core/canonical-types/ecommerce";
+import { defineShopwareAction } from "../../middleware/defineShopware.js";
+import { handleCartMutationErrors } from "../../shopware-helper/cartErrors.js";
+import { persistContextToken } from "../../shopware-helper/persistContextToken.js";
+export default defineShopwareAction(CartRemoveItemsAction, async ({ event, context, input }) => {
+  const { storefrontClient } = context;
+  if (input.length === 0) return;
+  const cart = await storefrontClient.invoke("removeLineItem post /checkout/cart/line-item/delete", {
+    // The store-api types the ids as a non-empty tuple; the length guard above satisfies it.
+    body: { ids: input }
+  });
+  await persistContextToken(event, cart.data.token);
+  handleCartMutationErrors(cart.data.errors);
+});

package/dist/runtime/server/orchestr/cart/update-items.action.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/orchestr/cart/update-items.action.js

@@ -0,0 +1,16 @@
+import { CartUpdateItemsAction } from "@laioutr-core/canonical-types/ecommerce";
+import { defineShopwareAction } from "../../middleware/defineShopware.js";
+import { handleCartMutationErrors } from "../../shopware-helper/cartErrors.js";
+import { persistContextToken } from "../../shopware-helper/persistContextToken.js";
+export default defineShopwareAction(CartUpdateItemsAction, async ({ event, context, input }) => {
+  const { storefrontClient } = context;
+  const items = input.filter((item) => item.quantity !== void 0).map((item) => ({ id: item.itemId, quantity: item.quantity }));
+  if (items.length === 0) return;
+  const cart = await storefrontClient.invoke("updateLineItem patch /checkout/cart/line-item", {
+    // Shopware only needs id + quantity to update a line item; the generated LineItem
+    // type over-specifies required fields, so we send the minimal shape and cast.
+    body: { items }
+  });
+  await persistContextToken(event, cart.data.token);
+  handleCartMutationErrors(cart.data.errors);
+});

package/dist/runtime/server/orchestr/cart-item/base.resolver.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/orchestr/cart-item/base.resolver.js

@@ -0,0 +1,33 @@
+import {
+  CartItemAvailability,
+  CartItemBase,
+  CartItemCost,
+  CartItemProductData,
+  CartItemQuantityRule
+} from "@laioutr-core/canonical-types/entity/cart-item";
+import { cartFragmentToken } from "../../const/passthroughTokens.js";
+import { defineShopwareComponentResolver } from "../../middleware/defineShopware.js";
+import { mapCartItem } from "../../shopware-helper/cartMapper.js";
+import { getCart } from "../../shopware-helper/getCart.js";
+export default defineShopwareComponentResolver({
+  entityType: "CartItem",
+  label: "Shopware Cart Item Component Resolver",
+  provides: [CartItemBase, CartItemCost, CartItemAvailability, CartItemQuantityRule, CartItemProductData],
+  resolve: async ({ entityIds, context, $entity, passthrough }) => {
+    const cart = passthrough.get(cartFragmentToken) ?? await getCart(context.storefrontClient);
+    passthrough.set(cartFragmentToken, cart);
+    const lineItemsById = new Map((cart.lineItems ?? []).map((li) => [li.id, li]));
+    const entities = entityIds.map((id) => lineItemsById.get(id)).filter((li) => !!li && li.type === "product").map((li) => {
+      const mapped = mapCartItem(li, context.swCurrency);
+      return $entity({
+        id: li.id,
+        base: () => mapped.base,
+        cost: () => mapped.cost,
+        availability: () => mapped.availability,
+        quantityRule: () => mapped.quantityRule,
+        productData: () => mapped.productData
+      });
+    });
+    return { entities };
+  }
+});

package/dist/runtime/server/orchestr/category/all.query.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/orchestr/category/all.query.js

@@ -0,0 +1,15 @@
+import { CategoryAllQuery } from "@laioutr-core/canonical-types/ecommerce";
+import { defineShopwareQuery } from "../../middleware/defineShopware.js";
+export default defineShopwareQuery(CategoryAllQuery, async ({ context, pagination }) => {
+  const { storefrontClient } = context;
+  const response = await storefrontClient.invoke("readCategoryList post /category", {
+    body: {
+      page: pagination.page,
+      limit: pagination.limit,
+      includes: {
+        category: ["id"]
+      }
+    }
+  });
+  return { ids: (response.data.elements ?? [])?.map((element) => element.id) };
+});

package/dist/runtime/server/orchestr/category/base.resolver.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

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

@@ -0,0 +1,47 @@
+import { CategoryBase, CategoryContent, CategoryMedia, CategorySeo } from "@laioutr-core/canonical-types/entity/category";
+import { categoriesToken } from "../../const/passthroughTokens.js";
+import { defineShopwareComponentResolver } from "../../middleware/defineShopware.js";
+import { entitySlug } from "../../shopware-helper/mappers/slugMapper.js";
+import { mapMedia } from "../../shopware-helper/mediaMapper.js";
+import { swTranslated } from "../../shopware-helper/swTranslated.js";
+export default defineShopwareComponentResolver({
+  entityType: "Category",
+  label: "Shopware Category Connector",
+  provides: [CategoryBase, CategoryContent, CategoryMedia, CategorySeo],
+  resolve: async ({ entityIds, context, passthrough, $entity }) => {
+    const { storefrontClient } = context;
+    const categories = passthrough.has(categoriesToken) ? passthrough.get(categoriesToken) : (await storefrontClient.invoke("readCategoryList post /category", {
+      // Neither association is returned by default; without `media` the media component is always empty.
+      body: { ids: entityIds, associations: { seoUrls: {}, media: {} } }
+    })).data.elements;
+    if (!categories) {
+      throw new Error(
+        "Categories not found in passthrough. The component resolver does not request categories from shopware at the moment."
+      );
+    }
+    return {
+      entities: categories.filter((category) => entityIds.includes(category.id)).map(
+        (category) => $entity({
+          id: category.id,
+          base: () => ({
+            slug: entitySlug(category),
+            title: swTranslated(category, "name") ?? category.name
+          }),
+          content: () => ({
+            description: { html: swTranslated(category, "description") ?? category.description ?? "" }
+          }),
+          media: () => ({
+            media: category.media ? [mapMedia(category.media)] : []
+          }),
+          seo: () => ({
+            title: category.metaTitle,
+            description: category.metaDescription
+          })
+        })
+      )
+    };
+  },
+  cache: {
+    ttl: "10 minutes"
+  }
+});

package/dist/runtime/server/orchestr/category/bySlug.query.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/orchestr/category/bySlug.query.js

@@ -0,0 +1,12 @@
+import { CategoryBySlugQuery } from "@laioutr-core/canonical-types/ecommerce";
+import { defineShopwareQuery } from "../../middleware/defineShopware.js";
+import { useSeoResolver } from "../../shopware-helper/useSeoResolver.js";
+export default defineShopwareQuery(CategoryBySlugQuery, async ({ context, input }) => {
+  const { slug } = input;
+  const seoResolver = useSeoResolver(context.storefrontClient);
+  const seoEntry = await seoResolver.resolve("category", slug);
+  if (!seoEntry) {
+    throw new Error(`No seo url found for category slug: ${slug}`);
+  }
+  return { id: seoEntry.id };
+});

package/dist/runtime/server/orchestr/category/child-categories.link.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/orchestr/category/child-categories.link.js

@@ -0,0 +1,36 @@
+import { ChildCategoriesLink } from "@laioutr-core/canonical-types/ecommerce";
+import { defineShopwareLink } from "../../middleware/defineShopware.js";
+const readChildren = async (storefrontClient, categoryId) => {
+  const response = await storefrontClient.invoke("readNavigation post /navigation/{activeId}/{rootId}", {
+    pathParams: { activeId: categoryId, rootId: categoryId },
+    body: {
+      depth: 1,
+      // A projection, so unlike a filter it removes no rows and cannot disturb the server's order.
+      includes: { category: ["id"] }
+    }
+  });
+  return response.data ?? [];
+};
+export default defineShopwareLink({
+  implements: ChildCategoriesLink,
+  run: async ({ entityIds, context, pagination }) => {
+    if (entityIds.length === 0) return { links: [] };
+    const childrenPerSource = await Promise.all(entityIds.map((categoryId) => readChildren(context.storefrontClient, categoryId)));
+    return {
+      links: entityIds.map((sourceId, index) => {
+        const children = childrenPerSource[index] ?? [];
+        return {
+          sourceId,
+          targetIds: children.slice(pagination.offset, pagination.offset + pagination.limit).map((child) => child.id),
+          entityTotal: children.length
+        };
+      })
+    };
+  },
+  cache: {
+    strategy: "ttl",
+    ttl: "10 minutes",
+    // `linkRunner` already prefixes a client-env key, so locale, market and currency are covered.
+    buildCacheKey: ({ entityIds, pagination }) => `${[...entityIds].sort().join(",")}:${pagination.offset}:${pagination.limit}`
+  }
+});

package/dist/runtime/server/orchestr/category/listing-page.page-index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/orchestr/category/listing-page.page-index.js

@@ -0,0 +1,79 @@
+import { paginate } from "#imports";
+import { ProductListingPage } from "@laioutr-core/canonical-types/ecommerce";
+import { defineShopwarePageIndex } from "../../middleware/defineShopware.js";
+import { toCategoryPageEntry } from "../../shopware-helper/pageIndexEntries.js";
+import { readCategoryPageMeta } from "../../shopware-helper/readCategoryPageMeta.js";
+import { SHOPWARE_MAX_LIMIT, storeApiPageFetcher } from "../../shopware-helper/storeApiPageFetcher.js";
+import { useSeoResolver } from "../../shopware-helper/useSeoResolver.js";
+const membershipFilter = [
+  { type: "equals", field: "type", value: "page" },
+  { type: "equals", field: "active", value: true },
+  { type: "range", field: "level", parameters: { gt: 1 } }
+];
+const pageIndexCriteria = {
+  associations: { seoUrls: {}, media: {} },
+  includes: {
+    category: ["id", "name", "translated", "updatedAt", "seoUrls", "media"],
+    seo_url: ["seoPathInfo", "isCanonical", "routeName"],
+    media: ["url"]
+  },
+  filter: membershipFilter,
+  // Page-number cursors need a stable upstream order, or a resumed walk shifts entries between passes.
+  sort: [{ field: "id", order: "ASC" }]
+};
+export default defineShopwarePageIndex({
+  for: ProductListingPage,
+  label: "Shopware Category",
+  batchSize: SHOPWARE_MAX_LIMIT,
+  cache: { ttl: "1h", search: { ttl: "5m" }, locate: { ttl: "1 day" } },
+  /**
+   * Point lookup down the same slug→id path as `bySlug.query.ts`, so the index and the rendered page
+   * always agree on which category a URL means. The resolver yields only an id, so the page metadata
+   * costs a second store-API read — absorbed by `cache.locate`, and non-fatal: the subject still
+   * resolves when it fails.
+   *
+   * `locales` is left unset: the store API scopes SEO reads by the `sw-language-id` header, so
+   * cross-locale slugs need one read per language and are not implemented. Reporting only the current
+   * locale would claim the category has no page in any other.
+   */
+  locate: async ({ context, params }) => {
+    const seoEntry = await useSeoResolver(context.storefrontClient).resolve("category", params.slug);
+    if (!seoEntry) return void 0;
+    return {
+      subject: { type: "Category", id: seoEntry.id },
+      meta: await readCategoryPageMeta(context.storefrontClient, seoEntry.id)
+    };
+  },
+  count: async ({ context }) => {
+    const response = await context.storefrontClient.invoke("readCategoryList post /category", {
+      body: { ...pageIndexCriteria, limit: 1, "total-count-mode": "exact" }
+    });
+    return response.data.total ?? 0;
+  },
+  /** Substring match on name and metaTitle, the same form the query-template picker uses for categories. */
+  search: ({ context, term, take }) => context.storefrontClient.invoke("readCategoryList post /category", {
+    body: {
+      ...pageIndexCriteria,
+      filter: [
+        ...membershipFilter,
+        {
+          type: "multi",
+          operator: "or",
+          queries: [
+            { type: "contains", field: "name", value: term },
+            { type: "contains", field: "metaTitle", value: term }
+          ]
+        }
+      ],
+      limit: take
+    }
+  }).then((response) => (response.data.elements ?? []).map(toCategoryPageEntry)),
+  list: ({ context, batchSize, startCursor }) => paginate(
+    storeApiPageFetcher(
+      ({ page, limit }) => context.storefrontClient.invoke("readCategoryList post /category", { body: { ...pageIndexCriteria, page, limit } }).then((response) => response.data),
+      toCategoryPageEntry,
+      batchSize
+    ),
+    startCursor
+  )
+});

package/dist/runtime/server/orchestr/category/menu-item.link.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/orchestr/category/menu-item.link.js

@@ -0,0 +1,10 @@
+import { CategoryBreadcrumbLink } from "@laioutr-core/canonical-types/ecommerce";
+import { defineShopwareLink } from "../../middleware/defineShopware.js";
+export default defineShopwareLink(CategoryBreadcrumbLink, async ({ entityIds }) => ({
+  links: entityIds.map(
+    (id) => ({
+      sourceId: id,
+      targetId: id
+    })
+  )
+}));

package/dist/runtime/server/orchestr/menu/base.resolver.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

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

@@ -0,0 +1,63 @@
+import { MenuItemBase } from "@laioutr-core/canonical-types/entity/menuItem";
+import { categoriesToken } from "../../const/passthroughTokens.js";
+import { defineShopwareComponentResolver } from "../../middleware/defineShopware.js";
+import { entitySlug } from "../../shopware-helper/mappers/slugMapper.js";
+import { swTranslated } from "../../shopware-helper/swTranslated.js";
+export default defineShopwareComponentResolver({
+  entityType: "MenuItem",
+  label: "Shopware Menu Connector",
+  provides: [MenuItemBase],
+  resolve: async ({ passthrough, $entity }) => {
+    const categories = passthrough.require(categoriesToken);
+    return {
+      entities: categories.map(
+        (category) => $entity({
+          id: category.id,
+          base: () => {
+            const baseItem = {
+              type: "link",
+              name: swTranslated(category, "name"),
+              childIds: category.children?.map((child) => child.id),
+              parentId: category.parentId
+            };
+            if (category.type === "folder") {
+              return {
+                ...baseItem,
+                type: "folder"
+              };
+            }
+            if (category.type === "link") {
+              return {
+                ...baseItem,
+                link: {
+                  type: "url",
+                  href: category.internalLink ?? category.externalLink ?? "/"
+                }
+              };
+            }
+            if (category.type === "page") {
+              return {
+                ...baseItem,
+                link: {
+                  type: "reference",
+                  reference: {
+                    type: category.linkType ?? "Category",
+                    slug: entitySlug(category),
+                    id: category.id
+                  }
+                }
+              };
+            }
+            return {
+              ...baseItem,
+              type: "folder"
+            };
+          }
+        })
+      )
+    };
+  },
+  cache: {
+    ttl: "10 minutes"
+  }
+});

package/dist/runtime/server/orchestr/menu/byAlias.query.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/orchestr/menu/byAlias.query.js

@@ -0,0 +1,29 @@
+import { MenuByAliasQuery } from "@laioutr-core/canonical-types/ecommerce";
+import { categoriesToken } from "../../const/passthroughTokens.js";
+import { defineShopwareQuery } from "../../middleware/defineShopware.js";
+import { flattenCategories } from "../../shopware-helper/categoryFlattener.js";
+export default defineShopwareQuery({
+  implements: MenuByAliasQuery,
+  run: async ({ input, context, passthrough }) => {
+    const { alias } = input;
+    const response = await context.storefrontClient.invoke("readNavigation post /navigation/{activeId}/{rootId}", {
+      pathParams: {
+        activeId: alias,
+        rootId: alias
+      },
+      body: { associations: { seoUrls: {} } }
+    });
+    const flattenedCategories = flattenCategories(response.data ?? []);
+    passthrough.set(categoriesToken, flattenedCategories);
+    return {
+      ids: flattenedCategories.map((item) => item.id)
+    };
+  },
+  cache: {
+    strategy: "ttl",
+    ttl: "10 minutes",
+    buildCacheKey({ input }) {
+      return input.alias;
+    }
+  }
+});

package/dist/runtime/server/orchestr/menu/byAlias.template.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/orchestr/menu/byAlias.template.js

@@ -0,0 +1,25 @@
+import { MenuByAliasQuery } from "@laioutr-core/canonical-types/ecommerce";
+import { defineShopwareQueryTemplateProvider } from "../../middleware/defineShopware.js";
+export default defineShopwareQueryTemplateProvider({
+  for: MenuByAliasQuery,
+  run: async ({ input, context }) => [
+    {
+      input: {
+        alias: "main-navigation"
+      },
+      label: "Main Navigation"
+    },
+    {
+      input: {
+        alias: "service-navigation"
+      },
+      label: "Service Navigation"
+    },
+    {
+      input: {
+        alias: "footer-navigation"
+      },
+      label: "Footer Navigation"
+    }
+  ]
+});

package/dist/runtime/server/orchestr/newsletter/subscribe.action.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/server/orchestr/newsletter/subscribe.action.js

@@ -0,0 +1,27 @@
+import { consola } from "consola";
+import { useRuntimeConfig } from "#imports";
+import { SubscribeAction } from "@laioutr-core/canonical-types/newsletter";
+import { defineShopwareAction } from "../../middleware/defineShopware.js";
+const logger = consola.withTag("shopware/newsletter");
+export default defineShopwareAction(SubscribeAction, async ({ context, input }) => {
+  const { storefrontUrl } = useRuntimeConfig()["@laioutr/app-shopware"];
+  if (!storefrontUrl) {
+    logger.error("Cannot subscribe to newsletter: storefrontUrl is not configured");
+    return { status: "error" };
+  }
+  await context.storefrontClient.invoke("subscribeToNewsletter post /newsletter/subscribe", {
+    body: {
+      option: "subscribe",
+      storefrontUrl,
+      email: input.email,
+      firstName: input.person?.firstName,
+      lastName: input.person?.lastName,
+      street: input.address?.address1,
+      city: input.address?.city,
+      zipCode: input.address?.postalCode,
+      languageId: context.currentSystemEntities.locale.languageId,
+      salutationId: context.systemEntities.salutations.find((salutation) => salutation.key === input.person?.salutation)?.id
+    }
+  });
+  return { status: "success" };
+});

package/dist/runtime/server/orchestr/product/base.resolver.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

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

@@ -0,0 +1,119 @@
+import { Money } from "@screeny05/ts-money";
+import {
+  ProductBase,
+  ProductDefaultVariant,
+  ProductDescription,
+  ProductFlags,
+  ProductInfo,
+  ProductMedia,
+  ProductPrices,
+  ProductRating,
+  ProductSeo
+} from "@laioutr-core/canonical-types/entity/product";
+import { FALLBACK_IMAGE } from "../../const/fallbacks.js";
+import { parentIdToDefaultVariantIdToken, productVariantsToken } from "../../const/passthroughTokens.js";
+import { defineShopwareComponentResolver } from "../../middleware/defineShopware.js";
+import { fetchAllProducts } from "../../shopware-helper/fetchAllProductVariants.js";
+import { entitySlug } from "../../shopware-helper/mappers/slugMapper.js";
+import { mapMedia } from "../../shopware-helper/mediaMapper.js";
+import { swTranslated } from "../../shopware-helper/swTranslated.js";
+export default defineShopwareComponentResolver({
+  label: "Shopware Product Connector",
+  entityType: "Product",
+  provides: [
+    ProductBase,
+    ProductInfo,
+    ProductPrices,
+    ProductMedia,
+    ProductFlags,
+    ProductSeo,
+    ProductDescription,
+    ProductDefaultVariant,
+    ProductRating
+  ],
+  resolve: async ({ entityIds, context, $entity, passthrough }) => {
+    const parentIdToDefaultVariantId = passthrough.get(parentIdToDefaultVariantIdToken);
+    const variantIds = entityIds.map((id) => parentIdToDefaultVariantId?.[id] ?? id);
+    const loadedVariants = passthrough.get(productVariantsToken) ?? [];
+    const missingVariantIds = variantIds.filter((id) => !loadedVariants.some((variant) => variant.id === id));
+    if (missingVariantIds.length > 0) {
+      const response = await fetchAllProducts(context.storefrontClient, { productIds: missingVariantIds, loadVariants: false });
+      loadedVariants.push(...response);
+    }
+    const shopwareProducts = variantIds.map((id) => {
+      const rawVariant = loadedVariants.find((variant) => variant.id === id);
+      if (!rawVariant) return void 0;
+      return {
+        rawVariant,
+        rawProduct: loadedVariants.find((variant) => variant.id === variant.parentId) ?? rawVariant
+      };
+    }).filter((product) => !!product);
+    const entities = shopwareProducts.map(({ rawProduct, rawVariant }) => {
+      const mappedCover = rawProduct.cover?.media ? mapMedia(rawVariant.cover?.media ?? rawProduct.cover.media) : FALLBACK_IMAGE;
+      return $entity({
+        // The parent-id is the actual product-id, even if the product has variants.
+        id: rawProduct.id,
+        base: {
+          name: swTranslated(rawProduct, "name"),
+          slug: entitySlug(rawProduct)
+        },
+        defaultVariant: {
+          id: rawVariant.id
+        },
+        info: {
+          cover: mappedCover,
+          shortDescription: swTranslated(rawProduct, "description") || swTranslated(rawVariant, "description"),
+          brand: swTranslated(rawProduct.manufacturer, "name") || swTranslated(rawVariant.manufacturer, "name") || ""
+        },
+        description: {
+          html: swTranslated(rawProduct, "description") || swTranslated(rawVariant, "description") || ""
+        },
+        seo: {
+          title: swTranslated(rawProduct, "metaTitle") || swTranslated(rawVariant, "metaTitle"),
+          description: swTranslated(rawProduct, "metaDescription") || swTranslated(rawVariant, "metaDescription")
+        },
+        media: () => {
+          const mappedMedia = (rawProduct.media ?? rawVariant.media)?.filter((image) => !!image.media).map((image) => mapMedia(image.media)) ?? [];
+          const isFirstMediaCover = mappedCover.sources.at(0)?.src === mappedMedia.at(0)?.sources.at(0)?.src;
+          const allMedia = isFirstMediaCover ? mappedMedia : [mappedCover, ...mappedMedia];
+          return {
+            cover: mappedCover,
+            media: allMedia,
+            images: allMedia.filter((media) => media.type === "image")
+          };
+        },
+        prices: () => {
+          const rawListPrice = rawProduct.calculatedCheapestPrice?.listPrice?.price ?? rawProduct.calculatedPrice.listPrice?.price ?? rawVariant.calculatedCheapestPrice?.listPrice?.price ?? rawVariant.calculatedPrice.listPrice?.price;
+          const listPrice = rawListPrice ? Money.fromDecimal(rawListPrice, context.swCurrency) : void 0;
+          const totalPrice = Money.fromDecimal(
+            rawProduct.calculatedCheapestPrice?.totalPrice ?? rawProduct.calculatedPrice.totalPrice,
+            context.swCurrency
+          );
+          const hasSavings = typeof listPrice === "object" && listPrice.greaterThan(totalPrice);
+          const savingsPercent = hasSavings ? 100 - totalPrice.percentageOf(listPrice) : void 0;
+          return {
+            price: totalPrice,
+            strikethroughPrice: hasSavings ? listPrice : void 0,
+            savingsPercent,
+            isOnSale: hasSavings,
+            isStartingFrom: rawProduct.calculatedCheapestPrice?.hasRange || rawProduct.calculatedPrice.hasRange
+          };
+        },
+        flags: [],
+        rating: {
+          average: rawProduct.ratingAverage ?? rawVariant.ratingAverage ?? 0,
+          count: rawProduct.productReviews?.length ?? 0
+        }
+      });
+    });
+    return { entities };
+  },
+  cache: {
+    ttl: "1 day",
+    components: {
+      prices: {
+        ttl: "15 minutes"
+      }
+    }
+  }
+});