How to fix UNAUTHENTICATED: The caller does not have permission to execute the specified operation. in Firebase

import { getAuth, signInAnonymously } from "firebase/auth";
import { getFirestore, collection, getDocs } from "firebase/firestore";

const auth = getAuth();
const db = getFirestore();

// Check if user is authenticated
if (!auth.currentUser) {
  // Option 1: Sign in anonymously (allows database access)
  await signInAnonymously(auth);
  // Option 2: Redirect to login page
}

// Now database operations will work
const querySnapshot = await getDocs(collection(db, "users"));

import { useAuth } from "./useAuth";

function MyComponent() {
  const user = useAuth();

  if (!user) {
    return <div>Please sign in to continue</div>;
  }

  // Database queries here
}

const admin = require("firebase-admin");
admin.initializeApp({
  credential: admin.credential.cert("/path/to/serviceAccountKey.json"),
});

const db = admin.firestore();
// Admin SDK automatically authenticates, no need to sign in
const docs = await db.collection("users").get();

rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    // Allow authenticated users to read/write
    match /{document=**} {
      allow read, write: if request.auth.uid != null;
    }

    // More restrictive: only owner can access their data
    match /users/{userId} {
      allow read, write: if request.auth.uid == userId;
    }
  }
}

{
  "rules": {
    ".read": "auth != null",
    ".write": "auth != null",
    "users": {
      "$uid": {
        ".read": "auth.uid == $uid",
        ".write": "auth.uid == $uid"
      }
    }
  }
}

import { getAuth, signInWithEmailAndPassword } from "firebase/auth";
import { getFunctions, httpsCallable } from "firebase/functions";

const auth = getAuth();
const functions = getFunctions();

// 1. Sign in the user
await signInWithEmailAndPassword(auth, email, password);

// 2. Call the function - auth token is automatically included
const myFunction = httpsCallable(functions, "myFunction");
const result = await myFunction({ data: "value" });

// Sign in first
FirebaseAuth.getInstance().signInWithEmailAndPassword(email, password)
  .addOnSuccessListener {
    // Now call function
    val functions = FirebaseFunctions.getInstance()
    functions.getHttpsCallable("myFunction")
      .call(mapOf("data" to "value"))
      .addOnSuccessListener { result ->
        Log.d("Function", "Success: ${result.data}")
      }
      .addOnFailureListener { exception ->
        Log.e("Function", "Error: ${exception.message}")
      }
  }
  .addOnFailureListener { exception ->
    Log.e("Auth", "Sign in failed: ${exception.message}")
  }

Auth.auth().signIn(withEmail: email, password: password) { result, error in
  guard error == nil else { return }
  
  // User is authenticated, call function
  let functions = Functions.functions()
  functions.httpsCallable("myFunction").call(["data": "value"]) { result, error in
    guard error == nil else {
      print("Function error: \(error?.localizedDescription ?? "Unknown")")
      return
    }
    print("Success: \(result?.data ?? "")")
  }
}

import { getAuth, signInAnonymously, onAuthStateChanged } from "firebase/auth";
import { getFirestore, collection, getDocs } from "firebase/firestore";

const auth = getAuth();
const db = getFirestore();

onAuthStateChanged(auth, async (user) => {
  if (!user) {
    // Sign in anonymously if not already signed in
    try {
      await signInAnonymously(auth);
    } catch (error) {
      console.error("Anonymous sign-in failed:", error);
    }
  } else {
    // User is authenticated (anonymously or otherwise)
    const querySnapshot = await getDocs(collection(db, "items"));
    querySnapshot.forEach(doc => console.log(doc.data()));
  }
});

rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    // Allow anonymous and authenticated users
    match /{document=**} {
      allow read, write: if request.auth != null;
    }
  }
}

import { getAuth } from "firebase/auth";

const auth = getAuth();

// Force token refresh
const user = auth.currentUser;
if (user) {
  const refreshedToken = await user.getIdToken(true);
  console.log("Token refreshed:", refreshedToken);
}

// Or let Firebase SDK handle it automatically
onAuthStateChanged(auth, async (user) => {
  if (user) {
    // Firebase automatically refreshes expired tokens
    const token = await user.getIdToken();
  }
});

const expirationTime = user.stsTokenManager.expirationTime;
const currentTime = new Date().getTime();

if (currentTime > expirationTime) {
  console.log("Token expired, refreshing...");
  await user.getIdToken(true); // Force refresh
} else {
  console.log("Token is still valid");
}

const admin = require("firebase-admin");
// No need to manage tokens with Admin SDK
const doc = await admin.firestore().collection("users").doc("userId").get();