Firebase — a teljes platform áttekintése

my-saas-prod                          # project ID
├── apps
│   ├── web         # Angular frontend
│   ├── ios         # Swift app
│   ├── android     # Kotlin app
│   └── admin-web   # second Angular app, admin UI
├── firestore       # shared database for all 4 apps
├── auth            # shared user base
├── storage         # shared file storage
├── functions       # shared backend code
└── hosting
    ├── site:web         # app.example.com
    └── site:admin       # admin.example.com

{
  "projects": {
    "default": "my-saas-dev",
    "dev":     "my-saas-dev",
    "staging": "my-saas-staging",
    "prod":    "my-saas-prod"
  }
}

users                              # collection
├── usr_abc123                     # document
│   ├── displayName: "Anna Kovács"
│   ├── email: "anna@example.com"
│   ├── createdAt: Timestamp
│   └── orders                     # subcollection
│       ├── ord_001 { ... }
│       └── ord_002 { ... }
└── usr_xyz789
    └── ...

import { collection, query, where, onSnapshot } from 'firebase/firestore';

const q = query(
  collection(db, 'orders'),
  where('status', '==', 'active')
);

// Subscribe — every change arrives via push
onSnapshot(q, (snap) => {
  const orders = snap.docs.map(d => ({ id: d.id, ...d.data() }));
  // UI update
});

import { getAuth, signInWithEmailAndPassword } from 'firebase/auth';

const auth = getAuth();

try {
  const cred = await signInWithEmailAndPassword(auth, email, password);
  const token = await cred.user.getIdToken();
  // The token is automatically attached to every Firestore/Storage call
} catch (err) {
  // auth/wrong-password, auth/user-not-found, ...
}

import { getAuth } from 'firebase-admin/auth';

await getAuth().setCustomUserClaims(uid, {
  role: 'admin',
  tenantId: 'acme-corp',
});

// The user receives the new claims on the next token refresh
// Client side: await user.getIdToken(true) forces a refresh

rules_version = '2';

service cloud.firestore {
  match /databases/{database}/documents {

    // users/{uid} document: only the owner can read or write
    match /users/{uid} {
      allow read, write: if request.auth.uid == uid;
    }

    // orders: a user sees only their own; admin sees and writes all
    match /orders/{orderId} {
      allow read:  if request.auth.uid == resource.data.userId
                || request.auth.token.role == 'admin';
      allow create: if request.auth != null
                 && request.resource.data.userId == request.auth.uid;
      allow update, delete: if request.auth.token.role == 'admin';
    }
  }
}

{
  "hosting": [
    {
      "target": "web",
      "public": "dist/web/browser",
      "ignore": ["firebase.json", "**/.*"],
      "rewrites": [
        { "source": "/api/**", "function": "api" },
        { "source": "**", "destination": "/index.html" }
      ],
      "headers": [
        {
          "source": "**/*.@(js|css|woff2)",
          "headers": [{ "key": "Cache-Control", "value": "max-age=31536000, immutable" }]
        }
      ]
    }
  ]
}

import { onDocumentCreated } from 'firebase-functions/v2/firestore';
import { onCall, HttpsError } from 'firebase-functions/v2/https';
import { onSchedule } from 'firebase-functions/v2/scheduler';

// 1) Firestore trigger — send confirmation email on new order
export const onOrderCreated = onDocumentCreated('orders/{orderId}', async (event) => {
  const order = event.data?.data();
  await sendConfirmationEmail(order);
});

// 2) Callable — secured operation, admin only
export const deleteUser = onCall(async (request) => {
  if (request.auth?.token.role !== 'admin') {
    throw new HttpsError('permission-denied', 'Admin only');
  }
  // ...
});

// 3) Scheduled — archive every night at 02:00
export const nightlyArchive = onSchedule('0 2 * * *', async () => {
  // ...
});

import { getStorage, ref, uploadBytes, getDownloadURL } from 'firebase/storage';

const storage = getStorage();
const avatarRef = ref(storage, `users/${user.uid}/avatar.jpg`);

const snap = await uploadBytes(avatarRef, file);
const url  = await getDownloadURL(snap.ref);

// `url` is a public download link, token-protected — safe to store in Firestore

rules_version = '2';

service firebase.storage {
  match /b/{bucket}/o {

    // Own avatar: max 5 MB, image type, only the user themselves
    match /users/{uid}/avatar.{ext} {
      allow read:  if true;
      allow write: if request.auth.uid == uid
                && request.resource.size < 5 * 1024 * 1024
                && request.resource.contentType.matches('image/.*');
    }
  }
}

import { getMessaging } from 'firebase-admin/messaging';

await getMessaging().send({
  token: userDeviceToken,
  notification: {
    title: 'New order received',
    body:  '#ORD-2026-0421 — Anna Kovács',
  },
  data: { orderId: 'ord_xyz' },
});