@raxonltd/raxon-core 1.1.7 → 1.1.8

package/core/interface/product.interface.ts

@@ -0,0 +1,111 @@
+import {ProductContent, ProductType, Property, SaleType, WeightType} from '@/core/interface/prisma.interface';
+
+
+export interface Price {
+  mainPrice: number;
+  discountPrice: number;
+  taxAmount?: number;
+  depositAmount?: number;
+  basketPrice?: number;
+  payPrice?: number;
+}
+export interface Product {
+  id: string;
+  name: string;
+  saleType: SaleType;
+  createdAt?: string;
+  updatedAt?: string;
+  type: ProductType;
+  slug: string;
+  stock?: number;
+  sku?: string;
+  productContent? : ProductContent
+  articleNumber?: string;
+  tags?: string[];
+  currentStock?: number;
+  icon?: string;
+  shortDescription?: string;
+  brand?: string;
+  weightType: WeightType;
+  weightValue: number;
+  barcode?: string;
+  dynamicContent?: any;
+  isFavorite?: boolean;
+  status?: 'PUBLISHED' | 'OUT_OF_STOCK' | 'UNKNOWN';
+  price?: Price;
+  review: {
+    count: number;
+    rating: number;
+  };
+  images: {
+    relativePath: string;
+    variantIds: string[];
+    attributeOptionId: string;
+    id: string;
+  }[];
+  categories: {
+    id: string;
+    name: string;
+    slug: string;
+  }[];
+  productUnit?: {
+    id: string;
+    unit: {
+      id: string;
+      name: string;
+    };
+    quantityPerUnitOfMeasure: number;
+    price?: Price;
+  }[];
+  variant:  {
+    id: string;
+    price: Price;
+    stock: number;
+    attributeOption1: {
+      id: string;
+      label: string;
+      value?: string | null;
+      icon?: string | null;
+      attributeId?: string | null;
+    };
+    attributeOption2: {
+      id: string;
+      label: string;
+      value?: string | null;
+      icon?: string | null;
+      attributeId?: string | null;
+    };
+  }[]
+}
+export interface ProductDetail extends Product {
+  baseUnit: string;
+  productUnits: {
+    id: string;
+    unit: string;
+    quantityPerUnitOfMeasure: number;
+  }[];
+  richContent: string;
+  description: string;
+  saleUnit: string;
+  property : Property[];
+  purchaseUnit: string;
+  shortDescription: string;
+  productContent: ProductContent;
+  matrix?: ProductPriceMatrixResponse[] | null;
+}
+
+export interface ProductPriceMatrixResponse {
+  supplier: {
+    id: string;
+    name: string;
+  } | null;
+  unit: {
+    id: string;
+    name: string;
+  } | null;
+  price: {
+    mainPrice: number;
+    discountPrice: number;
+    minimumQuantity: number;
+  };
+}

package/core/raxon.context.tsx

