How to make Firestore queries case-insensitive?

 

Step 1: Set Up Your Firestore Project

 

• Ensure that you've set up Firebase in your project and have initialized Firestore. If you haven't, follow these steps:

  ```javascript
  import { initializeApp } from "firebase/app";
  import { getFirestore } from "firebase/firestore";

  // Your web app's Firebase configuration
  const firebaseConfig = {
  apiKey: "YOUR_API_KEY",
  authDomain: "YOUR_AUTH_DOMAIN",
  projectId: "YOUR_PROJECT_ID",
  storageBucket: "YOUR_STORAGE_BUCKET",
  messagingSenderId: "YOUR_MESSAGING_SENDER_ID",
  appId: "YOUR_APP_ID"
  };

  // Initialize Firebase
  const app = initializeApp(firebaseConfig);
  const db = getFirestore(app);
  ```

 

Step 2: Store Data in Lowercase

 

• To ensure case-insensitivity, store fields that you want to query in lowercase:

  ```javascript
  import { collection, addDoc } from "firebase/firestore";

  async function addUser() {
  try {
  const docRef = await addDoc(collection(db, "users"), {
  username: "exampleuser".toLowerCase(),
  email: "user@example.com",
  });
  console.log("Document written with ID: ", docRef.id);
  } catch (e) {
  console.error("Error adding document: ", e);
  }
  }
  ```

 

Step 3: Query with Lowercase

 

• When querying, also convert the input to lowercase to match the stored data:

  ```javascript
  import { collection, query, where, getDocs } from "firebase/firestore";

  async function queryUser(username) {
  const q = query(collection(db, "users"), where("username", "==", username.toLowerCase()));
  const querySnapshot = await getDocs(q);

  querySnapshot.forEach((doc) => {
  console.log(doc.id, " => ", doc.data());
  });
  }
  ```

 

Step 4: Normalize User Input

 

• Always normalize user input to ensure consistency. You may use a utility function to handle this:

  ```javascript
  function normalizeInput(input) {
  return input.trim().toLowerCase();
  }
  ```

• Use this utility function whenever you handle input that is meant to be case-insensitive:

  ```javascript
  const username = normalizeInput(userInputValue);
  queryUser(username);
  ```

 

Step 5: Update the Existing Data if Necessary

 

• If you have existing data, consider writing a script to update existing fields to lowercase. Use a batch operation for efficiency:

  ```javascript
  import { collection, getDocs, writeBatch, doc } from "firebase/firestore";

  async function normalizeExistingUsers() {
  const usersRef = collection(db, "users");
  const querySnapshot = await getDocs(usersRef);
  const batch = writeBatch(db);

  querySnapshot.forEach((docSnapshot) => {
  const userData = docSnapshot.data();
  const userRef = doc(db, "users", docSnapshot.id);
  batch.update(userRef, {
  username: userData.username.toLowerCase()
  });
  });

  await batch.commit();
  console.log("All user documents have been updated.");
  }
  ```

 

Conclusion

 

• By storing and querying data in lowercase, Firestore queries can effectively be made case-insensitive. This approach maintains consistency in data retrieval and display without the need for complex transformations or additional indexes.