@osimart/create-storefront 0.0.0-stage → 1.0.1

package/app/services/CartServices.js

@@ -0,0 +1,91 @@
+import { apiService, getBaseUrl } from './ApiServices';
+import { getCartToken, setCartToken, clearCartToken } from './CartToken';
+import { analytics } from '#osi/utils/analytics';
+
+export const cartHeaders = () => {
+  const token = getCartToken();
+  return token ? { "X-Cart-Token": token } : {};
+};
+
+// Every cart response — view, add, remove, merge — comes through here, so it is
+// also where analytics learns what the cart holds. (Used to tell what an edit
+// changed: the server's answer to a remove no longer contains the removed line.)
+const persistCartToken = (responseData) => {
+  if (responseData?.cart_token) setCartToken(responseData.cart_token);
+  analytics.rememberCart(responseData);
+  return responseData;
+};
+
+/**
+ * Add to / remove from a cart line (a line is a variant id).
+ *
+ * `context` is optional: callers that hold the product (product page, card,
+ * quick buy) pass `{ product, variant }` so the analytics event carries its
+ * brand and category, which the cart payload doesn't repeat. Cart-side callers
+ * (drawer, checkout) omit it and get it from what was remembered at add time.
+ *
+ * This is the single place add_to_cart / remove_from_cart are reported: every
+ * cart edit in the storefront goes through here, once.
+ */
+const EditCart = async (item_id, quantity = 1, action, context) => {
+  try {
+    const baseUrl = getBaseUrl();
+    const before = analytics.peekCartLine(item_id);
+    const responseData = await apiService(`${baseUrl}store/apis/cart/update-item/`, {
+      method: "POST",
+      headers: cartHeaders(),
+      body: JSON.stringify({ quantity, item_id, action }),
+    });
+    persistCartToken(responseData);
+    analytics.cartEdited({
+      itemId: item_id,
+      quantity,
+      action,
+      before,
+      after: responseData?.cart?.[item_id] ?? null,
+      context,
+    });
+    return responseData;
+  } catch (error) {
+    console.error('Cart fetch error:', error);
+    throw error;
+  }
+};
+
+const fetchCart = async () => {
+  try {
+    const baseUrl = getBaseUrl();
+    const responseData = await apiService(`${baseUrl}store/apis/cart/view/`, {
+      method: 'GET',
+      headers: cartHeaders(),
+    });
+    return persistCartToken(responseData);
+  } catch (error) {
+    console.error('Cart fetch error:', error);
+    throw error;
+  }
+};
+
+const mergeCart = async () => {
+  const token = getCartToken();
+  if (!token) return null;
+  try {
+    const baseUrl = getBaseUrl();
+    const responseData = await apiService(`${baseUrl}store/apis/cart/merge/`, {
+      method: 'POST',
+      headers: cartHeaders(),
+      body: JSON.stringify({ cart_token: token }),
+    });
+    clearCartToken();
+    return responseData;
+  } catch (error) {
+    console.error('Cart merge error:', error);
+    throw error;
+  }
+};
+
+export default {
+  EditCart,
+  fetchCart,
+  mergeCart,
+};

package/app/services/CartToken.js

@@ -0,0 +1,26 @@
+const KEY = "cart_token";
+
+export const getCartToken = () => {
+  try {
+    return localStorage.getItem(KEY);
+  } catch {
+    return null;
+  }
+};
+
+export const setCartToken = (token) => {
+  if (!token) return;
+  try {
+    localStorage.setItem(KEY, token);
+  } catch {
+    /* ignore */
+  }
+};
+
+export const clearCartToken = () => {
+  try {
+    localStorage.removeItem(KEY);
+  } catch {
+    /* ignore */
+  }
+};

package/app/services/CategoryServices.js

