medusa-storefront-data 1.0.0

package/dist/server/products.js

@@ -0,0 +1,285 @@
+"use server";
+import { sdk } from "../config";
+import { getAuthHeaders, getCacheOptions } from "../cookies";
+import { getRegion, retrieveRegion } from "./regions";
+import Color from "color";
+export const listProducts = async ({ pageParam = 1, queryParams, countryCode, regionId, }) => {
+    if (!countryCode && !regionId) {
+        throw new Error("Country code or region ID is required");
+    }
+    const limit = queryParams?.limit || 12;
+    const _pageParam = Math.max(pageParam, 1);
+    const offset = _pageParam === 1 ? 0 : (_pageParam - 1) * limit;
+    let region;
+    if (countryCode) {
+        region = await getRegion(countryCode);
+    }
+    else {
+        region = await retrieveRegion(regionId);
+    }
+    if (!region) {
+        return {
+            response: { products: [], count: 0 },
+            nextPage: null,
+        };
+    }
+    const headers = {
+        ...(await getAuthHeaders()),
+    };
+    const next = {
+        ...(await getCacheOptions("products")),
+    };
+    // 1. Standard Medusa query parameters
+    const standardQuery = {
+        limit,
+        offset,
+        region_id: region?.id,
+        fields: "*variants.calculated_price,+variants.inventory_quantity,*variants.images,+variants.metadata,+variants.options,+metadata,+tags,+average_rating,+total_rating_count,+total_rating_sum,",
+    };
+    // 2. Identify advanced filters that require the product-helper API
+    const advancedFilterKeys = [
+        "metadata", "min_price", "max_price", "q", "collection_id", "category_id",
+        "tags", "option_value", "gender", "color", "material", "style", "brand",
+        "type", "product_type", "order"
+    ];
+    const hasAdvancedFilters = !!(queryParams && Object.keys(queryParams).some(key => advancedFilterKeys.includes(key) && queryParams[key] !== undefined));
+    const endpoint = hasAdvancedFilters ? "/store/product-helper/products" : "/store/products";
+    let finalQuery = { ...standardQuery };
+    if (hasAdvancedFilters) {
+        // We use URLSearchParams to ensure correct formatting and handle repeated keys if needed
+        const params = new URLSearchParams();
+        // 1. Add standard params
+        params.append("limit", limit.toString());
+        params.append("offset", offset.toString());
+        if (region?.id)
+            params.append("region_id", region.id);
+        // Use '*' for helper endpoint to let it resolve necessary relations
+        params.append("fields", "*");
+        // 2. Map queryParams
+        for (const [key, value] of Object.entries(queryParams || {})) {
+            if (["metadata", "min_price", "max_price", "limit", "offset", "region_id", "fields"].includes(key))
+                continue;
+            const values = Array.isArray(value) ? value : [value];
+            const lowerKey = key.toLowerCase();
+            if (lowerKey === "color") {
+                // Map 'color' filter to 'option_value' which backend understands for variants
+                values.forEach(v => params.append("option_value[]", String(v)));
+            }
+            else if (["material", "gender", "product_type", "type", "style", "brand"].includes(lowerKey)) {
+                // Map these to metadata as they are defined as metadata in your config
+                const metaKey = lowerKey === "type" ? "product_type" : lowerKey;
+                values.forEach(v => params.append(`metadata[${metaKey}]`, String(v)));
+            }
+            else {
+                // Standard mapping for others (tags, collection_id, etc.)
+                if (Array.isArray(value)) {
+                    value.forEach(v => params.append(`${key}[]`, String(v)));
+                }
+                else if (value !== undefined && value !== null) {
+                    params.append(key, String(value));
+                }
+            }
+        }
+        // 3. Map price filters (min_price -> price_min, max_price -> price_max)
+        if (queryParams.min_price)
+            params.append("price_min", String(queryParams.min_price));
+        if (queryParams.max_price)
+            params.append("price_max", String(queryParams.max_price));
+        // 4. Map metadata filters to metadata[key] format
+        if (queryParams.metadata) {
+            for (const [key, value] of Object.entries(queryParams.metadata)) {
+                const values = Array.isArray(value) ? value : [value];
+                values.forEach(v => {
+                    if (key.toLowerCase() === "color") {
+                        // Map color in metadata to option_value[]
+                        params.append("option_value[]", String(v));
+                    }
+                    else {
+                        // Standard metadata format: metadata[key]=value
+                        params.append(`metadata[${key}]`, String(v));
+                    }
+                });
+            }
+        }
+        finalQuery = params;
+    }
+    else {
+        // Standard endpoint - only merge known safe Medusa keys from queryParams 
+        // to avoid "Unrecognized fields" errors
+        const safeKeys = ["order", "id", "handle", "status", "created_at", "updated_at", "type_id"];
+        for (const key of safeKeys) {
+            if (queryParams && queryParams[key]) {
+                finalQuery[key] = queryParams[key];
+            }
+        }
+    }
+    // Use the appended query string to avoid SDK's default serialization issues with brackets
+    const requestUrl = hasAdvancedFilters ? `${endpoint}?${finalQuery.toString()}` : endpoint;
+    return sdk.client
+        .fetch(requestUrl, {
+        method: "GET",
+        query: hasAdvancedFilters ? undefined : finalQuery,
+        headers,
+        next: {
+            ...next,
+            revalidate: 0, // Disable Next.js cache for now to show logs
+        },
+        cache: "no-store", // Ensure it hits backend every time for testing
+    })
+        .then(({ products, count }) => {
+        const nextPage = count > offset + limit ? _pageParam + 1 : null;
+        if (products && products.length > 0) {
+        }
+        return {
+            response: {
+                products: products || [],
+                count: count || 0,
+            },
+            nextPage: nextPage,
+            queryParams,
+        };
+    })
+        .catch((error) => {
+        throw error;
+    });
+};
+/**
+ * This will fetch 100 products to the Next.js cache and sort them based on the sortBy parameter.
+ * It will then return the paginated products based on the page and limit parameters.
+ */
+export const listProductsWithSort = async ({ page = 1, queryParams, sortBy = "created_at_desc", countryCode, }) => {
+    const limit = queryParams?.limit || 12;
+    // Directly fetch from backend with correct pagination
+    // This ensures the backend terminal logs the specific request
+    const { response: { products, count }, } = await listProducts({
+        pageParam: page,
+        queryParams: {
+            ...queryParams,
+            limit,
+        },
+        countryCode,
+    });
+    // Sorting is now handled natively by the backend API via the 'order' query param.
+    const finalProducts = products;
+    const nextPage = count > page * limit ? page + 1 : null;
+    return {
+        response: {
+            products: finalProducts,
+            count,
+        },
+        nextPage,
+        queryParams,
+    };
+};
+/**
+ * Fetch products that have a specific tag value
+ */
+export async function getProductsByTag({ tagValue, limit = 12, countryCode, }) {
+    try {
+        const result = await listProducts({
+            queryParams: { tags: [tagValue], limit },
+            countryCode,
+        });
+        return result.response.products;
+    }
+    catch (error) {
+        console.error("Error fetching products by tag:", error);
+        return [];
+    }
+}
+/**
+ * Fetch dynamic filter options from the backend API
+ */
+export const getDynamicFilters = async (countryCode) => {
+    const backendUrl = process.env.MEDUSA_BACKEND_URL || "http://localhost:9000";
+    const publishableKey = process.env.NEXT_PUBLIC_MEDUSA_PUBLISHABLE_KEY;
+    try {
+        if (!publishableKey)
+            return { genders: [], productTypes: [], materials: [], colors: [] };
+        const response = await fetch(`${backendUrl}/store/product-helper/filters`, {
+            method: "GET",
+            headers: {
+                "Content-Type": "application/json",
+                "x-publishable-api-key": publishableKey,
+            },
+            cache: "no-store",
+        });
+        if (!response.ok) {
+            return { genders: [], productTypes: [], materials: [], colors: [] };
+        }
+        const data = await response.json();
+        const formatLabel = (str) => {
+            return str
+                .split(/[_-]/)
+                .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+                .join(' ');
+        };
+        const metadata = data.metadata || {};
+        const variantOptions = data.variant_options || [];
+        // Gather all unique colors from all possible sources
+        const colorSet = new Set();
+        // 1. From variant options (check all options with title 'color')
+        variantOptions.forEach((o) => {
+            if (o.option_title.toLowerCase() === 'color' || o.option_title.toLowerCase() === 'colour') {
+                o.values?.forEach((v) => {
+                    if (v)
+                        colorSet.add(v.trim().toLowerCase());
+                });
+            }
+        });
+        // 2. From metadata colors (handle newline/comma separated values)
+        if (metadata.color) {
+            metadata.color.forEach((c) => {
+                if (c) {
+                    const parts = c.split(/[,/\n\r]+/).map(s => s.trim()).filter(Boolean);
+                    parts.forEach(p => colorSet.add(p.toLowerCase()));
+                }
+            });
+        }
+        return {
+            genders: (metadata.gender || []).sort().map((g) => ({
+                value: g,
+                label: formatLabel(g)
+            })),
+            productTypes: (data.product_types || []).sort((a, b) => a.label.localeCompare(b.label)).map((t) => ({
+                value: t.label,
+                label: formatLabel(t.label)
+            })),
+            materials: (metadata.material || []).sort().map((m) => ({
+                value: m,
+                label: formatLabel(m)
+            })),
+            colors: Array.from(colorSet).sort().map((c) => {
+                let hex = "";
+                try {
+                    // Try to resolve color hex code using the Color library
+                    hex = Color(c.replace(/\s+/g, '').toLowerCase()).hex();
+                }
+                catch (e) {
+                    try {
+                        hex = Color(c.toLowerCase()).hex();
+                    }
+                    catch (e2) {
+                        // No hex found
+                    }
+                }
+                return {
+                    value: c,
+                    label: formatLabel(c),
+                    hex
+                };
+            })
+        };
+    }
+    catch (error) {
+        console.error("Error fetching dynamic filters:", error);
+        return { genders: [], productTypes: [], materials: [], colors: [] };
+    }
+};
+/**
+ * Fetch a single product by its handle
+ */
+export async function getProductByHandle(handle) {
+    const result = await sdk.store.product.list({ handle, fields: "*variants.calculated_price,+variants.inventory_quantity,+variants.manage_inventory,+variants.allow_backorder,*variants.options,*options,*options.values,*images,*thumbnail,+metadata" }, { next: { tags: ["products"] } });
+    return result.products[0];
+}