@@ -0,0 +1,256 @@
+"use client";
+
+import {
+  Article,
+  BankAccount,
+  Branch,
+  Campaign,
+  CampaignType,
+  Category,
+  Collection,
+  DeliveryMethod,
+  DynamicData,
+  Faq,
+  Feed,
+  Holiday,
+  Material,
+  PaymentMethod,
+  Review,
+  User,
+} from "@/core/interface/prisma.interface";
+import { createContext, useContext, useEffect, useMemo, useRef, useState } from "react";
+import { nexineAxios } from "@/core/util/nexine.axios";
+import { Product as CustomProduct } from "@/core/interface/product.interface";
+import { ModalAuth, ModalAuthRef } from "@/core/feature/auth/modal/modal.auth";
+import { ModalNewsletterVariantProduct, ModalNewsletterVariantProductRef } from "@/core/feature/newsletter/modal/modal.newsletter.product";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { useSecurityState } from "@/core/context/security.context";
+import { useCartState, CartState } from "@/core/context/cart.context";
+import { AnalyticEventProvider } from "@/core/feature/analytic-event/analytic.event.context";
+import { RaxonContextBrand } from "./interface/context.interface";
+import { RaxonBootstrapPayload } from "./interface/bootstrap.interface";
+
+export const RaxonContext = createContext<RaxonContextType | undefined>(undefined);
+
+
+interface RaxonBootstrapData {
+  campaign: Campaign[];
+  basketCampaign: Campaign[];
+  branch: Branch | null;
+  banner: Collection[];
+  collection: Collection[];
+  subHeroCollection: Collection[];
+  category: Category[];
+  flatCategory: Category[];
+  review: Review[];
+  article: Article[];
+  faq: Faq[];
+  feed: Feed[];
+  material: Material[];
+  holiday: Holiday[];
+  product: CustomProduct[];
+  bankAccount: BankAccount[];
+  bestSeller: CustomProduct[];
+  dynamicData: DynamicData[];
+  deliveryMethod: DeliveryMethod[];
+  paymentMethod: PaymentMethod[];
+  defaultDeliveryMethod: DeliveryMethod | null;
+  brand: RaxonContextBrand[];
+  modalAuthRef: React.RefObject<ModalAuthRef | null>;
+  modalNewsletterVariantProductRef: React.RefObject<ModalNewsletterVariantProductRef | null>;
+}
+
+export interface RaxonContextType extends RaxonBootstrapData, CartState {
+  isLoading: boolean;
+  profile: User | null | undefined;
+  authLoading: boolean;
+  isAuthenticated: boolean;
+  isGuest: boolean;
+}
+
+export interface RaxonProviderProps {
+  children: React.ReactNode;
+  apiKey: string;
+  apiUrl: string;
+  productPathPrefix?: string;
+  analyticAutoTrack?: boolean;
+  /** Varsayılan: `/api/bootstrap` — Next.js BFF veya özel proxy */
+  bootstrapUrl?: string;
+  /** SSR ile layout'tan geçirilen bootstrap verisi */
+  initialBootstrapData?: RaxonBootstrapPayload | null;
+}
+
+function normalizeBootstrapPayload(raxon: RaxonBootstrapPayload | null | undefined) {
+  if (!raxon) return null;
+
+  const flatten = (categories: Category[]): Category[] => {
+    return categories.flatMap((cat) => [cat, ...flatten(cat.children ?? [])]);
+  };
+
+  const category = Array.isArray(raxon.category) ? raxon.category : [];
+  const flatCategory = flatten(category);
+
+  return {
+    campaign: raxon.campaign ?? [],
+    basketCampaign: (raxon.campaign ?? []).filter((it) => it.type !== CampaignType.COLLECTION),
+    branch: raxon.branch ?? null,
+    collection: raxon.collection ?? [],
+    subHeroCollection: raxon.subHeroCollection ?? [],
+    banner: (raxon.collection ?? []).filter((it) => it.tags?.includes("banner")),
+    category,
+    flatCategory,
+    faq: raxon.faq ?? [],
+    product: raxon.product ?? [],
+    bankAccount: raxon.bankAccount ?? [],
+    material: raxon.material ?? [],
+    holiday: raxon.holiday ?? [],
+    bestSeller: raxon.bestSeller ?? [],
+    dynamicData: raxon.dynamicData ?? [],
+    deliveryMethod: raxon.deliveryMethod ?? [],
+    paymentMethod: raxon.paymentMethod ?? [],
+    defaultDeliveryMethod: (raxon.deliveryMethod ?? []).find((it) => it.isDefault) ?? null,
+    review: raxon.review ?? [],
+    article: raxon.article ?? [],
+    feed: raxon.feed ?? [],
+    brand: raxon.brand ?? [],
+  };
+}
+
+const RaxonProviderInner = ({
+  children,
+  apiKey,
+  apiUrl,
+  productPathPrefix,
+  analyticAutoTrack,
+  bootstrapUrl = "/api/bootstrap",
+  initialBootstrapData = null,
+}: RaxonProviderProps) => {
+  const initialNormalized = useMemo(
+    () => normalizeBootstrapPayload(initialBootstrapData),
+    [initialBootstrapData],
+  );
+
+  const [raxon, setRaxon] = useState<RaxonBootstrapPayload | null>(
+    initialBootstrapData ?? null,
+  );
+  const [isLoading, setIsLoading] = useState<boolean>(!initialNormalized);
+  const [hasFetched, setHasFetched] = useState<boolean>(!!initialNormalized);
+
+  const modalAuthRef = useRef<ModalAuthRef>(null);
+  const modalNewsletterVariantProductRef = useRef<ModalNewsletterVariantProductRef>(null);
+
+  if (typeof window !== "undefined") {
+    (window as any).__RAXON_API_KEY__ = apiKey;
+    (window as any).__RAXON_API_URL__ = apiUrl;
+    nexineAxios.defaults.baseURL = apiUrl;
+    nexineAxios.defaults.headers.common["x-api-key"] = apiKey;
+  }
+
+  const { profile, authLoading, isAuthenticated, isGuest } = useSecurityState();
+  const cartState = useCartState(isAuthenticated);
+
+  useEffect(() => {
+    if (hasFetched || !bootstrapUrl) return;
+    setHasFetched(true);
+
+    fetch(bootstrapUrl, { credentials: "same-origin" })
+      .then((res) => {
+        if (!res.ok) throw new Error(`Bootstrap ${res.status}`);
+        return res.json();
+      })
+      .then((data: RaxonBootstrapPayload) => {
+        setRaxon(data);
+        setIsLoading(false);
+      })
+      .catch((err) => {
+        console.error("[RAXON] ERROR:", err);
+        setIsLoading(false);
+      });
+  }, [hasFetched, bootstrapUrl]);
+
+  const normalized = useMemo(
+    () => normalizeBootstrapPayload(raxon) ?? initialNormalized,
+    [raxon, initialNormalized],
+  );
+
+  const value = useMemo<RaxonContextType>(
+    () => ({
+      campaign: normalized?.campaign ?? [],
+      basketCampaign: normalized?.basketCampaign ?? [],
+      branch: normalized?.branch ?? null,
+      collection: normalized?.collection ?? [],
+      subHeroCollection: normalized?.subHeroCollection ?? [],
+      banner: normalized?.banner ?? [],
+      category: normalized?.category ?? [],
+      flatCategory: normalized?.flatCategory ?? [],
+      faq: normalized?.faq ?? [],
+      product: normalized?.product ?? [],
+      bankAccount: normalized?.bankAccount ?? [],
+      material: normalized?.material ?? [],
+      holiday: normalized?.holiday ?? [],
+      bestSeller: normalized?.bestSeller ?? [],
+      isLoading,
+      dynamicData: normalized?.dynamicData ?? [],
+      deliveryMethod: normalized?.deliveryMethod ?? [],
+      paymentMethod: normalized?.paymentMethod ?? [],
+      defaultDeliveryMethod: normalized?.defaultDeliveryMethod ?? null,
+      review: normalized?.review ?? [],
+      article: normalized?.article ?? [],
+      feed: normalized?.feed ?? [],
+      brand: normalized?.brand ?? [],
+      modalAuthRef,
+      modalNewsletterVariantProductRef,
+      profile,
+      authLoading,
+      isAuthenticated,
+      isGuest,
+      ...cartState,
+    }),
+    [normalized, isLoading, profile, authLoading, isAuthenticated, isGuest, cartState],
+  );
+
+  return (
+    <RaxonContext.Provider value={value}>
+      <AnalyticEventProvider productPathPrefix={productPathPrefix} autoTrack={analyticAutoTrack}>
+        {children}
+      </AnalyticEventProvider>
+      <ModalAuth ref={modalAuthRef} />
+      <ModalNewsletterVariantProduct ref={modalNewsletterVariantProductRef} />
+    </RaxonContext.Provider>
+  );
+};
+
+export const RaxonProvider = ({
+  children,
+  apiKey,
+  apiUrl,
+  productPathPrefix,
+  analyticAutoTrack,
+  bootstrapUrl,
+  initialBootstrapData,
+}: RaxonProviderProps) => {
+  const [queryClient] = useState(() => new QueryClient());
+
+  return (
+    <QueryClientProvider client={queryClient}>
+      <RaxonProviderInner
+        apiKey={apiKey}
+        apiUrl={apiUrl}
+        productPathPrefix={productPathPrefix}
+        analyticAutoTrack={analyticAutoTrack}
+        bootstrapUrl={bootstrapUrl}
+        initialBootstrapData={initialBootstrapData}
+      >
+        {children}
+      </RaxonProviderInner>
+    </QueryClientProvider>
+  );
+};
+
+export const useRaxon = (): RaxonContextType => {
+  const context = useContext(RaxonContext);
+  if (context === undefined) {
+    throw new Error("useRaxon must be used within a RaxonProvider");
+  }
+  return context;
+};

