How to fix INVALID_ARGUMENT: The argument provided is invalid in Firebase

import { initializeApp } from 'firebase/app';
import { getFirestore, collection, query, where } from 'firebase/firestore';

try {
  const db = getFirestore();
  const q = query(
    collection(db, 'users'),
    where('nonexistentField', '==', 'value') // Invalid field
  );
} catch (error) {
  console.error('Full error:', error);
  console.error('Error code:', error.code);
  console.error('Error message:', error.message);

  // Look for details array with fieldViolations
  if (error.details) {
    console.error('Field violations:', error.details);
  }
}

// INCORRECT - passing object for databaseId
import { initializeApp } from 'firebase/app';
import { getFirestore } from 'firebase/firestore';

const app = initializeApp(config);
const db = getFirestore(app, {
  databaseId: { projectId: 'my-project' } // WRONG!
});

// CORRECT - pass string or omit for default database
const db = getFirestore(app); // Uses default database

// Or explicitly pass string
const db = getFirestore(app, 'my-database');

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

const db = getFirestore();

// INCORRECT - field doesn't exist in documents
const q1 = query(
  collection(db, 'posts'),
  where('authorName', '==', 'Alice') // Field doesn't exist
);

// CORRECT - use actual field from documents
const q2 = query(
  collection(db, 'posts'),
  where('author', '==', 'Alice')
);

// For combined queries, orderBy must match the field in whereIn/inequality
// INCORRECT - orderBy field doesn't match filter
const q3 = query(
  collection(db, 'products'),
  where('category', 'in', ['electronics', 'books']),
  orderBy('price') // Price not used in where clause
);

// CORRECT - use same field for first orderBy
const q4 = query(
  collection(db, 'products'),
  where('category', 'in', ['electronics', 'books']),
  orderBy('category'), // Match the inequality field first
  orderBy('price')
);

import { getFirestore, collection, doc, setDoc } from 'firebase/firestore';

const db = getFirestore();

// INCORRECT - indexed field exceeds 1,500 bytes
const largeString = 'x'.repeat(2000); // Too large for indexed field
await setDoc(doc(db, 'users', 'user1'), {
  description: largeString // Indexed field can't exceed 1,500 bytes
});

// CORRECT - use unindexed field for large values
// Go to Firestore > Indexes and disable indexing for 'content' field
await setDoc(doc(db, 'users', 'user1'), {
  description: largeString // Now fine if unindexed
});

// Or keep strings under 1,500 bytes
const reasonableSize = largeString.substring(0, 1000);

import { getFunction, httpsCallable } from 'firebase/functions';
import { functions } from './firebase-config';

// Function expects { email: string, name: string }
const createUser = httpsCallable(functions, 'createUser');

// INCORRECT - passing wrong types
try {
  await createUser({
    email: 12345, // Should be string!
    name: { first: 'John', last: 'Doe' } // Should be string!
  });
} catch (error) {
  if (error.code === 'functions/invalid-argument') {
    console.error('Invalid parameter types');
  }
}

// CORRECT - matching parameter types
await createUser({
  email: 'user@example.com',
  name: 'John Doe'
});

import admin from 'firebase-admin';

const messaging = admin.messaging();

// INCORRECT - invalid token format
const invalidToken = 'abc123'; // Not a valid FCM token

// CORRECT - validate token is well-formed
const validToken = 'exJhbGc...'; // Real FCM registration token

try {
  await messaging.send({
    token: validToken,
    data: {
      key1: 'value1', // Data values must be strings
      key2: 'value2'
    },
    notification: {
      title: 'Hello',
      body: 'World'
    }
  });
} catch (error) {
  if (error.code === 'messaging/invalid-argument') {
    console.error('Invalid messaging parameters:', error.message);
  }
}

# Check Firestore rules file size
ls -lh firestore.rules

# Rules file is too large (>50KB) - consider splitting
# or optimize rules syntax

rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    // Check authentication - never use broad allow rules
    match /users/{userId} {
      allow read, write: if request.auth != null && request.auth.uid == userId;
    }

    match /public/{document=**} {
      allow read: if true;
      allow write: if request.auth != null;
    }
  }
}

firebase deploy --only firestore:rules