@raxonltd/raxon-core 1.1.6 → 1.1.8

package/core/feature/cart/util/cart-optimistic.ts

@@ -0,0 +1,425 @@
+import { BasketItemSummaryInterface, BasketSummaryInterface } from '@/core/interface/basket.interface';
+import { SaleType } from '@/core/interface/prisma.interface';
+import type { QueryClient } from '@tanstack/react-query';
+
+export const CART_QUERY_KEY = ['organization', 'cart'] as const;
+
+export const CART_QUANTITY_DEBOUNCE_MS = 400;
+
+export function createEmptyOptimisticCart(): BasketSummaryInterface {
+  return {
+    id: 'optimistic-cart',
+    acceptedAlternativeProduct: false,
+    items: [],
+    info: {
+      count: { VKE: 0, Basis: 0, Gesamt: 0, Artikel: 0 },
+      basePrice: { total: 0, tax: 0, pay: 0 },
+      deposit: { total: 0, tax: 0, pay: 0 },
+      tax: [],
+      delivery: { total: 0, tax: 0, pay: 0 },
+      discount: { total: 0, tax: 0, pay: 0 },
+      promotion: { total: 0, tax: 0, pay: 0 },
+      campaign: { info: { status: null, message: null, name: null }, total: 0, tax: 0, pay: 0 },
+      payPrice: { total: 0, tax: 0, pay: 0, delivery: 0, discount: 0, deposit: 0, promotion: 0, campaign: 0 },
+    },
+  } as unknown as BasketSummaryInterface;
+}
+
+export interface PendingCartAdd {
+  productId: string;
+  variantId?: string;
+  quantity: number;
+  linePay?: number;
+}
+
+export function unionMergeCarts(carts: (BasketSummaryInterface | undefined)[]): BasketSummaryInterface | undefined {
+  const valid = carts.filter((c): c is BasketSummaryInterface => Boolean(c));
+  if (valid.length === 0) return undefined;
+
+  const lineMap = new Map<string, BasketItemSummaryInterface>();
+
+  for (const cart of valid) {
+    for (const item of cart.items ?? []) {
+      const identity = cartLineIdentity(item);
+      const existing = lineMap.get(identity);
+      if (!existing) {
+        lineMap.set(identity, item);
+        continue;
+      }
+
+      const existingOptimistic = String(existing.id).startsWith('optimistic-');
+      const itemOptimistic = String(item.id).startsWith('optimistic-');
+
+      if (existingOptimistic && !itemOptimistic) {
+        lineMap.set(identity, item);
+        continue;
+      }
+
+      if (!existingOptimistic && !itemOptimistic && Number(item.quantity) >= Number(existing.quantity)) {
+        lineMap.set(identity, item);
+      }
+    }
+  }
+
+  if (lineMap.size === 0) return valid[valid.length - 1];
+
+  const base = valid.find((cart) => (cart.items?.length ?? 0) > 0) ?? valid[0];
+  return recalcCartTotals(base, Array.from(lineMap.values()));
+}
+
+export function readCartCache(queryClient: QueryClient): BasketSummaryInterface | undefined {
+  const direct = queryClient.getQueryData<BasketSummaryInterface>(CART_QUERY_KEY);
+  const entries = queryClient.getQueriesData<BasketSummaryInterface>({ queryKey: CART_QUERY_KEY });
+  const snapshots = [direct, ...entries.map(([, data]) => data)];
+  return unionMergeCarts(snapshots);
+}
+
+export function patchCartCache(
+  queryClient: QueryClient,
+  updater: (old: BasketSummaryInterface | undefined) => BasketSummaryInterface
+) {
+  queryClient.setQueryData(CART_QUERY_KEY, (old: BasketSummaryInterface | undefined) => updater(old));
+}
+
+export function cartLineKey(productId: string | number, variantId?: string | number | null) {
+  return `${productId}:${variantId ?? ''}`;
+}
+
+export function cartLineIdentity(item: BasketItemSummaryInterface) {
+  const variantId = item.variant?.id ?? item.variantId ?? '';
+  return cartLineKey(item.productId, variantId);
+}
+
+export function findCartLine(
+  cart: BasketSummaryInterface | null | undefined,
+  productId: string | number,
+  variantId?: string | number | null
+) {
+  if (!cart?.items) return undefined;
+
+  return cart.items.find((item) => {
+    const sameProduct = String(item.productId) === String(productId);
+    if (!sameProduct) return false;
+
+    const itemVariantId = item.variant?.id ?? item.variantId ?? '';
+    const targetVariantId = variantId ?? '';
+    return String(itemVariantId) === String(targetVariantId);
+  });
+}
+
+export function findConfirmedCartLine(
+  cart: BasketSummaryInterface | null | undefined,
+  productId: string | number,
+  variantId?: string | number | null
+) {
+  const line = findCartLine(cart, productId, variantId);
+  if (!line || String(line.id).startsWith('optimistic-')) return undefined;
+  return line;
+}
+
+export function isFullBasketSnapshot(basket: BasketSummaryInterface, cached?: BasketSummaryInterface): boolean {
+  if (!cached?.items?.length) return true;
+
+  const basketItems = basket.items ?? [];
+  if (basketItems.length >= cached.items.length) return true;
+
+  const basketKeys = new Set(basketItems.map(cartLineIdentity));
+  return cached.items.every((item) => basketKeys.has(cartLineIdentity(item)));
+}
+
+export function mergeCartWithOptimisticExtras(
+  server: BasketSummaryInterface,
+  cached?: BasketSummaryInterface
+): BasketSummaryInterface {
+  if (!cached?.items?.length) return server;
+  if (!server?.items?.length) return cached;
+
+  const serverKeys = new Set(server.items.map(cartLineIdentity));
+  const optimisticExtras = cached.items.filter(
+    (item) => !serverKeys.has(cartLineIdentity(item)) && String(item.id).startsWith('optimistic-')
+  );
+
+  if (optimisticExtras.length === 0) return server;
+
+  return recalcCartTotals(server, [...server.items, ...optimisticExtras]);
+}
+
+export function applyBasketInsertResponse(
+  basket: BasketSummaryInterface,
+  cached?: BasketSummaryInterface
+): BasketSummaryInterface {
+  if (!cached?.items?.length) return basket;
+
+  if (isFullBasketSnapshot(basket, cached)) {
+    return mergeCartWithOptimisticExtras(basket, cached);
+  }
+
+  return (
+    basket.items?.reduce(
+      (acc, item) =>
+        mergeInsertItemIntoCart(acc, {
+          id: String(item.id),
+          productId: String(item.productId),
+          variantId: item.variantId != null ? String(item.variantId) : null,
+          quantity: Number(item.quantity || 1),
+        }),
+      cached
+    ) ?? cached
+  );
+}
+
+export function removeCartLineByKey(cart: BasketSummaryInterface, lineKey: string): BasketSummaryInterface {
+  const items = (cart.items ?? []).filter((item) => {
+    if (String(item.id) === `optimistic-${lineKey}`) return false;
+    return cartLineKey(item.productId, item.variant?.id ?? item.variantId) !== lineKey;
+  });
+  return recalcCartTotals(cart, items);
+}
+
+export function createOptimisticCartLine(add: PendingCartAdd): BasketItemSummaryInterface {
+  const linePay = Number(add.linePay || 0);
+  const quantity = Number(add.quantity || 1);
+
+  return {
+    id: `optimistic-${cartLineKey(add.productId, add.variantId)}`,
+    productId: String(add.productId),
+    variantId: add.variantId ? String(add.variantId) : null,
+    variant: add.variantId ? { id: String(add.variantId) } as BasketItemSummaryInterface['variant'] : null,
+    taxPercentage: 0,
+    images: [],
+    product: {
+      articleNumber: '',
+      type: 'product',
+      baseUnit: { id: '', name: '' },
+      productUnits: [],
+      id: String(add.productId),
+      name: '',
+    },
+    productUnit: { id: '', name: '' },
+    productSaleUnit: '',
+    unitName: '',
+    quantityPerUnitOfMeasure: 1,
+    quantity,
+    saleType: SaleType.UNIT,
+    weight: 0,
+    stock: 0,
+    basePrice: linePay / quantity,
+    discountPrice: 0,
+    lineTotal: linePay,
+    lineTax: 0,
+    linePay,
+    taxAmount: { baseTaxAmount: 0, payTaxAmount: 0 },
+  };
+}
+
+export function applyPendingAdds(
+  cart: BasketSummaryInterface,
+  pendingAdds: Record<string, PendingCartAdd>
+): BasketSummaryInterface {
+  const entries = Object.entries(pendingAdds);
+  if (entries.length === 0) return cart;
+
+  let items = [...(cart.items || [])];
+
+  for (const [, add] of entries) {
+    const existingIndex = items.findIndex((item) => {
+      const sameProduct = String(item.productId) === String(add.productId);
+      const itemVariantId = item.variant?.id ?? item.variantId ?? '';
+      const targetVariantId = add.variantId ?? '';
+      return sameProduct && String(itemVariantId) === String(targetVariantId);
+    });
+
+    if (existingIndex >= 0) {
+      const existing = items[existingIndex];
+      const unitPrice = Number(existing.linePay || add.linePay || 0) / (Number(existing.quantity || add.quantity) || 1);
+      items[existingIndex] = {
+        ...existing,
+        quantity: add.quantity,
+        linePay: unitPrice * add.quantity,
+      };
+      continue;
+    }
+
+    items = [...items, createOptimisticCartLine(add)];
+  }
+
+  return recalcCartTotals(cart, items);
+}
+
+export function extractBasketFromInsertResponse(data: unknown): BasketSummaryInterface | null {
+  if (!data || typeof data !== 'object') return null;
+
+  const payload = data as Record<string, unknown>;
+  if (Array.isArray(payload.items)) return payload as unknown as BasketSummaryInterface;
+
+  const nested = payload.data;
+  if (nested && typeof nested === 'object' && Array.isArray((nested as BasketSummaryInterface).items)) {
+    return nested as unknown as BasketSummaryInterface;
+  }
+
+  return null;
+}
+
+export interface InsertCartItemResponse {
+  id: string;
+  productId: string;
+  variantId?: string | null;
+  quantity: number;
+}
+
+export function extractInsertCartItem(data: unknown): InsertCartItemResponse | null {
+  if (!data || typeof data !== 'object') return null;
+
+  const payload = data as Record<string, unknown>;
+  const raw =
+    payload.data && typeof payload.data === 'object' && !Array.isArray(payload.data)
+      ? (payload.data as Record<string, unknown>)
+      : payload;
+
+  if (!raw.id || !raw.productId) return null;
+
+  return {
+    id: String(raw.id),
+    productId: String(raw.productId),
+    variantId: raw.variantId != null ? String(raw.variantId) : null,
+    quantity: Number(raw.quantity || 1),
+  };
+}
+
+function recalcCartTotals(cart: BasketSummaryInterface, items: BasketItemSummaryInterface[]): BasketSummaryInterface {
+  const newGesamt = items.reduce((sum, item) => sum + Number(item.quantity || 0), 0);
+  const newPay = items.reduce((sum, item) => sum + Number(item.linePay || 0), 0);
+
+  return {
+    ...cart,
+    items,
+    info: {
+      ...cart.info,
+      count: {
+        ...cart.info?.count,
+        Gesamt: newGesamt,
+        Artikel: items.length,
+      },
+      payPrice: {
+        ...cart.info?.payPrice,
+        total: newPay,
+        pay: newPay,
+      },
+    },
+  };
+}
+
+export function mergeInsertItemIntoCart(
+  cart: BasketSummaryInterface,
+  insertItem: InsertCartItemResponse,
+  pendingAdd?: PendingCartAdd
+): BasketSummaryInterface {
+  const items = [...(cart.items || [])];
+  const targetQuantity = Math.max(Number(pendingAdd?.quantity || 0), Number(insertItem.quantity || 1));
+
+  const index = items.findIndex((item) => {
+    if (String(item.id) === `optimistic-${cartLineKey(insertItem.productId, insertItem.variantId)}`) {
+      return true;
+    }
+
+    const sameProduct = String(item.productId) === String(insertItem.productId);
+    const itemVariantId = item.variant?.id ?? item.variantId ?? '';
+    const targetVariantId = insertItem.variantId ?? '';
+    return sameProduct && String(itemVariantId) === String(targetVariantId);
+  });
+
+  const unitPrice =
+    index >= 0
+      ? Number(items[index].linePay || 0) / (Number(items[index].quantity || 0) || 1)
+      : Number(pendingAdd?.linePay || 0) / (Number(pendingAdd?.quantity || 0) || 1);
+
+  const nextLine = {
+    ...(index >= 0
+      ? items[index]
+      : createOptimisticCartLine({
+          productId: insertItem.productId,
+          variantId: insertItem.variantId ?? undefined,
+          quantity: targetQuantity,
+          linePay: unitPrice * targetQuantity,
+        })),
+    id: insertItem.id,
+    productId: insertItem.productId,
+    variantId: insertItem.variantId ?? null,
+    variant: insertItem.variantId ? ({ id: insertItem.variantId } as BasketItemSummaryInterface['variant']) : null,
+    quantity: targetQuantity,
+    linePay: unitPrice * targetQuantity,
+  };
+
+  if (index >= 0) {
+    items[index] = nextLine;
+  } else {
+    items.push(nextLine);
+  }
+
+  return recalcCartTotals(cart, items);
+}
+
+export function patchCartItemQuantity(
+  cart: BasketSummaryInterface,
+  itemId: string,
+  quantity: number,
+  productId?: string,
+  variantId?: string | number | null
+): BasketSummaryInterface {
+  if (!cart.items?.length) return cart;
+
+  let targetId = itemId;
+  const hasTarget = cart.items.some((item) => String(item.id) === itemId);
+
+  if (!hasTarget && productId) {
+    const line = findCartLine(cart, productId, variantId);
+    if (line) targetId = String(line.id);
+  }
+
+  if (!cart.items.some((item) => String(item.id) === targetId)) return cart;
+
+  let priceDiff = 0;
+  const updatedItems = cart.items.map((item) => {
+    if (String(item.id) !== targetId) return item;
+
+    const oldQty = Number(item.quantity || 0);
+    const unitPrice = Number(item.linePay || 0) / (oldQty || 1);
+    priceDiff = (quantity - oldQty) * unitPrice;
+
+    return {
+      ...item,
+      quantity,
+      linePay: quantity * unitPrice,
+    };
+  });
+
+  const newGesamt = updatedItems.reduce((sum, item) => sum + Number(item.quantity || 0), 0);
+
+  return {
+    ...cart,
+    items: updatedItems,
+    info: {
+      ...cart.info,
+      count: {
+        ...cart.info?.count,
+        Gesamt: newGesamt,
+        Artikel: updatedItems.length,
+      },
+      payPrice: {
+        ...cart.info?.payPrice,
+        total: Number(cart.info?.payPrice?.total || 0) + priceDiff,
+        pay: Number(cart.info?.payPrice?.pay || 0) + priceDiff,
+      },
+    },
+  };
+}
+
+export function applyPendingQuantities(
+  cart: BasketSummaryInterface,
+  pendingQuantities: Record<string, number>
+): BasketSummaryInterface {
+  return Object.entries(pendingQuantities).reduce(
+    (acc, [itemId, quantity]) => patchCartItemQuantity(acc, itemId, quantity),
+    cart
+  );
+}