@@ -0,0 +1,54 @@
+import { apiService, getBaseUrl } from "./ApiServices";
+
+// See HomeServices.js — optional trailing baseUrl, resolved by the caller
+// before its first await when this is used from SSR (category/listing pages).
+
+const getCategoryProducts = async (id, params = {}, baseUrl) => {
+  try {
+    baseUrl = baseUrl || getBaseUrl();
+    const { page, pageSize, ordering, values } = params;
+    const searchParams = new URLSearchParams();
+
+    if (Array.isArray(id)) {
+      id.forEach(catId => {
+        if (catId) searchParams.append('categories', catId);
+      });
+    } else if (id) {
+      searchParams.append('categories', id);
+    }
+
+    if (page) searchParams.set('page', page);
+    if (pageSize) searchParams.set('page_size', pageSize);
+    if (ordering) searchParams.set('ordering', ordering);
+    if (Array.isArray(values)) {
+      values.forEach((v) => {
+        if (v) searchParams.append('variant_values', v);
+      });
+    }
+
+    const responseData = await apiService(`${baseUrl}store/apis/products/?${searchParams.toString()}`, {
+      method: 'GET',
+    });
+
+    return responseData;
+  } catch (error) {
+    throw error;
+  }
+};
+
+const getFilters = async (baseUrl) => {
+  try {
+    baseUrl = baseUrl || getBaseUrl();
+    const responseData = await apiService(`${baseUrl}store/apis/variant-types/`, {
+      method: 'GET',
+    });
+    return responseData;
+  } catch (error) {
+    throw error;
+  }
+};
+
+export default {
+  getCategoryProducts,
+  getFilters,
+};

package/app/services/CheckoutServices.js

@@ -0,0 +1,113 @@
+import { apiService, getBaseUrl } from "./ApiServices";
+import { getCartToken, setCartToken } from "./CartToken";
+
+const cartHeaders = () => {
+  const token = getCartToken();
+  return token ? { "X-Cart-Token": token } : {};
+};
+
+const fetchCart = async () => {
+  try {
+    const baseUrl = getBaseUrl();
+    const responseData = await apiService(`${baseUrl}store/apis/cart/view/`, {
+      method: "GET",
+      headers: cartHeaders(),
+    });
+
+    if (responseData?.cart_token) setCartToken(responseData.cart_token);
+    return responseData;
+  } catch (error) {
+    console.error("Cart fetch error:", error);
+    throw error;
+  }
+};
+
+// Posts the payload as built by the checkout page. The cart itself is resolved
+// server-side from X-Cart-Token — the `cart` key in the body is a leftover the
+// backend ignores, kept so the request shape matches what the live stores send.
+const placeOrder = async (data) => {
+  try {
+    const baseUrl = getBaseUrl();
+    const responseData = await apiService(`${baseUrl}store/apis/checkout/`, {
+      method: "POST",
+      headers: cartHeaders(),
+      body: JSON.stringify(data),
+    });
+
+    return responseData;
+  } catch (error) {
+    console.error("Error in placeOrder:", error);
+    throw error;
+  }
+};
+
+const getOrder = async (orderId) => {
+  try {
+    const baseUrl = getBaseUrl();
+    const responseData = await apiService(
+      `${baseUrl}store/apis/order-summaries/${orderId}/`,
+      {
+        method: "GET",
+        headers: cartHeaders(),
+      },
+    );
+
+    return responseData;
+  } catch (error) {
+    console.error("Error fetching order summary:", error);
+    throw error;
+  }
+};
+
+const promoCode = async (code) => {
+  try {
+    const baseUrl = getBaseUrl();
+    const responseData = await apiService(
+      `${baseUrl}store/apis/promocodes/?code=${code}`,
+      { method: "GET" },
+    );
+    return responseData;
+  } catch (error) {
+    console.error("Promo code error:", error);
+    throw error;
+  }
+};
+
+const freeDeliveries = async (country) => {
+  try {
+    const baseUrl = getBaseUrl();
+    const responseData = await apiService(
+      `${baseUrl}store/apis/freedeliveries/?countries=${country}`,
+      { method: "GET" },
+    );
+    return responseData;
+  } catch (error) {
+    console.error("Free deliveries error:", error);
+    throw error;
+  }
+};
+
+// Optional per-store checkout add-ons (donations, packaging, service fees).
+// Rendered by components/checkout/ExtraFees.vue and sent back as
+// payload.extra_fees on checkout.
+const extraFees = async () => {
+  try {
+    const baseUrl = getBaseUrl();
+    const responseData = await apiService(`${baseUrl}store/apis/extrafees/`, {
+      method: "GET",
+    });
+    return responseData;
+  } catch (error) {
+    console.error("Extra fees error:", error);
+    throw error;
+  }
+};
+
+export default {
+  fetchCart,
+  placeOrder,
+  getOrder,
+  promoCode,
+  freeDeliveries,
+  extraFees,
+};

