@raxonltd/raxon-core 1.1.6 → 1.1.8

package/core/component/general.image.tsx

@@ -0,0 +1,86 @@
+'use client';
+
+import { useEffect, useState } from 'react';
+import Image from 'next/image';
+
+interface GeneralImageProps {
+  src?: string;
+  alt: string;
+
+  width?: number;
+  height?: number;
+  className?: string;
+  fill?: boolean;
+  aspectRatio?: string;
+  style?: React.CSSProperties;
+  wrapperClassName?: string;
+  sizes?: string;
+  priority?: boolean;
+  quality?: number;
+  placeholder?: 'blur' | 'empty';
+  blurDataURL?: string;
+  onLoad?: () => void;
+  onError?: () => void;
+  loading?: 'lazy' | 'eager';
+  fetchPriority?: 'low' | 'high';
+  objectFit?: 'contain' | 'cover' | 'fill' | 'none' | 'scale-down';
+  fallback?: 'placeholder' | 'hide' | 'error';
+}
+
+const GeneralImage = (props: GeneralImageProps) => {
+  // Placeholder image URL
+  const placeholderImage = 'https://placehold.co/600x400';
+  const [isLoading, setIsLoading] = useState(true);
+
+  if(!props.src) {
+    return null;
+  }
+  
+  let mageData = (
+    <>
+      {isLoading && (
+        <div className="absolute inset-0 flex items-center justify-center bg-gray-100">
+          <div className="animate-spin rounded-full h-8 w-8 border-b-2 border-gray-900"></div>
+        </div>
+      )}
+      <Image
+        placeholder="empty"
+        src={props.src!}
+        alt={props.alt}
+        fill={props.fill}
+        style={{
+          ...props.style,
+          opacity: isLoading ? 0 : 1,
+          transition: 'opacity 0.3s ease-in-out'
+        }}
+        className={props.className}
+        width={props.width}
+        height={props.height}
+        priority={props.priority}
+        quality={props.quality ?? 80}
+        objectFit={props.objectFit}
+        fetchPriority={props.fetchPriority}
+        onLoad={() => {
+          setIsLoading(false);
+          props.onLoad?.();
+        }}
+        onError={() => {
+          setIsLoading(false);
+          props.onError?.();
+        }}
+      />
+    </>
+  );
+
+  if (props.aspectRatio) {
+    return (
+      <>
+        <div className={`aspect-[${props.aspectRatio}] ${props.wrapperClassName}`}>{mageData}</div>
+      </>
+    );
+  } else {
+    return mageData;
+  }
+};
+
+export { GeneralImage };

package/core/context/cart.context.tsx

