@mohasinac/appkit 2.4.11 → 2.5.0

package/dist/features/stores/repository/store.repository.js

@@ -176,5 +176,44 @@ export class StoreRepository extends BaseRepository {
         const snap = await this.db.collection(this.collection).select().get();
         return snap.docs.map((d) => d.id);
     }
+    /**
+     * Check whether a slug is available (not taken by any existing store).
+     */
+    async isSlugAvailable(slug) {
+        const existing = await this.findById(slug);
+        return existing === null;
+    }
+    /**
+     * Atomically migrate a store to a new slug (new document ID).
+     * Creates a new doc with the new slug, copies all data, then deletes the old doc.
+     * Throws if newSlug is already taken.
+     */
+    async changeSlug(currentSlug, newSlug) {
+        if (currentSlug === newSlug)
+            throw new DatabaseError("New slug must differ from current slug");
+        if (newSlug === "" || !/^[a-z0-9-]+$/.test(newSlug)) {
+            throw new DatabaseError("Slug may only contain lowercase letters, numbers, and hyphens");
+        }
+        const existing = await this.findById(currentSlug);
+        if (!existing)
+            throw new DatabaseError(`Store "${currentSlug}" not found`);
+        const available = await this.isSlugAvailable(newSlug);
+        if (!available)
+            throw new DatabaseError(`Slug "${newSlug}" is already taken`);
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { id: _id, ...data } = existing;
+        const newDoc = {
+            ...data,
+            storeSlug: newSlug,
+            updatedAt: new Date(),
+        };
+        const batch = this.db.batch();
+        const newRef = this.db.collection(this.collection).doc(newSlug);
+        const oldRef = this.db.collection(this.collection).doc(currentSlug);
+        batch.create(newRef, prepareForFirestore(newDoc));
+        batch.delete(oldRef);
+        await batch.commit();
+        return { id: newSlug, ...newDoc };
+    }
 }
 export const storeRepository = new StoreRepository();

package/dist/features/stores/schemas/firestore.d.ts

