const { data } = useDocument('users/fernando')
This is the fork of swr-firestore with support for Firebase Modular SDK (v9).
- Use the stable channel of firebase (v9.1.x)
- Update SWR to version 1.
- useDocument and useCollection won't return
revalidate()
due to SWR changes. - API functions renamed for similarity with the new firebase SDK.
-
set()
is nowsetDoc()
-
update()
is nowupdateDoc()
-
deleteDocument()
is nowdeleteDoc()
-
revalidateDocument()
is nowrevalidateDoc()
-
getDocument()
is nowgetDoc()
-
getCollection()
is nowgetDocs()
-
- Use
getFuego()
to get the current database instance instead of importingfuego
variable directly.
It's that easy.
🔥 This library provides the hooks you need for querying Firestore, that you can actually use in production, on every screen.
⚡️ It aims to be the fastest way to use Firestore in a React app, both from a developer experience and app performance perspective.
🍕 This library is built on top useSWR, meaning you get all of its awesome benefits out-of-the-box.
You can now fetch, add, and mutate Firestore data with zero boilerplate.
- Shared state / cache between collection and document queries (instead of Redux??)
- Works with both React and React Native.
- Offline mode with Expo (without detaching!)
- Blazing fast
- Query collection groups (new in
0.14.x
!) -
set
,update
, andadd
update your global cache, instantly - TypeScript-ready (see docs)
- Realtime subscriptions (example)
- Prevent memory leaks from Firestore subscriptions
- No more parsing
document.data()
from Firestore requests - Server-side rendering (SSR or SSG) with Next.js (example)
- Automatic date parsing (no more
.toDate()
) - Firebase v8 support (see #59)
...along with the features touted by Vercel's incredible SWR library:
"With SWR, components will get a stream of data updates constantly and automatically. Thus, the UI will be always fast and reactive."
- Transport and protocol agnostic data fetching
- Fast page navigation
- Revalidation on focus
- Interval polling
- Request deduplication
- Local mutation
- Pagination
- TypeScript ready
- SSR support
- Suspense mode
- Minimal API
yarn add swr-firebase
# or
npm install swr-firebase
Install firebase:
# if you're using expo:
expo install firebase
# if you aren't using expo:
yarn add firebase
# or
npm i firebase
In the root of your app, create an instance of Fuego and pass it to the FuegoProvider.
If you're using next.js
, this goes in your pages/_app.js
file.
App.js
import React from 'react'
import 'firebase/firestore'
import 'firebase/auth'
import { Fuego, FuegoProvider } from 'swr-firebase'
const firebaseConfig = {
// put yours here
}
const fuego = new Fuego(firebaseConfig)
export default function App() {
return (
<FuegoProvider fuego={fuego}>
<YourAppHere />
</FuegoProvider>
)
}
Make sure to create your Fuego
instance outside of the component. The only argument Fuego
takes is your firebase config
variable.
Under the hood, this step initializes firebase for you. No need to call firebase.initializeApp
.
Assuming you've already completed the setup...
import React from 'react'
import { useDocument } from 'swr-firebase'
import { Text } from 'react-native'
export default function User() {
const user = { id: 'Fernando' }
const { data, update, error } = useDocument(`users/${user.id}`, {
listen: true,
})
if (error) return <Text>Error!</Text>
if (!data) return <Text>Loading...</Text>
return <Text>Name: {data.name}</Text>
}
import React from 'react'
import { useCollection } from 'swr-firebase'
import { Text } from 'react-native'
export default function UserList() {
const { data, update, error } = useCollection(`users`)
if (error) return <Text>Error!</Text>
if (!data) return <Text>Loading...</Text>
return data.map(user => <Text key={user.id}>{user.name}</Text>)
}
useDocument
accepts a document path
as its first argument here. useCollection
works similarly.
const { data } = useCollection('users')
const { data } = useDocument(`users/${user.id}`, { listen: true })
const { data } = useCollection('users', {
where: ['name', '==', 'fernando'],
limit: 10,
orderBy: ['age', 'desc'],
listen: true,
})
// pass SWR options
const { data } = useDocument('albums/nothing-was-the-same', {
shouldRetryOnError: false,
onSuccess: console.log,
loadingTimeout: 2000,
})
// pass SWR options
const { data } = useCollection(
'albums',
{
listen: true,
// you can pass multiple where conditions if you want
where: [
['artist', '==', 'Drake'],
['year', '==', '2020'],
],
},
{
shouldRetryOnError: false,
onSuccess: console.log,
loadingTimeout: 2000,
}
)
const { data, add } = useCollection('albums', {
where: ['artist', '==', 'Drake'],
})
const onPress = async () => {
// calling this will automatically update your global cache & Firestore
const documentId = await add({
title: 'Dark Lane Demo Tapes',
artist: 'Drake',
year: '2020',
})
}
const { data, set, update } = useDocument('albums/dark-lane-demo-tapes')
const onReleaseAlbum = () => {
// calling this will automatically update your global cache & Firestore
set(
{
released: true,
},
{ merge: true }
)
// or you could call this:
update({
released: true,
})
}
If you pass null
as the collection or document key, the request won't send.
Once the key is set to a string, the request will send.
Get list of users who have you in their friends list
import { useDoormanUser } from 'react-doorman'
const { uid } = useDoormanUser()
const { data } = useCollection(uid ? 'users' : null, {
where: ['friends', 'array-contains', uid],
})
Get your favorite song
const me = { id: 'fernando' }
const { data: user } = useDocument<{ favoriteSong: string }>(`users/${me.id}`)
// only send the request once the user.favoriteSong exists!
const { data: song } = useDocument(
user?.favoriteSong ? `songs/${user.favoriteSong}` : null
)
Magically turn any Firestore timestamps into JS date objects! No more .toDate()
.
Imagine your user
document schema looks like this:
type User = {
name: string
lastUpdated: {
date: Date
}
createdAt: Date
}
In order to turn createdAt
and lastUpdated.date
into JS objects, just use the parseDates
field:
In a document query
const { data } = useDocument<User>('user/fernando', {
parseDates: ['createdAt', 'lastUpdated.date'],
})
let createdAt: Date
if (data) {
// ✅ all good! it's a JS Date now.
createdAt = data.createdAt
}
data.createdAt
and data.lastUpdated.date
are both JS dates now!
In a collection query
const { data } = useCollection<User>('user', {
parseDates: ['createdAt', 'lastUpdated.date'],
})
if (data) {
data.forEach(document => {
document.createdAt // JS date!
})
}
For more explanation on the dates, see issue #4.
If you set ignoreFirestoreDocumentSnapshotField
to false
, you can access the __snapshot
field.
const { data } = useDocument('users/fernando', {
ignoreFirestoreDocumentSnapshotField: false, // default: true
})
if (data) {
const id = data?.__snapshot.id
}
You can do the same for useCollection
and useCollectionGroup
. The snapshot will be on each item in the data
array.
This comes in handy when you are working with forms for data edits:
With Formik
const { data, set } = useDocument('users/fernando', {
ignoreFirestoreDocumentSnapshotField: false,
})
if (!data) return <Loading />
<Formik
initialValues={data.__snapshot.data()}
...
/>
With state and hooks
const { data, set } = useDocument('users/fernando', {
ignoreFirestoreDocumentSnapshotField: false,
})
const [values, setValues] = useState(null);
useEffect(() => {
if (data) {
setValues(data.__snapshot.data());
}
}, [data]);
Video here.
import React from 'react'
import { fuego, useCollection } from 'swr-firebase'
const collection = 'dump'
const limit = 1
const orderBy = 'text'
export default function Paginate() {
const { data, mutate } = useCollection<{ text: string }>(
collection,
{
limit,
orderBy,
// 🚨 this is required to get access to the snapshot!
ignoreFirestoreDocumentSnapshotField: false,
},
{
// this lets us update the local cache + paginate without interruptions
revalidateOnFocus: false,
refreshWhenHidden: false,
refreshWhenOffline: false,
refreshInterval: 0,
}
)
const paginate = async () => {
if (!data?.length) return
const ref = fuego.db.collection(collection)
// get the snapshot of last document we have right now in our query
const startAfterDocument = data[data.length - 1].__snapshot
// get more documents, after the most recent one we have
const moreDocs = await ref
.orderBy(orderBy)
.startAfter(startAfterDocument)
.limit(limit)
.get()
.then(d => {
const docs = []
d.docs.forEach(doc => docs.push({ ...doc.data(), id: doc.id, __snapshot: doc }))
return docs
})
// mutate our local cache, adding the docs we just added
// set revalidate to false to prevent SWR from revalidating on its own
mutate(state => [...state, ...moreDocs], false)
}
return data ? (
<div>
{data.map(({ id, text }) => (
<div key={id}>{text}</div>
))}
<button onClick={paginate}>paginate</button>
</div>
) : (
<div>Loading...</div>
)
}
You'll rely on useDocument
to query documents.
import React from 'react'
import { useDocument } from 'swr-firebase'
const user = { id: 'Fernando' }
export default () => {
const { data, error } = useDocument(`users/${user.id}`)
}
If you want to set up a listener (or, in Firestore-speak, onSnapshot
) just set listen
to true
.
const { data, error } = useDocument(`users/${user.id}`, { listen: true })
import {
useDocument,
useCollection,
useCollectionGroup, // 👋 new!
revalidateDoc,
revalidateCollection,
// these all update BOTH Firestore & the local cache ⚡️
setDoc, // set a firestore document
updateDoc, // update a firestore document
getFuego, // get the firebase instance used by this lib
getDocs, // prefetch a collection, without being hooked into SWR or React
getDoc, // prefetch a document, without being hooked into SWR or React
} from 'swr-firebase'
const {
data,
set,
update,
deleteDocument,
error,
isValidating,
mutate,
unsubscribe
} = useDocument(path, options)
-
path
required The unique document path for your Firestore document.-
string
|null
. Ifnull
, the request will not be sent. This is useful if you want to get a user document, but the user ID hasn't loaded yet, for instance. - This follows the same pattern as the
key
argument inuseSWR
. See the SWR docs for more. Functions are not currently supported for this argument.
-
-
options
(optional) A dictionary with added options for the query. Takes the folowing values:-
listen = false
: Iftrue
, sets up a listener for this document that updates whenever it changes. - You can also pass any of the options available from
useSWR
. -
ignoreFirestoreDocumentSnapshotField = true
. See elaboration below. -
parseDates
: An array of string keys that correspond to dates in your document. Example.
-
If true
, docs returned in data
will not include the firestore __snapshot
field. If false
, it will include a __snapshot
field. This lets you access the document snapshot, but makes the document not JSON serializable.
By default, it ignores the __snapshot
field. This makes it easier for newcomers to use JSON.stringify
without weird errors. You must explicitly set it to false
to use it.
// include the firestore document snapshots
const { data } = useDocument('users/fernando', {
ignoreFirestoreDocumentSnapshotField: false,
})
if (data) {
const path = data.__snapshot.ref.path
}
The __snapshot
field is the exact snapshot returned by Firestore.
See Firestore's snapshot docs for more.
Returns a dictionary with the following values:
-
set(data, SetOptions?)
: Extends thefirestore
documentset
function.- You can call this when you want to edit your document.
- It also updates the local cache using SWR's
mutate
. This will prove highly convenient over the regular Firestoreset
function. - The second argument is the same as the second argument for Firestore
set
.
-
update(data)
: Extends the Firestore documentupdate
function.- It also updates the local cache using SWR's
mutate
. This will prove highly convenient over the regularset
function.
- It also updates the local cache using SWR's
-
deleteDocument()
: Extends the Firestore documentdelete
function.- It also updates the local cache using SWR's
mutate
by deleting your document from this query and all collection queries that have fetched this document. This will prove highly convenient over the regulardelete
function from Firestore.
- It also updates the local cache using SWR's
-
unsubscribe()
A function that, when called, unsubscribes the Firestore listener.- The function can be null, so make sure to check that it exists before calling it.
-
Note: This is not necessary to use.
useDocument
already unmounts the listener for you. This is only intended if you want to unsubscribe on your own.
The dictionary also includes the following from useSWR
:
-
data
: data for the given key resolved by fetcher (or undefined if not loaded) -
error
: error thrown by fetcher (or undefined) -
isValidating
: if there's a request or revalidation loading -
mutate(data?, shouldRevalidate?)
: function to mutate the cached data
const { data, add, error, isValidating, mutate, unsubscribe } = useCollection(
path,
query,
options
)
-
path
required string, path to collection. -
query
optional dictionary with Firestore query details -
options
SWR options (see SWR docs)
path
required The unique document path for your Firestore document.
-
string
|null
. Ifnull
, the request will not be sent. This is useful if you want to get a user document, but the user ID hasn't loaded yet, for instance. - This follows the same pattern as the
key
argument inuseSWR
. See the SWR docs for more. Functions are not currently supported for this argument.
(optional) Dictionary that accepts any of the following optional values:
-
listen = false
: if true, will set up a real-time listener that automatically updates. -
limit
: number that limits the number of documents -
where
: filter documents by certain conditions based on their fields -
orderBy
: sort documents by their fields -
startAt
: number to start at -
endAt
: number to end at -
startAfter
: number to start after -
endBefore
: number to end before -
ignoreFirestoreDocumentSnapshotField = true
: Iftrue
, docs returned indata
will not include the firestore__snapshot
field. Iffalse
, it will include a__snapshot
field. This lets you access the document snapshot, but makes the document not JSON serializable.
Can be an array, or an array of arrays.
Each array follows this outline: ['key', 'comparison-operator', 'value']
. This is pulled directly from Firestore's where pattern.
// get all users whose names are Fernando
useCollection('users', {
where: ['name', '==', 'Fernando'],
})
// get all users whose names are Fernando & who are hungry
useCollection('users', {
where: [
['name', '==', 'Fernando'],
['isHungry', '==', true],
],
})
// get all users whose friends array contains Fernando
useCollection('users', {
where: ['friends', 'array-contains', 'Fernando'],
})
Can be a string, array, or an array of arrays.
Each array follows this outline: ['key', 'desc' | 'asc']
. This is pulled directly from Firestore's orderBy pattern.
// get users, ordered by name
useCollection('users', {
orderBy: 'name',
})
// get users, ordered by name in descending order
useCollection('users', {
orderBy: ['name', 'desc'],
})
// get users, ordered by name in descending order & hunger in ascending order
useCollection('users', {
orderBy: [
['name', 'desc'], //
['isHungry', 'asc'],
],
})
If true
, docs returned in data
will not include the firestore __snapshot
field. If false
, it will include a __snapshot
field. This lets you access the document snapshot, but makes the document not JSON serializable.
By default, it ignores the __snapshot
field. This makes it easier for newcomers to use JSON.stringify
without weird errors. You must explicitly set it to false
to use it.
// include the firestore document snapshots
const { data } = useCollection('users', {
ignoreFirestoreDocumentSnapshotField: false,
})
if (data) {
data.forEach(document => {
const path = document?.__snapshot.ref.path
})
}
The __snapshot
field is the exact snapshot returned by Firestore.
See Firestore's snapshot docs for more.
(optional) A dictionary with added options for the request. See the options available from SWR.
Returns a dictionary with the following values:
-
add(data)
: Extends the Firestore documentadd
function. Returns the added document ID(s).- It also updates the local cache using SWR's
mutate
. This will prove highly convenient over the regularadd
function provided by Firestore.
- It also updates the local cache using SWR's
The returned dictionary also includes the following from useSWR
:
-
data
: data for the given key resolved by fetcher (or undefined if not loaded) -
error
: error thrown by fetcher (or undefined) -
isValidating
: if there's a request or revalidation loading -
mutate(data?, shouldRevalidate?)
: function to mutate the cached data -
unsubscribe()
A function that, when called, unsubscribes the Firestore listener.- The function can be null, so make sure to check that it exists before calling it.
-
Note: This is not necessary to use.
useCollection
already unmounts the listener for you. This is only intended if you want to unsubscribe on your own.
Follows an identical API as useCollection
, except that it leverages Firestore's collection group query for merging subcollections with the same name.
To see how to use it, follow the instructions from useCollection
.
See the Firestore docs on collecttion groups to learn more.
Extends the firestore
document setDoc
function.
- You can call this when you want to edit your document.
- It also updates the local cache using SWR's
mutate
. This will prove highly convenient over the regular FirestoresetDoc
function.
This is useful if you want to set a document in a component that isn't connected to the useDocument
hook.
Extends the Firestore document updateDoc
function.
- It also updates the local cache using SWR's
mutate
. This will prove highly convenient over the regularupdateDoc
function.
This is useful if you want to update a document in a component that isn't connected to the useDocument
hook.
Extends the Firestore document deleteDoc
function.
- It also updates the local cache using SWR's
mutate
by deleting your document from this query and all collection queries that have fetched this document. This will prove highly convenient over the regulardelete
function from Firestore. - Second argument is a boolean that defaults to false. If
true
, it will not update the local cache, and instead only send delete to Firestore.
Refetch a document from Firestore, and update the local cache. Useful if you want to update a given document without calling the connected revalidate
function from use useDocument
hook.
- Only argument is the Firestore document path (ex:
users/Fernando
)
Refetch a collection query from Firestore, and update the local cache. Useful if you want to update a given collection without calling the connected revalidate
function from use useCollection
hook.
- Only argument is the Firestore document path (ex:
users
) -
Note Calling
revalidateCollection
will update all collection queries. If you're paginating data for a given collection, you probably won't want to use this function for that collection.
Returns the current firebase instance used by this library. Throws an error if the instance hasn't initialized yet.
If you don't want to use useDocument
in a component, you can use this function outside of the React scope.
-
path
required The unique document path for your Firestore document. -
options
-
ignoreFirestoreDocumentSnapshotField = true
. Iffalse
, it will return a__snapshot
field too. -
parseDates
: An array of string keys that correspond to dates in your document. Example.
-
A promise with the firestore doc and some useful fields. See the useDocument data
return type for more info.
If you don't want to use useCollection
in a component, you can use this function outside of the React scope.
-
path
required The unique collection path for your Firestore collection.-
ignoreFirestoreDocumentSnapshotField = true
. Iffalse
, it will return a__snapshot
field too. -
parseDates
: An array of string keys that correspond to dates in your document. Example.
-
-
query
refer to the second argument ofuseCollection
. -
options
-
ignoreFirestoreDocumentSnapshotField = true
. Iffalse
, it will return a__snapshot
field too in each document. -
parseDates
: An array of string keys that correspond to dates in your documents. Example.
-
Create a model for your typescript
types, and pass it as a generic to useDocument
or useCollection
.
The data
item will include your TypeScript model (or null
), and will also include an id
string, an exists
boolean, and hasPendingWrites
boolean.
type User = {
name: string
}
const { data } = useDocument<User>('users/fernando')
if (data) {
const {
id, // string
name, // string
exists, // boolean
hasPendingWrites, // boolean
} = data
}
const id = data?.id // string | undefined
const name = data?.name // string | undefined
const exists = data?.exists // boolean | undefined
const hasPendingWrites = data?.hasPendingWrites // boolean | undefind
The data
item will include your TypeScript model (or null
), and will also include an id
string.
type User = {
name: string
}
const { data } = useCollection<User>('users')
if (data) {
data.forEach(({ id, name }) => {
// ...
})
}
A great feature of this library is shared data between documents and collections. Until now, this could only be achieved with something like a verbose Redux set up.
So, what does this mean exactly?
Simply put, any documents pulled from a Firestore request will update the global cache.
To make it clear, let's look at an example.
Imagine you query a user
document from Firestore:
const { data } = useDocument('users/fernando')
And pretend that this document's data
returns the following:
{ "id": "fernando", "isHungry": false }
Remember that isHungry
is false
here ^
Now, let's say you query the users
collection anywhere else in your app:
const { data } = useCollection('users')
And pretend that this collection's data
returns the following:
[
{ "id": "fernando", "isHungry": true },
{
//...
}
]
Whoa, isHungry
is now true. But what happens to the original document query? Will we have stale data?
Answer: It will automatically re-render with the new data!
swr-firestore
uses document id
fields to sync any collection queries with existing document queries across your app.
That means that if you somehow fetch the same document twice, the latest version will update everywhere.
MIT