Epicure/apps/web/app/(app)/collections/page.tsx

import type { Metadata } from "next";
import { headers } from "next/headers";
import { auth } from "@/lib/auth/server";
import { db, collections, collectionRecipes, eq, and, or, ilike, sql } from "@epicure/db";
import { CollectionsPageContent } from "@/components/collections/collections-page-content";
import { getPublicUrl } from "@/lib/storage";

export const metadata: Metadata = {};

export default async function CollectionsPage({
  searchParams,
}: {
  searchParams: Promise<{ q?: string }>;
}) {
  const session = await auth.api.getSession({ headers: await headers() });
  if (!session) return null;

  const { q } = await searchParams;
  const query = q?.trim();

  const where = query
    ? and(
        eq(collections.userId, session.user.id),
        or(
          ilike(collections.name, `%${query}%`),
          ilike(collections.description, `%${query}%`),
          sql`exists (
            select 1 from collection_recipes cr
            inner join recipes r on r.id = cr.recipe_id
            where cr.collection_id = ${collections.id} and r.title ilike ${`%${query}%`}
          )`
        )
      )
    : eq(collections.userId, session.user.id);

  const [userCollections, countRows] = await Promise.all([
    db.query.collections.findMany({
      where,
      orderBy: (t, { desc }) => desc(t.updatedAt),
      with: {
        recipes: {
          limit: 4,
          orderBy: (t, { asc }) => asc(t.position),
          with: { recipe: { with: { photos: true } } },
        },
      },
    }),
    // Separate grouped count — the `with: { recipes: { limit: 4 } }` above is
    // capped for thumbnail previews, so `.recipes.length` off that relation
    // would only ever report up to 4, never the real total.
    db
      .select({ collectionId: collectionRecipes.collectionId, count: sql<number>`count(*)::int` })
      .from(collectionRecipes)
      .innerJoin(collections, eq(collectionRecipes.collectionId, collections.id))
      .where(eq(collections.userId, session.user.id))
      .groupBy(collectionRecipes.collectionId),
  ]);

  const countByCollection = new Map(countRows.map((r) => [r.collectionId, r.count]));

  return (
    <CollectionsPageContent
      query={query ?? ""}
      collections={userCollections.map((col) => ({
        id: col.id,
        name: col.name,
        description: col.description,
        tags: col.tags,
        isPublic: col.isPublic,
        recipeCount: countByCollection.get(col.id) ?? 0,
        thumbnails: col.recipes.flatMap((r) => {
          if (!r.recipe) return [];
          const cover = r.recipe.photos.find((p) => p.isCover) ?? r.recipe.photos[0];
          return [{
            recipeId: r.recipe.id,
            recipeType: r.recipe.recipeType,
            coverIcon: r.recipe.coverIcon,
            coverColor: r.recipe.coverColor,
            photoUrl: cover ? getPublicUrl(cover.storageKey) : null,
          }];
        }),
      }))}
    />
  );
}