@laioutr/app-shopware 0.14.4

package/dist/runtime/server/orchestr/product/breadcrumb.link.d.ts

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

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

@@ -0,0 +1,57 @@
+import { ProductBreadcrumbLink } from "@laioutr-core/canonical-types/ecommerce";
+import { BreadcrumbItemBase } from "@laioutr-core/canonical-types/entity/breadcrumb-item";
+import { productsFragmentToken } from "../../const/passthroughTokens.js";
+import { defineShopwareLink } from "../../middleware/defineShopware.js";
+import { entitySlug } from "../../shopware-helper/mappers/slugMapper.js";
+import { swTranslated } from "../../shopware-helper/swTranslated.js";
+export default defineShopwareLink({
+  implements: ProductBreadcrumbLink,
+  provides: [BreadcrumbItemBase],
+  run: async ({ context, entityIds, passthrough, $entity }) => {
+    const loadProducts = async () => {
+      const response = await context.storefrontClient.invoke("readProduct post /product", {
+        body: {
+          ids: entityIds,
+          associations: {
+            seoUrls: {}
+          },
+          includes: {
+            product: ["id", "name", "translated", "seoCategory", "seoUrls"],
+            category: ["id", "name", "translated", "seoUrls"]
+          }
+        }
+      });
+      return response.data.elements ?? [];
+    };
+    const products = passthrough.get(productsFragmentToken) ?? await loadProducts();
+    return {
+      links: products.map((rawProduct) => {
+        const seoCategory = rawProduct.seoCategory;
+        const categoryBreadcrumb = seoCategory?.id ? $entity({
+          id: `breadcrumb:${seoCategory.id}`,
+          base: () => ({
+            name: swTranslated(seoCategory, "name"),
+            link: {
+              type: "reference",
+              reference: { type: "Category", slug: entitySlug(seoCategory), id: seoCategory.id }
+            }
+          })
+        }) : void 0;
+        const productBreadcrumb = $entity({
+          id: `breadcrumb:${rawProduct.id}`,
+          base: () => ({
+            name: swTranslated(rawProduct, "name"),
+            link: {
+              type: "reference",
+              reference: { type: "Product", slug: entitySlug(rawProduct), id: rawProduct.id }
+            }
+          })
+        });
+        return {
+          sourceId: rawProduct.id,
+          entities: categoryBreadcrumb ? [categoryBreadcrumb, productBreadcrumb] : [productBreadcrumb]
+        };
+      })
+    };
+  }
+});

package/dist/runtime/server/orchestr/product/byCategoryId.query.d.ts

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

package/dist/runtime/server/orchestr/product/byCategoryId.query.js

@@ -0,0 +1,47 @@
+import { ProductsByCategoryIdQuery } from "@laioutr-core/canonical-types/ecommerce";
+import { cacheProductParentIds } from "../../composable/useGetProductParentId.js";
+import { parentIdToDefaultVariantIdToken } from "../../const/passthroughTokens.js";
+import { defineShopwareQuery } from "../../middleware/defineShopware.js";
+import {
+  mapSelectedFiltersToShopwareFilters,
+  mapShopwareAggregationToAvailableFilters
+} from "../../shopware-helper/facetMapper.js";
+import { mapShopwareSortingToOrchestr } from "../../shopware-helper/sortingMapper.js";
+export default defineShopwareQuery(
+  ProductsByCategoryIdQuery,
+  async ({ context, input, pagination, filter: selectedFilters, sorting, passthrough }) => {
+    const { categoryId } = input;
+    const { swFilters, swBuiltInFilters } = selectedFilters ? mapSelectedFiltersToShopwareFilters(selectedFilters, context.swCurrency) : {};
+    const response = await context.storefrontClient.invoke("readProductListing post /product-listing/{categoryId}", {
+      pathParams: { categoryId },
+      body: {
+        page: pagination.page,
+        limit: pagination.limit,
+        filter: [...swFilters ?? []],
+        order: sorting,
+        includes: {
+          product: ["id", "parentId"]
+        },
+        "total-count-mode": "exact",
+        "min-price": swBuiltInFilters?.["min-price"],
+        "max-price": swBuiltInFilters?.["max-price"],
+        manufacturer: swBuiltInFilters?.manufacturer,
+        "shipping-free": swBuiltInFilters?.["shipping-free"]
+      }
+    });
+    const availableFilters = mapShopwareAggregationToAvailableFilters(response.data.aggregations);
+    const availableSortings = mapShopwareSortingToOrchestr(response.data.availableSortings);
+    const parentIdToDefaultVariantId = Object.fromEntries(
+      response.data.elements.map((product) => [product.parentId ?? product.id, product.id])
+    );
+    passthrough.set(parentIdToDefaultVariantIdToken, parentIdToDefaultVariantId);
+    cacheProductParentIds(response.data.elements.map((product) => [product.id, product.parentId ?? product.id]));
+    return {
+      // Return the parent-id, in case the received product is a variant
+      ids: response.data.elements.map((product) => product.parentId ?? product.id),
+      total: response.data.total,
+      availableSortings,
+      availableFilters
+    };
+  }
+);

