medusa-storefront-data 1.0.0 → 2.1.0

package/src/util/sort-products.ts

@@ -1,47 +1,2 @@
-import { HttpTypes } from "@medusajs/types";
-
-export type SortOptions =
-    | "price_asc"
-    | "price_desc"
-    | "created_at_desc"
-    | "created_at_asc"
-    | "bestsellers"
-    | "created_at";
-
-interface MinPricedProduct extends HttpTypes.StoreProduct {
-    _minPrice?: number;
-}
-
-export function sortProducts(
-    products: HttpTypes.StoreProduct[],
-    sortBy: SortOptions
-): HttpTypes.StoreProduct[] {
-    const sortedProducts = products as MinPricedProduct[];
-
-    if (["price_asc", "price_desc"].includes(sortBy)) {
-        sortedProducts.forEach((product) => {
-            if (product.variants && product.variants.length > 0) {
-                product._minPrice = Math.min(
-                    ...product.variants.map(
-                        (variant) => variant?.calculated_price?.calculated_amount || 0
-                    )
-                );
-            } else {
-                product._minPrice = Infinity;
-            }
-        });
-
-        sortedProducts.sort((a, b) => {
-            const diff = a._minPrice! - b._minPrice!;
-            return sortBy === "price_asc" ? diff : -diff;
-        });
-    }
-
-    if (sortBy === "created_at") {
-        sortedProducts.sort((a, b) => {
-            return new Date(b.created_at!).getTime() - new Date(a.created_at!).getTime();
-        });
-    }
-
-    return sortedProducts;
-}
+export type { SortOptions } from "medusa-services/product-listing";
+export { sortProducts } from "medusa-services/product-listing";

package/src/util/store-client.ts

@@ -0,0 +1,93 @@
+import type { MedusaStoreClientOptions } from "medusa-services/store-api"
+import { getStoreAuthOptions, type MedusaAuthClientOptions } from "medusa-services/auth"
+import { getAuthHeaders, getGuestAuthHeaders } from "../cookies"
+import { getLocaleHeader } from "./get-locale-header"
+import { cookies as nextCookies } from "next/headers"
+
+function getBackendUrl(): string {
+  return (
+    process.env.MEDUSA_BACKEND_URL?.replace(/\/$/, "") ||
+    process.env.NEXT_PUBLIC_MEDUSA_BACKEND_URL?.replace(/\/$/, "") ||
+    "http://localhost:9000"
+  )
+}
+
+function getPublishableApiKey(): string {
+  const key = process.env.NEXT_PUBLIC_MEDUSA_PUBLISHABLE_KEY
+  if (!key) {
+    throw new Error("NEXT_PUBLIC_MEDUSA_PUBLISHABLE_KEY is not configured")
+  }
+  return key
+}
+
+/**
+ * Builds portable Medusa store client options from Next.js cookies and env.
+ */
+export async function getStoreClientOptions(): Promise<MedusaStoreClientOptions> {
+  const auth = await getAuthHeaders()
+  const localeHeader = await getLocaleHeader().catch(() => ({} as Record<string, string>))
+
+  return {
+    backendUrl: getBackendUrl(),
+    publishableApiKey: getPublishableApiKey(),
+    authorization: "authorization" in auth ? auth.authorization : undefined,
+    headers: localeHeader["x-medusa-locale"]
+      ? { "x-medusa-locale": localeHeader["x-medusa-locale"] }
+      : undefined,
+  }
+}
+
+/** @deprecated Use getStoreClientOptions */
+export const getStoreCartClientOptions = getStoreClientOptions
+
+export function getMedusaBackendUrl(): string {
+  return getBackendUrl()
+}
+
+export async function getGuestStoreClientOptions(): Promise<MedusaStoreClientOptions | null> {
+  const guestAuth = await getGuestAuthHeaders()
+  let authorization = "authorization" in guestAuth ? guestAuth.authorization : undefined
+
+  if (!authorization) {
+    try {
+      const cookieStore = await nextCookies()
+      const legacyToken = cookieStore.get("_medusa_guest_token")?.value
+      if (legacyToken) {
+        authorization = `Bearer ${legacyToken}`
+      }
+    } catch {
+      return null
+    }
+  }
+
+  if (!authorization) return null
+
+  return {
+    backendUrl: getBackendUrl(),
+    publishableApiKey: getPublishableApiKey(),
+    authorization,
+  }
+}
+
+export async function getStoreClientOptionsWithToken(
+  token: string
+): Promise<MedusaStoreClientOptions> {
+  return {
+    backendUrl: getBackendUrl(),
+    publishableApiKey: getPublishableApiKey(),
+    authorization: token.startsWith("Bearer ") ? token : `Bearer ${token}`,
+  }
+}
+
+export async function getAuthClientOptions(authorization?: string): Promise<MedusaAuthClientOptions> {
+  if (authorization) {
+    return getStoreAuthOptions({
+      backendUrl: getBackendUrl(),
+      publishableApiKey: getPublishableApiKey(),
+      authorization,
+    })
+  }
+
+  const storeOptions = await getStoreClientOptions()
+  return getStoreAuthOptions(storeOptions)
+}

package/src/services/middleware.ts

@@ -1,54 +0,0 @@
-/** Edge-safe Medusa store fetches (no Node SDK). */
-
-export interface MedusaMiddlewareClientOptions {
-    backendUrl: string;
-    publishableApiKey: string;
-}
-
-function normalizeBackendUrl(backendUrl: string): string {
-    return backendUrl.replace(/\/$/, "");
-}
-
-export async function medusaListRegions(
-    options: MedusaMiddlewareClientOptions,
-    init?: RequestInit
-): Promise<{ regions: unknown[] }> {
-    const url = `${normalizeBackendUrl(options.backendUrl)}/store/regions`;
-    const response = await fetch(url, {
-        ...init,
-        headers: {
-            "x-publishable-api-key": options.publishableApiKey,
-            ...(init?.headers as Record<string, string> | undefined),
-        },
-    });
-
-    const json = (await response.json()) as { regions?: unknown[]; message?: string };
-    if (!response.ok) {
-        throw new Error(json.message || "Failed to fetch regions");
-    }
-    return { regions: json.regions ?? [] };
-}
-
-export async function medusaMergeCarts(
-    options: MedusaMiddlewareClientOptions & {
-        authorization: string;
-        cartId?: string;
-    },
-    init?: RequestInit
-): Promise<Response> {
-    const url = `${normalizeBackendUrl(options.backendUrl)}/store/carts/merge`;
-    return fetch(url, {
-        method: "POST",
-        ...init,
-        headers: {
-            "Content-Type": "application/json",
-            "x-publishable-api-key": options.publishableApiKey,
-            Authorization: options.authorization.startsWith("Bearer ")
-                ? options.authorization
-                : `Bearer ${options.authorization}`,
-            ...(init?.headers as Record<string, string> | undefined),
-        },
-        body: options.cartId ? JSON.stringify({ cart_id: options.cartId }) : init?.body,
-        cache: init?.cache ?? "no-store",
-    });
-}