@@ -0,0 +1,446 @@
+'use client';
+
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { useQueryClient } from '@tanstack/react-query';
+import { useCart } from '@/core/feature/cart/hook/use.cart';
+import toast from 'react-hot-toast';
+import { BasketSummaryInterface } from '@/core/interface/basket.interface';
+import { PromoCode } from '@/core/interface/prisma.interface';
+import {
+  applyPendingAdds,
+  applyPendingQuantities,
+  cartLineKey,
+  CART_QUANTITY_DEBOUNCE_MS,
+  createEmptyOptimisticCart,
+  extractBasketFromInsertResponse,
+  extractInsertCartItem,
+  findCartLine,
+  applyBasketInsertResponse,
+  mergeInsertItemIntoCart,
+  patchCartCache,
+  patchCartItemQuantity,
+  readCartCache,
+  removeCartLineByKey,
+  PendingCartAdd,
+} from '@/core/feature/cart/util/cart-optimistic';
+
+interface PendingQuantityUpdate {
+  quantity: number;
+  productId?: string;
+}
+
+interface AddToCartPayload {
+  productId: string | number;
+  quantity: number;
+  variantId?: string | number;
+  linePay?: number;
+  type?: string;
+  deposit?: string;
+}
+
+export interface CartState {
+  cart: BasketSummaryInterface | null;
+  cartLoading: boolean;
+  isAddingToCart: boolean;
+  isUpdatingCart: boolean;
+  isProductAdding: (productId: string | number, variantId?: string | number | null) => boolean;
+  addToCart: (productId: string | number, quantity: number, variantId?: string | number, options?: { linePay?: number }) => void;
+  updateQuantity: (itemId: string | number, quantity: number, productId?: string) => void;
+  changeQuantity: (itemId: string | number, delta: number, productId?: string, variantId?: string | number | null) => void;
+  removeItem: (itemId: string | number) => void;
+  cartTotal: number;
+  promoCode: PromoCode | null;
+  setPromoCode: (promoCode: PromoCode | null) => void;
+}
+
+export const useCartState = (isAuthenticated: boolean): CartState => {
+  const queryClient = useQueryClient();
+  const [promoCode, setPromoCode] = useState<PromoCode | null>(null);
+  const [pendingQuantities, setPendingQuantities] = useState<Record<string, number>>({});
+  const [pendingAdds, setPendingAdds] = useState<Record<string, PendingCartAdd>>({});
+  const [addingKeys, setAddingKeys] = useState<Record<string, boolean>>({});
+
+  const pendingUpdatesRef = useRef<Map<string, PendingQuantityUpdate>>(new Map());
+  const debounceTimersRef = useRef<Map<string, ReturnType<typeof setTimeout>>>(new Map());
+  const pendingAddsRef = useRef<Record<string, PendingCartAdd>>({});
+  const pendingQuantitiesRef = useRef<Record<string, number>>({});
+  const insertQueueRef = useRef<Promise<void>>(Promise.resolve());
+  const cancelledInsertKeysRef = useRef<Set<string>>(new Set());
+  const displayCartRef = useRef<BasketSummaryInterface | null>(null);
+
+  const cartHook = useCart();
+
+  const { data: cart, isLoading: cartLoading } = cartHook.fetch({
+    isEnabled: isAuthenticated,
+  });
+
+  const insertMutation = cartHook.insert();
+  const updateItemMutation = cartHook.updateItem();
+  const removeMutation = cartHook.remove();
+
+  const isUpdatingCart = updateItemMutation.isPending || removeMutation.isPending;
+  const isAddingToCart = Object.keys(addingKeys).length > 0 || insertMutation.isPending;
+
+  const serverCart = useMemo(() => readCartCache(queryClient) ?? cart, [cart, queryClient]);
+
+  const displayCart = useMemo(() => {
+    if (!serverCart && Object.keys(pendingAdds).length === 0) return null;
+
+    const base = serverCart ?? createEmptyOptimisticCart();
+
+    let result = base;
+    if (Object.keys(pendingAdds).length > 0) {
+      result = applyPendingAdds(result, pendingAdds);
+    }
+    if (Object.keys(pendingQuantities).length > 0) {
+      result = applyPendingQuantities(result, pendingQuantities);
+    }
+    return result;
+  }, [serverCart, pendingAdds, pendingQuantities]);
+
+  displayCartRef.current = displayCart;
+
+  useEffect(() => {
+    pendingAddsRef.current = pendingAdds;
+  }, [pendingAdds]);
+
+  useEffect(() => {
+    pendingQuantitiesRef.current = pendingQuantities;
+  }, [pendingQuantities]);
+
+  useEffect(() => {
+    if (!cart) return;
+    if (cart.promoCode?.id) {
+      setPromoCode((prev) => (prev?.id === cart.promoCode?.id ? prev : (cart.promoCode as PromoCode)));
+      return;
+    }
+    if (!cart.promoCode?.id) {
+      setPromoCode(null);
+    }
+  }, [cart?.promoCode?.id, cart?.promoCode?.code]);
+
+  useEffect(() => {
+    return () => {
+      debounceTimersRef.current.forEach((timer) => clearTimeout(timer));
+      debounceTimersRef.current.clear();
+    };
+  }, []);
+
+  const isProductAdding = (productId: string | number, variantId?: string | number | null) => {
+    return Boolean(addingKeys[cartLineKey(productId, variantId)]);
+  };
+
+  const setAdding = (key: string, value: boolean) => {
+    setAddingKeys((prev) => {
+      if (value) return { ...prev, [key]: true };
+      if (!(key in prev)) return prev;
+      const next = { ...prev };
+      delete next[key];
+      return next;
+    });
+  };
+
+  const applyLocalQuantity = (itemId: string, quantity: number) => {
+    setPendingQuantities((prev) => {
+      const next = { ...prev, [itemId]: quantity };
+      pendingQuantitiesRef.current = next;
+      return next;
+    });
+  };
+
+  const getLineQuantity = (itemId: string) => {
+    if (itemId in pendingQuantitiesRef.current) {
+      return Number(pendingQuantitiesRef.current[itemId]);
+    }
+
+    if (itemId.startsWith('optimistic-')) {
+      const key = itemId.replace('optimistic-', '');
+      const add = pendingAddsRef.current[key];
+      if (add) return Number(add.quantity);
+    }
+
+    const item = displayCartRef.current?.items?.find((line) => String(line.id) === itemId);
+    return Number(item?.quantity || 0);
+  };
+
+  const clearPendingQuantity = (itemId: string) => {
+    setPendingQuantities((prev) => {
+      if (!(itemId in prev)) return prev;
+      const next = { ...prev };
+      delete next[itemId];
+      return next;
+    });
+    pendingUpdatesRef.current.delete(itemId);
+
+    const timer = debounceTimersRef.current.get(itemId);
+    if (timer) {
+      clearTimeout(timer);
+      debounceTimersRef.current.delete(itemId);
+    }
+  };
+
+  const flushQuantityUpdate = (itemId: string) => {
+    const pending = pendingUpdatesRef.current.get(itemId);
+    if (!pending) return;
+
+    pendingUpdatesRef.current.delete(itemId);
+    debounceTimersRef.current.delete(itemId);
+
+    updateItemMutation.mutate(
+      { id: itemId, quantity: pending.quantity, productId: pending.productId },
+      {
+        onSuccess: (data) => {
+          patchCartCache(queryClient, (old) => applyBasketInsertResponse(data, old));
+          if (!pendingUpdatesRef.current.has(itemId)) {
+            setPendingQuantities((prev) => {
+              if (!(itemId in prev)) return prev;
+              const next = { ...prev };
+              delete next[itemId];
+              return next;
+            });
+          }
+        },
+        onError: (error: any) => {
+          queryClient.invalidateQueries({ queryKey: ['organization', 'cart'] });
+          setPendingQuantities((prev) => {
+            if (!(itemId in prev)) return prev;
+            const next = { ...prev };
+            delete next[itemId];
+            return next;
+          });
+          toast.error(error?.response?.data?.info?.message || 'Hata oluştu');
+        },
+      }
+    );
+  };
+
+  const applyInsertSuccess = (response: unknown, key: string, productId: string | number) => {
+    if (cancelledInsertKeysRef.current.has(key)) {
+      cancelledInsertKeysRef.current.delete(key);
+      const insertItem = extractInsertCartItem(response);
+      if (insertItem?.id) {
+        removeMutation.mutate(insertItem.id);
+      }
+      return;
+    }
+
+    const pendingAdd = pendingAddsRef.current[key];
+    const pendingQuantity = pendingAdd?.quantity ?? 1;
+
+    const basket = extractBasketFromInsertResponse(response);
+    const insertItem = extractInsertCartItem(response);
+
+    if (basket) {
+      patchCartCache(queryClient, (old) => applyBasketInsertResponse(basket, old));
+    } else if (insertItem) {
+      patchCartCache(queryClient, (old) => {
+        const base = old ?? createEmptyOptimisticCart();
+        return mergeInsertItemIntoCart(
+          base,
+          insertItem,
+          pendingAdd ? { ...pendingAdd, quantity: pendingQuantity } : undefined
+        );
+      });
+    } else {
+      queryClient.invalidateQueries({ queryKey: ['organization', 'cart'] });
+    }
+
+    if (insertItem || basket) {
+      const updatedCart = readCartCache(queryClient);
+      if (findCartLine(updatedCart, productId, pendingAdd?.variantId)) {
+        setPendingAdds((prev) => {
+          if (!(key in prev)) return prev;
+          const next = { ...prev };
+          delete next[key];
+          pendingAddsRef.current = next;
+          return next;
+        });
+      }
+    }
+
+    if (insertItem && pendingQuantity > insertItem.quantity) {
+      updateItemMutation.mutate(
+        { id: insertItem.id, quantity: pendingQuantity, productId: String(productId) },
+        {
+          onSuccess: (data) => {
+            patchCartCache(queryClient, (old) => applyBasketInsertResponse(data, old));
+          },
+        }
+      );
+    }
+  };
+
+  const enqueueInsert = (payload: AddToCartPayload, key: string) => {
+    setAdding(key, true);
+
+    insertQueueRef.current = insertQueueRef.current
+      .then(() => insertMutation.mutateAsync(payload))
+      .then((response) => {
+        applyInsertSuccess(response, key, payload.productId);
+      })
+      .catch((error: any) => {
+        setPendingAdds((prev) => {
+          if (!(key in prev)) return prev;
+          const next = { ...prev };
+          delete next[key];
+          pendingAddsRef.current = next;
+          return next;
+        });
+        patchCartCache(queryClient, (old) => {
+          const base = old ?? createEmptyOptimisticCart();
+          return removeCartLineByKey(base, key);
+        });
+        queryClient.invalidateQueries({ queryKey: ['organization', 'cart'] });
+        toast.error(error?.response?.data?.info?.message || 'Sepete eklenirken bir hata oluştu');
+      })
+      .finally(() => {
+        setAdding(key, false);
+      });
+  };
+
+  const addToCart = (
+    productId: string | number,
+    quantity: number,
+    variantId?: string | number,
+    options?: { linePay?: number }
+  ) => {
+    const key = cartLineKey(productId, variantId);
+    const existing = findCartLine(displayCart, productId, variantId);
+
+    if (existing) {
+      changeQuantity(existing.id, quantity, String(productId), variantId);
+      return;
+    }
+
+    const pendingAdd: PendingCartAdd = {
+      productId: String(productId),
+      variantId: variantId != null ? String(variantId) : undefined,
+      quantity,
+      linePay: options?.linePay,
+    };
+
+    const nextPending = { ...pendingAddsRef.current, [key]: pendingAdd };
+    pendingAddsRef.current = nextPending;
+    setPendingAdds(nextPending);
+
+    patchCartCache(queryClient, (old) => {
+      const base = old ?? createEmptyOptimisticCart();
+      return applyPendingAdds(base, { [key]: pendingAdd });
+    });
+
+    enqueueInsert(
+      {
+        productId,
+        quantity,
+        variantId,
+        type: 'increment',
+        deposit: 'disable',
+        linePay: options?.linePay,
+      },
+      key
+    );
+  };
+
+  const updateQuantity = (
+    itemId: string | number,
+    quantity: number,
+    productId?: string,
+    variantId?: string | number | null
+  ) => {
+    const id = itemId.toString();
+    if (quantity < 1) return;
+
+    if (id.startsWith('optimistic-')) {
+      const key = id.replace('optimistic-', '');
+      const currentAdd = pendingAddsRef.current[key];
+      if (!currentAdd) return;
+
+      const nextAdd = { ...currentAdd, quantity };
+      const nextPending = { ...pendingAddsRef.current, [key]: nextAdd };
+      pendingAddsRef.current = nextPending;
+      setPendingAdds(nextPending);
+
+      patchCartCache(queryClient, (old) => {
+        const base = old ?? createEmptyOptimisticCart();
+        return applyPendingAdds(base, { [key]: nextAdd });
+      });
+      return;
+    }
+
+    applyLocalQuantity(id, quantity);
+
+    patchCartCache(queryClient, (old) => {
+      const base = old ?? createEmptyOptimisticCart();
+      return patchCartItemQuantity(base, id, quantity, productId, variantId);
+    });
+
+    pendingUpdatesRef.current.set(id, { quantity, productId });
+
+    const existingTimer = debounceTimersRef.current.get(id);
+    if (existingTimer) clearTimeout(existingTimer);
+
+    debounceTimersRef.current.set(
+      id,
+      setTimeout(() => flushQuantityUpdate(id), CART_QUANTITY_DEBOUNCE_MS)
+    );
+  };
+
+  const changeQuantity = (
+    itemId: string | number,
+    delta: number,
+    productId?: string,
+    variantId?: string | number | null
+  ) => {
+    const id = itemId.toString();
+    const nextQuantity = getLineQuantity(id) + delta;
+
+    if (nextQuantity < 1) {
+      removeItem(id);
+      return;
+    }
+
+    updateQuantity(id, nextQuantity, productId, variantId);
+  };
+
+  const removeItem = (itemId: string | number) => {
+    const id = itemId.toString();
+    clearPendingQuantity(id);
+
+    if (id.startsWith('optimistic-')) {
+      const key = id.replace('optimistic-', '');
+      cancelledInsertKeysRef.current.add(key);
+      setPendingAdds((prev) => {
+        if (!(key in prev)) return prev;
+        const next = { ...prev };
+        delete next[key];
+        return next;
+      });
+      setAdding(key, false);
+      return;
+    }
+
+    removeMutation.mutate(id, {
+      onSuccess: () => {
+        toast.success('Ürün sepetten çıkarıldı');
+      },
+      onError: (error: any) => {
+        toast.error(error?.response?.data?.info?.message || 'Silinirken hata oluştu');
+      },
+    });
+  };
+
+  return {
+    cart: displayCart,
+    cartLoading,
+    isAddingToCart,
+    isUpdatingCart,
+    isProductAdding,
+    addToCart,
+    updateQuantity,
+    changeQuantity,
+    removeItem,
+    cartTotal: displayCart?.info?.payPrice?.pay || 0,
+    promoCode,
+    setPromoCode,
+  };
+};