package/dist/runtime/server/orchestr/product/byCategorySlug.query.d.ts

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

package/dist/runtime/server/orchestr/product/byCategorySlug.query.js

@@ -0,0 +1,59 @@
+import { ProductsByCategorySlugQuery } from "@laioutr-core/canonical-types/ecommerce";
+import { cacheProductParentIds } from "../../composable/useGetProductParentId.js";
+import { parentIdToDefaultVariantIdToken, productVariantsToken } from "../../const/passthroughTokens.js";
+import { defineShopwareQuery } from "../../middleware/defineShopware.js";
+import {
+  mapSelectedFiltersToShopwareFilters,
+  mapShopwareAggregationToAvailableFilters
+} from "../../shopware-helper/facetMapper.js";
+import { fetchAllProducts } from "../../shopware-helper/fetchAllProductVariants.js";
+import { mapShopwareSortingToOrchestr } from "../../shopware-helper/sortingMapper.js";
+import { useSeoResolver } from "../../shopware-helper/useSeoResolver.js";
+export default defineShopwareQuery(
+  ProductsByCategorySlugQuery,
+  async ({ context, input, pagination, filter: selectedFilters, sorting, passthrough }) => {
+    const { categorySlug } = input;
+    const seoResolver = useSeoResolver(context.storefrontClient);
+    const seoEntry = await seoResolver.resolve("category", categorySlug);
+    if (!seoEntry) {
+      throw new Error(`No seo url found for category slug: ${categorySlug}`);
+    }
+    const { swFilters, swBuiltInFilters } = selectedFilters ? mapSelectedFiltersToShopwareFilters(selectedFilters, context.swCurrency) : {};
+    const response = await context.storefrontClient.invoke("readProductListing post /product-listing/{categoryId}", {
+      pathParams: { categoryId: seoEntry.id },
+      body: {
+        p: pagination.page,
+        limit: pagination.limit,
+        filter: [...swFilters ?? []],
+        order: sorting,
+        includes: {
+          product: ["id", "parentId"]
+        },
+        "total-count-mode": "exact",
+        "min-price": swBuiltInFilters?.["min-price"],
+        "max-price": swBuiltInFilters?.["max-price"],
+        manufacturer: swBuiltInFilters?.manufacturer,
+        "shipping-free": swBuiltInFilters?.["shipping-free"]
+      }
+    });
+    const availableFilters = mapShopwareAggregationToAvailableFilters(response.data.aggregations);
+    const availableSortings = mapShopwareSortingToOrchestr(response.data.availableSortings);
+    const parentIdToDefaultVariantId = Object.fromEntries(
+      response.data.elements.map((product) => [product.parentId ?? product.id, product.id])
+    );
+    passthrough.set(parentIdToDefaultVariantIdToken, parentIdToDefaultVariantId);
+    cacheProductParentIds(response.data.elements.map((product) => [product.id, product.parentId ?? product.id]));
+    const allVariants = await fetchAllProducts(context.storefrontClient, {
+      productIds: Object.keys(parentIdToDefaultVariantId),
+      loadVariants: true
+    });
+    passthrough.set(productVariantsToken, allVariants);
+    return {
+      // Return the parent-id, in case the received product is a variant
+      ids: response.data.elements.map((product) => product.parentId ?? product.id),
+      total: response.data.total,
+      availableSortings,
+      availableFilters
+    };
+  }
+);