package/core/schema/checkout.schema.ts

@@ -0,0 +1,103 @@
+import { z } from 'zod';
+
+export const addressCreateSchema = z.object({
+  title: z.string().min(1, 'Adres başlığı zorunludur'),
+  fullName: z.string().min(3, 'Ad soyad zorunludur'),
+  phoneNumber: z.string().min(10, 'Geçerli telefon giriniz'),
+  country: z.string().min(1, 'Ülke seçiniz'),
+  administrativeAreaLevel1: z.string().min(1, 'İl seçiniz'),
+  administrativeAreaLevel2: z.string().min(1, 'İlçe seçiniz'),
+  fullAddress: z.string().min(5, 'Adres zorunludur'),
+  postalCode: z.string().optional(),
+  invoiceType: z.enum(['individual', 'corporate']),
+  taxNumber: z.string().optional(),
+});
+
+export const checkoutSchema = z.object({
+  deliveryAddressId: z.string().optional(),
+  invoiceAddressId: z.string().optional(),
+  differentInvoiceAddress: z.boolean().optional(),
+  deliveryMethodId: z.string().min(1, 'Teslimat yöntemi seçiniz'),
+  paymentMethodId: z.string().min(1, 'Ödeme yöntemi seçiniz'),
+  bankAccountId: z.string().optional(),
+});
+
+export type AddressCreateFormData = z.infer<typeof addressCreateSchema>;
+export type CheckoutFormData = z.infer<typeof checkoutSchema>;
+
+export function getDeliveryFee(
+  method: { courierFee?: number | null; minimumOrderAmount?: number | null; isForceFee?: boolean },
+  subtotal: number
+) {
+  const fee = Number(method.courierFee ?? 0);
+  const minAmount = Number(method.minimumOrderAmount ?? 0);
+
+  if (minAmount > 0 && subtotal >= minAmount && !method.isForceFee) {
+    return 0;
+  }
+
+  return fee;
+}
+
+export function formatTry(amount: number) {
+  return new Intl.NumberFormat('tr-TR', {
+    style: 'currency',
+    currency: 'TRY',
+    maximumFractionDigits: 2,
+  }).format(amount);
+}
+
+export type PaymentUiType = 'credit_card' | 'bank_transfer' | 'garanti' | 'other';
+
+export function getPaymentUiType(name: string, provider?: string): PaymentUiType {
+  const n = name.toLowerCase();
+  const p = (provider || '').toUpperCase();
+
+  if (p === 'GARANTI' || p.includes('GARANTI') || n.includes('garanti')) return 'garanti';
+  if (p === 'PAYTR' || p.includes('PAYTR') || p === 'STRIPE' || n.includes('kredi') || n.includes('kart')) {
+    return 'credit_card';
+  }
+  if (
+    p === 'BANK_TRANSFER' ||
+    p.includes('BANK') ||
+    n.includes('havale') ||
+    n.includes('eft') ||
+    n.includes('peşin') ||
+    n.includes('pesin')
+  ) {
+    return 'bank_transfer';
+  }
+  return 'other';
+}
+
+export function getPaymentDisplayName(name: string, provider?: string): string {
+  const type = getPaymentUiType(name, provider);
+  if (type === 'credit_card') return 'Kredi Kartı';
+  if (type === 'bank_transfer') return 'Havale';
+  if (type === 'garanti') return 'GarantiPay';
+  return name;
+}
+
+export function sortPaymentMethods<T extends { name: string; provider?: string }>(methods: T[]): T[] {
+  const order: PaymentUiType[] = ['credit_card', 'bank_transfer', 'garanti', 'other'];
+  return [...methods].sort((a, b) => {
+    const ai = order.indexOf(getPaymentUiType(a.name, a.provider));
+    const bi = order.indexOf(getPaymentUiType(b.name, b.provider));
+    return ai - bi;
+  });
+}
+
+/** Checkout'ta gösterilecek ödeme yöntemleri: Kredi Kartı → Havale → GarantiPay */
+export function getCheckoutPaymentMethods<T extends { id: string; name: string; provider?: string }>(
+  methods: T[]
+): T[] {
+  const order: PaymentUiType[] = ['credit_card', 'bank_transfer', 'garanti'];
+  const picked: T[] = [];
+
+  for (const type of order) {
+    const match = methods.find((m) => getPaymentUiType(m.name, m.provider) === type);
+    if (match) picked.push(match);
+  }
+
+  return picked;
+}