package/app/services/HomeServices.js

@@ -0,0 +1,133 @@
+import { apiService, getBaseUrl } from "./ApiServices";
+
+/**
+ * Every method here accepts an optional trailing `baseUrl`. Pass it when
+ * calling from SSR (resolve it in the composable/setup with
+ * useState('base-url') or useStoreInit(), *before* your first await, then
+ * hand it down). Without it, this falls back to getBaseUrl() internally —
+ * fine for client-only calls (button handlers, onMounted), but on the server
+ * that internal call happens after this function's own await boundary, where
+ * Nuxt's instance context is already gone. See ApiServices.js and
+ * storefront.service.js for the full explanation.
+ */
+
+const getCategories = async (baseUrl) => {
+  try {
+    baseUrl = baseUrl || getBaseUrl();
+    const responseData = await apiService(`${baseUrl}store/apis/categories/`, {
+      method: 'GET',
+    });
+    return responseData;
+  } catch (error) {
+    throw error;
+  }
+};
+
+const getNewArrivals = async (pageSize = 10, baseUrl) => {
+  try {
+    baseUrl = baseUrl || getBaseUrl();
+    const responseData = await apiService(`${baseUrl}store/apis/products/?page_size=${pageSize}`, {
+      method: 'GET',
+    });
+    return responseData;
+  } catch (error) {
+    throw error;
+  }
+};
+
+const getSectionProduct = async (section, pageSize = 10, baseUrl) => {
+  try {
+    baseUrl = baseUrl || getBaseUrl();
+    const responseData = await apiService(`${baseUrl}store/apis/products/?sections=${section}&page_size=${pageSize}`, {
+      method: 'GET',
+    });
+    return responseData;
+  } catch (error) {
+    throw error;
+  }
+};
+
+const getTrendingProducts = async (baseUrl) => {
+  try {
+    baseUrl = baseUrl || getBaseUrl();
+    const responseData = await apiService(`${baseUrl}store/apis/products/`, {
+      method: 'GET',
+    });
+    return responseData;
+  } catch (error) {
+    throw error;
+  }
+};
+
+const getBanners = async (baseUrl) => {
+  try {
+    baseUrl = baseUrl || getBaseUrl();
+    const responseData = await apiService(`${baseUrl}store/apis/banners/`, {
+      method: "GET",
+    });
+    return responseData;
+  } catch (error) {
+    throw error;
+  }
+};
+
+const getCollections = async (baseUrl) => {
+  try {
+    baseUrl = baseUrl || getBaseUrl();
+    const responseData = await apiService(`${baseUrl}store/apis/collections/`, {
+      method: 'GET',
+    });
+    return responseData;
+  } catch (error) {
+    throw error;
+  }
+};
+
+const getCollectionProducts = async (id, params = {}, baseUrl) => {
+  try {
+    baseUrl = baseUrl || getBaseUrl();
+    const { page, pageSize, ordering, values } = params;
+    const searchParams = new URLSearchParams();
+    if (id) {
+      searchParams.set('collections', id);
+    }
+    if (page) searchParams.set('page', page);
+    if (pageSize) searchParams.set('page_size', pageSize);
+    if (ordering) searchParams.set('ordering', ordering);
+    if (Array.isArray(values)) {
+      values.forEach((v) => {
+        if (v) searchParams.append('variant_values', v);
+      });
+    }
+
+    const responseData = await apiService(`${baseUrl}store/apis/products/?${searchParams.toString()}`, {
+      method: 'GET',
+    });
+    return responseData;
+  } catch (error) {
+    throw error;
+  }
+};
+
+const getAnnouncements = async (baseUrl) => {
+  try {
+    baseUrl = baseUrl || getBaseUrl();
+    const responseData = await apiService(`${baseUrl}store/apis/announcementbars/`, {
+      method: "GET",
+    });
+    return responseData;
+  } catch (error) {
+    throw error;
+  }
+};
+
+export default {
+  getNewArrivals,
+  getCategories,
+  getTrendingProducts,
+  getBanners,
+  getSectionProduct,
+  getCollections,
+  getCollectionProducts,
+  getAnnouncements,
+};

