Łączenie danych użytkowników z Auth

Why connect user authentication with your database? It's crucial for building personalized and secure applications.

By linking, you can:

• Store user-specific data like profiles or settings.
• Control access to data based on who is logged in.
• Create personalized experiences for each user.

Every authenticated user in Firebase has a unique User ID (UID). This ID is your key to linking their authentication status to their data.

You can get the current user's UID from the currentUser object after a user signs in.

Once you have the UID, you can use it as a unique identifier in your Firebase Realtime Database paths. This creates a secure and organized way to store user-specific data.

Think of it like a folder for each user, named after their UID:

• /users/{UID}/profile
• /users/{UID}/preferences

Let's store some basic profile information for a signed-in user. We'll use the user's UID to create a unique path in the database.

This example stores a username and email under /users/{uid}.

After the previous code runs, your Realtime Database might look something like this:

{
  "users": {
    "YOUR_USER_UID_HERE": {
      "username": "JaneDoe",
      "email": "janedoe@example.com",
      "createdAt": 1678886400000
    }
  }
}

Each user gets their own top-level key under /users, making it easy to manage their data.

To retrieve personalized content, you simply read from the path constructed with the current user's UID. This ensures they only see their own information.

Here's how to fetch the profile data we just stored:

Users might want to change their profile information. You can easily update specific fields within their UID's data path using the update() method.

This updates only the username field without affecting others.

It's important to always check if a user is signed in (firebase.auth().currentUser is not null) before trying to access their UID or database path.

Also, when reading data, check if snapshot.val() returns actual data or null. This prevents errors if a user's data hasn't been created yet.

For efficiency and scalability, consider these tips:

• Keep UIDs consistent: Always use the authenticated UID as the primary key for user data.
• Denormalize for lookups: If you often need a user's name next to another piece of data (e.g., a post), store a copy of the name with the post instead of always querying the user profile.
• Security Rules: Use Realtime Database Security Rules to enforce that only the authenticated user can read/write their own data. (More on this in a later lesson!)

In this lesson, you learned how to effectively link authenticated users to their specific data in the Firebase Realtime Database.

• We accessed the unique User ID (UID).
• We used the UID as a key in the database path.
• We practiced storing and reading user-specific information.
• We covered important considerations for handling missing data.

This foundational skill is vital for building personalized and secure applications!