React devs might find this archived course helpful to reference, but this course has been updated! We now recommend you take the Firebase Fundamentals course.
Table of Contents
Introduction
Introduction
Steve Kinney gives mention to the new features offered in Firebase since the last iteration of the course, and also what will be accomplished in the course.
Cloud Firestore
Steve introduces Cloud Firestore, the database replacing Realtime Database in Firebase.
The Structure of Cloud Firestore
Steve explains how Cloud Firestore differs in structure from Realtime Database.
Collections Introduction
Steve gives an introduction on how to query data from the Cloud Firestore.
Ordering, Limiting, & Querying
Steve gives examples of how to perform ordering, limiting, and querying on the Cloud Firestore.
Code Tour
Steve demonstrates the prewritten application’s functionality, and briefly walks through the code.
Firebase Console
Steve gives the application the concept of Firebase by using the Firebase console.
Setup
Configuring Firebase
Steve configures the Firebase application and exports necessary variables.
Creating a Firestore Database
Steve sets up a new Cloud Firestore database, then wires it into the application.
Querying the Database
Steve utilizes a promise to query the Cloud Firestore database and create a QuerySnapshot.
Querying & Updating
QuerySnapshots
Steve introduces key properties and methods of the QuerySnapshot objects.
DocumentSnapshots
Steve introduces key properties and methods of the DocumentSnapshot objects.
Creating a DocumentSnapshot
Steve demonstrates how to utilize asynchronicity to iterate over the QuerySnapshot and extract the data
Manually Adding a Document to Firestore
Steve demonstrates how to use the Firebase console to manually create a document inside of a collection.
Rendering Documents to Component State
Steve maps over the posts collection to display the data in the app.
Adding a Post
Steve posts a document to the database, then demonstrates how to GET the same document and update the state of the application to reflect the new data.
Removing a Post
Steve demonstrates how to add functionality to the app that allows the user to delete posts, then also removes it permanently from the database.
Subscribing to Database Updates
Steve utilizes the onSnapshot method to ensure that the page is listening to the database changes being made.
Isolating Database Calls to a Component
Steve refactors the existing code such that the database calls are isolated to one component.
Update a Document Exercise
Students are instructed to implement the star functionality to the application using the method learned from removing a post.
Update a Document Solution
Steve live codes the solution to the exercise, and adds the date to the individual posts.
OAuth
Configuring OAuth
Steve demonstrates how easy it is to configure the OAuth with the Firebase console.
Authentication UI
Steve exposes the prewritten UI to allow the user to sign in or sign up.
OAuth Sign In with Google
Steve wires up the app to allow the user to sign in via Google.
Sign Out Exercise
Students are instructed to allow users to sign out of the application.
Sign Out Solution
Steve live codes the solution to the exercise.
Cloud Functions Q&A
Steve discusses the benefits and disadvantages of not having an enforced schema, and how a cloud function might be triggered.
Security Rules
Security Rules Introduction
Steve introduces the basic structure of security rules, how to nest rules to sub collections, how to validate based on the document, accessing other documents, and basic rules to keep in mind when writing security rules.
Writing Security Rules
Steve writes a few security rules, and demonstrates how they limit access in the application.
Verifying Security Rules
Steve logs in to create a user profile in the database, then verifies that the current security rules are working.
Validating Data Exercise
Students are instructed to create a security rule that validates whether the title of a post is null, and rejects it if it is.
Validating Data Solution
Steve live codes the solution to the exercise.
Authentication & User Documents
User Documents
Steve explains the pitfalls of the current design, and how that can be solved with user documents.
Display Name
Steve demonstrates how to allow users to set a display name.
Firebase Authentication Settings
Steve introduces some authentication settings that are offered out of the box by Firebase.
Creating a User Document
Steve constructs a function that creates a user document.
Getting User Document Data
Steve constructs a function that GETs a user document.
Add Security Rules for Registration
Steve adds security rules so that users can read their own blog posts.
Modifying User Profiles
Steve demonstrates how the data is being read from the user profile as opposed to the auth object.
State Management
State Management
Steve approaches the problem of scaling, should the application grow in size.
React Context API
Steve pulls out the posts into the the React Context API.
Creating a React Context Consumer
Steve wraps the top level component into the provider to ensure that other components can hook into it, then wraps the posts in the consumer as well to create a more modular application.
Refactoring with React Context
Steve deletes unnecessary code that was rendered obsolete by the consumer.
React Context & Hooks Exercise
Student are instructed to abstract code out of the Application component into the UserProvider component, as was done with the PostsProvider component in the last few sections.
React Context & Hooks Solution
Steve live codes the solution the exercise. A question is also asked about the architectural decision to use the Context API over using React hooks.
User Interface
UI Permissions
Steve augments the user interface so that the delete button doesn’t show when the post doesn’t belong to the current user.
Routing
Steve adds routing to the application.
Changing User Profile Data
Steve adds the ability for users to change their screen name and upload a file in the application.
Subscribing to User Profile Changes
Steve adds functionality to the application that updates the user's screen name as soon as the submit button is clicked.
File Uploading
Firebase Storage
Steve adds the ability to upload a file to the application using Firebase storage.
Security Rules for Uploading
Steve changes the security rules to allow users to upload their images.
Uploading a Profile Picture
Steve gives a proof of concept by uploading a new profile picture to the application, and reviews what was done to get to this point.
Sub Collections
Document Routing
Steve explains the benefits of subcollections, then introduces the next feature in the application, which is to allow the user to fetch a specific post via a URL.
Routing to Document Data
Steve begins constructing a page where the specified post will be placed.
Adding Comments
Steve demonstrates how to nest documents with subcollections by adding comments to the posts.
Higher Order Components
Steve creates a higher order component, which takes a component, wraps it in another component, and returns it.
Deployment
Cloud Functions
Cloud Functions
Steve introduces what cloud functions are, and discusses use cases.
Deploying Cloud Functions
Steve demonstrates how to set up cloud functions, and how to deploy them.
Creating an API Endpoint
Steve creates an API endpoint using cloud functions to get all of the posts. The Firebase function logs are also briefly introduced.
Local Cloud Functions
Steve demonstrates how to run a cloud function on a local machine, rather than Google's.
Modifying Documents
Steve sanitizes a document of a specific word by using a cloud function.
Document Counter Function
Steve adds a comment counter feature to the cloud functions.
Wrapping Up
Steve reviews what was covered, as well as the main points to take away from the course.