@shopbite-de/storefront 1.16.1 → 1.17.0

package/test/nuxt/PaymentAndDelivery.test.ts

@@ -50,7 +50,7 @@ describe("PaymentAndDelivery", () => {
   it("updates payment method when changed", async () => {
     const wrapper = await mountSuspended(PaymentAndDelivery);
 
-    // @ts-ignore - access internal state
+    // @ts-expect-error - access internal state
     wrapper.vm.selectedPaymentMethodId = "pm2";
     await new Promise((resolve) => setTimeout(resolve, 50));
 
@@ -60,7 +60,7 @@ describe("PaymentAndDelivery", () => {
   it("updates shipping method and refreshes cart when changed", async () => {
     const wrapper = await mountSuspended(PaymentAndDelivery);
 
-    // @ts-ignore - access internal state
+    // @ts-expect-error - access internal state
     wrapper.vm.selectedShippingMethodId = "sm2";
     await new Promise((resolve) => setTimeout(resolve, 50));
 

package/test/nuxt/RegistrationForm.test.ts

@@ -38,6 +38,7 @@ mockNuxtImport("useToast", () => () => ({
 
 // Mock useRuntimeConfig
 mockNuxtImport("useRuntimeConfig", () => () => ({
+  app: { baseURL: "/" },
   public: {
     shopware: {
       devStorefrontUrl: "http://localhost:3000",
@@ -154,7 +155,7 @@ describe("RegistrationForm", () => {
     await new Promise((resolve) => setTimeout(resolve, 100));
 
     expect(mockRegister).toHaveBeenCalled();
-    const calledData = mockRegister.mock.calls[0][0];
+    const calledData = mockRegister.mock.calls[0]![0];
     expect(calledData.email).toBe("john@example.com");
     expect(calledData.billingAddress.street).toBe("Musterstr 1");
     // Check if firstName/lastName were copied to billing address as per logic in onSubmit
@@ -169,7 +170,7 @@ describe("RegistrationForm", () => {
           detail: 'The email address "lirim@veliu.net" is already in use',
         },
       ],
-    });
+    } as unknown as ConstructorParameters<typeof ApiClientError>[0]);
     mockRegister.mockRejectedValueOnce(apiClientError);
     const wrapper = await mountSuspended(RegistrationForm);
 
@@ -209,7 +210,9 @@ describe("RegistrationForm", () => {
   });
 
   it("handles ApiClientError with missing errors gracefully", async () => {
-    const apiClientError = new ApiClientError({});
+    const apiClientError = new ApiClientError(
+      {} as unknown as ConstructorParameters<typeof ApiClientError>[0],
+    );
     mockRegister.mockRejectedValueOnce(apiClientError);
     const wrapper = await mountSuspended(RegistrationForm);
 

package/test/nuxt/registrationSchema.test.ts

@@ -46,11 +46,11 @@ describe("registrationSchema", () => {
     const result = schema.safeParse(businessData);
     expect(result.success).toBe(false);
     if (!result.success) {
-      expect(result.error.issues[0].message).toBe(
+      expect(result.error.issues[0]!.message).toBe(
         "Als Geschäftskunde ist der Firmenname ein Pflichtfeld.",
       );
-      expect(result.error.issues[0].path).toContain("billingAddress");
-      expect(result.error.issues[0].path).toContain("company");
+      expect(result.error.issues[0]!.path).toContain("billingAddress");
+      expect(result.error.issues[0]!.path).toContain("company");
     }
   });
 
@@ -189,10 +189,10 @@ describe("registrationSchema", () => {
     });
     expect(result.success).toBe(false);
     if (!result.success) {
-      expect(result.error.issues[0].message).toBe(
+      expect(result.error.issues[0]!.message).toBe(
         "Bitte akzeptieren Sie die Datenschutzbestimmungen.",
       );
-      expect(result.error.issues[0].path).toContain("acceptedDataProtection");
+      expect(result.error.issues[0]!.path).toContain("acceptedDataProtection");
     }
   });
 
@@ -207,11 +207,11 @@ describe("registrationSchema", () => {
     });
     expect(result.success).toBe(false);
     if (!result.success) {
-      expect(result.error.issues[0].message).toBe(
+      expect(result.error.issues[0]!.message).toBe(
         "Bitte geben Sie Ihre Straße und Hausnummer an.",
       );
-      expect(result.error.issues[0].path).toContain("billingAddress");
-      expect(result.error.issues[0].path).toContain("street");
+      expect(result.error.issues[0]!.path).toContain("billingAddress");
+      expect(result.error.issues[0]!.path).toContain("street");
     }
   });
 

package/test/nuxt/useAddToCart.test.ts

@@ -1,7 +1,8 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import { mockNuxtImport } from "@nuxt/test-utils/runtime";
 
-import { useAddToCart } from "../../app/composables/useAddToCart";
+import { useAddToCart } from "~/composables/useAddToCart";
+import type { Schemas } from "#shopware";
 import { nextTick } from "vue";
 
 // Use vi.hoisted for variables used in mocks
@@ -66,7 +67,7 @@ describe("useAddToCart", () => {
     translated: {
       name: "Test Pizza",
     },
-  } as any;
+  } as unknown as Schemas["Product"];
 
   beforeEach(() => {
     vi.clearAllMocks();
@@ -109,7 +110,7 @@ describe("useAddToCart", () => {
       cartItemLabel,
     } = useAddToCart();
     setSelectedProduct(mockProduct);
-    setSelectedExtras([{ label: "Extra Cheese", value: "cheese" }] as any);
+    setSelectedExtras([{ label: "Extra Cheese", value: "cheese", price: "" }]);
     setDeselectedIngredients(["Onions"]);
     await nextTick();
     expect(cartItemLabel.value).toBe("Test Pizza +Extra Cheese -Onions");
@@ -141,7 +142,7 @@ describe("useAddToCart", () => {
   it("should add product with extras to cart as container", async () => {
     const { setSelectedProduct, setSelectedExtras, addToCart } = useAddToCart();
     setSelectedProduct(mockProduct);
-    setSelectedExtras([{ label: "Extra Cheese", value: "cheese" }] as any);
+    setSelectedExtras([{ label: "Extra Cheese", value: "cheese", price: "" }]);
 
     mockAddProducts.mockResolvedValue({ id: "cart-123" });
 

package/test/nuxt/useAddressAutocomplete.test.ts

@@ -11,6 +11,8 @@ mockNuxtImport("useFetch", () => mockUseFetch);
 
 // Mock useRuntimeConfig
 mockNuxtImport("useRuntimeConfig", () => () => ({
+  app: { baseURL: "/" },
+  public: { shopware: {} },
   geoapifyApiKey: "test-api-key",
 }));
 

package/test/nuxt/useBusinessHours.test.ts

@@ -5,7 +5,7 @@ import { useBusinessHours } from "~/composables/useBusinessHours";
 
 // Mock useAsyncData
 mockNuxtImport("useAsyncData", () => {
-  return (key: string, handler: () => Promise<any>) => {
+  return (key: string, handler: () => Promise<unknown>) => {
     const data = ref(null);
     const pending = ref(false);
     const refresh = vi.fn(async () => {
@@ -97,10 +97,10 @@ describe("useBusinessHours", () => {
     const intervals = getServiceIntervals(monday);
 
     expect(intervals).toHaveLength(2);
-    expect(intervals[0].start.getHours()).toBe(11);
-    expect(intervals[1].start.getHours()).toBe(17);
-    expect(intervals[0].start.getTime()).toBeLessThan(
-      intervals[1].start.getTime(),
+    expect(intervals[0]!.start.getHours()).toBe(11);
+    expect(intervals[1]!.start.getHours()).toBe(17);
+    expect(intervals[0]!.start.getTime()).toBeLessThan(
+      intervals[1]!.start.getTime(),
     );
   });
 });

package/test/nuxt/useDeliveryTime.test.ts

@@ -21,7 +21,7 @@ const { mockDeliveryTime, mockBusinessHours, mockHolidays } = vi.hoisted(
         { dayOfWeek: 0, openingTime: "17:30", closingTime: "23:00" },
       ],
     },
-    mockHolidays: { value: [] },
+    mockHolidays: { value: [] as { start: string; end: string }[] | null },
   }),
 );
 
@@ -36,8 +36,12 @@ mockNuxtImport("useBusinessHours", () => () => ({
     return mockBusinessHours.value
       .filter((bh) => bh.dayOfWeek === dayOfWeek)
       .map((bh) => {
-        const [startH, startM] = bh.openingTime.split(":").map(Number);
-        const [endH, endM] = bh.closingTime.split(":").map(Number);
+        const startParts = bh.openingTime.split(":").map(Number);
+        const endParts = bh.closingTime.split(":").map(Number);
+        const startH = startParts[0] ?? 0;
+        const startM = startParts[1] ?? 0;
+        const endH = endParts[0] ?? 0;
+        const endM = endParts[1] ?? 0;
         const start = new Date(date);
         start.setHours(startH, startM, 0, 0);
         const end = new Date(date);
@@ -73,8 +77,12 @@ mockNuxtImport("useBusinessHours", () => () => ({
     ]
       .filter((bh) => bh.dayOfWeek === currentTime.getDay())
       .map((bh) => {
-        const [startH, startM] = bh.openingTime.split(":").map(Number);
-        const [endH, endM] = bh.closingTime.split(":").map(Number);
+        const startParts = bh.openingTime.split(":").map(Number);
+        const endParts = bh.closingTime.split(":").map(Number);
+        const startH = startParts[0] ?? 0;
+        const startM = startParts[1] ?? 0;
+        const endH = endParts[0] ?? 0;
+        const endM = endParts[1] ?? 0;
         const start = new Date(currentTime);
         start.setHours(startH, startM, 0, 0);
         const end = new Date(currentTime);
@@ -98,10 +106,10 @@ mockNuxtImport("useBusinessHours", () => () => ({
 mockNuxtImport("useHolidays", () => () => ({
   isClosedHoliday: (date: Date) => {
     if (!mockHolidays.value) return undefined;
-    const formattedDate = date.toISOString().split("T")[0];
-    return mockHolidays.value.some((h: any) => {
-      const start = h.start.split("T")[0];
-      const end = h.end.split("T")[0];
+    const formattedDate = date.toISOString().split("T")[0]!;
+    return mockHolidays.value.some((h: { start: string; end: string }) => {
+      const start = h.start.split("T")[0] as string;
+      const end = h.end.split("T")[0] as string;
       return formattedDate >= start && formattedDate <= end;
     });
   },

package/test/nuxt/useProductConfigurator.test.ts

@@ -31,7 +31,7 @@ describe("useProductConfigurator", () => {
       id: "p1",
       optionIds: [],
       options: [],
-    } as any;
+    } as unknown as typeof mockProduct.value;
   });
 
   it("should initialize with selected options from product", () => {
@@ -41,20 +41,22 @@ describe("useProductConfigurator", () => {
         name: "Size",
         options: [{ id: "o1", name: "Small" }],
       },
-    ] as any;
+    ] as unknown as typeof mockConfigurator.value;
     mockProduct.value = {
       id: "p1-v1",
       parentId: "p1",
       optionIds: ["o1"],
       options: [{ id: "o1" }],
-    } as any;
+    } as unknown as typeof mockProduct.value;
 
     const { isLoadingOptions } = useProductConfigurator();
     expect(isLoadingOptions.value).toBe(true);
   });
 
   it("should find variant for selected options", async () => {
-    mockProduct.value = { parentId: "parent-1" } as any;
+    mockProduct.value = {
+      parentId: "parent-1",
+    } as unknown as typeof mockProduct.value;
     mockInvoke.mockResolvedValue({
       data: {
         elements: [{ id: "variant-1" }],

package/test/nuxt/useProductVariants.test.ts

@@ -1,11 +1,13 @@
 import { describe, it, expect } from "vitest";
-import { useProductVariants } from "../../app/composables/useProductVariants";
+import { useProductVariants } from "~/composables/useProductVariants";
 import { ref } from "vue";
 
 describe("useProductVariants", () => {
   it("should return empty object when no settings provided", () => {
     const settings = ref([]);
-    const { variants } = useProductVariants(settings as any);
+    const { variants } = useProductVariants(
+      settings as unknown as Parameters<typeof useProductVariants>[0],
+    );
     expect(variants.value).toEqual({});
   });
 
@@ -49,20 +51,22 @@ describe("useProductVariants", () => {
       },
     ]);
 
-    const { variants } = useProductVariants(settings as any);
+    const { variants } = useProductVariants(
+      settings as unknown as Parameters<typeof useProductVariants>[0],
+    );
 
     expect(variants.value["group-size"]).toBeDefined();
-    expect(variants.value["group-size"].name).toBe("Größe");
-    expect(variants.value["group-size"].options).toHaveLength(2);
-    expect(variants.value["group-size"].options[0]).toEqual({
+    expect(variants.value["group-size"]!.name).toBe("Größe");
+    expect(variants.value["group-size"]!.options).toHaveLength(2);
+    expect(variants.value["group-size"]!.options[0]).toEqual({
       label: "Klein",
       value: "opt-1",
       productId: "opt-1",
     });
 
     expect(variants.value["group-color"]).toBeDefined();
-    expect(variants.value["group-color"].name).toBe("Farbe");
-    expect(variants.value["group-color"].options).toHaveLength(1);
+    expect(variants.value["group-color"]!.name).toBe("Farbe");
+    expect(variants.value["group-color"]!.options).toHaveLength(1);
   });
 
   it("should avoid duplicate options", () => {
@@ -83,7 +87,9 @@ describe("useProductVariants", () => {
       },
     ]);
 
-    const { variants } = useProductVariants(settings as any);
-    expect(variants.value["group-size"].options).toHaveLength(1);
+    const { variants } = useProductVariants(
+      settings as unknown as Parameters<typeof useProductVariants>[0],
+    );
+    expect(variants.value["group-size"]!.options).toHaveLength(1);
   });
 });

package/test/nuxt/useProductVariantsZwei.test.ts

@@ -22,7 +22,9 @@ describe("useProductVariantsZwei", () => {
       },
     ]);
 
-    const { variants } = useProductVariantsZwei(settings);
+    const { variants } = useProductVariantsZwei(
+      settings as unknown as Parameters<typeof useProductVariantsZwei>[0],
+    );
 
     expect(variants.value["group-size"]).toBeDefined();
     expect(variants.value["group-size"]?.name).toBe("Größe");
@@ -42,7 +44,9 @@ describe("useProductVariantsZwei", () => {
       },
     ]);
 
-    const { variants } = useProductVariantsZwei(settings);
+    const { variants } = useProductVariantsZwei(
+      settings as unknown as Parameters<typeof useProductVariantsZwei>[0],
+    );
     expect(variants.value["group-size"]?.options).toHaveLength(1);
   });
 });

package/test/nuxt/useScrollAnimation.test.ts

@@ -1,13 +1,13 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
-import { useScrollAnimation } from "../../app/composables/useScrollAnimation";
+import { useScrollAnimation } from "~/composables/useScrollAnimation";
 import { mount } from "@vue/test-utils";
 import { defineComponent, nextTick } from "vue";
 
 describe("useScrollAnimation", () => {
-  let observeMock: any;
-  let unobserveMock: any;
-  let disconnectMock: any;
-  let intersectionCallback: any;
+  let observeMock: ReturnType<typeof vi.fn>;
+  let unobserveMock: ReturnType<typeof vi.fn>;
+  let disconnectMock: ReturnType<typeof vi.fn>;
+  let intersectionCallback: IntersectionObserverCallback;
 
   beforeEach(() => {
     observeMock = vi.fn();
@@ -15,14 +15,17 @@ describe("useScrollAnimation", () => {
     disconnectMock = vi.fn();
 
     // Mock IntersectionObserver
-    global.IntersectionObserver = vi
-      .fn()
-      .mockImplementation(function (callback) {
-        intersectionCallback = callback;
-        this.observe = observeMock;
-        this.unobserve = unobserveMock;
-        this.disconnect = disconnectMock;
-      }) as any;
+    global.IntersectionObserver = vi.fn().mockImplementation(function (
+      this: IntersectionObserver,
+      callback: IntersectionObserverCallback,
+    ) {
+      intersectionCallback = callback;
+      this.observe = observeMock as unknown as IntersectionObserver["observe"];
+      this.unobserve =
+        unobserveMock as unknown as IntersectionObserver["unobserve"];
+      this.disconnect =
+        disconnectMock as unknown as IntersectionObserver["disconnect"];
+    }) as unknown as typeof IntersectionObserver;
   });
 
   it("should initialize with isVisible false", () => {

package/test/nuxt/useTopSellers.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import { mockNuxtImport } from "@nuxt/test-utils/runtime";
-import { useTopSellers } from "../../app/composables/useTopSellers";
+import { useTopSellers } from "~/composables/useTopSellers";
 
 const { mockInvoke } = vi.hoisted(() => ({
   mockInvoke: vi.fn(),
@@ -31,7 +31,7 @@ describe("useTopSellers", () => {
     const result = await loadTopSellers();
 
     expect(mockInvoke).toHaveBeenCalledWith(
-      "getTopSellers post /product",
+      "readProduct post /product",
       expect.any(Object),
     );
     expect(result).toEqual(mockElements);

package/test/nuxt/useWishlistActions.test.ts

@@ -1,6 +1,7 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import { mockNuxtImport } from "@nuxt/test-utils/runtime";
 import { useWishlistActions } from "../../app/composables/useWishlistActions";
+import type { Schemas } from "#shopware";
 
 const {
   mockAddProducts,
@@ -44,7 +45,7 @@ describe("useWishlistActions", () => {
     id: "prod-1",
     translated: { name: "Test Product" },
     productNumber: "SW123",
-  } as any;
+  } as unknown as Schemas["Product"];
 
   beforeEach(() => {
     vi.clearAllMocks();
@@ -93,7 +94,7 @@ describe("useWishlistActions", () => {
     const products = [
       { id: "p1", translated: { name: "P1" } },
       { id: "p2", translated: { name: "P2" } },
-    ] as any[];
+    ] as unknown as Schemas["Product"][];
     const { addAllItemsToCart, isAddingToCart } = useWishlistActions();
     mockAddProducts.mockResolvedValue({ id: "cart-1" });
 
@@ -119,7 +120,7 @@ describe("useWishlistActions", () => {
     const products = [
       { id: "p1", translated: { name: "P1" } },
       { id: "p2", childCount: 1, translated: { name: "P2" } },
-    ] as any[];
+    ] as unknown as Schemas["Product"][];
     const { addAllItemsToCart } = useWishlistActions();
     mockAddProducts.mockResolvedValue({ id: "cart-1" });
 

package/test/unit/useCategorySeo.spec.ts

@@ -1,6 +1,9 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import { ref } from "vue";
 
+// Re-import the mocks for assertions
+import { useHead, useSeoMeta } from "#imports";
+
 // Create shared mocks to be exported by both '#imports' and '#app' in a hoisted-safe way
 const shared = vi.hoisted(() => ({
   useHead: vi.fn(),
@@ -41,24 +44,25 @@ vi.mock("#app", async () => {
   };
 });
 
-// Re-import the mocks for assertions
-import { useHead, useSeoMeta } from "#imports";
-
 // Target under test will be dynamically imported after setting up globals
-let useCategorySeo: (arg: any) => any;
+let useCategorySeo: (
+  arg: unknown,
+) => ReturnType<
+  (typeof import("../../app/composables/useCategorySeo"))["useCategorySeo"]
+>;
 
 describe("useCategorySeo", () => {
   beforeEach(async () => {
     vi.clearAllMocks();
     // Provide globals for auto-imported functions (when not transformed in unit env)
     const vue = await import("vue");
-    (globalThis as any).computed = vue.computed;
-    (globalThis as any).ref = vue.ref;
-    (globalThis as any).useRuntimeConfig = () => ({
+    (globalThis as Record<string, unknown>).computed = vue.computed;
+    (globalThis as Record<string, unknown>).ref = vue.ref;
+    (globalThis as Record<string, unknown>).useRuntimeConfig = () => ({
       public: { site: { name: "My Store" }, storeUrl: "https://example.com" },
     });
-    (globalThis as any).useHead = useHead;
-    (globalThis as any).useSeoMeta = useSeoMeta;
+    (globalThis as Record<string, unknown>).useHead = useHead;
+    (globalThis as Record<string, unknown>).useSeoMeta = useSeoMeta;
 
     // Dynamic import after globals are ready
     useCategorySeo = (await import("../../app/composables/useCategorySeo"))
@@ -66,7 +70,17 @@ describe("useCategorySeo", () => {
   });
 
   it("computes core SEO refs and injects head tags", () => {
-    const category = ref<any>({
+    const category = ref<{
+      translated?: {
+        metaTitle?: string;
+        metaDescription?: string;
+        breadcrumb?: string[];
+        name?: string;
+      };
+      seoUrl?: string;
+      active?: boolean;
+      media?: { url?: string };
+    }>({
       translated: {
         metaTitle: "Pizza & Pasta",
         metaDescription: "Leckere Pizza und Pasta bestellen",
@@ -96,7 +110,7 @@ describe("useCategorySeo", () => {
       useHead as unknown as ReturnType<typeof vi.fn>,
     ).toHaveBeenCalledTimes(1);
     const headArg = (useHead as unknown as ReturnType<typeof vi.fn>).mock
-      .calls[0][0];
+      .calls[0]![0]!;
 
     // Canonical link
     const link = headArg.link?.[0];
@@ -116,7 +130,7 @@ describe("useCategorySeo", () => {
   });
 
   it("sets robots to noindex when category is inactive", () => {
-    const category = ref<any>({
+    const category = ref({
       translated: { name: "Salate" },
       active: false,
       seoUrl: "/c/salate",

package/tsconfig.json

@@ -1,4 +1,24 @@
 {
-  // https://v3.nuxtjs.org/concepts/typescript
   "extends": "./.nuxt/tsconfig.json",
+  "include": [
+    ".nuxt/nuxt.d.ts",
+    ".nuxt/nuxt.node.d.ts",
+    "app/**/*",
+    "server/**/*",
+    "shared/**/*",
+    "modules/**/*",
+    "layers/**/*",
+    "test/**/*",
+    "tests/**/*",
+    "*.d.ts",
+    "nuxt.config.*",
+    ".config/nuxt.*",
+    "content.config.*"
+  ],
+  "exclude": [
+    "node_modules",
+  ],
+  "compilerOptions": {
+    "typeRoots": ["./api-types", "./node_modules/@types", "./node_modules"]
+  }
 }

package/server/utils/shopware/adminApiClient.ts

@@ -1,24 +0,0 @@
-import { createAdminAPIClient } from "@shopware/api-client";
-import type { operations } from "@shopware/api-client/admin-api-types";
-
-/**
- * Creates a Shopware Admin API client
- */
-export function createAdminApiClient(baseURL: string, accessToken: string) {
-  return createAdminAPIClient<operations>({
-    baseURL,
-    accessToken,
-  });
-}
-
-/**
- * Fetches sales channels using the Admin API client
- */
-export async function getSalesChannels(client: any) {
-  const response = await client.invoke({
-    method: "GET",
-    path: "/api/v3/sales-channel",
-  });
-
-  return response.data;
-}

package/test/unit/sales-channels.test.ts

@@ -1,66 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import {
-  createAdminApiClient,
-  getSalesChannels,
-} from "../../server/utils/shopware/adminApiClient";
-
-describe("Shopware Admin API Client", () => {
-  describe("createAdminApiClient", () => {
-    it("should create a client with correct configuration", () => {
-      const endpoint = "https://shopware.example.com/api";
-      const accessToken = "test-token";
-
-      const client = createAdminApiClient(endpoint, accessToken);
-
-      expect(client).toBeDefined();
-      // The client should have the invoke method
-      expect(client).toHaveProperty("invoke");
-      expect(typeof client.invoke).toBe("function");
-    });
-  });
-
-  describe("getSalesChannels", () => {
-    it("should fetch sales channels successfully", async () => {
-      // Mock the client
-      const mockClient = {
-        invoke: vi.fn().mockResolvedValue({
-          data: [
-            { id: "1", name: "Storefront", typeId: "storefront" },
-            { id: "2", name: "Headless", typeId: "headless" },
-          ],
-        }),
-      };
-
-      const result = await getSalesChannels(mockClient);
-
-      expect(result).toEqual([
-        { id: "1", name: "Storefront", typeId: "storefront" },
-        { id: "2", name: "Headless", typeId: "headless" },
-      ]);
-
-      expect(mockClient.invoke).toHaveBeenCalledWith({
-        method: "GET",
-        path: "/api/v3/sales-channel",
-      });
-    });
-
-    it("should handle errors when fetching sales channels", async () => {
-      const mockClient = {
-        invoke: vi.fn().mockRejectedValue(new Error("API error")),
-      };
-
-      await expect(getSalesChannels(mockClient)).rejects.toThrow("API error");
-    });
-
-    it("should handle empty response gracefully", async () => {
-      const mockClient = {
-        invoke: vi.fn().mockResolvedValue({
-          data: [],
-        }),
-      };
-
-      const result = await getSalesChannels(mockClient);
-      expect(result).toEqual([]);
-    });
-  });
-});