@cobrastyle/adapter-magento2 1.0.1

package/dist/adapter.js

@@ -0,0 +1,815 @@
+import { makeCartUserError } from "./cart-errors";
+import { graphqlFetch } from "./client";
+import { getConfig, withCustomerAuth } from "./config";
+import * as queries from "./queries";
+import * as mappers from "./mappers";
+import { stripSuffix } from "./urls";
+import { getStores } from "./stores";
+import { getStoreConfig } from "./store-config";
+import { getAttributeLabels } from "./attribute-labels";
+/**
+ * Next.js cache tags attached to cacheable content reads so they can be purged
+ * on demand via revalidateTag() (e.g. from a product-import webhook) instead of
+ * only expiring on the time-based revalidate window. These strings are a shared
+ * contract with the host app's revalidation endpoint — keep them in sync with
+ * the app's cacheTags map.
+ */
+const CONTENT_TAGS = {
+    products: "products",
+    product: (sku) => `product:${sku}`,
+    categories: "categories",
+    category: (id) => `category:${id}`,
+    navigation: "navigation",
+    cms: "cms",
+    search: "search",
+};
+// Map a Magento cart to our Cart, applying the store's product URL suffix to
+// line-item links. Centralizes the storeConfig lookup (memoized) so every cart
+// return path stays consistent without threading the suffix through each one.
+async function mapCartWithUrls(cart) {
+    const { productUrlSuffix } = await getStoreConfig();
+    return mappers.mapCart(cart, productUrlSuffix);
+}
+export const magento2Adapter = {
+    product: {
+        get: async (id) => {
+            const [{ productUrlSuffix, categoryUrlSuffix }, attributeLabels] = await Promise.all([getStoreConfig(), getAttributeLabels()]);
+            // Note: id is typically the SKU in our system
+            const data = await graphqlFetch(queries.GET_PRODUCT_BY_ID, { sku: id }, { tags: [CONTENT_TAGS.products, CONTENT_TAGS.product(String(id))] });
+            const product = data.products.items[0];
+            return product
+                ? mappers.mapProduct(product, productUrlSuffix, categoryUrlSuffix, attributeLabels)
+                : null;
+        },
+        getByUrlKey: async (urlKey) => {
+            const [{ productUrlSuffix, categoryUrlSuffix }, attributeLabels] = await Promise.all([getStoreConfig(), getAttributeLabels()]);
+            // Strip any store URL suffix (e.g. ".html") and, for nested paths like
+            // "category/product-url-key", extract the last segment.
+            const stripped = stripSuffix(urlKey, productUrlSuffix);
+            const productUrlKey = stripped.includes("/")
+                ? stripped.split("/").pop()
+                : stripped;
+            const data = await graphqlFetch(queries.GET_PRODUCT_BY_URL_KEY, { urlKey: productUrlKey }, { tags: [CONTENT_TAGS.products] });
+            const product = data.products.items[0];
+            return product
+                ? mappers.mapProduct(product, productUrlSuffix, categoryUrlSuffix, attributeLabels)
+                : null;
+        },
+        getRelated: async (productId) => {
+            const { productUrlSuffix } = await getStoreConfig();
+            // productId is typically the SKU - fetch directly with related_products
+            const data = await graphqlFetch(queries.GET_RELATED_PRODUCTS_BY_SKU, { sku: productId });
+            const relatedProducts = data.products.items[0]?.related_products ?? [];
+            return relatedProducts.map((p) => mappers.mapProductListItem(p, productUrlSuffix));
+        },
+        getUpsells: async (productId) => {
+            const { productUrlSuffix } = await getStoreConfig();
+            // productId is typically the SKU - fetch directly with upsell_products
+            const data = await graphqlFetch(queries.GET_RELATED_PRODUCTS_BY_SKU, { sku: productId });
+            const upsellProducts = data.products.items[0]?.upsell_products ?? [];
+            return upsellProducts.map((p) => mappers.mapProductListItem(p, productUrlSuffix));
+        },
+        getBySkus: async (skus) => {
+            const unique = [...new Set(skus)].filter(Boolean);
+            if (unique.length === 0)
+                return [];
+            const { productUrlSuffix } = await getStoreConfig();
+            const data = await graphqlFetch(queries.GET_PRODUCTS_BY_SKUS, { skus: unique, pageSize: unique.length }, { tags: [CONTENT_TAGS.products] });
+            return data.products.items.map((p) => mappers.mapProductListItem(p, productUrlSuffix));
+        },
+    },
+    category: {
+        get: async (id) => {
+            const { categoryUrlSuffix } = await getStoreConfig();
+            const data = await graphqlFetch(queries.GET_CATEGORY_BY_URL_KEY, { urlKey: id }, { tags: [CONTENT_TAGS.categories, CONTENT_TAGS.category(String(id))] });
+            const category = data.categoryList[0];
+            return category ? mappers.mapCategory(category, categoryUrlSuffix) : null;
+        },
+        // Resolve a category by its Magento uid. This is the robust lookup used by
+        // URL resolution: uid is unambiguous, immune to stale `url_path` and to
+        // duplicate `url_key`s across the tree (e.g. two "magasin" categories).
+        getByUid: async (uid) => {
+            const { categoryUrlSuffix } = await getStoreConfig();
+            const data = await graphqlFetch(queries.GET_CATEGORY_BY_UID, { uid }, { tags: [CONTENT_TAGS.categories] });
+            const category = data.categoryList[0];
+            return category ? mappers.mapCategory(category, categoryUrlSuffix) : null;
+        },
+        getByUrlKey: async (urlKey) => {
+            const { categoryUrlSuffix } = await getStoreConfig();
+            // Accept paths that still carry the store URL suffix (e.g. ".html").
+            const path = stripSuffix(urlKey, categoryUrlSuffix);
+            // First try the full path (e.g. "produkter/backljus").
+            let data = await graphqlFetch(queries.GET_CATEGORY_BY_URL_KEY, { urlKey: path }, { tags: [CONTENT_TAGS.categories] });
+            // If not found and the path contains slashes, try the last segment only.
+            // (Magento's `url_path` can be stale, so the full-path filter may miss.)
+            if (!data.categoryList[0] && path.includes("/")) {
+                const lastSegment = path.split("/").pop();
+                data = await graphqlFetch(queries.GET_CATEGORY_BY_URL_KEY_SINGLE, { urlKey: lastSegment }, { tags: [CONTENT_TAGS.categories] });
+            }
+            // If still not found, try as a single url_key.
+            if (!data.categoryList[0]) {
+                data = await graphqlFetch(queries.GET_CATEGORY_BY_URL_KEY_SINGLE, { urlKey: path }, { tags: [CONTENT_TAGS.categories] });
+            }
+            const category = data.categoryList[0];
+            return category ? mappers.mapCategory(category, categoryUrlSuffix) : null;
+        },
+        getProducts: async (input) => {
+            const { productUrlSuffix } = await getStoreConfig();
+            // Build the filter object for Magento GraphQL
+            // Use category_uid for Magento 2.4+ compatibility
+            // If categoryId looks like a numeric ID, convert to base64 UID
+            const categoryUid = /^\d+$/.test(input.categoryId)
+                ? Buffer.from(input.categoryId).toString("base64")
+                : input.categoryId;
+            const filter = {
+                category_uid: { eq: categoryUid },
+            };
+            // Helper to detect and parse range filter values (format: "from_to" like "10_100" or "*_100" or "100_*")
+            const parseRangeValue = (value) => {
+                // Range values typically have underscore separator: "min_max"
+                const rangeMatch = value.match(/^(\*|\d+(?:\.\d+)?)_(\*|\d+(?:\.\d+)?)$/);
+                if (rangeMatch) {
+                    const [, fromVal, toVal] = rangeMatch;
+                    const result = {};
+                    if (fromVal !== "*")
+                        result.from = fromVal;
+                    if (toVal !== "*")
+                        result.to = toVal;
+                    return result;
+                }
+                return null;
+            };
+            // Known range filter attributes in Magento (price is always range, others can be custom)
+            const knownRangeFilters = new Set(["price"]);
+            // Add attribute filters from input
+            if (input.filters) {
+                for (const [code, values] of Object.entries(input.filters)) {
+                    const valueArray = Array.isArray(values) ? values : [values];
+                    if (valueArray.length === 0)
+                        continue;
+                    // Check if this looks like a range filter
+                    const firstValue = valueArray[0];
+                    const rangeValue = parseRangeValue(firstValue);
+                    if (rangeValue || knownRangeFilters.has(code)) {
+                        // This is a range filter - use from/to syntax
+                        // For range filters, we use the first value only (ranges can't be combined with "in")
+                        const parsed = rangeValue || parseRangeValue(firstValue);
+                        if (parsed) {
+                            filter[code] = parsed;
+                        }
+                        else {
+                            // Fallback: treat as a single equality value if it doesn't match range pattern
+                            filter[code] = { eq: firstValue };
+                        }
+                    }
+                    else {
+                        // Standard filter - use eq/in syntax
+                        filter[code] =
+                            valueArray.length === 1
+                                ? { eq: valueArray[0] }
+                                : { in: valueArray };
+                    }
+                }
+            }
+            const data = await graphqlFetch(queries.GET_CATEGORY_PRODUCTS, {
+                filter,
+                pageSize: input.pageSize ?? 12,
+                currentPage: input.page ?? 1,
+                sort: input.sort
+                    ? { [input.sort.field]: input.sort.direction }
+                    : undefined,
+            }, { tags: [CONTENT_TAGS.categories, CONTENT_TAGS.products] });
+            return {
+                items: data.products.items.map((p) => mappers.mapProductListItem(p, productUrlSuffix)),
+                totalCount: data.products.total_count,
+                pageInfo: {
+                    currentPage: data.products.page_info.current_page,
+                    pageSize: data.products.page_info.page_size,
+                    totalPages: data.products.page_info.total_pages,
+                },
+                filters: (data.products.aggregations ?? []).map((agg) => {
+                    // Detect range filters - price is always range, others check for underscore pattern in values
+                    const isRangeFilter = agg.attribute_code === "price" ||
+                        agg.options?.some((opt) => /^\*?\d*_\d*\*?$/.test(opt.value));
+                    return {
+                        code: agg.attribute_code,
+                        label: agg.label,
+                        type: isRangeFilter ? "range" : "multiselect",
+                        values: (agg.options ?? []).map((opt) => ({
+                            value: opt.value,
+                            label: opt.label,
+                            count: opt.count,
+                        })),
+                    };
+                }),
+                sortOptions: (data.products.sort_fields?.options ?? []).map((opt) => ({
+                    value: opt.value,
+                    label: opt.label,
+                })),
+            };
+        },
+        searchByName: async (query, limit = 5) => {
+            const q = query.trim();
+            if (q.length < 2)
+                return [];
+            const data = await graphqlFetch(queries.GET_CATEGORY_SUGGESTIONS, { name: q });
+            return (data.categoryList ?? [])
+                .slice(0, limit)
+                .map((c) => ({ name: c.name, urlKey: c.url_key, urlPath: c.url_path }));
+        },
+    },
+    navigation: {
+        get: async () => {
+            try {
+                // Need the store config for the URL suffix; it also provides the root
+                // category id when it isn't set via env.
+                const storeConfig = await getStoreConfig();
+                const rootCategoryId = getConfig().rootCategoryId ?? storeConfig.rootCategoryId;
+                const suffix = storeConfig.categoryUrlSuffix;
+                const data = await graphqlFetch(queries.GET_NAVIGATION, { id: rootCategoryId }, { tags: [CONTENT_TAGS.navigation] });
+                if (!data.category)
+                    return [];
+                return (data.category.children ?? [])
+                    .filter(mappers.isIncludedInMenu)
+                    .map((child) => mappers.mapNavigationItem(child, 1, [], suffix));
+            }
+            catch (error) {
+                console.warn("Failed to fetch navigation:", error);
+                return [];
+            }
+        },
+    },
+    cart: {
+        create: async () => {
+            const authOpts = await withCustomerAuth();
+            let cartId;
+            if (authOpts.customerToken) {
+                // Authenticated: get or create the customer's cart
+                const data = await graphqlFetch(queries.GET_CUSTOMER_CART, undefined, authOpts);
+                cartId = data.customerCart.id;
+            }
+            else {
+                // Guest: create a new empty cart
+                try {
+                    const data = await graphqlFetch(queries.CREATE_EMPTY_CART);
+                    cartId = data.createEmptyCart;
+                }
+                catch (error) {
+                    // Magento blocks guest cart creation when login is required
+                    const message = error instanceof Error ? error.message : String(error);
+                    if (message.includes("allowed for logged in customer") ||
+                        message.includes("requires authentication")) {
+                        throw new Error("Guest checkout is not available. Please log in or create an account to continue shopping.");
+                    }
+                    throw error;
+                }
+            }
+            return {
+                id: cartId,
+                items: [],
+                totals: {
+                    subtotal: 0,
+                    subtotalIncludingTax: 0,
+                    grandTotal: 0,
+                    discounts: [],
+                    taxes: [],
+                    currency: "USD",
+                },
+                appliedCoupons: [],
+                shippingAddresses: [],
+                availableShippingMethods: [],
+                availablePaymentMethods: [],
+            };
+        },
+        get: async (cartId) => {
+            try {
+                const data = await graphqlFetch(queries.GET_CART, {
+                    cartId,
+                }, await withCustomerAuth({ cache: "no-store" })); // Cart data is user-specific, never cache
+                return mapCartWithUrls(data.cart);
+            }
+            catch (error) {
+                return null;
+            }
+        },
+        addItem: async (cartId, input) => {
+            // Handle grouped products - add each child item separately
+            if (input.groupedItems && input.groupedItems.length > 0) {
+                const cartItems = input.groupedItems
+                    .filter((item) => item.quantity > 0)
+                    .map((item) => ({
+                    sku: item.sku,
+                    quantity: item.quantity,
+                }));
+                if (cartItems.length === 0) {
+                    throw new Error("Please specify the quantity for at least one product");
+                }
+                const data = await graphqlFetch(queries.ADD_TO_CART, {
+                    cartId,
+                    cartItems,
+                }, await withCustomerAuth());
+                if (data.addProductsToCart.user_errors?.length) {
+                    throw new Error(data.addProductsToCart.user_errors[0].message);
+                }
+                return mapCartWithUrls(data.addProductsToCart.cart);
+            }
+            // Build cart item input for simple/configurable products
+            const cartItem = {
+                sku: input.sku,
+                quantity: input.quantity,
+            };
+            // Add selected options for configurable products
+            if (input.selectedOptions && input.selectedOptions.length > 0) {
+                cartItem.selected_options = input.selectedOptions;
+            }
+            const data = await graphqlFetch(queries.ADD_TO_CART, {
+                cartId,
+                cartItems: [cartItem],
+            }, await withCustomerAuth());
+            if (data.addProductsToCart.user_errors?.length) {
+                throw makeCartUserError(data.addProductsToCart.user_errors[0]);
+            }
+            return mapCartWithUrls(data.addProductsToCart.cart);
+        },
+        updateItem: async (cartId, input) => {
+            const data = await graphqlFetch(queries.UPDATE_CART_ITEM, {
+                cartId,
+                itemUid: input.itemUid,
+                quantity: input.quantity,
+            }, await withCustomerAuth());
+            return mapCartWithUrls(data.updateCartItems.cart);
+        },
+        removeItem: async (cartId, itemUid) => {
+            const data = await graphqlFetch(queries.REMOVE_CART_ITEM, { cartId, itemUid }, await withCustomerAuth());
+            return mapCartWithUrls(data.removeItemFromCart.cart);
+        },
+        applyCoupon: async (cartId, input) => {
+            const authOpts = await withCustomerAuth();
+            const data = await graphqlFetch(`mutation ApplyCoupon($cartId: String!, $couponCode: String!) {
+          applyCouponToCart(input: { cart_id: $cartId, coupon_code: $couponCode }) {
+            cart { id applied_coupons { code } }
+          }
+        }`, { cartId, couponCode: input.couponCode }, authOpts);
+            // Re-fetch full cart to get updated totals
+            const fullCart = await graphqlFetch(queries.GET_CART, {
+                cartId,
+            }, await withCustomerAuth({ cache: "no-store" }));
+            return mapCartWithUrls(fullCart.cart);
+        },
+        removeCoupon: async (cartId) => {
+            const authOpts = await withCustomerAuth();
+            await graphqlFetch(`mutation RemoveCoupon($cartId: String!) {
+          removeCouponFromCart(input: { cart_id: $cartId }) {
+            cart { id }
+          }
+        }`, { cartId }, authOpts);
+            const fullCart = await graphqlFetch(queries.GET_CART, {
+                cartId,
+            }, await withCustomerAuth({ cache: "no-store" }));
+            return mapCartWithUrls(fullCart.cart);
+        },
+        setEmail: async (cartId, email) => {
+            const authOpts = await withCustomerAuth();
+            // setGuestEmailOnCart is only for guests; for logged-in customers
+            // the email is already associated with their account.
+            if (!authOpts.customerToken) {
+                await graphqlFetch(`mutation SetGuestEmail($cartId: String!, $email: String!) {
+            setGuestEmailOnCart(input: { cart_id: $cartId, email: $email }) {
+              cart { id email }
+            }
+          }`, { cartId, email }, authOpts);
+            }
+            const fullCart = await graphqlFetch(queries.GET_CART, {
+                cartId,
+            }, await withCustomerAuth({ cache: "no-store" }));
+            return mapCartWithUrls(fullCart.cart);
+        },
+        merge: async (guestCartId, customerCartId) => {
+            const authOpts = await withCustomerAuth();
+            await graphqlFetch(queries.MERGE_CARTS, { guestCartId, customerCartId }, authOpts);
+            const fullCart = await graphqlFetch(queries.GET_CART, {
+                cartId: customerCartId,
+            }, await withCustomerAuth({ cache: "no-store" }));
+            return mapCartWithUrls(fullCart.cart);
+        },
+    },
+    checkout: {
+        setShippingAddress: async (cartId, input) => {
+            const authOpts = await withCustomerAuth();
+            await graphqlFetch(queries.SET_SHIPPING_ADDRESS, {
+                cartId,
+                address: {
+                    address: {
+                        firstname: input.address.firstname,
+                        lastname: input.address.lastname,
+                        street: input.address.street,
+                        city: input.address.city,
+                        // Magento requires region_id for countries that have predefined
+                        // regions; `region` (free text) is used when there is no id.
+                        region: input.address.regionCode || input.address.region,
+                        region_id: input.address.regionId,
+                        postcode: input.address.postcode,
+                        country_code: input.address.countryCode,
+                        telephone: input.address.telephone,
+                        company: input.address.company,
+                        // Don't add a new entry to the customer's address book on every
+                        // checkout (Magento otherwise saves it, creating duplicates).
+                        save_in_address_book: false,
+                    },
+                },
+            }, authOpts);
+            const fullCart = await graphqlFetch(queries.GET_CART, {
+                cartId,
+            }, await withCustomerAuth({ cache: "no-store" }));
+            return mapCartWithUrls(fullCart.cart);
+        },
+        setBillingAddress: async (cartId, input) => {
+            const authOpts = await withCustomerAuth();
+            await graphqlFetch(`mutation SetBillingAddress($cartId: String!, $address: BillingAddressInput!) {
+          setBillingAddressOnCart(input: { cart_id: $cartId, billing_address: $address }) {
+            cart { id }
+          }
+        }`, {
+                cartId,
+                address: input.sameAsShipping
+                    ? { same_as_shipping: true }
+                    : {
+                        address: {
+                            firstname: input.address.firstname,
+                            lastname: input.address.lastname,
+                            street: input.address.street,
+                            city: input.address.city,
+                            region: input.address.regionCode || input.address.region,
+                            region_id: input.address.regionId,
+                            postcode: input.address.postcode,
+                            country_code: input.address.countryCode,
+                            telephone: input.address.telephone,
+                            save_in_address_book: false,
+                        },
+                    },
+            }, authOpts);
+            const fullCart = await graphqlFetch(queries.GET_CART, {
+                cartId,
+            }, await withCustomerAuth({ cache: "no-store" }));
+            return mapCartWithUrls(fullCart.cart);
+        },
+        setShippingMethod: async (cartId, input) => {
+            const authOpts = await withCustomerAuth();
+            await graphqlFetch(queries.SET_SHIPPING_METHOD, {
+                cartId,
+                carrierCode: input.carrierCode,
+                methodCode: input.methodCode,
+            }, authOpts);
+            const fullCart = await graphqlFetch(queries.GET_CART, {
+                cartId,
+            }, await withCustomerAuth({ cache: "no-store" }));
+            return mapCartWithUrls(fullCart.cart);
+        },
+        setPaymentMethod: async (cartId, input) => {
+            const authOpts = await withCustomerAuth();
+            await graphqlFetch(queries.SET_PAYMENT_METHOD, {
+                cartId,
+                code: input.code,
+            }, authOpts);
+            const fullCart = await graphqlFetch(queries.GET_CART, {
+                cartId,
+            }, await withCustomerAuth({ cache: "no-store" }));
+            return mapCartWithUrls(fullCart.cart);
+        },
+        placeOrder: async (cartId) => {
+            try {
+                const data = await graphqlFetch(queries.PLACE_ORDER, { cartId }, await withCustomerAuth());
+                return {
+                    success: true,
+                    orderNumber: data.placeOrder.order.order_number,
+                    orderId: data.placeOrder.order.order_number,
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: error instanceof Error ? error.message : "Order placement failed",
+                };
+            }
+        },
+        getCountries: async () => {
+            const data = await graphqlFetch(queries.GET_COUNTRIES);
+            return mappers.mapCountries(data.countries ?? []);
+        },
+    },
+    cms: {
+        getPage: async (identifier) => {
+            try {
+                const data = await graphqlFetch(queries.GET_CMS_PAGE, {
+                    identifier,
+                }, { tags: [CONTENT_TAGS.cms] });
+                return data.cmsPage ? mappers.mapCmsPage(data.cmsPage) : null;
+            }
+            catch {
+                return null;
+            }
+        },
+        getPageByUrlKey: async (urlKey) => {
+            try {
+                const data = await graphqlFetch(queries.GET_CMS_PAGE, {
+                    identifier: urlKey,
+                }, { tags: [CONTENT_TAGS.cms] });
+                return data.cmsPage ? mappers.mapCmsPage(data.cmsPage) : null;
+            }
+            catch {
+                return null;
+            }
+        },
+        getBlock: async (identifier) => {
+            try {
+                const data = await graphqlFetch(queries.GET_CMS_BLOCKS, { identifiers: [identifier] }, { tags: [CONTENT_TAGS.cms] });
+                const item = data.cmsBlocks?.items?.[0];
+                return item ? mappers.mapCmsBlock(item) : null;
+            }
+            catch {
+                return null;
+            }
+        },
+        resolveUrl: async (urlKey) => {
+            try {
+                const data = await graphqlFetch(queries.URL_RESOLVER, {
+                    url: urlKey,
+                });
+                return mappers.mapUrlResolver(data.route);
+            }
+            catch {
+                return { type: "NOT_FOUND", id: "", urlKey };
+            }
+        },
+        getStoreConfig: async () => {
+            const config = await getStoreConfig();
+            return {
+                storeCode: config.storeCode,
+                storeName: config.storeName,
+                baseCurrencyCode: config.baseCurrencyCode,
+                defaultDisplayCurrencyCode: config.defaultDisplayCurrencyCode,
+                locale: config.locale,
+                timezone: config.timezone,
+                useStoreInUrl: config.useStoreInUrl,
+                homePageIdentifier: config.homePageIdentifier,
+                notFoundPageIdentifier: config.notFoundPageIdentifier,
+                defaultTitle: config.defaultTitle,
+                defaultDescription: config.defaultDescription,
+                defaultKeywords: config.defaultKeywords,
+                titlePrefix: config.titlePrefix,
+                titleSuffix: config.titleSuffix,
+                titleSeparator: config.titleSeparator,
+            };
+        },
+        getStores: async () => getStores(),
+    },
+    search: {
+        search: async (query, options) => {
+            const { productUrlSuffix } = await getStoreConfig();
+            const data = await graphqlFetch(queries.SEARCH_PRODUCTS, {
+                search: query,
+                pageSize: options?.pageSize ?? 12,
+                currentPage: options?.page ?? 1,
+            }, { tags: [CONTENT_TAGS.search] });
+            return {
+                items: data.products.items.map((p) => mappers.mapProductListItem(p, productUrlSuffix)),
+                totalCount: data.products.total_count,
+                pageInfo: {
+                    currentPage: data.products.page_info.current_page,
+                    pageSize: data.products.page_info.page_size,
+                    totalPages: data.products.page_info.total_pages,
+                },
+            };
+        },
+    },
+    customer: {
+        login: async (credentials) => {
+            const tokenData = await graphqlFetch(queries.GENERATE_CUSTOMER_TOKEN, {
+                email: credentials.email,
+                password: credentials.password,
+            });
+            const token = tokenData.generateCustomerToken.token;
+            const customerData = await graphqlFetch(queries.GET_CUSTOMER, {}, { customerToken: token });
+            return {
+                customer: mappers.mapCustomer(customerData.customer),
+                token,
+                expiresAt: new Date(Date.now() + 3600000).toISOString(), // 1 hour
+            };
+        },
+        register: async (input) => {
+            const data = await graphqlFetch(queries.CREATE_CUSTOMER, {
+                input: {
+                    email: input.email,
+                    password: input.password,
+                    firstname: input.firstname,
+                    lastname: input.lastname,
+                    date_of_birth: input.dateOfBirth,
+                    is_subscribed: input.isSubscribed,
+                },
+            });
+            // Auto-login after registration
+            const tokenData = await graphqlFetch(queries.GENERATE_CUSTOMER_TOKEN, {
+                email: input.email,
+                password: input.password,
+            });
+            return {
+                customer: mappers.mapCustomer(data.createCustomerV2.customer),
+                token: tokenData.generateCustomerToken.token,
+                expiresAt: new Date(Date.now() + 3600000).toISOString(),
+            };
+        },
+        logout: async (token) => {
+            await graphqlFetch(`mutation RevokeCustomerToken { revokeCustomerToken { result } }`, {}, { customerToken: token });
+        },
+        get: async (token) => {
+            try {
+                const data = await graphqlFetch(queries.GET_CUSTOMER, {}, { customerToken: token });
+                return mappers.mapCustomer(data.customer);
+            }
+            catch {
+                return null;
+            }
+        },
+        update: async (token, input) => {
+            const data = await graphqlFetch(`mutation UpdateCustomer($input: CustomerUpdateInput!) {
+          updateCustomerV2(input: $input) {
+            customer {
+              id email firstname lastname date_of_birth gender created_at
+            }
+          }
+        }`, {
+                input: {
+                    firstname: input.firstname,
+                    lastname: input.lastname,
+                    email: input.email,
+                    date_of_birth: input.dateOfBirth,
+                },
+            }, { customerToken: token });
+            return mappers.mapCustomer(data.updateCustomerV2.customer);
+        },
+        changePassword: async (token, input) => {
+            await graphqlFetch(`mutation ChangePassword($currentPassword: String!, $newPassword: String!) {
+          changeCustomerPassword(currentPassword: $currentPassword, newPassword: $newPassword) {
+            email
+          }
+        }`, {
+                currentPassword: input.currentPassword,
+                newPassword: input.newPassword,
+            }, { customerToken: token });
+            return true;
+        },
+        requestPasswordReset: async (email) => {
+            await graphqlFetch(`mutation RequestPasswordReset($email: String!) {
+          requestPasswordResetEmail(email: $email)
+        }`, { email });
+            return true;
+        },
+        getOrders: async (token, page = 1, pageSize = 10) => {
+            const data = await graphqlFetch(queries.GET_CUSTOMER_ORDERS, { pageSize, currentPage: page }, { customerToken: token });
+            return {
+                items: data.customer.orders.items.map(mappers.mapCustomerOrder),
+                totalCount: data.customer.orders.total_count,
+                pageInfo: {
+                    currentPage: data.customer.orders.page_info.current_page,
+                    pageSize: data.customer.orders.page_info.page_size,
+                    totalPages: data.customer.orders.page_info.total_pages,
+                },
+            };
+        },
+        createAddress: async (token, input) => {
+            const data = await graphqlFetch(queries.CREATE_CUSTOMER_ADDRESS, {
+                input: {
+                    firstname: input.firstname,
+                    lastname: input.lastname,
+                    street: input.street,
+                    city: input.city,
+                    region: input.regionId != null || input.regionCode || input.region
+                        ? {
+                            region_id: input.regionId,
+                            region_code: input.regionCode || undefined,
+                            region: input.region || undefined,
+                        }
+                        : undefined,
+                    postcode: input.postcode,
+                    country_code: input.countryCode,
+                    telephone: input.telephone,
+                    company: input.company,
+                    default_shipping: input.isDefaultShipping ?? false,
+                    default_billing: input.isDefaultBilling ?? false,
+                },
+            }, { customerToken: token });
+            return mappers.mapCustomerAddress(data.createCustomerAddress);
+        },
+        updateAddress: async (token, input) => {
+            const { id, ...fields } = input;
+            const addressInput = {};
+            if (fields.firstname !== undefined)
+                addressInput.firstname = fields.firstname;
+            if (fields.lastname !== undefined)
+                addressInput.lastname = fields.lastname;
+            if (fields.street !== undefined)
+                addressInput.street = fields.street;
+            if (fields.city !== undefined)
+                addressInput.city = fields.city;
+            if (fields.regionId != null ||
+                fields.regionCode !== undefined ||
+                fields.region !== undefined)
+                addressInput.region = {
+                    region_id: fields.regionId,
+                    region_code: fields.regionCode || undefined,
+                    region: fields.region || undefined,
+                };
+            if (fields.postcode !== undefined)
+                addressInput.postcode = fields.postcode;
+            if (fields.countryCode !== undefined)
+                addressInput.country_code = fields.countryCode;
+            if (fields.telephone !== undefined)
+                addressInput.telephone = fields.telephone;
+            if (fields.company !== undefined)
+                addressInput.company = fields.company;
+            if (fields.isDefaultShipping !== undefined)
+                addressInput.default_shipping = fields.isDefaultShipping;
+            if (fields.isDefaultBilling !== undefined)
+                addressInput.default_billing = fields.isDefaultBilling;
+            const data = await graphqlFetch(queries.UPDATE_CUSTOMER_ADDRESS, { id: parseInt(id, 10), input: addressInput }, { customerToken: token });
+            return mappers.mapCustomerAddress(data.updateCustomerAddress);
+        },
+        deleteAddress: async (token, addressId) => {
+            await graphqlFetch(queries.DELETE_CUSTOMER_ADDRESS, { id: parseInt(addressId, 10) }, { customerToken: token });
+            return true;
+        },
+    },
+    wishlist: {
+        get: async (token) => {
+            const data = await graphqlFetch(queries.GET_CUSTOMER_WISHLIST, {}, { customerToken: token });
+            // wishlists returns an array - take the first (default) wishlist
+            const wishlist = data.customer.wishlists[0];
+            if (!wishlist) {
+                // Return empty wishlist if none exists
+                return { id: "", items: [], itemsCount: 0 };
+            }
+            return mappers.mapWishlist(wishlist);
+        },
+        addItem: async (token, productSku) => {
+            // First get the wishlist ID
+            const wishlistData = await graphqlFetch(queries.GET_CUSTOMER_WISHLIST, {}, { customerToken: token });
+            const wishlist = wishlistData.customer.wishlists[0];
+            if (!wishlist) {
+                throw new Error("No wishlist found for customer");
+            }
+            const wishlistId = wishlist.id;
+            // Add product to wishlist
+            const data = await graphqlFetch(queries.ADD_TO_WISHLIST, {
+                wishlistId,
+                items: [{ sku: productSku, quantity: 1 }],
+            }, { customerToken: token });
+            if (data.addProductsToWishlist.user_errors?.length > 0) {
+                throw new Error(data.addProductsToWishlist.user_errors[0].message);
+            }
+            return mappers.mapWishlist(data.addProductsToWishlist.wishlist);
+        },
+        removeItem: async (token, itemId) => {
+            // First get the wishlist ID
+            const wishlistData = await graphqlFetch(queries.GET_CUSTOMER_WISHLIST, {}, { customerToken: token });
+            const wishlist = wishlistData.customer.wishlists[0];
+            if (!wishlist) {
+                throw new Error("No wishlist found for customer");
+            }
+            const wishlistId = wishlist.id;
+            // Remove product from wishlist
+            const data = await graphqlFetch(queries.REMOVE_FROM_WISHLIST, {
+                wishlistId,
+                itemIds: [itemId],
+            }, { customerToken: token });
+            if (data.removeProductsFromWishlist.user_errors?.length > 0) {
+                throw new Error(data.removeProductsFromWishlist.user_errors[0].message);
+            }
+            return mappers.mapWishlist(data.removeProductsFromWishlist.wishlist);
+        },
+        clear: async (token) => {
+            // Get wishlist with all items
+            const wishlistData = await graphqlFetch(queries.GET_CUSTOMER_WISHLIST, {}, { customerToken: token });
+            const wishlist = wishlistData.customer.wishlists[0];
+            if (!wishlist) {
+                return { id: "", items: [], itemsCount: 0 };
+            }
+            const wishlistId = wishlist.id;
+            const itemIds = (wishlist.items_v2?.items ?? [])
+                .filter((item) => item != null)
+                .map((item) => item.id);
+            if (itemIds.length === 0) {
+                return mappers.mapWishlist(wishlist);
+            }
+            // Remove all items
+            const data = await graphqlFetch(queries.REMOVE_FROM_WISHLIST, {
+                wishlistId,
+                itemIds,
+            }, { customerToken: token });
+            if (data.removeProductsFromWishlist.user_errors?.length > 0) {
+                throw new Error(data.removeProductsFromWishlist.user_errors[0].message);
+            }
+            return mappers.mapWishlist(data.removeProductsFromWishlist.wishlist);
+        },
+    },
+};
+export default magento2Adapter;