package/dist/server/regions.d.ts

@@ -0,0 +1,5 @@
+import { HttpTypes } from "@medusajs/types";
+export declare const listRegions: () => Promise<HttpTypes.StoreRegion[]>;
+export declare const retrieveRegion: (id: string) => Promise<HttpTypes.StoreRegion>;
+export declare const getRegion: (countryCode: string) => Promise<HttpTypes.StoreRegion>;
+//# sourceMappingURL=regions.d.ts.map

package/dist/server/regions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"regions.d.ts","sourceRoot":"","sources":["../../src/server/regions.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAG3C,eAAO,MAAM,WAAW,wCAavB,CAAA;AAED,eAAO,MAAM,cAAc,GAAU,IAAI,MAAM,mCAa9C,CAAA;AAID,eAAO,MAAM,SAAS,GAAU,aAAa,MAAM,mCA0BlD,CAAA"}

package/dist/server/regions.js

@@ -0,0 +1,54 @@
+"use server";
+import { sdk } from "../config";
+import medusaError from "../util/medusa-error";
+import { getCacheOptions } from "../cookies";
+export const listRegions = async () => {
+    const next = {
+        ...(await getCacheOptions("regions")),
+    };
+    return sdk.client
+        .fetch(`/store/regions`, {
+        method: "GET",
+        next,
+        cache: "force-cache",
+    })
+        .then(({ regions }) => regions)
+        .catch(medusaError);
+};
+export const retrieveRegion = async (id) => {
+    const next = {
+        ...(await getCacheOptions(["regions", id].join("-"))),
+    };
+    return sdk.client
+        .fetch(`/store/regions/${id}`, {
+        method: "GET",
+        next,
+        cache: "force-cache",
+    })
+        .then(({ region }) => region)
+        .catch(medusaError);
+};
+const regionMap = new Map();
+export const getRegion = async (countryCode) => {
+    try {
+        if (regionMap.has(countryCode)) {
+            return regionMap.get(countryCode);
+        }
+        const regions = await listRegions();
+        if (!regions) {
+            return null;
+        }
+        regions.forEach((region) => {
+            region.countries?.forEach((c) => {
+                regionMap.set(c?.iso_2 ?? "", region);
+            });
+        });
+        const region = countryCode
+            ? regionMap.get(countryCode)
+            : regionMap.get("us");
+        return region;
+    }
+    catch (e) {
+        return null;
+    }
+};

