medusa-storefront-data 1.0.0

package/dist/server/swaps.js

@@ -0,0 +1,123 @@
+"use server";
+import { sdk } from "../config";
+import { cookies } from "next/headers";
+import { getAuthHeaders } from "../cookies";
+import { revalidateTag } from "next/cache";
+/**
+ * Create an exchange (swap) request.
+ * Supports both authenticated customers and guest users.
+ */
+export const createSwapRequest = async (prevState, formData) => {
+    const orderId = formData.get("order_id");
+    const returnItemsJson = formData.get("return_items");
+    const newItemsJson = formData.get("new_items");
+    const reason = formData.get("reason");
+    const note = formData.get("note");
+    if (!orderId)
+        return { success: false, error: "Order ID is required", swap: null };
+    if (!returnItemsJson)
+        return { success: false, error: "Items to return are required", swap: null };
+    if (!newItemsJson)
+        return { success: false, error: "New items are required", swap: null };
+    let returnItems = [];
+    let newItems = [];
+    try {
+        returnItems = JSON.parse(returnItemsJson);
+        newItems = JSON.parse(newItemsJson);
+    }
+    catch (e) {
+        return { success: false, error: "Invalid items data format", swap: null };
+    }
+    if (returnItems.length === 0) {
+        return { success: false, error: "At least one item must be selected for return", swap: null };
+    }
+    const headers = {
+        ...(await getAuthHeaders()),
+    };
+    try {
+        const payload = {
+            order_id: orderId,
+            return_items: returnItems,
+            new_items: newItems,
+            reason: reason || "Size exchange",
+            note: note || "Exchange requested from storefront",
+        };
+        const cookieStore = await cookies();
+        const guestToken = cookieStore.get("_medusa_guest_jwt")?.value || cookieStore.get("_medusa_guest_token")?.value;
+        const token = cookieStore.get("_medusa_jwt")?.value;
+        let swapData;
+        // Check if we should use the guest endpoint
+        if (guestToken && !token) {
+            const response = await sdk.client.fetch(`/store/guest-orders/${orderId}/swaps`, {
+                method: "POST",
+                body: {
+                    return_items: payload.return_items,
+                    new_items: payload.new_items,
+                    reason: payload.reason,
+                    note: payload.note,
+                },
+                headers: {
+                    ...headers,
+                    "Authorization": `Bearer ${guestToken}`
+                },
+                cache: "no-store",
+            });
+            swapData = response.swap || response;
+        }
+        else {
+            const response = await sdk.client.fetch(`/store/swaps`, {
+                method: "POST",
+                body: payload,
+                headers,
+                cache: "no-store",
+            });
+            swapData = response.swap || response;
+        }
+        revalidateTag("orders");
+        return { success: true, error: null, swap: swapData };
+    }
+    catch (error) {
+        // Extract error message from response if possible
+        let errorMsg = "Failed to create exchange request";
+        if (error.response?.data?.message) {
+            errorMsg = error.response.data.message;
+        }
+        else if (error.message) {
+            errorMsg = error.message;
+        }
+        return { success: false, error: errorMsg, swap: null };
+    }
+};
+/**
+ * List swaps for an order or customer
+ */
+export const listSwaps = async (orderId) => {
+    const headers = {
+        ...(await getAuthHeaders()),
+    };
+    // Authenticated flow
+    if (headers.authorization) {
+        return sdk.client.fetch(`/store/swaps`, {
+            method: "GET",
+            query: orderId ? { order_id: orderId } : {},
+            headers,
+            cache: "no-store",
+        });
+    }
+    // Guest flow
+    if (orderId) {
+        const cookieStore = await cookies();
+        const guestToken = cookieStore.get("_medusa_guest_jwt")?.value || cookieStore.get("_medusa_guest_token")?.value;
+        if (guestToken) {
+            return sdk.client.fetch(`/store/guest-orders/${orderId}/swaps`, {
+                method: "GET",
+                headers: {
+                    ...headers,
+                    "Authorization": `Bearer ${guestToken}`
+                },
+                cache: "no-store",
+            });
+        }
+    }
+    return { swaps: [], count: 0 };
+};

package/dist/server/variants.d.ts

@@ -0,0 +1,3 @@
+import { HttpTypes } from "@medusajs/types";
+export declare const retrieveVariant: (variant_id: string) => Promise<HttpTypes.StoreProductVariant | null>;
+//# sourceMappingURL=variants.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"variants.d.ts","sourceRoot":"","sources":["../../src/server/variants.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAI3C,eAAO,MAAM,eAAe,GAC1B,YAAY,MAAM,KACjB,OAAO,CAAC,SAAS,CAAC,mBAAmB,GAAG,IAAI,CA4B9C,CAAA"}