package/core/feature/cart/util/garanti-payment.ts

@@ -0,0 +1,27 @@
+const GARANTI_PAYMENT_HTML_KEY_PREFIX = 'payment:garanti:';
+
+export function storeGarantiPaymentHtml(transactionId: string, html: string) {
+  if (typeof window === 'undefined') return;
+  sessionStorage.setItem(`${GARANTI_PAYMENT_HTML_KEY_PREFIX}${transactionId}`, html);
+}
+
+export function consumeGarantiPaymentHtml(transactionId: string): string | null {
+  if (typeof window === 'undefined') return null;
+  const key = `${GARANTI_PAYMENT_HTML_KEY_PREFIX}${transactionId}`;
+  const html = sessionStorage.getItem(key);
+  if (html) {
+    sessionStorage.removeItem(key);
+  }
+  return html;
+}
+
+export function submitGarantiPaymentHtml(html: string) {
+  const wrapper = document.createElement('div');
+  wrapper.innerHTML = html;
+  const form = wrapper.querySelector('form');
+  if (!(form instanceof HTMLFormElement)) {
+    throw new Error('Garanti ödeme formu bulunamadı.');
+  }
+  document.body.appendChild(form);
+  form.submit();
+}

package/core/feature/collection/hook/use.collection.tsx

