Firestore — gondolkodj lekérdezésekben

users / usr_abc                    # root collection
  └── orders / ord_001            # subcollection
  └── orders / ord_002

users / usr_abc                    # root collection
orders / ord_001                   # separate root collection
  └── userId: "usr_abc"          # field for the relation

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

// Every order across every user — regardless of hierarchy
const q = query(
  collectionGroup(db, 'orders'),
  where('status', '==', 'active'),
  orderBy('createdAt', 'desc'),
  limit(20)
);

{
  "id": "ord_001",
  "userId": "usr_abc",
  "userName": "Anna Kovács",           // denormalized
  "userEmail": "anna@example.com",      // denormalized
  "total": 12990,
  "createdAt": "2026-04-21T09:14:00Z"
}

{
  "id": "usr_abc",
  "name": "Anna Kovács",
  "groupIds": ["grp_eng", "grp_design", "grp_admin"]
}

{
  "id": "usr_abc",
  "groups": {
    "grp_eng":    { "role": "admin",  "joinedAt": "2024-08-12" },
    "grp_design": { "role": "member", "joinedAt": "2025-03-04" }
  }
}

memberships
├── usr_abc__grp_eng                # compound ID
│   ├── userId: "usr_abc"
│   ├── groupId: "grp_eng"
│   ├── role: "admin"
│   └── joinedAt: Timestamp
└── usr_xyz__grp_eng

import { collection, query, where, getCountFromServer, getAggregateFromServer, sum } from 'firebase/firestore';

// How many active orders are there?
const q = query(collection(db, 'orders'), where('status', '==', 'active'));
const snap = await getCountFromServer(q);
console.log(snap.data().count);

// What's total revenue?
const agg = await getAggregateFromServer(q, { revenue: sum('total') });
console.log(agg.data().revenue);

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

await updateDoc(doc(db, 'posts', postId), {
  likeCount: increment(1)
});

// Structure: posts/{postId}/likeShards/{shardId}
// Each shard: { count: number }

const NUM_SHARDS = 10;

// Like — write to a random shard
async function incrementLike(postId: string) {
  const shardId = Math.floor(Math.random() * NUM_SHARDS).toString();
  const ref = doc(db, `posts/${postId}/likeShards/${shardId}`);
  await updateDoc(ref, { count: increment(1) });
}

// Read — sum every shard
async function getLikeCount(postId: string): Promise<number> {
  const snap = await getDocs(collection(db, `posts/${postId}/likeShards`));
  return snap.docs.reduce((sum, d) => sum + d.data().count, 0);
}

stats
├── 2026-04-28-h00          # 0:00 - 0:59
├── 2026-04-28-h01
├── 2026-04-28-h02
└── ...

import { collection, query, orderBy, limit, startAfter, getDocs } from 'firebase/firestore';

// First page
const first = query(
  collection(db, 'orders'),
  orderBy('createdAt', 'desc'),
  limit(20)
);
const snap = await getDocs(first);
const lastDoc = snap.docs[snap.docs.length - 1];

// Next page — continue from here
const next = query(
  collection(db, 'orders'),
  orderBy('createdAt', 'desc'),
  startAfter(lastDoc),
  limit(20)
);

// One /orders root collection, every doc has a tenantId field
{
  "id": "ord_001",
  "tenantId": "acme-corp",
  "userId": "usr_abc",
  "total": 12990
}

tenants
├── acme-corp
│   ├── orders / ord_001
│   ├── products / prod_001
│   └── members / usr_abc
└── beta-inc
    └── ...

tenants / {tid}
├── name, plan, createdAt
├── members / {uid}                # tenant-bound user
│   ├── role: 'admin' | 'user'
│   ├── displayName, email          # denormalized from /users
│   └── joinedAt
├── products / {pid}
│   ├── name, price, stock
│   ├── purchaseCount               # denormalized, for top lists
│   └── updatedAt
├── orders / {oid}
│   ├── userId, userDisplayName     # denormalized
│   ├── items: [                    # embedded array, max ~50 items
│   │     { productId, name, price, qty }
│   │   ]
│   ├── total, status, createdAt
│   └── month: '2026-04'             # precomputed for reports
└── monthlyStats / {YYYY-MM}        # aggregated monthly data
    └── revenue, orderCount

import { onDocumentWritten } from 'firebase-functions/v2/firestore';
import { getFirestore, FieldValue } from 'firebase-admin/firestore';

export const onOrderWritten = onDocumentWritten(
  'tenants/{tid}/orders/{oid}',
  async (event) => {
    const db = getFirestore();
    const tid = event.params.tid;
    const before = event.data?.before.data();
    const after  = event.data?.after.data();

    // 1) Update monthly stats
    if (after) {
      const month = after.month;
      const diff = (after.total ?? 0) - (before?.total ?? 0);
      await db.doc(`tenants/${tid}/monthlyStats/${month}`).set({
        revenue: FieldValue.increment(diff),
        orderCount: FieldValue.increment(before ? 0 : 1),
      }, { merge: true });
    }

    // 2) Product purchase counters
    if (!before && after) {
      for (const item of after.items) {
        await db.doc(`tenants/${tid}/products/${item.productId}`).update({
          purchaseCount: FieldValue.increment(item.qty),
          stock: FieldValue.increment(-item.qty),
        });
      }
    }
  }
);