package/dist/server/returns.d.ts

@@ -0,0 +1,29 @@
+import { HttpTypes } from "@medusajs/types";
+export declare const listReturnReasons: () => Promise<any[] | HttpTypes.StoreReturnReason[]>;
+export declare const listReturnShippingOptions: (cartId: string, regionId?: string, productIds?: string[]) => Promise<HttpTypes.StoreShippingOption[]>;
+export declare const createReturnRequest: (state: {
+    success: boolean;
+    error: string | null;
+    return: HttpTypes.StoreReturn | null;
+}, formData: FormData) => Promise<{
+    success: boolean;
+    error: string | null;
+    return: HttpTypes.StoreReturn | null;
+}>;
+/**
+ * Link a payment method to a return (for Refund Destination)
+ */
+export declare const updateReturnPayment: (returnId: string, paymentId: string) => Promise<{
+    success: boolean;
+    data: any;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: any;
+    data?: undefined;
+}>;
+/**
+ * List returns for an order or customer
+ */
+export declare const listReturns: (orderId?: string) => Promise<any>;
+//# sourceMappingURL=returns.d.ts.map

package/dist/server/returns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"returns.d.ts","sourceRoot":"","sources":["../../src/server/returns.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAK3C,eAAO,MAAM,iBAAiB,sDAkB7B,CAAA;AAED,eAAO,MAAM,yBAAyB,GACpC,QAAQ,MAAM,EACd,WAAW,MAAM,EACjB,aAAa,MAAM,EAAE,KACpB,OAAO,CAAC,SAAS,CAAC,mBAAmB,EAAE,CAmEzC,CAAA;AAED,eAAO,MAAM,mBAAmB,GAC9B,OAAO;IACL,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,MAAM,EAAE,SAAS,CAAC,WAAW,GAAG,IAAI,CAAA;CACrC,EACD,UAAU,QAAQ,KACjB,OAAO,CAAC;IACT,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,MAAM,EAAE,SAAS,CAAC,WAAW,GAAG,IAAI,CAAA;CACrC,CA2GA,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,mBAAmB,GAAU,UAAU,MAAM,EAAE,WAAW,MAAM;;;;;;;;EAoB5E,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,WAAW,GAAU,UAAU,MAAM,iBA4CjD,CAAA"}

