좋아요/북마크/공유 시스템

CREATE TABLE likes (
  user_id UUID NOT NULL,
  post_id UUID NOT NULL,
  created_at TIMESTAMP DEFAULT NOW(),
  PRIMARY KEY (user_id, post_id)
);

CREATE INDEX ON likes(post_id);
CREATE INDEX ON likes(user_id, created_at DESC);


CREATE TABLE bookmarks (
  user_id UUID NOT NULL,
  post_id UUID NOT NULL,
  collection_id UUID,  -- 컬렉션 분류
  created_at TIMESTAMP DEFAULT NOW(),
  PRIMARY KEY (user_id, post_id)
);


-- 컬렉션 (북마크 분류)
CREATE TABLE bookmark_collections (
  id UUID PRIMARY KEY,
  user_id UUID NOT NULL,
  name VARCHAR NOT NULL,
  is_private BOOLEAN DEFAULT true,
  created_at TIMESTAMP DEFAULT NOW()
);


-- 공유 통계
CREATE TABLE shares (
  id UUID PRIMARY KEY,
  post_id UUID NOT NULL,
  user_id UUID,                -- NULL = 비로그인
  channel VARCHAR NOT NULL,    -- 'twitter', 'kakao', 'copy_link', 'email'
  created_at TIMESTAMP DEFAULT NOW()
);

CREATE INDEX ON shares(post_id, created_at DESC);

async function toggleLike(userId: string, postId: string) {
  return db.$transaction(async (tx) => {
    const existing = await tx.like.findUnique({
      where: { userId_postId: { userId, postId } },
    });

    if (existing) {
      // 취소
      await tx.like.delete({
        where: { userId_postId: { userId, postId } },
      });
      await tx.post.update({
        where: { id: postId },
        data: { likesCount: { decrement: 1 } },
      });
      return { liked: false };
    } else {
      await tx.like.create({
        data: { userId, postId },
      });
      await tx.post.update({
        where: { id: postId },
        data: { likesCount: { increment: 1 } },
      });

      // 알림 (자기 자신 제외)
      const post = await tx.post.findUnique({ where: { id: postId } });
      if (post!.userId !== userId) {
        await notify({
          userId: post!.userId,
          type: 'like',
          title: '좋아요',
          body: `누군가가 회원님의 게시물에 좋아요를 눌렀습니다`,
          link: `/posts/${postId}`,
        });
      }

      return { liked: true };
    }
  });
}

'use client';
import { useMutation, useQueryClient } from '@tanstack/react-query';

function LikeButton({ postId }: { postId: string }) {
  const qc = useQueryClient();

  const mutation = useMutation({
    mutationFn: async () => {
      const res = await fetch(`/api/posts/${postId}/like`, { method: 'POST' });
      return res.json();
    },

    // 낙관적 업데이트
    onMutate: async () => {
      await qc.cancelQueries({ queryKey: ['post', postId] });
      const prev = qc.getQueryData(['post', postId]);

      qc.setQueryData(['post', postId], (old: any) => ({
        ...old,
        liked: !old.liked,
        likesCount: old.likesCount + (old.liked ? -1 : 1),
      }));

      return { prev };
    },

    // 실패 시 롤백
    onError: (err, _vars, ctx) => {
      qc.setQueryData(['post', postId], ctx?.prev);
      toast.error('실패했습니다');
    },

    // 서버 응답 후 재동기화
    onSettled: () => {
      qc.invalidateQueries({ queryKey: ['post', postId] });
    },
  });

  const post = qc.getQueryData<Post>(['post', postId])!;

  return (
    <button
      onClick={() => mutation.mutate()}
      className={post.liked ? 'liked' : ''}
    >
      {post.liked ? '❤️' : '🤍'} {post.likesCount.toLocaleString()}
    </button>
  );
}

// 동시성 폭주 시 — Redis 카운터 + 주기적 동기화
async function fastLike(userId: string, postId: string) {
  // 1. Redis에 즉시 반영
  const liked = await redis.sismember(`post:${postId}:likes`, userId);

  if (liked) {
    await redis.srem(`post:${postId}:likes`, userId);
    await redis.decr(`post:${postId}:likes_count`);
  } else {
    await redis.sadd(`post:${postId}:likes`, userId);
    await redis.incr(`post:${postId}:likes_count`);
  }

  // 2. 큐에 영속화 작업 추가
  await likeQueue.add('persist', { userId, postId, action: liked ? 'unlike' : 'like' });

  return { liked: !liked };
}


// Worker — DB 동기화
const persistWorker = new Worker('like', async (job) => {
  const { userId, postId, action } = job.data;
  if (action === 'like') {
    await db.like.upsert({
      where: { userId_postId: { userId, postId } },
      create: { userId, postId },
      update: {},
    });
  } else {
    await db.like.delete({
      where: { userId_postId: { userId, postId } },
    }).catch(() => {});
  }
});


// 주기적 카운터 동기화 (1시간)
setInterval(async () => {
  const posts = await db.post.findMany({ select: { id: true } });
  for (const post of posts) {
    const count = await redis.scard(`post:${post.id}:likes`);
    await db.post.update({ where: { id: post.id }, data: { likesCount: count } });
  }
}, 3600000);

async function bookmark(userId: string, postId: string, collectionId?: string) {
  return db.bookmark.upsert({
    where: { userId_postId: { userId, postId } },
    create: { userId, postId, collectionId },
    update: { collectionId },
  });
}


// 사용자의 모든 북마크
async function getBookmarks(userId: string, collectionId?: string) {
  return db.bookmark.findMany({
    where: { userId, ...(collectionId && { collectionId }) },
    include: { post: { include: { user: true } } },
    orderBy: { createdAt: 'desc' },
  });
}

function ShareButton({ post }: { post: Post }) {
  const trackShare = (channel: string) => {
    fetch(`/api/posts/${post.id}/share`, {
      method: 'POST',
      body: JSON.stringify({ channel }),
    });
  };

  const url = `${window.location.origin}/posts/${post.id}`;

  return (
    <Dropdown>
      <Item onClick={() => {
        navigator.clipboard.writeText(url);
        trackShare('copy_link');
        toast.success('링크 복사됨');
      }}>
        링크 복사
      </Item>
      <Item onClick={() => {
        window.open(`https://twitter.com/intent/tweet?url=${encodeURIComponent(url)}`);
        trackShare('twitter');
      }}>
        Twitter
      </Item>
      <Item onClick={() => {
        // KakaoTalk SDK
        Kakao.Share.sendDefault({
          objectType: 'feed',
          content: { title: post.title, link: { mobileWebUrl: url, webUrl: url } },
        });
        trackShare('kakao');
      }}>
        카카오톡
      </Item>
    </Dropdown>
  );
}