데이터 모델링과 아키텍처 설계

// ❌ 정규화된 구조 — 게시글 목록 렌더링에 N+1 읽기 발생
// posts/{postId} 문서에는 authorId만 있고, 작성자 이름을 별도 조회해야 함
const post = await getDoc(doc(db, 'posts', postId));
const author = await getDoc(doc(db, 'users', post.data().authorId)); // 게시글마다 반복

// ✅ 비정규화 — 작성자 정보를 posts 문서에 내장
// posts/{postId}
{
  title: "Firestore 설계 전략",
  content: "...",
  authorId: "uid_abc",
  authorName: "김개발",       // users 문서에서 복사
  authorPhotoURL: "https://...",
  createdAt: Timestamp,
  likeCount: 0
}

// ✅ 서브컬렉션 — 댓글은 게시글에 종속
// posts/{postId}/comments/{commentId}
await addDoc(collection(db, 'posts', postId, 'comments'), {
  text: "좋은 글 감사합니다.",
  authorId: "uid_xyz",
  authorName: "이댓글",
  createdAt: serverTimestamp()
});

// 특정 게시글의 댓글만 쿼리
const commentsRef = collection(db, 'posts', postId, 'comments');
const q = query(commentsRef, orderBy('createdAt', 'desc'), limit(20));

// ✅ 루트 컬렉션 — 여러 부모에 걸친 쿼리가 필요한 경우
// comments/{commentId}
{
  postId: "post_abc",
  text: "좋은 글 감사합니다.",
  authorId: "uid_xyz",
  createdAt: Timestamp
}

// 특정 사용자의 전체 댓글을 한 번에 조회 가능
const q = query(
  collection(db, 'comments'),
  where('authorId', '==', currentUserId),
  orderBy('createdAt', 'desc')
);

import { collectionGroup, query, where, getDocs } from 'firebase/firestore';

// posts/{postId}/comments 서브컬렉션 전체를 한 번에 검색
const q = query(
  collectionGroup(db, 'comments'),
  where('authorId', '==', currentUserId)
);
const snapshot = await getDocs(q);

// ❌ 배열에 무한정 누적 — 1MB 한도와 동시 쓰기 충돌 위험
// users/{userId}
{
  followers: ["uid_1", "uid_2", "uid_3", ...] // 팔로워가 늘수록 문서 크기 증가
}

// ✅ 서브컬렉션으로 분리 — 무제한 확장 가능
// users/{userId}/followers/{followerId}
{
  followedAt: Timestamp,
  displayName: "팔로워이름" // 비정규화로 목록 렌더링 최적화
}

// ❌ 단일 문서에 동적 키 누적
// posts/{postId}
{
  likes: {
    "uid_001": true,
    "uid_002": true,
    // ... 수만 명이 좋아요를 누르면 1MB 초과
  }
}

// ✅ 서브컬렉션으로 분산
// posts/{postId}/likes/{userId}
{
  likedAt: Timestamp
}

// 좋아요 여부 확인
const likeRef = doc(db, 'posts', postId, 'likes', currentUserId);
const likeSnap = await getDoc(likeRef);
const isLiked = likeSnap.exists();

import { doc, runTransaction, increment, serverTimestamp } from 'firebase/firestore';

// 좋아요 추가 + 카운터 동기화를 트랜잭션으로 묶기
async function addLike(postId, userId) {
  const postRef = doc(db, 'posts', postId);
  const likeRef = doc(db, 'posts', postId, 'likes', userId);

  await runTransaction(db, async (transaction) => {
    const likeSnap = await transaction.get(likeRef);
    if (likeSnap.exists()) {
      throw new Error('이미 좋아요를 눌렀습니다.');
    }
    transaction.set(likeRef, { likedAt: serverTimestamp() });
    transaction.update(postRef, { likeCount: increment(1) });
  });
}

// 좋아요 취소
async function removeLike(postId, userId) {
  const postRef = doc(db, 'posts', postId);
  const likeRef = doc(db, 'posts', postId, 'likes', userId);

  await runTransaction(db, async (transaction) => {
    const likeSnap = await transaction.get(likeRef);
    if (!likeSnap.exists()) return;
    transaction.delete(likeRef);
    transaction.update(postRef, { likeCount: increment(-1) });
  });
}

const SHARD_COUNT = 10;

// 쓰기: 랜덤 샤드에 분산
// updateDoc()은 대상 문서가 없으면 'NOT_FOUND' 오류를 던지므로,
// setDoc(..., { merge: true })로 샤드가 없으면 생성하고 있으면 누적한다.
async function incrementShardedCounter(docRef) {
  const shardId = Math.floor(Math.random() * SHARD_COUNT).toString();
  const shardRef = doc(docRef, 'shards', shardId);
  await setDoc(shardRef, { count: increment(1) }, { merge: true });
}

// 읽기: 모든 샤드 합산
async function getShardedCount(docRef) {
  const shardsRef = collection(docRef, 'shards');
  const snapshot = await getDocs(shardsRef);
  return snapshot.docs.reduce((total, doc) => total + (doc.data().count || 0), 0);
}

// Cloud Functions (v2) — 리뷰 추가 시 요약 문서 업데이트
import { onDocumentCreated } from 'firebase-functions/v2/firestore';
import { getFirestore, increment } from 'firebase-admin/firestore';