package/dist/server/returns.js

@@ -0,0 +1,236 @@
+"use server";
+import { sdk } from "../config";
+import { cookies } from "next/headers";
+import { getAuthHeaders, getCacheOptions } from "../cookies";
+import { revalidateTag } from "next/cache";
+export const listReturnReasons = async () => {
+    const headers = {
+        ...(await getAuthHeaders()),
+    };
+    const next = {
+        ...(await getCacheOptions("return_reasons")),
+    };
+    return sdk.client
+        .fetch(`/store/return-reasons`, {
+        method: "GET",
+        headers,
+        next,
+        cache: "force-cache", // Reasons change rarely
+    })
+        .then(({ return_reasons }) => return_reasons)
+        .catch(() => []);
+};
+export const listReturnShippingOptions = async (cartId, regionId, productIds) => {
+    const headers = {
+        ...(await getAuthHeaders()),
+    };
+    const next = {
+        ...(await getCacheOptions("fulfillment")),
+    };
+    // Strategy 1: Try with cart_id (preferred as it has context)
+    if (cartId) {
+        try {
+            const { shipping_options } = await sdk.client.fetch(`/store/shipping-options`, {
+                method: "GET",
+                query: {
+                    cart_id: cartId,
+                    is_return: true,
+                },
+                headers,
+                next,
+                cache: "no-store",
+            });
+            if (shipping_options.length > 0) {
+                return shipping_options;
+            }
+        }
+        catch (e) {
+            // Fallback strategy
+        }
+    }
+    // Strategy 2: Fallback - Create ephemeral cart if region_id is available
+    // This is required because /store/shipping-options STRICTLY requires a cart_id for return options
+    if (regionId) {
+        try {
+            // Create a temporary cart for this region to get valid shipping options
+            const { cart } = await sdk.store.cart.create({ region_id: regionId }, {}, headers);
+            if (cart?.id) {
+                const { shipping_options } = await sdk.client.fetch(`/store/shipping-options`, {
+                    method: "GET",
+                    query: {
+                        cart_id: cart.id,
+                        is_return: true,
+                    },
+                    headers,
+                    next,
+                    cache: "no-store",
+                });
+                return shipping_options;
+            }
+        }
+        catch (e) {
+            // Silence error
+        }
+    }
+    return [];
+};
+export const createReturnRequest = async (state, formData) => {
+    const orderId = formData.get("order_id");
+    const returnShippingOptionId = formData.get("return_shipping_option_id");
+    const itemsJson = formData.get("items");
+    const note = formData.get("note");
+    const locationId = formData.get("location_id");
+    if (!orderId)
+        return { success: false, error: "Order ID is required", return: null };
+    if (!itemsJson)
+        return { success: false, error: "Items are required", return: null };
+    let items = [];
+    try {
+        items = JSON.parse(itemsJson);
+    }
+    catch (e) {
+        return { success: false, error: "Invalid items data", return: null };
+    }
+    if (items.length === 0) {
+        return { success: false, error: "At least one item must be selected", return: null };
+    }
+    const headers = {
+        ...(await getAuthHeaders()),
+    };
+    try {
+        // Standard Medusa v2 payload
+        const payload = {
+            order_id: orderId,
+            items: items.map((item) => ({
+                id: item.id,
+                quantity: item.quantity,
+                reason_id: item.return_reason_id || undefined,
+                note: (note && note.trim().length > 0) ? note : undefined,
+            })),
+            ...(returnShippingOptionId ? {
+                return_shipping: {
+                    option_id: returnShippingOptionId,
+                    location_id: locationId || items[0].location_id || "default_location"
+                }
+            } : {}),
+            // Optional: keep global note if supported
+            note: (note && note.trim().length > 0) ? note : "Return request",
+        };
+        // Double check location_id is NOT nested incorrectly if already set above
+        // The plugin expects return_shipping.location_id
+        // Check for any available guest tokens
+        const cookieStore = await cookies();
+        const guestToken = cookieStore.get("_medusa_guest_jwt")?.value
+            || cookieStore.get("_medusa_guest_token")?.value
+            || cookieStore.get("guest_id")?.value;
+        const token = cookieStore.get("_medusa_jwt")?.value;
+        let returnData;
+        // If we have a guest token, try the guest specific endpoint
+        if (guestToken && !token) {
+            try {
+                const response = await sdk.client.fetch(`/store/guest-orders/${orderId}/returns`, {
+                    method: "POST",
+                    body: payload,
+                    headers: {
+                        ...headers,
+                        "Authorization": `Bearer ${guestToken}`
+                    },
+                    cache: "no-store",
+                });
+                returnData = response.return || response;
+            }
+            catch (e) {
+                // Fallback to standard if guest endpoint fails
+                const response = await sdk.client.fetch(`/store/returns`, {
+                    method: "POST",
+                    body: payload,
+                    headers,
+                    cache: "no-store",
+                });
+                returnData = response.return;
+            }
+        }
+        else {
+            // Standard flow
+            const response = await sdk.client.fetch(`/store/returns`, {
+                method: "POST",
+                body: payload,
+                headers,
+                cache: "no-store",
+            });
+            returnData = response.return;
+        }
+        revalidateTag("orders");
+        return { success: true, error: null, return: returnData };
+    }
+    catch (error) {
+        return { success: false, error: error.message || "Failed to create return request", return: null };
+    }
+};
+/**
+ * Link a payment method to a return (for Refund Destination)
+ */
+export const updateReturnPayment = async (returnId, paymentId) => {
+    const headers = {
+        ...(await getAuthHeaders()),
+    };
+    try {
+        const response = await sdk.client.fetch(`/store/refund-payment-mapping/${returnId}`, {
+            method: "PUT",
+            body: { payment_id: paymentId },
+            headers,
+            cache: "no-store",
+        });
+        return { success: true, data: response };
+    }
+    catch (error) {
+        console.error("Update return payment fail:", error);
+        return { success: false, error: error.message };
+    }
+};
+/**
+ * List returns for an order or customer
+ */
+export const listReturns = async (orderId) => {
+    const headers = {
+        ...(await getAuthHeaders()),
+    };
+    // Authenticated flow
+    const authHeaders = headers;
+    if (authHeaders.authorization || authHeaders.Authorization) {
+        try {
+            const response = await sdk.client.fetch(`/store/returns`, {
+                method: "GET",
+                query: orderId ? { order_id: orderId } : {},
+                headers,
+                cache: "no-store",
+            });
+            return response;
+        }
+        catch (e) {
+            return { returns: [], count: 0 };
+        }
+    }
+    // Guest flow
+    if (orderId) {
+        const cookieStore = await cookies();
+        const guestToken = cookieStore.get("_medusa_guest_jwt")?.value || cookieStore.get("_medusa_guest_token")?.value;
+        if (guestToken) {
+            try {
+                const response = await sdk.client.fetch(`/store/guest-orders/${orderId}/returns`, {
+                    method: "GET",
+                    headers: {
+                        ...headers,
+                        "Authorization": `Bearer ${guestToken}`
+                    },
+                    cache: "no-store",
+                });
+                return response;
+            }
+            catch (e) {
+                return { returns: [], count: 0 };
+            }
+        }
+    }
+    return { returns: [], count: 0 };
+};

package/dist/server/swaps.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Create an exchange (swap) request.
+ * Supports both authenticated customers and guest users.
+ */
+export declare const createSwapRequest: (prevState: any, formData: FormData) => Promise<{
+    success: boolean;
+    error: string | null;
+    swap: any | null;
+}>;
+/**
+ * List swaps for an order or customer
+ */
+export declare const listSwaps: (orderId?: string) => Promise<any>;
+//# sourceMappingURL=swaps.d.ts.map

package/dist/server/swaps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swaps.d.ts","sourceRoot":"","sources":["../../src/server/swaps.ts"],"names":[],"mappings":"AASA;;;GAGG;AACH,eAAO,MAAM,iBAAiB,GAC1B,WAAW,GAAG,EACd,UAAU,QAAQ,KACnB,OAAO,CAAC;IACP,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,IAAI,EAAE,GAAG,GAAG,IAAI,CAAA;CACnB,CA4FA,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,SAAS,GAAU,UAAU,MAAM,iBAgC/C,CAAA"}