package/app/services/NewsletterServices.js

@@ -0,0 +1,29 @@
+import { apiService, getBaseUrl } from "./ApiServices";
+
+/**
+ * Newsletter subscriptions.
+ *
+ * ⚠ There is no subscribe endpoint in the storefront API yet — UserServices has
+ * contact() but nothing for mailing lists, and Terazar's footer form only ever
+ * called alert(). So this file is the one place that has to change once the
+ * backend route exists.
+ *
+ * If the real path differs, edit ENDPOINT and nothing else: NewsletterSection
+ * doesn't know the URL.
+ *
+ * Expected contract:
+ *   POST <base>store/apis/newsletter-subscribers/
+ *   { email, source }
+ *   201 -> created; 400 with { email: [...] } -> already subscribed / invalid
+ */
+const ENDPOINT = "store/apis/newsletter-subscribers/";
+
+const subscribe = async (email, source = "STOREFRONT") => {
+  const baseUrl = getBaseUrl();
+  return apiService(`${baseUrl}${ENDPOINT}`, {
+    method: "POST",
+    body: JSON.stringify({ email, source }),
+  });
+};
+
+export default { subscribe };

package/app/services/PaymentServices.js

@@ -0,0 +1,71 @@
+import { apiService, getBaseUrl } from "./ApiServices";
+
+// The tenant is resolved from the Host/Origin by StoreResolutionMiddleware, so
+// there's no ?store= param here — and no VITE_BASE_URL either: one Nuxt process
+// serves every store, so the host is read at request time via getBaseUrl().
+const paymentsUrl = () => `${getBaseUrl()}store/apis/payments/`;
+
+const REFERENCE_KEY = "pay_reference";
+
+// Only methods that are active, unlisted-free and fully configured come back —
+// the server already filtered, so the storefront renders whatever it gets.
+const getMethods = async () => {
+  try {
+    const responseData = await apiService(`${paymentsUrl()}methods/`, {
+      method: "GET",
+    });
+    // tolerate both a bare array and a DRF paginated envelope
+    return Array.isArray(responseData) ? responseData : responseData?.results || [];
+  } catch (error) {
+    console.error("Payment methods fetch error:", error);
+    throw error;
+  }
+};
+
+const completeClientSecretPayment = async (reference, transientToken) => {
+  try {
+    return await apiService(`${paymentsUrl()}verify/`, {
+      method: "POST",
+      body: JSON.stringify({ reference, transient_token: transientToken }),
+    });
+  } catch (error) {
+    console.error("Payment completion error:", error);
+    throw error;
+  }
+};
+
+const verify = async (reference) => {
+  try {
+    return await apiService(
+      `${paymentsUrl()}verify/?reference=${encodeURIComponent(reference)}`,
+      { method: "GET" },
+    );
+  } catch (error) {
+    console.error("Payment verify error:", error);
+    throw error;
+  }
+};
+
+const setReference = (reference) => {
+  if (typeof window === "undefined" || !reference) return;
+  sessionStorage.setItem(REFERENCE_KEY, reference);
+};
+
+const getReference = () => {
+  if (typeof window === "undefined") return null;
+  return sessionStorage.getItem(REFERENCE_KEY);
+};
+
+const clearReference = () => {
+  if (typeof window === "undefined") return;
+  sessionStorage.removeItem(REFERENCE_KEY);
+};
+
+export default {
+  getMethods,
+  verify,
+  completeClientSecretPayment,
+  setReference,
+  getReference,
+  clearReference,
+};