package/dist/server/variants.js

@@ -0,0 +1,26 @@
+"use server";
+import { sdk } from "../config";
+import { getAuthHeaders, getCacheOptions } from "../cookies";
+export const retrieveVariant = async (variant_id) => {
+    const authHeaders = await getAuthHeaders();
+    if (!authHeaders)
+        return null;
+    const headers = {
+        ...authHeaders,
+    };
+    const next = {
+        ...(await getCacheOptions("variants")),
+    };
+    return await sdk.client
+        .fetch(`/store/product-variants/${variant_id}`, {
+        method: "GET",
+        query: {
+            fields: "*images",
+        },
+        headers,
+        next,
+        cache: "force-cache",
+    })
+        .then(({ variant }) => variant)
+        .catch(() => null);
+};

package/dist/util/get-locale-header.d.ts

@@ -0,0 +1,4 @@
+export declare function getLocaleHeader(): Promise<{
+    readonly "x-medusa-locale": string;
+}>;
+//# sourceMappingURL=get-locale-header.d.ts.map

package/dist/util/get-locale-header.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-locale-header.d.ts","sourceRoot":"","sources":["../../src/util/get-locale-header.ts"],"names":[],"mappings":"AAEA,wBAAsB,eAAe;;GAKpC"}

package/dist/util/get-locale-header.js

@@ -0,0 +1,7 @@
+import { getLocale } from "../server/locale-actions";
+export async function getLocaleHeader() {
+    const locale = await getLocale();
+    return {
+        "x-medusa-locale": locale,
+    };
+}

package/dist/util/medusa-error.d.ts

@@ -0,0 +1,2 @@
+export default function medusaError(error: any): never;
+//# sourceMappingURL=medusa-error.d.ts.map

package/dist/util/medusa-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"medusa-error.d.ts","sourceRoot":"","sources":["../../src/util/medusa-error.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,OAAO,UAAU,WAAW,CAAC,KAAK,EAAE,GAAG,GAAG,KAAK,CAkBrD"}

package/dist/util/medusa-error.js

@@ -0,0 +1,18 @@
+export default function medusaError(error) {
+    if (error.response) {
+        // The request was made and the server responded with a status code
+        // that falls out of the range of 2xx
+        const u = new URL(error.config.url, error.config.baseURL);
+        // Extracting the error message from the response data
+        const message = error.response.data.message || error.response.data;
+        throw new Error(message.charAt(0).toUpperCase() + message.slice(1) + ".");
+    }
+    else if (error.request) {
+        // The request was made but no response was received
+        throw new Error("No response received: " + error.request);
+    }
+    else {
+        // Something happened in setting up the request that triggered an Error
+        throw new Error("Error setting up the request: " + error.message);
+    }
+}

package/package.json