@@ -52,6 +52,13 @@ export interface StoreDocument {
      * Only meaningful when capabilities includes "lower_commission_rate".
      */
     customCommissionRate?: number;
+    googleReviews?: {
+        placeId: string;
+        enabled: boolean;
+        maxReviews?: number;
+        minRating?: number;
+        layout?: "grid" | "carousel";
+    };
     whatsappConfig?: {
         /** Seller's WhatsApp Business phone number, digits-only with country code e.g. "919876543210" */
         phoneNumber?: string;

package/dist/features/stores/schemas/index.d.ts

@@ -35,32 +35,32 @@ export declare const storeListItemSchema: z.ZodObject<{
     id: string;
     status: string;
     storeName: string;
-    ownerId: string;
     storeSlug: string;
     isPublic: boolean;
+    ownerId: string;
     createdAt?: string | undefined;
     itemsSold?: number | undefined;
-    totalProducts?: number | undefined;
     storeDescription?: string | undefined;
     storeCategory?: string | undefined;
     storeLogoURL?: string | undefined;
     storeBannerURL?: string | undefined;
+    totalProducts?: number | undefined;
     totalReviews?: number | undefined;
     averageRating?: number | undefined;
 }, {
     id: string;
     status: string;
     storeName: string;
-    ownerId: string;
     storeSlug: string;
     isPublic: boolean;
+    ownerId: string;
     createdAt?: string | undefined;
     itemsSold?: number | undefined;
-    totalProducts?: number | undefined;
     storeDescription?: string | undefined;
     storeCategory?: string | undefined;
     storeLogoURL?: string | undefined;
     storeBannerURL?: string | undefined;
+    totalProducts?: number | undefined;
     totalReviews?: number | undefined;
     averageRating?: number | undefined;
 }>;
@@ -72,14 +72,14 @@ export declare const storeListParamsSchema: z.ZodObject<{
     filters: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     sort?: string | undefined;
-    category?: string | undefined;
-    page?: number | undefined;
     pageSize?: number | undefined;
+    page?: number | undefined;
+    category?: string | undefined;
     filters?: string | undefined;
 }, {
     sort?: string | undefined;
-    category?: string | undefined;
-    page?: number | undefined;
     pageSize?: number | undefined;
+    page?: number | undefined;
+    category?: string | undefined;
     filters?: string | undefined;
 }>;

package/dist/features/stores/types/index.d.ts

@@ -40,14 +40,15 @@ export interface StoreProductItem {
     images?: string[];
     status: string;
     featured: boolean;
-    isAuction: boolean;
+    /** Canonical listing-kind discriminator (SB1-G Phase 4). */
+    listingType: "standard" | "auction" | "pre-order" | "prize-draw" | "bundle";
     currentBid?: number;
     isPromoted?: boolean;
     slug: string;
     availableQuantity?: number;
 }
-export interface StoreAuctionItem extends StoreProductItem {
-    isAuction: true;
+export interface StoreAuctionItem extends Omit<StoreProductItem, "listingType"> {
+    listingType: "auction";
     auctionEndDate: string;
     startingBid: number;
     bidCount: number;

package/dist/features/wishlist/actions/wishlist-actions.d.ts

@@ -4,15 +4,17 @@
  * Pure business functions for wishlist CRUD and product-enriched reads.
  * Auth, rate-limiting, and Next.js specifics are handled by the consumer.
  */
+import { wishlistRepository, type UserWishlistItem } from "../repository/user-wishlist.repository";
 import type { ProductDocument } from "../../products/schemas";
-export interface EnrichedWishlistItem {
-    productId: string;
-    addedAt: Date;
+export { WishlistFullError } from "../repository/user-wishlist.repository";
+export interface EnrichedWishlistItem extends UserWishlistItem {
     product: ProductDocument | null;
 }
-export declare function addToWishlist(userId: string, productId: string): Promise<void>;
-export declare function removeFromWishlist(userId: string, productId: string): Promise<void>;
-export declare function getWishlistForUser(userId: string): Promise<{
+export declare function addToWishlist(userSlug: string, productId: string, extras?: Parameters<typeof wishlistRepository.addItem>[2]): Promise<{
+    count: number;
+}>;
+export declare function removeFromWishlist(userSlug: string, productId: string): Promise<void>;
+export declare function getWishlistForUser(userSlug: string): Promise<{
     items: EnrichedWishlistItem[];
     meta: {
         total: number;

package/dist/features/wishlist/actions/wishlist-actions.js

@@ -5,20 +5,22 @@
  * Auth, rate-limiting, and Next.js specifics are handled by the consumer.
  */
 import { ValidationError } from "../../../errors";
-import { wishlistRepository } from "../repository/user-wishlist.repository";
+import { wishlistRepository, } from "../repository/user-wishlist.repository";
 import { productRepository } from "../../products/repository/products.repository";
-export async function addToWishlist(userId, productId) {
+export { WishlistFullError } from "../repository/user-wishlist.repository";
+export async function addToWishlist(userSlug, productId, extras) {
     if (!productId || typeof productId !== "string")
         throw new ValidationError("productId is required");
-    await wishlistRepository.addItem(userId, productId);
+    const count = await wishlistRepository.addItem(userSlug, productId, extras);
+    return { count };
 }
-export async function removeFromWishlist(userId, productId) {
+export async function removeFromWishlist(userSlug, productId) {
     if (!productId || typeof productId !== "string")
         throw new ValidationError("productId is required");
-    await wishlistRepository.removeItem(userId, productId);
+    await wishlistRepository.removeItem(userSlug, productId);
 }
-export async function getWishlistForUser(userId) {
-    const items = await wishlistRepository.getWishlistItems(userId);
+export async function getWishlistForUser(userSlug) {
+    const items = await wishlistRepository.getWishlistItems(userSlug);
     const productResults = await Promise.allSettled(items.map((item) => productRepository.findById(item.productId)));
     const enriched = items.map((item, i) => {
         const result = productResults[i];

package/dist/features/wishlist/components/WishlistCapWatcher.d.ts

@@ -0,0 +1 @@
+export declare function WishlistCapWatcher(): null;

package/dist/features/wishlist/components/WishlistCapWatcher.js

@@ -0,0 +1,24 @@
+"use client";
+/**
+ * WishlistCapWatcher — listens for the `appkit/wishlist/full` window event
+ * (dispatched by useWishlistCount when /api/wishlist/merge reports a cap
+ * reached) and surfaces a toast via the appkit ToastProvider.
+ *
+ * Mount once globally, inside ToastProvider.
+ */
+import { useEffect } from "react";
+import { useToast } from "../../../ui";
+import { WISHLIST_CAP_EVENT, } from "../hooks/useWishlistCount";
+export function WishlistCapWatcher() {
+    const { showToast } = useToast();
+    useEffect(() => {
+        function onCap(e) {
+            const detail = e.detail;
+            const limit = detail?.limit ?? 20;
+            showToast(`Wishlist full (${limit}/${limit}). Remove an item to add new ones.`, "warning");
+        }
+        window.addEventListener(WISHLIST_CAP_EVENT, onCap);
+        return () => window.removeEventListener(WISHLIST_CAP_EVENT, onCap);
+    }, [showToast]);
+    return null;
+}

package/dist/features/wishlist/components/index.d.ts

@@ -2,3 +2,4 @@ export { WishlistCard, WishlistPage } from "./WishlistPage";
 export { WishlistToggleButton } from "./WishlistToggleButton";
 export { WishlistView } from "./WishlistView";
 export type { WishlistViewProps, WishlistTab } from "./WishlistView";
+export { WishlistCapWatcher } from "./WishlistCapWatcher";

package/dist/features/wishlist/components/index.js

@@ -1,3 +1,4 @@
 export { WishlistCard, WishlistPage } from "./WishlistPage";
 export { WishlistToggleButton } from "./WishlistToggleButton";
 export { WishlistView } from "./WishlistView";
+export { WishlistCapWatcher } from "./WishlistCapWatcher";

package/dist/features/wishlist/hooks/useWishlistCount.d.ts

@@ -1,3 +1,10 @@
+/** Custom event fired when the server reports the wishlist is full during a merge. */
+export declare const WISHLIST_CAP_EVENT = "appkit/wishlist/full";
+export interface WishlistCapEventDetail {
+    limit: number;
+    current: number;
+    skippedFull: number;
+}
 /**
  * useWishlistCount
  *
@@ -13,3 +20,13 @@
  *   - Also syncs when the user visits /wishlist or /cart.
  */
 export declare function useWishlistCount(userId: string | null | undefined): number;
+/**
+ * useWishlistCountWithLimit — extends useWishlistCount with limit + isFull so
+ * UI can show "12/20" badges and disable add buttons at the cap.
+ */
+export declare function useWishlistCountWithLimit(userId: string | null | undefined): {
+    count: number;
+    limit: number;
+    isFull: boolean;
+    isNearLimit: boolean;
+};

package/dist/features/wishlist/hooks/useWishlistCount.js

@@ -3,12 +3,20 @@ import { useEffect, useRef } from "react";
 import { usePathname } from "next/navigation";
 import { useGuestWishlist } from "./useGuestWishlist";
 import { getGuestWishlistItems } from "../utils/guest-wishlist";
+import { WISHLIST_MAX } from "../../../constants/limits";
 const WISHLIST_API = "/api/wishlist";
 const WISHLIST_MERGE_API = "/api/wishlist/merge";
 const SYNC_MS = 60000;
 function getSyncableItems() {
     return getGuestWishlistItems().filter((i) => ["product", "auction", "preorder"].includes(i.type));
 }
+/** Custom event fired when the server reports the wishlist is full during a merge. */
+export const WISHLIST_CAP_EVENT = "appkit/wishlist/full";
+function dispatchCapEvent(detail) {
+    if (typeof window === "undefined")
+        return;
+    window.dispatchEvent(new CustomEvent(WISHLIST_CAP_EVENT, { detail }));
+}
 function pushToFirestore() {
     const items = getSyncableItems();
     if (!items.length)
@@ -17,7 +25,21 @@ function pushToFirestore() {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ items: items.map((i) => ({ productId: i.itemId })) }),
-    }).catch(() => { });
+    })
+        .then(async (res) => {
+        if (!res.ok)
+            return;
+        const json = (await res.json().catch(() => null));
+        const data = json?.data;
+        if (data?.capReached) {
+            dispatchCapEvent({
+                limit: data.limit ?? WISHLIST_MAX,
+                current: data.limit ?? WISHLIST_MAX,
+                skippedFull: data.skippedFull ?? 0,
+            });
+        }
+    })
+        .catch(() => { });
 }
 /**
  * useWishlistCount
@@ -93,3 +115,16 @@ export function useWishlistCount(userId) {
     }, [pathname, userId]);
     return count;
 }
+/**
+ * useWishlistCountWithLimit — extends useWishlistCount with limit + isFull so
+ * UI can show "12/20" badges and disable add buttons at the cap.
+ */
+export function useWishlistCountWithLimit(userId) {
+    const count = useWishlistCount(userId);
+    return {
+        count,
+        limit: WISHLIST_MAX,
+        isFull: count >= WISHLIST_MAX,
+        isNearLimit: count >= WISHLIST_MAX - 2,
+    };
+}

package/dist/features/wishlist/index.d.ts

@@ -6,6 +6,8 @@ export * from "./hooks/useUserWishlist";
 export * from "./hooks/useWishlistToggle";
 export * from "./hooks/useGuestWishlist";
 export * from "./hooks/useWishlistWithGuest";
+export { useWishlistCount, useWishlistCountWithLimit, WISHLIST_CAP_EVENT, } from "./hooks/useWishlistCount";
+export type { WishlistCapEventDetail } from "./hooks/useWishlistCount";
 export * from "./utils/guest-wishlist";
 export * from "./components";
 export type { UserWishlistItem } from "./repository/user-wishlist.repository";

package/dist/features/wishlist/index.js

@@ -6,6 +6,7 @@ export * from "./hooks/useUserWishlist";
 export * from "./hooks/useWishlistToggle";
 export * from "./hooks/useGuestWishlist";
 export * from "./hooks/useWishlistWithGuest";
+export { useWishlistCount, useWishlistCountWithLimit, WISHLIST_CAP_EVENT, } from "./hooks/useWishlistCount";
 export * from "./utils/guest-wishlist";
 export * from "./components";
 export { manifest } from "./manifest";

package/dist/features/wishlist/repository/user-wishlist.repository.d.ts

@@ -1,14 +1,59 @@
+/**
+ * UserWishlistRepository — one document per user at top-level `wishlists/wishlist-{userSlug}`.
+ *
+ * Doc shape: { userId: string, items: UserWishlistItem[], updatedAt: Date }
+ * - id === slug === `wishlist-{userSlug}` (LetItRip id-equals-slug convention)
+ * - userSlug === user.uid (per users-seed-data.ts: id === uid === slug)
+ * - items ordered newest-first (addedAt desc)
+ * - hard cap WISHLIST_MAX (20); idempotent re-add is a no-op; over-cap throws WishlistFullError
+ * - all mutations run inside a Firestore transaction (concurrent-write safe)
+ */
+export interface WishlistItemSnapshot {
+    title?: string;
+    thumb?: string;
+    currentPrice?: number;
+}
 export interface UserWishlistItem {
     productId: string;
+    productType?: "product" | "auction" | "preorder";
     addedAt: Date;
+    priceAtAdd?: number;
+    productSnapshot?: WishlistItemSnapshot;
+}
+export interface WishlistDocument {
+    userId: string;
+    items: UserWishlistItem[];
+    updatedAt: Date;
+}
+export declare class WishlistFullError extends Error {
+    readonly code: "WISHLIST_FULL";
+    readonly limit = 20;
+    readonly current: number;
+    constructor(current: number);
 }
 export declare class UserWishlistRepository {
-    private readonly subcollection;
-    private getUserWishlistRef;
-    getWishlistItems(uid: string): Promise<UserWishlistItem[]>;
-    addItem(uid: string, productId: string): Promise<void>;
-    removeItem(uid: string, productId: string): Promise<void>;
-    isInWishlist(uid: string, productId: string): Promise<boolean>;
-    clearWishlist(uid: string): Promise<void>;
+    private docRef;
+    getWishlistItems(userSlug: string): Promise<UserWishlistItem[]>;
+    private filterExistingProducts;
+    countByUser(userSlug: string): Promise<number>;
+    isInWishlist(userSlug: string, productId: string): Promise<boolean>;
+    /**
+     * Add a product to the wishlist. Idempotent on existing productId (no-op, no error).
+     * Throws WishlistFullError if at cap and productId is not already present.
+     * Returns the new total count.
+     */
+    addItem(userSlug: string, productId: string, extras?: {
+        productType?: UserWishlistItem["productType"];
+        priceAtAdd?: number;
+        productSnapshot?: WishlistItemSnapshot;
+    }): Promise<number>;
+    removeItem(userSlug: string, productId: string): Promise<void>;
+    clearWishlist(userSlug: string): Promise<void>;
+    /** Admin: returns one row per user (for the admin insights view). */
+    findAllSummaries(): Promise<{
+        userId: string;
+        itemCount: number;
+        updatedAt: Date;
+    }[]>;
 }
 export declare const wishlistRepository: UserWishlistRepository;

package/dist/features/wishlist/repository/user-wishlist.repository.js

@@ -1,91 +1,201 @@
+/**
+ * UserWishlistRepository — one document per user at top-level `wishlists/wishlist-{userSlug}`.
+ *
+ * Doc shape: { userId: string, items: UserWishlistItem[], updatedAt: Date }
+ * - id === slug === `wishlist-{userSlug}` (LetItRip id-equals-slug convention)
+ * - userSlug === user.uid (per users-seed-data.ts: id === uid === slug)
+ * - items ordered newest-first (addedAt desc)
+ * - hard cap WISHLIST_MAX (20); idempotent re-add is a no-op; over-cap throws WishlistFullError
+ * - all mutations run inside a Firestore transaction (concurrent-write safe)
+ */
 import { getAdminDb } from "../../../providers/db-firebase";
 import { serverLogger } from "../../../monitoring";
-import { USER_COLLECTION } from "../../auth/schemas";
-export class UserWishlistRepository {
-    constructor() {
-        this.subcollection = "wishlist";
+import { WISHLIST_COLLECTION, WISHLIST_DOC_ID, WISHLIST_MAX, } from "../../../constants/limits";
+export class WishlistFullError extends Error {
+    constructor(current) {
+        super(`Wishlist full (${current}/${WISHLIST_MAX})`);
+        this.code = "WISHLIST_FULL";
+        this.limit = WISHLIST_MAX;
+        this.name = "WishlistFullError";
+        this.current = current;
+    }
+}
+function toDate(raw) {
+    if (raw instanceof Date)
+        return raw;
+    if (raw && typeof raw.toDate === "function") {
+        return raw.toDate();
     }
-    getUserWishlistRef(uid) {
+    if (typeof raw === "string" || typeof raw === "number")
+        return new Date(raw);
+    return new Date();
+}
+function normaliseItems(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    return raw
+        .filter((r) => !!r && typeof r === "object")
+        .map((r) => ({
+        productId: String(r.productId ?? ""),
+        productType: r.productType,
+        addedAt: toDate(r.addedAt),
+        priceAtAdd: typeof r.priceAtAdd === "number" ? r.priceAtAdd : undefined,
+        productSnapshot: (r.productSnapshot ?? undefined),
+    }))
+        .filter((i) => i.productId);
+}
+export class UserWishlistRepository {
+    docRef(userSlug) {
         return getAdminDb()
-            .collection(USER_COLLECTION)
-            .doc(uid)
-            .collection(this.subcollection);
+            .collection(WISHLIST_COLLECTION)
+            .doc(WISHLIST_DOC_ID(userSlug));
     }
-    async getWishlistItems(uid) {
+    async getWishlistItems(userSlug) {
         try {
-            const snapshot = await this.getUserWishlistRef(uid)
-                .orderBy("addedAt", "desc")
-                .get();
-            return snapshot.docs.map((doc) => ({
-                productId: doc.id,
-                addedAt: doc.data().addedAt?.toDate?.() ?? new Date(),
-            }));
+            const snap = await this.docRef(userSlug).get();
+            if (!snap.exists)
+                return [];
+            const items = normaliseItems(snap.data()?.items);
+            // TS10: drop entries whose product no longer exists (was deleted/unpublished).
+            return await this.filterExistingProducts(items);
         }
         catch (error) {
             serverLogger.error("UserWishlistRepository.getWishlistItems error", {
-                uid,
+                userSlug,
                 error,
             });
             throw error;
         }
     }
-    async addItem(uid, productId) {
+    async filterExistingProducts(items) {
+        if (items.length === 0)
+            return items;
+        const db = getAdminDb();
+        const checks = await Promise.all(items.map(async (item) => {
+            try {
+                const doc = await db.collection("products").doc(item.productId).get();
+                return doc.exists ? item : null;
+            }
+            catch {
+                return item;
+            }
+        }));
+        return checks.filter((i) => i !== null);
+    }
+    async countByUser(userSlug) {
+        const snap = await this.docRef(userSlug).get();
+        if (!snap.exists)
+            return 0;
+        const items = snap.data()?.items;
+        return Array.isArray(items) ? items.length : 0;
+    }
+    async isInWishlist(userSlug, productId) {
+        const items = await this.getWishlistItems(userSlug);
+        return items.some((i) => i.productId === productId);
+    }
+    /**
+     * Add a product to the wishlist. Idempotent on existing productId (no-op, no error).
+     * Throws WishlistFullError if at cap and productId is not already present.
+     * Returns the new total count.
+     */
+    async addItem(userSlug, productId, extras) {
+        const db = getAdminDb();
+        const ref = this.docRef(userSlug);
         try {
-            await this.getUserWishlistRef(uid).doc(productId).set({
-                productId,
-                addedAt: new Date(),
+            return await db.runTransaction(async (tx) => {
+                const snap = await tx.get(ref);
+                const items = snap.exists
+                    ? normaliseItems(snap.data()?.items)
+                    : [];
+                if (items.some((i) => i.productId === productId)) {
+                    return items.length; // idempotent
+                }
+                if (items.length >= WISHLIST_MAX) {
+                    throw new WishlistFullError(items.length);
+                }
+                const newItem = {
+                    productId,
+                    productType: extras?.productType,
+                    addedAt: new Date(),
+                    priceAtAdd: extras?.priceAtAdd,
+                    productSnapshot: extras?.productSnapshot,
+                };
+                const next = [newItem, ...items];
+                tx.set(ref, {
+                    userId: userSlug,
+                    items: next,
+                    updatedAt: new Date(),
+                });
+                return next.length;
             });
         }
         catch (error) {
+            if (error instanceof WishlistFullError)
+                throw error;
             serverLogger.error("UserWishlistRepository.addItem error", {
-                uid,
+                userSlug,
                 productId,
                 error,
             });
             throw error;
         }
     }
-    async removeItem(uid, productId) {
+    async removeItem(userSlug, productId) {
+        const db = getAdminDb();
+        const ref = this.docRef(userSlug);
         try {
-            await this.getUserWishlistRef(uid).doc(productId).delete();
+            await db.runTransaction(async (tx) => {
+                const snap = await tx.get(ref);
+                if (!snap.exists)
+                    return;
+                const items = normaliseItems(snap.data()?.items);
+                const next = items.filter((i) => i.productId !== productId);
+                if (next.length === items.length)
+                    return;
+                tx.set(ref, {
+                    userId: userSlug,
+                    items: next,
+                    updatedAt: new Date(),
+                });
+            });
         }
         catch (error) {
             serverLogger.error("UserWishlistRepository.removeItem error", {
-                uid,
+                userSlug,
                 productId,
                 error,
             });
             throw error;
         }
     }
-    async isInWishlist(uid, productId) {
+    async clearWishlist(userSlug) {
         try {
-            const doc = await this.getUserWishlistRef(uid).doc(productId).get();
-            return doc.exists;
-        }
-        catch (error) {
-            serverLogger.error("UserWishlistRepository.isInWishlist error", {
-                uid,
-                productId,
-                error,
+            await this.docRef(userSlug).set({
+                userId: userSlug,
+                items: [],
+                updatedAt: new Date(),
             });
-            return false;
-        }
-    }
-    async clearWishlist(uid) {
-        try {
-            const snapshot = await this.getUserWishlistRef(uid).get();
-            const batch = getAdminDb().batch();
-            snapshot.docs.forEach((doc) => batch.delete(doc.ref));
-            await batch.commit();
         }
         catch (error) {
             serverLogger.error("UserWishlistRepository.clearWishlist error", {
-                uid,
+                userSlug,
                 error,
             });
             throw error;
         }
     }
+    /** Admin: returns one row per user (for the admin insights view). */
+    async findAllSummaries() {
+        const snap = await getAdminDb().collection(WISHLIST_COLLECTION).get();
+        return snap.docs.map((doc) => {
+            const data = doc.data();
+            const items = Array.isArray(data?.items) ? data.items : [];
+            return {
+                userId: String(data?.userId ?? doc.id.replace(/^wishlist-/, "")),
+                itemCount: items.length,
+                updatedAt: toDate(data?.updatedAt),
+            };
+        });
+    }
 }
 export const wishlistRepository = new UserWishlistRepository();