@shopbite-de/storefront 1.18.5 → 1.20.0

package/server/api/product/variant.get.ts

@@ -0,0 +1,99 @@
+import type { components } from "~~/api-types/storeApiTypes";
+
+type Schemas = components["schemas"];
+
+const MAX_OPTION_IDS = 20;
+const MAX_OPTION_ID_LENGTH = 64;
+
+function parseOptionIds(raw: unknown): string[] {
+  const arr = Array.isArray(raw) ? raw : [raw];
+  const seen = new Set<string>();
+  for (const v of arr) {
+    if (
+      typeof v !== "string" ||
+      v.trim() === "" ||
+      v.length > MAX_OPTION_ID_LENGTH
+    )
+      continue;
+    seen.add(v);
+    if (seen.size >= MAX_OPTION_IDS) break;
+  }
+  return [...seen];
+}
+
+export default defineCachedEventHandler(
+  async (event): Promise<Schemas["Product"] | null> => {
+    const { parentId, optionIds: rawOptionIds } = getQuery(event);
+
+    if (typeof parentId !== "string" || parentId.trim() === "") {
+      throw createError({
+        statusCode: 400,
+        message: "Missing or invalid parentId",
+      });
+    }
+
+    const optionIds = parseOptionIds(rawOptionIds);
+    if (optionIds.length === 0) {
+      throw createError({
+        statusCode: 400,
+        message: "At least one optionId is required",
+      });
+    }
+
+    const { endpoint, accessToken } = useRuntimeConfig().public.shopware;
+
+    const filter: Schemas["Filters"] = [
+      { type: "equals", field: "parentId", value: parentId },
+      ...optionIds.map(
+        (id) =>
+          ({
+            type: "equals",
+            field: "optionIds",
+            value: id,
+          }) as Schemas["EqualsFilter"],
+      ),
+    ];
+
+    const response = await $fetch<{ elements?: Schemas["Product"][] }>(
+      `${endpoint}/product`,
+      {
+        method: "POST",
+        headers: { "sw-access-key": accessToken },
+        body: {
+          filter,
+          limit: 1,
+          includes: {
+            product: [
+              "id",
+              "name",
+              "description",
+              "translated",
+              "productNumber",
+              "options",
+              "properties",
+              "calculatedPrice",
+            ],
+            product_option: ["id", "groupId", "name", "translated", "group"],
+            property: ["id", "name", "translated", "options"],
+            property_group_option: ["id", "name", "translated", "group"],
+          },
+          associations: {
+            options: { associations: { group: {} } },
+            properties: { associations: { group: {} } },
+          },
+        },
+      },
+    );
+
+    return response.elements?.[0] ?? null;
+  },
+  {
+    maxAge: useRuntimeConfig().public.shopBite.cacheTtl.variant,
+    name: "variant",
+    getKey: (event) => {
+      const { parentId, optionIds } = getQuery(event);
+      const ids = parseOptionIds(optionIds).sort();
+      return `variant-${parentId}-${ids.join("|")}`;
+    },
+  },
+);

package/test/nuxt/useProductConfigurator.test.ts

@@ -1,19 +1,15 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import { useProductConfigurator } from "../../app/composables/useProductConfigurator";
 
-const { mockInvoke, mockConfigurator, mockProduct } = vi.hoisted(() => ({
-  mockInvoke: vi.fn(),
+const { mockFetch, mockConfigurator, mockProduct } = vi.hoisted(() => ({
+  mockFetch: vi.fn(),
   mockConfigurator: { value: [] },
   mockProduct: { value: { id: "p1", optionIds: [], options: [] } },
 }));
 
-// Use vi.mock for explicit imports
+vi.stubGlobal("$fetch", mockFetch);
+
 vi.mock("@shopware/composables", () => ({
-  useShopwareContext: () => ({
-    apiClient: {
-      invoke: mockInvoke,
-    },
-  }),
   useProductConfigurator: () => ({
     handleChange: vi.fn(),
   }),
@@ -57,24 +53,25 @@ describe("useProductConfigurator", () => {
     mockProduct.value = {
       parentId: "parent-1",
     } as unknown as typeof mockProduct.value;
-    mockInvoke.mockResolvedValue({
-      data: {
-        elements: [{ id: "variant-1" }],
-      },
-    });
+    mockFetch.mockResolvedValue({ id: "variant-1" });
 
     const { findVariantForSelectedOptions } = useProductConfigurator();
     const result = await findVariantForSelectedOptions({ Size: "o1" });
 
-    expect(mockInvoke).toHaveBeenCalledWith(
-      "readProduct post /product",
-      expect.any(Object),
+    expect(mockFetch).toHaveBeenCalledWith(
+      "/api/product/variant",
+      expect.objectContaining({
+        query: {
+          parentId: "parent-1",
+          optionIds: ["o1"],
+        },
+      }),
     );
     expect(result).toEqual({ id: "variant-1" });
   });
 
   it("should return undefined on error in findVariantForSelectedOptions", async () => {
-    mockInvoke.mockRejectedValue(new Error("API Error"));
+    mockFetch.mockRejectedValue(new Error("API Error"));
     const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {});
 
     const { findVariantForSelectedOptions } = useProductConfigurator();