🔥 Filter Unknown Keys Or Keys With Incorrect Data Types Recursively Before Saving into Firestore and RTDB, Support All Field Values And Special Data Types.
MIT License
Do not use this library.
I will repurpose this library to support Firelord code first approach.
Some time our API data requirement is less strict, we do not want to reject the whole data just because:
At the same time we don't want to save them into database, we just want to save whatever that is correct.
This is where filtering come in handy.
npm i firesword [zod strip](https://github.com/colinhacks/zod#strip) to filter, it will destroys the special data types. Always only use FireSword to filter.
yourSchema.parse(data)
or yourSchema.safeParse(data)
depend on your use case. Keep in mind all members is required by default, you can set all members or certain members to partial, please read the Zod documentation for more parsing options.z.literal
, z.string
, z.number
, z.null
, z.boolean
, z.array
, z.union
, z.object
.Important: do not use zod st
z.union([z.object({}), z.someOtherType])
z.union([z.array(...), z.someOtherType])
zTimestamp
, zDocumentReference
and zGeoPoint
, zArrayUnionAndRemove
, zDelete
, zIncrement
and zServerTimestamp
are custom Firestore Zod types.z.date
.Timestamp
, DocumentReference
, GeoPoint
and all field values(ServerTimestamp, ArrayRemove, ArrayUnion, Increment, Delete
).import {
filter,
zTimestamp,
zDocumentReference,
zGeoPoint,
zArrayUnionAndRemove,
zDelete,
zIncrement,
} from 'firesword/firestore-web'
import { z } from 'zod'
import {
Timestamp,
getFirestore,
doc,
arrayRemove,
deleteField,
increment,
} from 'firebase/firestore'
import { initializeApp } from 'firebase/app'
initializeApp({ projectId: 'any' })
// schema type
// {
// a: string
// b: 1 | 2 | 3
// c: {
// d: Timestamp
// e: DocumentReference
// f: GeoPoint
// }
// d: number[]
// e: { i: boolean; j: 'a' | 'b' | 'c' }[]
// f: (number|boolean)[]
// g: string[]
// h: number
// i: number
// j: Date
// }
const schema = z.object({
a: z.string(),
b: z.union([z.literal(1), z.literal(2), z.literal(3)]),
c: z.object({ d: zTimestamp(), e: zDocumentReference(), f: zGeoPoint() }),
d: z.array(z.number()),
e: z.array(
z.object({
i: z.boolean(),
j: z.union([z.literal('a'), z.literal('b'), z.literal('c')]),
})
),
f: z.array(z.union([z.boolean(), z.number()])),
g: z.union([z.array(z.string()), zArrayUnionAndRemove(z.string())]),
h: z.union([zDelete(), z.number()]),
i: z.union([zIncrement(), z.number()]),
j: z.date(),
})
export const filteredData = filter({
schema,
data: {
// 'a' is missing
z: 'unknown member',
b: 1,
c: {
d: new Timestamp(0, 0),
e: doc(getFirestore(), 'a/b'),
// f is missing
z: 'unknown member',
},
d: [100, 200, 300],
e: [
{
i: true,
// j is missing
},
{
// i is missing
j: 'a',
z: 'unknown member',
},
],
f: arrayRemove('abc'),
g: deleteField(),
h: increment(1),
i: new Date(0),
},
})
console.log(filteredData)
// {
// b: 1,
// c: {
// d: new Timestamp(0, 0),
// e: doc(getFirestore(), 'a/b'),
// },
// d: [100, 200, 300],
// e: [{ i: true }, { j: 'a' }],
// f: arrayRemove('abc'),
// g: deleteField(),
// h: increment(1),
// i: new Date(0),
// }
This is how you import the same thing in admin, the rest are similar to web.
import {
filter,
zTimestamp,
zDocumentReference,
zGeoPoint,
zArrayUnionAndRemove,
zDelete,
zIncrement,
} from 'firesword/firestore-admin'
zServerTimestamp
and zIncrement
are custom RTDB Zod types.zServerTimestamp
for serverTimestamp
and zIncrement
for increment
.zServerTimestamp
and zIncrement
are not the same as Firestore's zServerTimestamp
and zIncrement
.import { filter, zServerTimestamp, zIncrement } from 'firesword/database'
import { z } from 'zod'
import { serverTimestamp, increment } from 'firebase/database'
// schema type
// {
// a: string
// b: number
// g: serverTimestamp[]
// h: { i: boolean; j: 'a' | 'b' | 'c' }[]
// }
const schema = z.object({
a: z.string(),
b: z.union([z.number(), zIncrement()]),
g: z.array(zServerTimestamp()),
h: z.array(
z.object({
i: z.boolean(),
j: z.union([z.literal('a'), z.literal('b'), z.literal('c')]),
})
),
})
export const filteredData = filter({
schema,
data: {
// missing 'a'
z: 'unknown member',
b: increment(1),
g: [serverTimestamp(), serverTimestamp(), serverTimestamp()],
h: [
{
i: true,
// missing j
},
{
// missing i
j: 'a',
z: 'unknown member',
},
],
},
})
// console.log(filteredData)
// {
// b: increment(1),
// g: [ServerTimestamp, ServerTimestamp, ServerTimestamp],
// h: [{ i: true }, { j: 'a' }],
// }
This section use Firestore filter as example but the same logic is applied to RTDB filter.
import { filter, zArrayUnionAndRemove } from 'firesword/firestore-web'
import { number, z } from 'zod'
import { arrayUnion } from 'firebase/firestore'
// {
// a: string
// b: 1 | 2 | 3
// g: { x: number, y: null }
// h: boolean[]
// i: zArrayUnionAndRemove(string)
// }
const schema = z.object({
a: z.string(),
b: z.union([z.literal(1), z.literal(2), z.literal(3)]),
g: z.object({ x: z.number(), y: z.null() }),
h: z.array(z.boolean()),
i: zArrayUnionAndRemove(z.string()),
j: z.array(
z.object({ x: z.number(), y: z.object({ a: z.null(), b: z.number() }) })
),
})
export const filteredData = filter({
schema,
data: {
a: true, // expect string
b: {}, // expect 1 | 2 | 3
g: 1, // expect { x:number, y:null }
h: null, // expect boolean[]
i: arrayUnion(1), // expect arrayUnion(string)
j: [{ x: 'abc', y: { a: null, b: 'abc' } }], // expect number for 'x' and 'b'
},
})
// console.log(filteredData) // { j:[{y: { a:null }}] }
export const filteredData2 = filter({
schema,
data: {
g: { a: {}, b: true, c: 'abc' }, // expect { x:number, y:null }
h: [1, true, 3], // expect boolean[], only the 2nd element is correct
},
})
// console.log(filteredData2) // { g: {}, h: [null, true, null] }
You need to type cast Firestore zTimestamp
, zDocumentReference
and zGeoPoint
.
import {
filter,
zTimestamp,
zDocumentReference,
zGeoPoint,
} from 'firesword/firestore-web'
import { z } from 'zod'
import {
Timestamp,
doc,
GeoPoint,
DocumentReference,
getFirestore,
} from 'firebase/firestore'
import { initializeApp } from 'firebase/app'
initializeApp({ projectId: 'any' })
// {
// d: Timestamp
// e: DocumentReference
// f: GeoPoint
// }
const schema = z.object({
d: zTimestamp(),
e: zDocumentReference(),
f: zGeoPoint(),
})
export const filteredData = filter({
schema,
data: {
d: new Timestamp(0, 0),
e: doc(getFirestore(), 'a/b'),
f: new GeoPoint(0, 0),
},
}) as unknown as {
d: Timestamp
e: DocumentReference
f: GeoPoint
}
If you see error like Cannot find module 'firesword/firestore'
or Cannot find module 'firesword/database'
, it means your compiler ignore package.json
exports
field.
Solution for Jest: jest-node-exports-resolver.
I am not aware of solution for other cases(eg webpack), please open issue if you are having similar issue.