@@ -0,0 +1,152 @@
+{
+  "name": "medusa-storefront-data",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "Medusa storefront server data layer extracted from Next.js storefront",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "src",
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist"
+  },
+  "peerDependencies": {
+    "next": ">=14",
+    "react": ">=18",
+    "@medusajs/js-sdk": ">=2",
+    "@medusajs/types": ">=2",
+    "medusa-reviews-logic": "*",
+    "medusa-wishlist-logic": "*"
+  },
+  "dependencies": {
+    "color": "^5.0.3",
+    "server-only": "^0.0.1"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.0",
+    "@types/react": "^18.3.0",
+    "next": "^15.0.0",
+    "@medusajs/js-sdk": "^2.0.0",
+    "@medusajs/types": "^2.0.0",
+    "@types/node": "^22.0.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./src/server/index.ts",
+      "import": "./src/server/index.ts"
+    },
+    "./cookies": {
+      "types": "./dist/cookies.d.ts",
+      "import": "./src/cookies.ts"
+    },
+    "./config": {
+      "types": "./dist/config.d.ts",
+      "import": "./src/config.ts"
+    },
+    "./locale-header": {
+      "types": "./dist/util/get-locale-header.d.ts",
+      "import": "./src/util/get-locale-header.ts"
+    },
+    "./medusa-error": {
+      "types": "./dist/util/medusa-error.d.ts",
+      "import": "./src/util/medusa-error.ts"
+    },
+    "./sort-products": {
+      "types": "./dist/util/sort-products.d.ts",
+      "import": "./src/util/sort-products.ts"
+    },
+    "./cart": {
+      "types": "./dist/server/cart.d.ts",
+      "import": "./src/server/cart.ts"
+    },
+    "./categories": {
+      "types": "./dist/server/categories.d.ts",
+      "import": "./src/server/categories.ts"
+    },
+    "./collections": {
+      "types": "./dist/server/collections.d.ts",
+      "import": "./src/server/collections.ts"
+    },
+    "./customer": {
+      "types": "./dist/server/customer.d.ts",
+      "import": "./src/server/customer.ts"
+    },
+    "./customer-registration": {
+      "types": "./dist/server/customer-registration.d.ts",
+      "import": "./src/server/customer-registration.ts"
+    },
+    "./dynamic-config": {
+      "types": "./dist/server/dynamic-config.d.ts",
+      "import": "./src/server/dynamic-config.ts"
+    },
+    "./fulfillment": {
+      "types": "./dist/server/fulfillment.d.ts",
+      "import": "./src/server/fulfillment.ts"
+    },
+    "./guest": {
+      "types": "./dist/server/guest.d.ts",
+      "import": "./src/server/guest.ts"
+    },
+    "./locale-actions": {
+      "types": "./dist/server/locale-actions.d.ts",
+      "import": "./src/server/locale-actions.ts"
+    },
+    "./locales": {
+      "types": "./dist/server/locales.d.ts",
+      "import": "./src/server/locales.ts"
+    },
+    "./notifications": {
+      "types": "./dist/server/notifications.d.ts",
+      "import": "./src/server/notifications.ts"
+    },
+    "./onboarding": {
+      "types": "./dist/server/onboarding.d.ts",
+      "import": "./src/server/onboarding.ts"
+    },
+    "./orders": {
+      "types": "./dist/server/orders.d.ts",
+      "import": "./src/server/orders.ts"
+    },
+    "./payment": {
+      "types": "./dist/server/payment.d.ts",
+      "import": "./src/server/payment.ts"
+    },
+    "./payment-details": {
+      "types": "./dist/server/payment-details.d.ts",
+      "import": "./src/server/payment-details.ts"
+    },
+    "./products": {
+      "types": "./dist/server/products.d.ts",
+      "import": "./src/server/products.ts"
+    },
+    "./regions": {
+      "types": "./dist/server/regions.d.ts",
+      "import": "./src/server/regions.ts"
+    },
+    "./returns": {
+      "types": "./dist/server/returns.d.ts",
+      "import": "./src/server/returns.ts"
+    },
+    "./swaps": {
+      "types": "./dist/server/swaps.d.ts",
+      "import": "./src/server/swaps.ts"
+    },
+    "./variants": {
+      "types": "./dist/server/variants.d.ts",
+      "import": "./src/server/variants.ts"
+    },
+    "./wishlist": {
+      "types": "./src/server/wishlist.ts",
+      "import": "./src/server/wishlist.ts"
+    },
+    "./middleware": {
+      "types": "./src/middleware.ts",
+      "import": "./src/middleware.ts"
+    }
+  }
+}

package/src/config.ts

@@ -0,0 +1,39 @@
+import { getLocaleHeader } from "./util/get-locale-header"
+import Medusa, { FetchArgs, FetchInput } from "@medusajs/js-sdk"
+
+// Defaults to standard port for Medusa server
+let MEDUSA_BACKEND_URL = "http://localhost:9000"
+
+if (process.env.MEDUSA_BACKEND_URL) {
+  MEDUSA_BACKEND_URL = process.env.MEDUSA_BACKEND_URL
+}
+
+export const sdk = new Medusa({
+  baseUrl: MEDUSA_BACKEND_URL,
+  debug: process.env.NODE_ENV === "development",
+  publishableKey: process.env.NEXT_PUBLIC_MEDUSA_PUBLISHABLE_KEY,
+})
+
+const originalFetch = sdk.client.fetch.bind(sdk.client)
+
+sdk.client.fetch = async <T>(
+  input: FetchInput,
+  init?: FetchArgs
+): Promise<T> => {
+  const headers = init?.headers ?? {}
+  let localeHeader: Record<string, string | null> | undefined
+  try {
+    localeHeader = await getLocaleHeader()
+    headers["x-medusa-locale"] ??= localeHeader["x-medusa-locale"]
+  } catch {}
+
+  const newHeaders = {
+    ...localeHeader,
+    ...headers,
+  }
+  init = {
+    ...init,
+    headers: newHeaders,
+  }
+  return originalFetch(input, init)
+}

package/src/cookies.ts