package/core/util/basket.item.display.ts

@@ -0,0 +1,19 @@
+import type { BasketItemSummaryInterface } from '../interface/basket.interface';
+
+export function formatBasketItemVariantLine(item: BasketItemSummaryInterface): string | null {
+  const v = item.variant;
+  if (!v) return null;
+  const parts: string[] = [];
+  if (v.attributeOption1) {
+    const n = v.attributeOption1.name;
+    const label = v.attributeOption1.attribute?.name;
+    parts.push(label && n ? `${label}: ${n}` : n || '');
+  }
+  if (v.attributeOption2) {
+    const n = v.attributeOption2.name;
+    const label = v.attributeOption2.attribute?.name;
+    parts.push(label && n ? `${label}: ${n}` : n || '');
+  }
+  const s = parts.filter(Boolean).join(' · ');
+  return s.length > 0 ? s : null;
+}

package/core/util/category.nav.ts

@@ -0,0 +1,46 @@
+import capitalize from 'lodash/capitalize';
+import { Category } from '../interface/prisma.interface';
+
+/** Header/footer ile aynı görünen kategori adı (çok dilli + eski getName formatı) */
+export function categoryNavLabel(cat: Category): string {
+  if (Array.isArray(cat.name) && cat.name.length > 0) {
+    return cat.name[0]?.value || '';
+  }
+  const raw = (cat.name as unknown as { getName?: () => string })?.getName?.() ?? '';
+  return raw ? capitalize(raw) : '';
+}
+
+export function getCategoryNavProductCount(cat: Category): number {
+  const c = cat as Category & {
+    totalProductCount?: number;
+    _count?: { product?: number; products?: number };
+  };
+  return c.totalProductCount ?? c._count?.product ?? c._count?.products ?? 0;
+}
+
+function categoryHasStoredParent(cat: Category): boolean {
+  const p = cat.parentId;
+  return p != null && String(p).trim().length > 0;
+}
+
+/**
+ * Header/footer menü kökleri: bazı API yanıtlarında tek şemsiye düğüm veya üst dizide hep dolu parentId gelir.
+ */
+export function resolveCategoryNavRoots(categoryTreeTopLevel: Category[]): Category[] {
+  if (!categoryTreeTopLevel?.length) return [];
+
+  const aliveTop = categoryTreeTopLevel.filter(c => !c.deletedAt);
+  const rootsWithoutParent = aliveTop.filter(c => !categoryHasStoredParent(c));
+
+  if (rootsWithoutParent.length === 1) {
+    const only = rootsWithoutParent[0];
+    const children = (only.children ?? []).filter(c => !c.deletedAt);
+    if (children.length > 0) return children;
+    return [only];
+  }
+
+  if (rootsWithoutParent.length > 0) return rootsWithoutParent;
+
+  /** parentId hep dolu: sunucunun döndürdüğü üst diziyi menü seviyesi kabul et */
+  return aliveTop;
+}

