Fan-out writes pattern in Firebase - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a fan-out update object for Firebase Realtime Database.

Firebase

const updates = {};
updates['/posts/' + postId] = postData;
updates[[1]] = postData;
return firebase.database().ref().update(updates);

Drag options to blanks, or click blank then click option'

A'/posts/' + userId + '/' + postId

B'/user-posts/' + userId + '/' + postId

C'/user-posts/' + postId

D'/posts/' + userId

Attempts:

3 left

💡 Hint

Common Mistakes

Using only postId without userId in the path.

Mixing up the order of userId and postId in the path.

In fan-out writes, you update multiple paths. Here, the second path is the user's posts path, which is '/user-posts/' + userId + '/' + postId.

2fill in blank

medium

Complete the code to perform a fan-out write using Firebase Admin SDK.

Firebase

const updates = {};
updates['/messages/' + messageId] = messageData;
updates[[1]] = messageData;
return admin.database().ref().update(updates);

Drag options to blanks, or click blank then click option'

A'/user-messages/' + messageId

B'/messages/' + userId + '/' + messageId

C'/user-messages/' + userId + '/' + messageId

D'/messages/' + userId

Attempts:

3 left

💡 Hint

Common Mistakes

Using only messageId without userId in the path.

Using the wrong base path for user messages.

The fan-out write updates both the general messages path and the user-specific messages path, which is '/user-messages/' + userId + '/' + messageId.

3fill in blank

hard

Fix the error in the fan-out write code to correctly update both paths.

Firebase

const updates = {};
updates['/comments/' + commentId] = commentData;
updates[[1]] = commentData;
return firebase.database().ref().update(updates);

Drag options to blanks, or click blank then click option'

A'/user-comments/' + commentId

B'/comments/' + commentId

C'/comments/' + userId + '/' + commentId

D'/user-comments/' + userId + '/' + commentId

Attempts:

3 left

💡 Hint

Common Mistakes

Omitting userId in the user-specific path.

Using the wrong base path for user comments.

The correct fan-out path includes both userId and commentId to uniquely identify the comment under the user-comments path.

4fill in blank

hard

Fill both blanks to create a fan-out write that updates posts and user-posts paths.

Firebase

const updates = {};
updates[[1]] = postData;
updates[[2]] = postData;
return admin.database().ref().update(updates);

Drag options to blanks, or click blank then click option'

A'/posts/' + postId

B'/posts/' + userId + '/' + postId

C'/user-posts/' + userId + '/' + postId

D'/user-posts/' + postId

Attempts:

3 left

💡 Hint

Common Mistakes

Using userId in the general posts path.

Omitting userId in the user-posts path.

The first path is the general posts path '/posts/' + postId, and the second is the user-specific posts path '/user-posts/' + userId + '/' + postId.

5fill in blank

hard

Fill all three blanks to complete the fan-out write for messages, user-messages, and user-inbox paths.

Firebase

const updates = {};
updates[[1]] = messageData;
updates[[2]] = messageData;
updates[[3]] = true;
return firebase.database().ref().update(updates);

Drag options to blanks, or click blank then click option'

A'/messages/' + messageId

B'/user-messages/' + userId + '/' + messageId

C'/user-inbox/' + userId + '/' + messageId

D'/messages/' + userId + '/' + messageId

Attempts:

3 left

💡 Hint

Common Mistakes

Using userId in the general messages path.

Omitting userId in user-specific paths.

Using incorrect values for the inbox update.

The fan-out write updates the general messages path, the user-specific messages path, and marks the message as present in the user's inbox with a boolean true.

Practice

1. What is the main purpose of the fan-out writes pattern in Firebase?

easy

A. To save the same data in multiple places at once for faster reads

B. To delete data from multiple locations simultaneously

C. To back up data to an external server

D. To encrypt data before saving it

Solution

1. Step 1: Understand fan-out writes concept

   Fan-out writes save identical data in many database locations at once.

2. Step 2: Identify the benefit

   This helps apps read data faster and simpler by having data ready where needed.

3. Final Answer:

   To save the same data in multiple places at once for faster reads -> Option A

4. Quick Check:

   Fan-out writes = save data in many places [OK]

Hint: Fan-out writes duplicate data to speed up reading [OK]

Common Mistakes:

• Thinking fan-out writes delete data
• Confusing fan-out with backup
• Assuming fan-out encrypts data

2. Which Firebase method is used to perform a fan-out write to multiple paths atomically?

easy

A. firebase.database().remove()

B. firebase.database().set()