package/dist/runtime/server/orchestr/product/byCategorySlug.template.d.ts

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

package/dist/runtime/server/orchestr/product/byCategorySlug.template.js

@@ -0,0 +1,40 @@
+import { ProductsByCategorySlugQuery } from "@laioutr-core/canonical-types/ecommerce";
+import { defineShopwareQueryTemplateProvider } from "../../middleware/defineShopware.js";
+import { entitySlug } from "../../shopware-helper/mappers/slugMapper.js";
+import { swTranslated } from "../../shopware-helper/swTranslated.js";
+export default defineShopwareQueryTemplateProvider({
+  for: ProductsByCategorySlugQuery,
+  run: async ({ input, context }) => {
+    const { storefrontClient } = context;
+    const response = await storefrontClient.invoke("readCategoryList post /category", {
+      body: {
+        filter: input.term ? [
+          {
+            type: "multi",
+            operator: "or",
+            queries: [
+              { type: "contains", field: "name", value: input.term },
+              { type: "contains", field: "metaTitle", value: input.term }
+            ]
+          }
+        ] : [],
+        associations: { seoUrls: {} },
+        includes: {
+          category: ["id", "name", "translated", "seoUrls"],
+          seo_url: ["seoPathInfo", "isCanonical", "routeName"]
+        },
+        limit: 50
+      }
+    });
+    const templates = [];
+    for (const element of response.data.elements ?? []) {
+      templates.push({
+        input: {
+          categorySlug: entitySlug(element)
+        },
+        label: swTranslated(element, "name")
+      });
+    }
+    return templates;
+  }
+});

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

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

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

@@ -0,0 +1,19 @@
+import { ProductBySlugQuery } from "@laioutr-core/canonical-types/ecommerce";
+import { useGetProductParentId } from "../../composable/useGetProductParentId.js";
+import { parentIdToDefaultVariantIdToken } from "../../const/passthroughTokens.js";
+import { defineShopwareQuery } from "../../middleware/defineShopware.js";
+import { useSeoResolver } from "../../shopware-helper/useSeoResolver.js";
+export default defineShopwareQuery(ProductBySlugQuery, async ({ context, input, passthrough }) => {
+  const seoResolver = useSeoResolver(context.storefrontClient);
+  const seoEntry = await seoResolver.resolve("product", input.slug);
+  if (!seoEntry) {
+    throw new Error(`No product found for slug: ${input.slug}`);
+  }
+  const getProductParentId = useGetProductParentId(context.storefrontClient);
+  const parentId = await getProductParentId(seoEntry.id);
+  const productId = parentId ?? seoEntry.id;
+  passthrough.set(parentIdToDefaultVariantIdToken, { [productId]: seoEntry.id });
+  return {
+    id: productId
+  };
+});

package/dist/runtime/server/orchestr/product/detail-page.page-index.d.ts

@@ -0,0 +1,3 @@
+/** `/product` returns fully-formed products (canonical SEO slug, translated name, cover), so entries need no per-entry enrichment fetch. */
+declare const _default: any;
+export default _default;

package/dist/runtime/server/orchestr/product/detail-page.page-index.js