@@ -0,0 +1,32 @@
+import { nexineAxios } from "@/core/util/nexine.axios";
+import { IData } from "@/core/interface/nexine.interface";
+import { Address, Campaign, Collection, Order, PromoCode } from "@/core/interface/prisma.interface";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+
+export const useCollection = () => {
+    
+    const queryClient = useQueryClient();
+
+    return {
+        fetch :  (params?: any) => {
+            return useQuery({
+                queryKey: ['web','collection','list',params],
+                queryFn: async () => {
+                    var response = await nexineAxios.get<IData<Collection>>(`/customer/collection`, {
+                        params: params
+                    })
+                    return response.data;
+                },
+            })
+        },
+        detail : (id:string) => {
+            return useQuery({
+                queryKey: ['web','collection','detail',id],
+                queryFn: async () => {
+                    var response = await nexineAxios.get<Collection>(`/customer/collection/${id}`)
+                    return response.data;
+                },
+            })
+        }
+    }
+};

package/core/feature/delivery-method/hook/use.delivery.method.tsx

@@ -0,0 +1,40 @@
+import { nexineAxios } from '@/core/util/nexine.axios';
+import { IData } from '@/core/interface/nexine.interface';
+import { DeliveryMethod } from '@/core/interface/prisma.interface';
+import { useQuery } from '@tanstack/react-query';
+import { getCheckoutDeliveryMethods } from '@/core/feature/delivery-method/util/checkout.delivery.method';
+
+async function fetchDeliveryMethods() {
+  const withTags = await nexineAxios.get<IData<DeliveryMethod>>('/customer/delivery/method', {
+    params: {
+      isCompanySpecificVisible: true,
+      tags: ['WEB'],
+    },
+  });
+
+  const tagged = withTags.data?.data ?? [];
+  if (tagged.length > 0) {
+    return { ...withTags.data, data: getCheckoutDeliveryMethods(tagged) };
+  }
+
+  const fallback = await nexineAxios.get<IData<DeliveryMethod>>('/customer/delivery/method', {
+    params: {
+      isCompanySpecificVisible: true,
+    },
+  });
+
+  const methods = fallback.data?.data ?? [];
+  return { ...fallback.data, data: getCheckoutDeliveryMethods(methods) };
+}
+
+export const useDeliveryMethod = () => {
+  return {
+    fetch: (opts?: { enabled?: boolean }) => {
+      return useQuery({
+        queryKey: ['delivery-method', 'web'],
+        queryFn: fetchDeliveryMethods,
+        enabled: opts?.enabled !== false,
+      });
+    },
+  };
+};