export const onReviewCreated = onDocumentCreated(
  'products/{productId}/reviews/{reviewId}',
  async (event) => {
    const review = event.data?.data();
    if (!review) return;

    const db = getFirestore();
    const statsRef = db.doc(`products/${event.params.productId}/meta/stats`);

    await statsRef.set(
      {
        reviewCount: increment(1),
        ratingSum: increment(review.rating),
        // 클라이언트에서 ratingSum / reviewCount 로 평균 계산
      },
      { merge: true }
    );
  }
);

// ❌ 풀 모델 — in 쿼리 30개 제한, 팔로잉이 많으면 다수의 쿼리 필요
const followingIds = ['uid_1', 'uid_2', ..., 'uid_200']; // 200명
// 30개씩 청크로 나눠 7번 쿼리, 결과를 메모리에서 병합해야 함

// Cloud Functions — 게시글 생성 시 팔로워 피드에 팬아웃
import { onDocumentCreated } from 'firebase-functions/v2/firestore';
import { getFirestore } from 'firebase-admin/firestore';

export const onPostCreated = onDocumentCreated(
  'posts/{postId}',
  async (event) => {
    const post = event.data?.data();
    if (!post) return;

    const db = getFirestore();
    const postId = event.params.postId;

    // 작성자의 팔로워 목록 조회
    const followersSnap = await db
      .collection(`users/${post.authorId}/followers`)
      .get();

    // 배치 쓰기로 각 팔로워의 feed에 복사
    const batch = db.batch();
    followersSnap.docs.forEach((followerDoc) => {
      const feedRef = db.doc(`users/${followerDoc.id}/feed/${postId}`);
      batch.set(feedRef, {
        postId,
        authorId: post.authorId,
        authorName: post.authorName,
        title: post.title,
        createdAt: post.createdAt,
        likeCount: 0
      });
    });

    // 자신의 피드에도 추가
    const ownFeedRef = db.doc(`users/${post.authorId}/feed/${postId}`);
    batch.set(ownFeedRef, {
      postId,
      authorId: post.authorId,
      authorName: post.authorName,
      title: post.title,
      createdAt: post.createdAt,
      likeCount: 0
    });

    await batch.commit();
  }
);

// 클라이언트 — 피드 조회가 단일 컬렉션 쿼리로 단순화됨
import { collection, query, orderBy, limit, onSnapshot } from 'firebase/firestore';

const feedRef = collection(db, 'users', currentUserId, 'feed');
const q = query(feedRef, orderBy('createdAt', 'desc'), limit(20));

const unsubscribe = onSnapshot(q, (snapshot) => {
  const feed = snapshot.docs.map(doc => ({ id: doc.id, ...doc.data() }));
  renderFeed(feed);
});

// ❌ 코드 레벨 JOIN — 게시글 100개라면 101번 읽기 발생
const postsSnap = await getDocs(collection(db, 'posts'));
const postsWithAuthors = await Promise.all(
  postsSnap.docs.map(async (postDoc) => {
    const post = postDoc.data();
    const author = await getDoc(doc(db, 'users', post.authorId)); // 매번 읽기
    return { ...post, author: author.data() };
  })
);

// ✅ 비정규화로 해결 — 작성자 정보를 posts 문서에 미리 포함
const postsSnap = await getDocs(collection(db, 'posts'));
const posts = postsSnap.docs.map(doc => ({ id: doc.id, ...doc.data() }));
// authorName, authorPhotoURL이 이미 posts 문서에 있으므로 추가 읽기 불필요

// ❌ 과도한 중첩 — 보안 규칙 작성이 복잡해지고 쿼리 유연성 저하
// companies/{companyId}/teams/{teamId}/projects/{projectId}/tasks/{taskId}/comments/{commentId}

// ✅ 2단계 이하로 유지, 깊은 데이터는 루트 컬렉션 + 참조 필드로 연결
// comments/{commentId}
{
  taskId: "task_abc",
  projectId: "proj_xyz",
  text: "완료 처리 부탁드립니다.",
  authorId: "uid_123"
}

// ❌ 맵 필드 내부는 쿼리 불가
// orders/{orderId}
{
  items: {
    "item_001": { name: "노트북", price: 1500000 },
    "item_002": { name: "마우스", price: 50000 }
  }
}
// where('items.item_001.price', '>', 1000000) 은 동작하지 않음

// ✅ 배열 또는 서브컬렉션으로 변환
// orders/{orderId}/items/{itemId}
{
  name: "노트북",
  price: 1500000,
  category: "electronics"
}
// 이제 category로 필터링하는 쿼리가 가능해짐

// ❌ 타입이 다른 이벤트를 하나의 컬렉션에 혼재
// events/{eventId}
// { type: 'click', elementId: '...' }
// { type: 'purchase', productId: '...', amount: 50000 }
// { type: 'signup', email: '...' }

// ✅ 이벤트 타입별로 별도 컬렉션 또는 서브컬렉션으로 분리
// clickEvents/{eventId}, purchaseEvents/{eventId}, signupEvents/{eventId}
// 또는 analytics/{type}/events/{eventId}