@@ -0,0 +1,58 @@
+import { paginate } from "#imports";
+import { ProductDetailPage } from "@laioutr-core/canonical-types/ecommerce";
+import { useGetProductParentId } from "../../composable/useGetProductParentId.js";
+import { defineShopwarePageIndex } from "../../middleware/defineShopware.js";
+import { toProductPageEntry } from "../../shopware-helper/pageIndexEntries.js";
+import { buildProductLocate } from "../../shopware-helper/productLocate.js";
+import { readProductPageMeta } from "../../shopware-helper/readProductPageMeta.js";
+import { SHOPWARE_MAX_LIMIT, storeApiPageFetcher } from "../../shopware-helper/storeApiPageFetcher.js";
+import { useSeoResolver } from "../../shopware-helper/useSeoResolver.js";
+const pageIndexCriteria = {
+  associations: { seoUrls: {}, cover: {} },
+  includes: {
+    product: ["id", "name", "translated", "updatedAt", "seoUrls", "cover"],
+    seo_url: ["seoPathInfo", "isCanonical", "routeName"],
+    product_media: ["media"],
+    media: ["url"]
+  },
+  // Variants collapse into their parent — one detail page per product, matching `bySlug`'s parent ids.
+  filter: [{ type: "equals", field: "parentId", value: null }]
+};
+export default defineShopwarePageIndex({
+  for: ProductDetailPage,
+  label: "Shopware Product",
+  batchSize: SHOPWARE_MAX_LIMIT,
+  cache: { ttl: "1h", search: { ttl: "5m" }, locate: { ttl: "1 day" } },
+  /**
+   * Point lookup, same slug→id path as `bySlug.query.ts`. The SEO 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 product has no page in any other.
+   */
+  locate: async ({ context, params }) => {
+    const client = context.storefrontClient;
+    const seoEntry = await useSeoResolver(client).resolve("product", params.slug);
+    if (!seoEntry) return void 0;
+    const parentId = await useGetProductParentId(client)(seoEntry.id);
+    const productId = parentId ?? seoEntry.id;
+    return buildProductLocate(productId, await readProductPageMeta(client, productId));
+  },
+  count: async ({ context }) => {
+    const response = await context.storefrontClient.invoke("readProduct post /product", {
+      body: { ...pageIndexCriteria, limit: 1, "total-count-mode": "exact" }
+    });
+    return response.data.total ?? 0;
+  },
+  search: ({ context, term, take }) => context.storefrontClient.invoke("readProduct post /product", { body: { ...pageIndexCriteria, term, limit: take } }).then((response) => (response.data.elements ?? []).map(toProductPageEntry)),
+  list: ({ context, batchSize, startCursor }) => paginate(
+    storeApiPageFetcher(
+      ({ page, limit }) => context.storefrontClient.invoke("readProduct post /product", { body: { ...pageIndexCriteria, page, limit } }).then((response) => response.data),
+      toProductPageEntry,
+      batchSize
+    ),
+    startCursor
+  )
+});

package/dist/runtime/server/orchestr/product/reviews.link.d.ts

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

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

@@ -0,0 +1,27 @@
+import { ProductReviewsLink } from "@laioutr-core/canonical-types/ecommerce";
+import { currentProductIdsToken } from "../../const/passthroughTokens.js";
+import { defineShopwareLink } from "../../middleware/defineShopware.js";
+export default defineShopwareLink(ProductReviewsLink, async ({ entityIds, context, pagination, passthrough }) => {
+  const { storefrontClient } = context;
+  const productToReviews = {};
+  await Promise.all(
+    entityIds.map(async (entityId) => {
+      const response = await storefrontClient.invoke("readProductReviews post /product/{productId}/reviews", {
+        pathParams: { productId: entityId },
+        body: {
+          page: pagination.page,
+          limit: pagination.limit,
+          includes: {
+            product_review: ["id"]
+          }
+        }
+      });
+      const reviewIds = (response.data.elements ?? []).map((element) => element.id);
+      productToReviews[entityId] = reviewIds;
+    })
+  );
+  passthrough.set(currentProductIdsToken, entityIds);
+  return {
+    links: Object.entries(productToReviews).map(([productId, reviewsIds]) => ({ sourceId: productId, targetIds: reviewsIds }))
+  };
+});

