@raxonltd/raxon-core 1.1.7 → 1.1.13

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/server/places.proxy.ts

@@ -0,0 +1,35 @@
+import { NextResponse } from 'next/server';
+import type { NextRequest } from 'next/server';
+
+const GOOGLE_PLACES_URL = {
+  autocomplete: 'https://maps.googleapis.com/maps/api/place/autocomplete/json',
+  details: 'https://maps.googleapis.com/maps/api/place/details/json',
+} as const;
+
+export type GooglePlacesEndpoint = keyof typeof GOOGLE_PLACES_URL;
+
+export async function proxyGooglePlaces(
+  request: NextRequest,
+  endpoint: GooglePlacesEndpoint,
+  googleMapsApiKey?: string,
+) {
+  const googleUrl = new URL(GOOGLE_PLACES_URL[endpoint]);
+
+  request.nextUrl.searchParams.forEach((value, key) => {
+    googleUrl.searchParams.set(key, value);
+  });
+
+  const apiKey = googleMapsApiKey ?? process.env.NEXT_PUBLIC_GOOGLE_MAPS_API_KEY ?? '';
+  if (!googleUrl.searchParams.has('key') && apiKey) {
+    googleUrl.searchParams.set('key', apiKey);
+  }
+
+  try {
+    const response = await fetch(googleUrl.toString());
+    const data = await response.json();
+    return NextResponse.json(data);
+  } catch (error) {
+    console.error('[raxonServer/places]', error);
+    return NextResponse.json({ error: 'Google Places API isteği başarısız' }, { status: 500 });
+  }
+}

package/core/server/raxon.bootstrap.route.ts

@@ -0,0 +1,39 @@
+import { NextResponse } from 'next/server';
+import { unstable_cache } from 'next/cache';
+import { fetchRaxonBootstrap } from '@/core/util/fetch.bootstrap';
+import {
+  BOOTSTRAP_REVALIDATE_SECONDS,
+  bootstrapCacheHeaders,
+} from '@/core/server/raxon.server';
+
+async function fetchBootstrapData() {
+  const apiUrl = process.env.NEXT_PUBLIC_API_URL;
+  const apiKey = process.env.NEXT_PUBLIC_API_KEY;
+
+  if (!apiUrl || !apiKey) {
+    throw new Error('[raxonServer] NEXT_PUBLIC_API_URL veya NEXT_PUBLIC_API_KEY tanımlı değil');
+  }
+
+  return fetchRaxonBootstrap(apiUrl, apiKey);
+}
+
+const getCachedBootstrap = unstable_cache(
+  fetchBootstrapData,
+  ['raxon-bootstrap'],
+  { revalidate: BOOTSTRAP_REVALIDATE_SECONDS },
+);
+
+/** API route kullanmak isteyenler için: export { GET, revalidate } from '@raxonltd/raxon-core/server/bootstrap' */
+export const revalidate = BOOTSTRAP_REVALIDATE_SECONDS;
+
+export async function GET() {
+  try {
+    const data = await getCachedBootstrap();
+    return NextResponse.json(data, {
+      headers: bootstrapCacheHeaders(revalidate),
+    });
+  } catch (error) {
+    console.error('[raxonServer]', error);
+    return NextResponse.json({ error: 'Bootstrap verisi alınamadı' }, { status: 502 });
+  }
+}

package/core/server/raxon.server.ts

@@ -0,0 +1,80 @@
+import { NextResponse } from 'next/server';
+import type { NextRequest } from 'next/server';
+import { fetchRaxonBootstrap } from '@/core/util/fetch.bootstrap';
+import { proxyGooglePlaces } from '@/core/server/places.proxy';
+
+const DEFAULT_REVALIDATE_SECONDS = 300;
+
+const RAXON_SERVER_PATHS = {
+  bootstrap: '/api/bootstrap',
+  placesAutocomplete: '/api/places/autocomplete',
+  placesDetails: '/api/places/details',
+} as const;
+
+export interface RaxonServerOptions {
+  apiUrl?: string;
+  apiKey?: string;
+  googleMapsApiKey?: string;
+  revalidate?: number;
+}
+
+function resolveCredentials(options: RaxonServerOptions = {}) {
+  const apiUrl = options.apiUrl ?? process.env.NEXT_PUBLIC_API_URL;
+  const apiKey = options.apiKey ?? process.env.NEXT_PUBLIC_API_KEY;
+  return { apiUrl, apiKey };
+}
+
+async function fetchBootstrapData(options: RaxonServerOptions = {}) {
+  const { apiUrl, apiKey } = resolveCredentials(options);
+
+  if (!apiUrl || !apiKey) {
+    throw new Error('[raxonServer] NEXT_PUBLIC_API_URL veya NEXT_PUBLIC_API_KEY tanımlı değil');
+  }
+
+  return fetchRaxonBootstrap(apiUrl, apiKey);
+}
+
+function bootstrapCacheHeaders(revalidate = DEFAULT_REVALIDATE_SECONDS) {
+  return {
+    'Cache-Control': `public, s-maxage=${revalidate}, stale-while-revalidate=${revalidate * 2}`,
+  };
+}
+
+/**
+ * Next.js middleware — bootstrap ve Google Places BFF isteklerini karşılar.
+ *
+ * @example
+ * // proxy.ts — config Next.js tarafından statik parse edilmeli, import edilemez
+ * import { raxonServer } from '@raxonltd/raxon-core/server';
+ * export default raxonServer();
+ * export const config = { matcher: ['/api/bootstrap', '/api/places/:path'] };
+ */
+export function raxonServer(options: RaxonServerOptions = {}) {
+  const revalidate = options.revalidate ?? DEFAULT_REVALIDATE_SECONDS;
+
+  return async function raxonMiddleware(request: NextRequest) {
+    const { pathname } = request.nextUrl;
+
+    if (pathname === RAXON_SERVER_PATHS.bootstrap) {
+      try {
+        const data = await fetchBootstrapData(options);
+        return NextResponse.json(data, { headers: bootstrapCacheHeaders(revalidate) });
+      } catch (error) {
+        console.error('[raxonServer/bootstrap]', error);
+        return NextResponse.json({ error: 'Bootstrap verisi alınamadı' }, { status: 502 });
+      }
+    }
+
+    if (pathname === RAXON_SERVER_PATHS.placesAutocomplete) {
+      return proxyGooglePlaces(request, 'autocomplete', options.googleMapsApiKey);
+    }
+
+    if (pathname === RAXON_SERVER_PATHS.placesDetails) {
+      return proxyGooglePlaces(request, 'details', options.googleMapsApiKey);
+    }
+
+    return NextResponse.next();
+  };
+}
+
+export { DEFAULT_REVALIDATE_SECONDS as BOOTSTRAP_REVALIDATE_SECONDS, bootstrapCacheHeaders };

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;
+}