package/app/services/PoliciesServices.js

@@ -0,0 +1,16 @@
+import { apiService, getBaseUrl } from "./ApiServices";
+
+const getPolicies = async () => {
+  try {
+    const baseUrl = getBaseUrl();
+    const responseData = await apiService(`${baseUrl}store/apis/policies/`, {
+      method: 'GET',
+    });
+
+    return responseData;
+  } catch (error) {
+    console.log(error);
+  }
+};
+
+export default { getPolicies };

package/app/services/ProductServices.js

@@ -0,0 +1,79 @@
+import { apiService, getBaseUrl } from "./ApiServices";
+
+// See HomeServices.js — optional trailing baseUrl, resolved by the caller
+// before its first await when this is used from SSR (product detail pages).
+
+const getProductDetail = async (id, baseUrl) => {
+  try {
+    baseUrl = baseUrl || getBaseUrl();
+    const responseData = await apiService(`${baseUrl}store/apis/products/${id}`, {
+      method: 'GET',
+      credentials: "include",
+    });
+
+    return responseData;
+  } catch (error) {
+    throw error;
+  }
+};
+
+const getProductId = async (id, baseUrl) => {
+  try {
+    baseUrl = baseUrl || getBaseUrl();
+    const responseData = await apiService(`${baseUrl}store/apis/products/?slugified_name=${id}`, {
+      method: 'GET',
+    });
+
+    return responseData;
+  } catch (error) {
+    throw error;
+  }
+};
+
+const getProductsByIds = async (productIds, baseUrl) => {
+  try {
+    baseUrl = baseUrl || getBaseUrl();
+    const searchParams = new URLSearchParams();
+
+    if (Array.isArray(productIds)) {
+      productIds.forEach(productId => {
+        if (productId) searchParams.append('id', productId);
+      });
+    }
+
+    const responseData = await apiService(`${baseUrl}store/apis/products/?${searchParams.toString()}`, {
+      method: 'GET',
+    });
+
+    return responseData;
+  } catch (error) {
+    throw error;
+  }
+};
+
+const listProducts = async (params = {}, baseUrl) => {
+  try {
+    baseUrl = baseUrl || getBaseUrl();
+    const searchParams = new URLSearchParams();
+
+    Object.entries(params).forEach(([key, value]) => {
+      if (value !== undefined && value !== null && value !== "") {
+        searchParams.append(key, value);
+      }
+    });
+
+    return await apiService(`${baseUrl}store/apis/products/?${searchParams.toString()}`, {
+      method: 'GET',
+    });
+  } catch (error) {
+    throw error;
+  }
+};
+
+
+export default {
+  getProductDetail,
+  getProductId,
+  getProductsByIds,
+  listProducts
+};

package/app/services/SearchServices.js

@@ -0,0 +1,18 @@
+import { apiService, getBaseUrl } from "./ApiServices";
+
+const search = async (searchQuery) => {
+  try {
+    const baseUrl = getBaseUrl();
+    const responseData = await apiService(`${baseUrl}store/apis/products/?search=${encodeURIComponent(searchQuery)}`, {
+      method: 'GET',
+    });
+
+    return responseData;
+  } catch (error) {
+    throw error;
+  }
+};
+
+export default {
+  search,
+};