package/core/feature/delivery-method/util/checkout.delivery.method.ts

@@ -0,0 +1,11 @@
+import { DeliveryMethod } from '@/core/interface/prisma.interface';
+
+export function isCashDeskDeliveryMethod(method: Pick<DeliveryMethod, 'name'>): boolean {
+  const name = method.name.toLowerCase();
+  return name.includes('kasadan') || name.includes('cash desk');
+}
+
+/** Web checkout'ta gösterilecek kargo yöntemleri (kasadan satış hariç). */
+export function getCheckoutDeliveryMethods(methods: DeliveryMethod[]): DeliveryMethod[] {
+  return methods.filter((m) => !isCashDeskDeliveryMethod(m));
+}

package/core/feature/faq/hook/use.faq.tsx

@@ -0,0 +1,23 @@
+import { nexineAxios } from "@/core/util/nexine.axios";
+import { IData } from "@/core/interface/nexine.interface";
+import { Brand, Category, Faq } from "@/core/interface/prisma.interface";
+import { useQuery } from "@tanstack/react-query";
+
+export const useFaq = () => {
+  return {
+    fetch: (params: { page: number, amount: number }) => {
+      return useQuery({
+        queryKey: ["faq"],
+        queryFn: async ( ) => {
+          var response = await nexineAxios.get<IData<Faq>>("/customer/faq", {
+            params: {
+              page: params.page,
+              amount: params.amount
+            }
+          });
+          return response.data;
+        },
+      });
+    },
+  };
+};