package/dist/runtime/server/orchestr/product/search.query.d.ts

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

package/dist/runtime/server/orchestr/product/search.query.js

@@ -0,0 +1,43 @@
+import { ProductSearchQuery } from "@laioutr-core/canonical-types/ecommerce";
+import { cacheProductParentIds } from "../../composable/useGetProductParentId.js";
+import { parentIdToDefaultVariantIdToken } from "../../const/passthroughTokens.js";
+import { defineShopwareQuery } from "../../middleware/defineShopware.js";
+import {
+  mapSelectedFiltersToShopwareFilters,
+  mapShopwareAggregationToAvailableFilters
+} from "../../shopware-helper/facetMapper.js";
+import { mapShopwareSortingToOrchestr } from "../../shopware-helper/sortingMapper.js";
+export default defineShopwareQuery(ProductSearchQuery, async ({ context, input, pagination, filter: selectedFilters, passthrough }) => {
+  const { query } = input;
+  const { swFilters, swBuiltInFilters } = selectedFilters ? mapSelectedFiltersToShopwareFilters(selectedFilters, context.swCurrency) : {};
+  const response = await context.storefrontClient.invoke("searchSuggest post /search-suggest", {
+    // Shopware API client exposes incorrect/incomplete types for this endpoint's body :<
+    body: {
+      search: query,
+      p: pagination.page,
+      limit: pagination.limit,
+      filter: [...swFilters ?? []],
+      includes: {
+        product: ["id", "parentId"]
+      },
+      "min-price": swBuiltInFilters?.["min-price"],
+      "max-price": swBuiltInFilters?.["max-price"],
+      manufacturer: swBuiltInFilters?.manufacturer,
+      "shipping-free": swBuiltInFilters?.["shipping-free"]
+    }
+  });
+  const availableFilters = mapShopwareAggregationToAvailableFilters(response.data.aggregations);
+  const availableSortings = mapShopwareSortingToOrchestr(response.data.availableSortings ?? []);
+  const parentIdToDefaultVariantId = Object.fromEntries(
+    response.data.elements.map((product) => [product.parentId ?? product.id, product.id])
+  );
+  passthrough.set(parentIdToDefaultVariantIdToken, parentIdToDefaultVariantId);
+  cacheProductParentIds(response.data.elements.map((product) => [product.id, product.parentId ?? product.id]));
+  return {
+    // Return the parent-id, in case the received product is a variant
+    ids: response.data.elements.map((product) => product.parentId ?? product.id),
+    total: response.data.total,
+    availableFilters,
+    availableSortings
+  };
+});

package/dist/runtime/server/orchestr/product/variants.link.d.ts

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

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

@@ -0,0 +1,18 @@
+import { ProductVariantsLink } from "@laioutr-core/canonical-types/ecommerce";
+import { productVariantsToken } from "../../const/passthroughTokens.js";
+import { defineShopwareLink } from "../../middleware/defineShopware.js";
+import { fetchAllProducts } from "../../shopware-helper/fetchAllProductVariants.js";
+export default defineShopwareLink(ProductVariantsLink, async ({ entityIds, context, passthrough }) => {
+  const allVariants = passthrough.get(productVariantsToken) ?? await fetchAllProducts(context.storefrontClient, { productIds: entityIds, loadVariants: true });
+  passthrough.set(productVariantsToken, allVariants);
+  return {
+    links: entityIds.map((productId) => {
+      const product = allVariants.find((variant) => variant.id === 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]
+      };
+    })
+  };
+});

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

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

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