package/core/context/security.context.tsx

@@ -0,0 +1,151 @@
+'use client';
+
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { useRouter, usePathname } from 'next/navigation';
+import { LoginType, User } from '@/core/interface/prisma.interface';
+import { useAuth } from '@/core/feature/auth/hook/use.auth';
+import { useProfile } from '@/core/feature/profile/hook/use.profile';
+
+export interface SecurityState {
+  profile: User | null | undefined;
+  authLoading: boolean;
+  isAuthenticated: boolean;
+  isGuest: boolean;
+}
+
+export const useSecurityState = (): SecurityState => {
+  const router = useRouter();
+  const pathname = usePathname();
+
+  const [authLoading, setAuthLoading] = useState<boolean>(true);
+  const [isAuthenticated, setIsAuthenticated] = useState<boolean>(false);
+  const [isAuthEstablished, setIsAuthEstablished] = useState<boolean>(false);
+
+  const { mutate: tokenCheck } = useAuth().token();
+  const { mutate: loginGuest } = useAuth().loginGuest();
+
+  const profileQuery = useProfile().fetch({ isEnabled: isAuthEstablished && isAuthenticated });
+  const profile = profileQuery.data;
+
+  const isGuest = useMemo(() => {
+    return profile?.loginType === LoginType.GUEST;
+  }, [profile]);
+
+  const isInvalidTokenError = (error: any) => {
+    const status = error?.response?.status;
+    return status === 401 || status === 403;
+  };
+
+  const isServerAccessError = (error: any) => {
+    const status = error?.response?.status;
+    return !error?.response || (typeof status === 'number' && status >= 500);
+  };
+
+  const ensureGuestLogin = useCallback(() => {
+    loginGuest(undefined, {
+      onSuccess: () => {
+        setIsAuthEstablished(true);
+        setIsAuthenticated(true);
+        setAuthLoading(false);
+      },
+      onError: () => {
+        setIsAuthEstablished(false);
+        setIsAuthenticated(false);
+        setAuthLoading(false);
+      },
+    });
+  }, [loginGuest]);
+
+  const checkToken = useCallback(() => {
+    if (typeof window !== 'undefined') {
+      const token = localStorage.getItem('koksal-token');
+      if (token && token.trim() !== '' && token.length > 3) {
+        setAuthLoading(true);
+        tokenCheck(undefined, {
+          onSuccess: () => {
+            setIsAuthEstablished(true);
+            setIsAuthenticated(true);
+            setAuthLoading(false);
+          },
+          onError: (error: any) => {
+            if (isServerAccessError(error)) {
+              setIsAuthEstablished(true);
+              setIsAuthenticated(true);
+              setAuthLoading(false);
+              return;
+            }
+
+            if (isInvalidTokenError(error)) {
+              localStorage.removeItem('koksal-token');
+              ensureGuestLogin();
+              return;
+            }
+
+            ensureGuestLogin();
+          },
+        });
+      } else {
+        setAuthLoading(true);
+        ensureGuestLogin();
+      }
+    }
+  }, [tokenCheck, ensureGuestLogin]);
+
+  useEffect(() => {
+    checkToken();
+  }, [checkToken]);
+
+  useEffect(() => {
+    if (typeof window !== 'undefined') {
+      const handleStorageChange = (e: StorageEvent) => {
+        if (e.key === 'koksal-token') {
+          checkToken();
+        }
+      };
+
+      const handleCustomStorageChange = () => {
+        checkToken();
+      };
+
+      window.addEventListener('storage', handleStorageChange);
+      window.addEventListener('koksal-token-changed', handleCustomStorageChange);
+
+      return () => {
+        window.removeEventListener('storage', handleStorageChange);
+        window.removeEventListener('koksal-token-changed', handleCustomStorageChange);
+      };
+    }
+  }, [checkToken]);
+
+  useEffect(() => {
+    const isLoading =
+      authLoading || (isAuthEstablished && (profileQuery.isLoading || profileQuery.isFetching));
+    if (isLoading) return;
+
+    if (pathname.startsWith('/guvenlik') && isAuthenticated && profile?.loginType !== LoginType.GUEST) {
+      router.push('/hesabim');
+    }
+    if (pathname.startsWith('/hesabim') && (!isAuthenticated || profile?.loginType === LoginType.GUEST)) {
+      router.push('/guvenlik/giris-yap');
+    }
+  }, [
+    pathname,
+    isAuthenticated,
+    authLoading,
+    isAuthEstablished,
+    profileQuery.isLoading,
+    profileQuery.isFetching,
+    router,
+    profile?.loginType,
+  ]);
+
+  const resolvedAuthLoading =
+    authLoading || (isAuthEstablished && (profileQuery.isLoading || profileQuery.isFetching));
+
+  return {
+    profile,
+    authLoading: resolvedAuthLoading,
+    isAuthenticated,
+    isGuest,
+  };
+};