package/core/feature/favorite/hook/use.favorite.tsx

@@ -0,0 +1,48 @@
+import { nexineAxios } from "@/core/util/nexine.axios";
+import { IData } from "@/core/interface/nexine.interface";
+import { Favorite } from "@/core/interface/prisma.interface";
+import { useMutation, useQuery, useQueryClient, UseQueryOptions } from "@tanstack/react-query";
+import toast from "react-hot-toast";
+
+export interface FavoriteListResponse extends IData<Favorite> {
+    info?: {
+        count?: {
+            Artikel?: number;
+        };
+    };
+}
+
+export const useFavorite = () => {
+
+    const queryClient = useQueryClient();
+
+    return {
+        list: (params?: Record<string, unknown>, options?: Omit<UseQueryOptions<FavoriteListResponse>, 'queryKey' | 'queryFn'>) => {
+            return useQuery<FavoriteListResponse>({
+                queryKey: ['favorite', 'list', params],
+                queryFn: async () => {
+                    const response = await nexineAxios.get<FavoriteListResponse>('/customer/favorite', { params });
+                    return response.data;
+                },
+                ...options
+            });
+        },
+        toggle: () => {
+            return useMutation({
+                mutationFn: async (data: { productId: string }) => {
+                    const response = await nexineAxios.post('/customer/favorite', data);
+                    return response.data;
+                },
+                onSuccess: (data, variables) => {
+                    queryClient.invalidateQueries({ queryKey: ['product'] });
+                    queryClient.invalidateQueries({ queryKey: ['campaign'] });
+                    queryClient.invalidateQueries({ queryKey: ['favorite'] });
+                    toast.success('Favori durumu güncellendi');
+                },
+                onError: () => {
+                    toast.error('Favori işlemi başarısız oldu');
+                }
+            });
+        },
+    };
+};