@@ -0,0 +1,129 @@
+import { Money } from "@screeny05/ts-money";
+import {
+  ProductVariantAvailability,
+  ProductVariantBase,
+  ProductVariantInfo,
+  ProductVariantOptions,
+  ProductVariantPrices,
+  ProductVariantQuantityPrices,
+  ProductVariantQuantityRule,
+  ProductVariantShipping
+} from "@laioutr-core/canonical-types/entity/product-variant";
+import { productVariantsToken } from "../../const/passthroughTokens.js";
+import { defineShopwareComponentResolver } from "../../middleware/defineShopware.js";
+import { resolveProductVariantFields } from "../../orchestr-helper/requestedFields.js";
+import { mapMedia } from "../../shopware-helper/mediaMapper.js";
+import { swTranslated } from "../../shopware-helper/swTranslated.js";
+export default defineShopwareComponentResolver({
+  entityType: "ProductVariant",
+  label: "Shopware Product Variant Connector",
+  provides: [
+    ProductVariantBase,
+    ProductVariantInfo,
+    ProductVariantAvailability,
+    ProductVariantPrices,
+    ProductVariantQuantityPrices,
+    ProductVariantQuantityRule,
+    ProductVariantShipping,
+    ProductVariantOptions
+  ],
+  resolve: async ({ entityIds, context, clientEnv, $entity, passthrough }) => {
+    const { currency } = clientEnv;
+    const loadedVariants = passthrough.get(productVariantsToken) ?? [];
+    const missingVariantIds = entityIds.filter((id) => !loadedVariants.some((variant) => variant.id === id));
+    if (missingVariantIds.length > 0) {
+      const response = await context.storefrontClient.invoke("readProduct post /product", {
+        body: {
+          ids: missingVariantIds,
+          ...resolveProductVariantFields()
+        }
+      });
+      loadedVariants.push(...response.data.elements ?? []);
+    }
+    return {
+      entities: entityIds.map((entityId) => loadedVariants.find((variant) => variant.id === entityId)).filter((entity) => !!entity).map(
+        (entity) => $entity({
+          id: entity.id,
+          base: () => ({
+            // Shopware SKU/product number
+            sku: entity.productNumber ?? entity.ean ?? entity.id,
+            name: entity.name,
+            // Shopware stores GTIN/EAN in `ean`
+            gtin: entity.ean ?? void 0
+          }),
+          availability: () => ({
+            status: entity.available ? "inStock" : "outOfStock",
+            // Prefer availableStock if you include it; fallback to stock
+            quantity: entity.availableStock ?? entity.stock ?? 0
+          }),
+          prices: () => {
+            const unit = entity.calculatedPrice?.unitPrice ?? 0;
+            const listPrice = entity.calculatedPrice?.listPrice?.price;
+            const price = Money.fromDecimal(Number(unit), currency);
+            const compareAtPrice = typeof listPrice === "number" && listPrice > unit ? Money.fromDecimal(Number(listPrice), currency) : void 0;
+            const rp = entity.calculatedPrice?.referencePrice;
+            return {
+              price,
+              isOnSale: !!compareAtPrice,
+              strikethroughPrice: compareAtPrice,
+              savingsPercent: compareAtPrice ? 100 - price.percentageOf(compareAtPrice) : void 0,
+              unitPrice: rp ? {
+                quantity: {
+                  value: rp.purchaseUnit ?? 1,
+                  // if you have your own unit normalizer, call it here
+                  unit: rp.unitName ?? rp.referenceUnit ?? void 0
+                },
+                price: Money.fromDecimal(Number(rp.price), currency),
+                reference: {
+                  value: rp.referenceUnit ?? 1,
+                  unit: rp.unitName ?? rp.referenceUnit ?? void 0
+                }
+              } : void 0
+            };
+          },
+          info: () => {
+            const allMedia = (entity.media ?? []).map((m) => m.media);
+            const media = entity.cover?.media ? [entity.cover.media, ...allMedia] : allMedia;
+            return {
+              image: media.map(mapMedia).find((m) => m.type === "image")
+            };
+          },
+          // Tiered/quantity prices:
+          // Shopware exposes calculatedPrices[] for price tiers (quantityStart/End etc.)
+          quantityPrices: () => {
+            const baseUnit = entity.calculatedPrice?.unitPrice ?? 0;
+            const base = Money.fromDecimal(Number(baseUnit), currency);
+            const tiers = Array.isArray(entity.calculatedPrices) ? entity.calculatedPrices : [];
+            return tiers.map((cp) => {
+              const tierUnit = cp?.unitPrice ?? baseUnit;
+              const price = Money.fromDecimal(Number(tierUnit), currency);
+              const qty = cp?.quantity ?? 1;
+              return {
+                quantity: qty,
+                price,
+                savingsPercent: price.percentageOf(base)
+              };
+            });
+          },
+          quantityRule: () => ({
+            min: entity.minPurchase ?? 1,
+            increment: entity.purchaseSteps ?? 1,
+            max: entity.maxPurchase ?? void 0
+          }),
+          shipping: () => ({
+            // Shopware doesn’t expose a direct "requiresShipping" boolean.
+            // If you track virtual/downloadable yourself, plug it here.
+            // Otherwise assume physical → requires shipping.
+            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"
+            })) ?? []
+          })
+        })
+      )
+    };
+  }
+});

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

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

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

