firebase-integration

rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    // Helper functions
    function isSignedIn() {
      return request.auth != null;
    }
    
    function isOwner(userId) {
      return request.auth.uid == userId;
    }
    
    function isAdmin() {
      return request.auth.token.admin == true;
    }
    
    // User documents - owner access only
    match /users/{userId} {
      allow read, write: if isOwner(userId);
    }
    
    // Posts - read if signed in, write if owner or admin
    match /posts/{postId} {
      allow read: if isSignedIn();
      allow create: if isSignedIn() && 
                       request.resource.data.author == request.auth.uid;
      allow update, delete: if isOwner(resource.data.author) || isAdmin();
    }
  }
}

// Document structure: { title: "...", roles: { "user123": "editor", "user456": "viewer" } }

match /documents/{docId} {
  function getRole() {
    return resource.data.roles[request.auth.uid];
  }
  
  function hasRole(allowedRoles) {
    return request.auth != null && getRole() in allowedRoles;
  }
  
  allow read: if hasRole(['owner', 'editor', 'viewer']);
  allow write: if hasRole(['owner', 'editor']);
  allow delete: if hasRole(['owner']);
}

match /tasks/{taskId} {
  function isValidTask() {
    let data = request.resource.data;
    return data.title is string &&
           data.title.size() > 0 &&
           data.title.size() <= 200 &&
           data.status in ['pending', 'in_progress', 'completed'];
  }
  
  allow create: if isSignedIn() && isValidTask();
  allow update: if isOwner(resource.data.createdBy) && isValidTask();
}

// Node.js Admin SDK
const admin = require('firebase-admin');

async function setUserRole(uid, role) {
  await admin.auth().setCustomUserClaims(uid, { role });
}

// Usage
await setUserRole('user123', 'admin');

// Flutter
Future<String?> getUserRole() async {
  final user = FirebaseAuth.instance.currentUser;
  final idTokenResult = await user?.getIdTokenResult(true); // Force refresh
  return idTokenResult?.claims?['role'] as String?;
}

// React Native
const idTokenResult = await auth().currentUser?.getIdTokenResult(true);
const role = idTokenResult?.claims?.role;

// Security rules can access claims via request.auth.token
allow read: if request.auth.token.role == 'admin';
allow write: if request.auth.token.admin == true;

import 'package:firebase_messaging/firebase_messaging.dart';

Future<void> initFCM() async {
  final messaging = FirebaseMessaging.instance;
  await messaging.requestPermission();
  
  // Foreground messages
  FirebaseMessaging.onMessage.listen((message) {
    print('Foreground: ${message.notification?.title}');
  });
  
  // Background messages (must be top-level function)
  FirebaseMessaging.onBackgroundMessage(_handleBackgroundMessage);
  
  // Notification taps
  FirebaseMessaging.onMessageOpenedApp.listen((message) {
    navigateToScreen(message.data);
  });
}

@pragma('vm:entry-point')
Future<void> _handleBackgroundMessage(RemoteMessage message) async {
  await Firebase.initializeApp();
  // Process silently
}

import messaging from '@react-native-firebase/messaging';

async function initFCM() {
  await messaging().requestPermission();
  
  messaging().onMessage(async (message) => {
    console.log('Foreground:', message.notification);
  });
  
  messaging().setBackgroundMessageHandler(async (message) => {
    console.log('Background:', message.data);
  });
  
  messaging().onNotificationOpenedApp((message) => {
    navigateToScreen(message.data);
  });
}

const admin = require('firebase-admin');

await admin.messaging().send({
  token: deviceToken,
  notification: { title: 'Hello', body: 'World' },
  data: { action: 'open_chat', chatId: '123' },
  android: { priority: 'high' },
  apns: { payload: { aps: { sound: 'default' } } },
});

// Flutter - Configure persistence
await FirebaseFirestore.instance.settings = Settings(
  persistenceEnabled: true,
  cacheSizeBytes: Settings.CACHE_SIZE_UNLIMITED,
);

// Check if data is from cache
final snapshot = await doc.get();
print('From cache: ${snapshot.metadata.isFromCache}');

// Flutter
await FirebaseDatabase.instance.setPersistenceEnabled(true);
await FirebaseDatabase.instance.setPersistenceCacheSizeBytes(50 * 1024 * 1024);

// Check connection state
database.ref('.info/connected').onValue.listen((event) {
  final connected = event.snapshot.value as bool;
  print(connected ? 'Online' : 'Offline');
});

// BAD: Fetch all documents
final all = await firestore.collection('products').get();

// GOOD: Paginate with limit
final page = await firestore
    .collection('products')
    .orderBy('createdAt', descending: true)
    .limit(20)
    .get();

// Continue pagination
final nextPage = await firestore
    .collection('products')
    .orderBy('createdAt', descending: true)
    .startAfterDocument(page.docs.last)
    .limit(20)
    .get();

// Store author info in post to avoid joins
const post = {
  title: 'My Post',
  authorId: 'user123',
  authorName: 'John',      // Denormalized
  authorAvatar: 'url...',  // Denormalized
};

// Update all posts when author changes
async function updateAuthor(authorId, updates) {
  const batch = firestore.batch();
  batch.update(firestore.doc(`authors/${authorId}`), updates);
  
  const posts = await firestore.collection('posts')
    .where('authorId', '==', authorId).get();
  
  posts.forEach(doc => {
    batch.update(doc.ref, {
      authorName: updates.name,
      authorAvatar: updates.avatar,
    });
  });
  
  await batch.commit();
}

match /posts/{postId} {
  allow read: if true;
  
  // Subcollection needs its own rules!
  match /comments/{commentId} {
    allow read: if true;
  }
}

await user.getIdTokenResult(true); // Force refresh

// WRONG: Instance method
class MyClass {
  Future<void> _handler(RemoteMessage m) async {} // Won't work
}

// RIGHT: Top-level function
@pragma('vm:entry-point')
Future<void> _handler(RemoteMessage m) async {}

await FirebaseFirestore.instance.clearPersistence();