package/core/util/client-ip.ts

@@ -0,0 +1,35 @@
+const CLIENT_IP_STORAGE_KEY = 'kuatto-client-ip';
+
+let clientIpPromise: Promise<string | null> | null = null;
+
+function isValidIp(ip: string): boolean {
+  const trimmed = ip.trim();
+  if (!trimmed) return false;
+  return /^(?:\d{1,3}\.){3}\d{1,3}$/.test(trimmed) || /^[0-9a-f:]+$/i.test(trimmed);
+}
+
+export async function resolveClientIp(): Promise<string | null> {
+  if (typeof window === 'undefined') {
+    return null;
+  }
+
+  const cached = sessionStorage.getItem(CLIENT_IP_STORAGE_KEY);
+  if (cached && isValidIp(cached)) {
+    return cached;
+  }
+
+  if (!clientIpPromise) {
+    clientIpPromise = fetch('https://api.ipify.org?format=json', { cache: 'no-store' })
+      .then(async response => {
+        if (!response.ok) return null;
+        const data = (await response.json()) as { ip?: string };
+        const ip = data.ip?.trim();
+        if (!ip || !isValidIp(ip)) return null;
+        sessionStorage.setItem(CLIENT_IP_STORAGE_KEY, ip);
+        return ip;
+      })
+      .catch(() => null);
+  }
+
+  return clientIpPromise;
+}