@@ -0,0 +1,38 @@
+import { ReviewBase } from "@laioutr-core/canonical-types/entity/review";
+import { currentProductIdsToken } from "../../const/passthroughTokens.js";
+import { defineShopwareComponentResolver } from "../../middleware/defineShopware.js";
+export default defineShopwareComponentResolver({
+  label: "Shopware Product Review Connector",
+  entityType: "Review",
+  provides: [ReviewBase],
+  resolve: async ({ entityIds, $entity, context, passthrough }) => {
+    const currentProductIds = passthrough.get(currentProductIdsToken);
+    if (!currentProductIds) throw new Error("Missing `currentProductIdsToken` in passthrough.");
+    let entities = [];
+    for (const productId of currentProductIds) {
+      const res = await context.storefrontClient.invoke("readProductReviews post /product/{productId}/reviews", {
+        pathParams: { productId },
+        body: {
+          ids: entityIds,
+          includes: {
+            product_review: ["id", "title", "content", "points", "externalUser"]
+          }
+        }
+      });
+      entities = entities.concat(...res.data.elements ?? []);
+    }
+    return {
+      entities: entities.map(
+        (review) => $entity({
+          id: review.id,
+          base: () => ({
+            title: review.title,
+            shortContent: review.content,
+            createdAt: new Date(review.createdAt),
+            rating: review.points
+          })
+        })
+      )
+    };
+  }
+});

package/dist/runtime/server/orchestr/review/create-review.action.d.ts

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

package/dist/runtime/server/orchestr/review/create-review.action.js

@@ -0,0 +1,14 @@
+import { CreateReviewAction } from "@laioutr-core/canonical-types/ecommerce";
+import { defineShopwareAction } from "../../middleware/defineShopware.js";
+export default defineShopwareAction(CreateReviewAction, async ({ context, input }) => {
+  try {
+    const { productId, name, email, title, content, points } = input;
+    const res = await context.storefrontClient.invoke("saveProductReview post /product/{productId}/review", {
+      pathParams: { productId },
+      body: { name, email, title, content, points }
+    });
+    return { success: res.status === 200 };
+  } catch (err) {
+    return { success: false, message: err.message };
+  }
+});

package/dist/runtime/server/orchestr/suggested-search/suggested-search-entry.link.d.ts

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

package/dist/runtime/server/orchestr/suggested-search/suggested-search-entry.link.js

@@ -0,0 +1,14 @@
+import { SuggestedSearchEntriesLink } from "@laioutr-core/canonical-types/suggested-search";
+import { suggestionResultsFragmentToken } from "../../const/passthroughTokens.js";
+import { defineShopwareLink } from "../../middleware/defineShopware.js";
+export default defineShopwareLink(SuggestedSearchEntriesLink, async ({ passthrough }) => {
+  const results = passthrough.require(suggestionResultsFragmentToken);
+  return {
+    links: [
+      {
+        sourceId: results.id,
+        targetIds: results.suggestions.map((res) => res.id)
+      }
+    ]
+  };
+});

package/dist/runtime/server/orchestr/suggested-search/suggested-search.query.d.ts

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