@@ -0,0 +1,171 @@
+import "server-only"
+import { cookies as nextCookies, headers } from "next/headers"
+
+export const getAuthHeaders = async (): Promise<
+  { authorization: string } | {}
+> => {
+  try {
+    const cookies = await nextCookies()
+    const token = cookies.get("_medusa_jwt")?.value
+
+    if (!token) {
+      return {}
+    }
+
+    return { authorization: `Bearer ${token}` }
+  } catch {
+    return {}
+  }
+}
+
+export const getGuestAuthHeaders = async (): Promise<
+  { authorization: string } | {}
+> => {
+  try {
+    const cookies = await nextCookies()
+    const token = cookies.get("_medusa_guest_jwt")?.value
+
+    if (!token) {
+      return {}
+    }
+
+    return { authorization: `Bearer ${token}` }
+  } catch {
+    return {}
+  }
+}
+
+export const getCacheTag = async (tag: string): Promise<string> => {
+  try {
+    const cookies = await nextCookies()
+    const cacheId = cookies.get("_medusa_cache_id")?.value
+
+    if (!cacheId) {
+      return ""
+    }
+
+    return `${tag}-${cacheId}`
+  } catch (error) {
+    return ""
+  }
+}
+
+export const getCacheOptions = async (
+  tag: string
+): Promise<{ tags: string[] } | {}> => {
+  if (typeof window !== "undefined") {
+    return {}
+  }
+
+  const cacheTag = await getCacheTag(tag)
+
+  if (!cacheTag) {
+    return {}
+  }
+
+  return { tags: [`${cacheTag}`] }
+}
+
+export const setAuthToken = async (token: string) => {
+  const cookies = await nextCookies()
+  cookies.set("_medusa_jwt", token, {
+    maxAge: 60 * 60 * 24 * 7,
+    httpOnly: true,
+    sameSite: "strict",
+    secure: process.env.NODE_ENV === "production",
+  })
+}
+
+export const removeAuthToken = async () => {
+  const cookies = await nextCookies()
+  cookies.set("_medusa_jwt", "", {
+    maxAge: -1,
+  })
+}
+
+export const getCartId = async () => {
+  const cookies = await nextCookies()
+  const headerList = await headers()
+
+  // Check for x-cart-id header FIRST (as it's the most up-to-date from middleware)
+  const headerId = headerList.get("x-cart-id")
+  if (headerId) {
+    return headerId
+  }
+
+  // Prioritize buy_now_cart_id if it exists
+  const buyNowId = cookies.get("buy_now_cart_id")?.value
+  if (buyNowId) {
+    return buyNowId
+  }
+
+  // Fallback to regular cart cookies
+  const id = cookies.get("_medusa_cart_id")?.value || 
+             cookies.get("cart_id")?.value || 
+             cookies.get("medusa_cart_id")?.value
+             
+  return id
+}
+
+export const setCartId = async (cartId: string) => {
+  const cookies = await nextCookies()
+  cookies.set("_medusa_cart_id", cartId, {
+    maxAge: 60 * 60 * 24 * 7,
+    httpOnly: true,
+    sameSite: "strict",
+    secure: process.env.NODE_ENV === "production",
+  })
+}
+
+export const removeCartId = async () => {
+  const cookies = await nextCookies()
+  cookies.set("_medusa_cart_id", "", {
+    maxAge: -1,
+  })
+}
+
+export const removeSyncLock = async () => {
+  const cookies = await nextCookies()
+  cookies.set("_medusa_cart_synced", "", {
+    maxAge: -1,
+  })
+}
+
+export const setHoldCartId = async (cartId: string) => {
+  const cookies = await nextCookies()
+  cookies.set("_medusa_hold_cart_id", cartId, {
+    maxAge: 60 * 60 * 24,
+    httpOnly: true,
+    sameSite: "strict",
+    secure: process.env.NODE_ENV === "production",
+  })
+}
+
+export const getHoldCartId = async () => {
+  const cookies = await nextCookies()
+  return cookies.get("_medusa_hold_cart_id")?.value
+}
+
+export const removeHoldCartId = async () => {
+  const cookies = await nextCookies()
+  cookies.set("_medusa_hold_cart_id", "", {
+    maxAge: -1,
+  })
+}
+
+export const setBuyNowCartId = async (cartId: string) => {
+  const cookies = await nextCookies()
+  cookies.set("buy_now_cart_id", cartId, {
+    maxAge: 60 * 60 * 24 * 7,
+    httpOnly: true,
+    sameSite: "strict",
+    secure: process.env.NODE_ENV === "production",
+  })
+}
+
+export const removeBuyNowCartId = async () => {
+  const cookies = await nextCookies()
+  cookies.set("buy_now_cart_id", "", {
+    maxAge: -1,
+  })
+}

package/src/middleware.ts

@@ -0,0 +1,2 @@
+export { medusaListRegions, medusaMergeCarts } from "./services/middleware";
+export type { MedusaMiddlewareClientOptions } from "./services/middleware";