C. firebase.database().push()

D. firebase.database().update()

Solution

1. Step 1: Recall Firebase write methods

   set() writes to one location, push() adds new child, remove() deletes data.

2. Step 2: Identify atomic multi-path update

   update() can write to many paths at once atomically, perfect for fan-out writes.

3. Final Answer:

   firebase.database().update() -> Option D

4. Quick Check:

   Multi-path atomic write = update() [OK]

Hint: Use update() for atomic multi-path writes [OK]

Common Mistakes:

• Using set() which overwrites one path only
• Using push() which adds new child, not multi-path
• Using remove() which deletes data

3. Given this update object for fan-out writes:

{
  '/posts/post1': { title: 'Hello' },
  '/user-posts/user1/post1': { title: 'Hello' }
}

What happens when you call firebase.database().ref().update(updateObject)?

medium

A. Data is saved only at '/posts/post1'

B. Data is saved at both '/posts/post1' and '/user-posts/user1/post1' atomically

C. Data is not saved due to syntax error

D. Data is saved only at '/user-posts/user1/post1'

Solution

1. Step 1: Understand update() with multiple paths

   Update accepts an object with multiple paths as keys and writes data atomically to all.

2. Step 2: Analyze given updateObject

   It has two paths: '/posts/post1' and '/user-posts/user1/post1', both with same data.

3. Step 3: Predict behavior

   Calling update() writes data to both paths at once, ensuring consistency.

4. Final Answer:

   Data is saved at both '/posts/post1' and '/user-posts/user1/post1' atomically -> Option B

5. Quick Check:

   update() writes all paths atomically [OK]

Hint: update() writes all paths in one call atomically [OK]

Common Mistakes:

• Thinking update() writes only one path
• Confusing update() with set()
• Assuming syntax error in object

4. You wrote this fan-out update object:

{
  '/posts/post1': { title: 'Hello' },
  '/posts/post1': { author: 'Alice' }
}

What is the problem with this update object?

medium

A. Duplicate keys cause only the last one to be saved

B. Firebase rejects duplicate keys with an error

C. Data will be merged correctly without issues

D. The update will only save the first key

Solution

1. Step 1: Identify duplicate keys in object

   The object has two entries with the same key '/posts/post1'.

2. Step 2: Understand JavaScript object behavior

   Duplicate keys in an object overwrite previous ones; only the last remains.

3. Step 3: Predict Firebase update behavior

   Firebase receives only the last key-value pair, so only { author: 'Alice' } is saved.

4. Final Answer:

   Duplicate keys cause only the last one to be saved -> Option A

5. Quick Check:

   Duplicate keys overwrite previous in objects [OK]

Hint: No duplicate keys in update object; last wins [OK]

Common Mistakes:

• Expecting Firebase to merge duplicate keys
• Thinking Firebase throws error on duplicates
• Assuming first key is saved instead of last

5. You want to save a new comment both under /comments/comment1 and also under /post-comments/post1/comment1 using fan-out writes. Which update object correctly implements this pattern?

hard

A. { '/comments/comment1': { text: 'Nice!' }, '/comments/comment1': { text: 'Nice!' } }

B. { '/comments/comment1': { text: 'Nice!' }, '/post-comments/post1': { text: 'Nice!' } }

C. { '/comments/comment1': { text: 'Nice!' }, '/post-comments/post1/comment1': { text: 'Nice!' } }

D. { '/comments/comment1': { text: 'Nice!' }, '/post-comments/post1/comment1': 'Nice!' }

Solution

1. Step 1: Understand fan-out write structure

   Each path key must be a full path string to the exact location, and values must be objects with data.

2. Step 2: Analyze each option

   A: duplicate keys for same path; only one location updated.
   B: distinct full paths to both locations with data objects; correct.
   C: second path too shallow ('/post-comments/post1'), places text directly under post1, missing /comment1.
   D: string instead of object at second path.

3. Step 3: Choose correct update object

   { '/comments/comment1': { text: 'Nice!' }, '/post-comments/post1/comment1': { text: 'Nice!' } } correctly writes the comment data to both paths atomically.

4. Final Answer:

   { '/comments/comment1': { text: 'Nice!' }, '/post-comments/post1/comment1': { text: 'Nice!' } } -> Option C

5. Quick Check:

   Full paths as keys with data objects = correct fan-out [OK]

Hint: Use full paths as keys with data objects for fan-out [OK]

Common Mistakes:

• Using duplicate keys in update object
• Nesting data instead of using full path keys
• Assigning string instead of object as value