@data-weave/backend-firestore 0.4.2 → 0.4.3

package/lib/FirestoreDataManager.ts

@@ -1,247 +0,0 @@
-import { injectable } from 'inversify'
-
-import { Cache, MapCache } from '@data-weave/datamanager/lib/Cache'
-import { CreateOptions, DataManager, Metadata, WithMetadata } from '@data-weave/datamanager/lib/DataManager'
-import { List, ListPaginationParams } from '@data-weave/datamanager/lib/List'
-import { IdentifiableReference, WithoutId } from '@data-weave/datamanager/lib/Reference'
-import { FirestoreList, FirestoreListContext } from './FirestoreList'
-import {
-    FIRESTORE_KEYS,
-    FirestoreMetadataConverter,
-    FirestoreSerializedMetadata,
-    queryNotDeleted,
-} from './FirestoreMetadata'
-import { FirestoreReference, FirestoreReferenceContext } from './FirestoreReference'
-import {
-    DocumentData,
-    FilterBy,
-    FirebaseCreateOptions,
-    Firestore,
-    FirestoreDataConverter,
-    FirestoreReadMode,
-    FirestoreReadOptions,
-    FirestoreTypes,
-    FirestoreWriteOptions,
-    InternalFirestoreDataConverter,
-    OrderBy,
-    WithFieldValue,
-} from './firestoreTypes'
-import { MergeConverters, checkIfReferenceExists } from './utils'
-
-export type FirebaseDataManagerDeleteMode = 'soft' | 'hard'
-
-export interface FirebaseDataManagerOptions {
-    readonly idResolver?: () => string
-    readonly deleteMode?: FirebaseDataManagerDeleteMode
-    readonly readMode?: FirestoreReadMode
-    readonly preventOverwriteOnCreate?: boolean
-    readonly errorInterceptor?: (error: unknown, ctx: FirestoreReferenceContext | FirestoreListContext) => void
-    readonly snapshotOptions?: FirestoreTypes.SnapshotOptions
-    // TODO: Add preventUpdateIfNotExists?
-    readonly Reference?: typeof FirestoreReference
-    readonly List?: typeof FirestoreList
-    readonly listCache?: Cache
-    readonly refCache?: Cache
-}
-
-const defaultFirebaseDataManagerOptions: FirebaseDataManagerOptions = {
-    deleteMode: 'soft',
-    preventOverwriteOnCreate: true,
-    readMode: 'static',
-    Reference: FirestoreReference,
-    List: FirestoreList,
-}
-
-export interface QueryParams<T extends FirestoreTypes.DocumentData> {
-    readonly filters?: Array<FilterBy<T & FirestoreSerializedMetadata>>
-    readonly orderBy?: Array<OrderBy<T & FirestoreSerializedMetadata>>
-}
-
-@injectable()
-export class FirestoreDataManager<
-    T extends FirestoreTypes.DocumentData,
-    SerializedT extends FirestoreTypes.DocumentData = T,
-> implements DataManager<T>
-{
-    private mergedConverter: InternalFirestoreDataConverter<T & Metadata, SerializedT & FirestoreSerializedMetadata>
-    private collection: FirestoreTypes.CollectionReference<T & Metadata, SerializedT & FirestoreSerializedMetadata>
-    private collectionQuery: FirestoreTypes.Query<T & Metadata, SerializedT & FirestoreSerializedMetadata>
-    private managerOptions: FirebaseDataManagerOptions
-
-    private refCache: Cache<string, IdentifiableReference<WithMetadata<T>>>
-    private listCache: Cache<string, List<WithMetadata<T>>>
-
-    constructor(
-        private readonly firestore: Firestore,
-        private readonly collectionPath: string,
-        private readonly converter: FirestoreDataConverter<T, SerializedT>,
-        private readonly opts?: FirebaseDataManagerOptions
-    ) {
-        // @ts-expect-error - Force merge FirestoreDataConverter and InternalFirestoreDataConverter
-        this.mergedConverter = new MergeConverters(this.converter, new FirestoreMetadataConverter())
-        this.managerOptions = Object.assign(defaultFirebaseDataManagerOptions, this.opts)
-
-        this.refCache = this.managerOptions.refCache || new MapCache(100)
-        this.listCache = this.managerOptions.listCache || new MapCache(100)
-
-        this.collection = this.firestore
-            .collection(this.firestore.app, this.collectionPath)
-            .withConverter(this.mergedConverter)
-
-        this.collectionQuery =
-            this.managerOptions.deleteMode === 'soft'
-                ? queryNotDeleted(this.collection, this.firestore.query, this.firestore.where)
-                : this.collection
-    }
-
-    public async read(id: string, options?: FirestoreReadOptions): Promise<WithMetadata<T> | undefined> {
-        if (!this.managerOptions?.Reference) throw new Error('ReferenceClass not defined')
-
-        const ref = this.getRef(id)
-
-        if (options?.transaction) {
-            const snapshot = await options.transaction.get<WithMetadata<T>, DocumentData>(
-                this.firestore.doc(this.collection, id)
-            )
-            if (!checkIfReferenceExists(snapshot)) return undefined
-            return snapshot.data()
-        }
-        return await ref.resolve()
-    }
-
-    public async create(data: WithFieldValue<WithoutId<T>>, options?: FirebaseCreateOptions) {
-        let id: string | undefined = undefined
-        if (options?.id) {
-            id = options?.id
-        } else if (this.managerOptions?.idResolver) {
-            id = this.managerOptions.idResolver()
-        }
-
-        let docRef: FirestoreTypes.DocumentReference
-        let docExists: boolean = false
-
-        if (id) {
-            docRef = this.firestore.doc(this.collection, id)
-            docExists = await this.preventOverwriteOnCreate(docRef, options)
-        } else {
-            docRef = this.firestore.doc(this.collection)
-        }
-
-        const docDataWithMetadata = {
-            ...data,
-            [FIRESTORE_KEYS.CREATED_AT]: docExists ? undefined : this.firestore.serverTimestamp(),
-            [FIRESTORE_KEYS.UPDATED_AT]: this.firestore.serverTimestamp(),
-            [FIRESTORE_KEYS.DELETED]: false,
-        }
-
-        const firebaseOptions = { merge: options?.merge }
-
-        if (options?.transaction) {
-            options?.transaction.set(docRef, docDataWithMetadata, firebaseOptions)
-        } else {
-            await this.firestore.setDoc(docRef, docDataWithMetadata, firebaseOptions)
-        }
-
-        return this.getRef(docRef.id)
-    }
-
-    private async _update(
-        id: string,
-        data: WithoutId<Partial<WithFieldValue<T & Metadata>>>,
-        options?: FirestoreWriteOptions
-    ) {
-        const extendedData = {
-            ...data,
-            [FIRESTORE_KEYS.UPDATED_AT]: this.firestore.serverTimestamp(),
-        }
-        // Firestore update method doesn't call converter like setDoc does, so we need to serialize the data manually.
-        const serializedData = this.mergedConverter.toFirestore(extendedData)
-
-        const ref = this.firestore.doc(this.collection, id)
-
-        if (options?.transaction) {
-            return options.transaction.update<DocumentData, DocumentData>(ref, serializedData)
-        }
-        return this.firestore.updateDoc(ref, serializedData)
-    }
-
-    public async update(id: string, data: WithoutId<Partial<WithFieldValue<T>>>, options?: FirestoreWriteOptions) {
-        await this._update(id, data, options)
-    }
-
-    public async upsert(id: string, data: WithFieldValue<WithoutId<T>>, options?: FirestoreWriteOptions) {
-        this.create(data, { ...options, id, merge: true })
-    }
-
-    public async delete(id: string, options?: FirestoreWriteOptions) {
-        if (this.managerOptions.deleteMode === 'soft') {
-            await this._update(
-                id,
-                {
-                    ...({} as Partial<T>),
-                    [FIRESTORE_KEYS.DELETED]: true,
-                },
-                options
-            )
-            return
-        }
-        return this.firestore.deleteDoc(this.firestore.doc(this.collection, id))
-    }
-
-    public getRef(id: string) {
-        if (!this.managerOptions?.Reference) throw new Error('ReferenceClass not defined')
-
-        if (this.refCache.has(id)) {
-            return this.refCache.get(id)!
-        }
-
-        const newRef = new this.managerOptions.Reference(this.firestore, this.firestore.doc(this.collection, id), {
-            readMode: this.managerOptions.readMode,
-            errorInterceptor: this.managerOptions.errorInterceptor,
-            snapshotOptions: this.managerOptions.snapshotOptions,
-        })
-        this.refCache.set(id, newRef)
-        return newRef
-    }
-
-    private _getFilteredQuery(params?: QueryParams<SerializedT>) {
-        let compoundQuery = this.collectionQuery
-
-        params?.filters?.forEach(filter => {
-            compoundQuery = this.firestore.query(compoundQuery, this.firestore.where(filter[0], filter[1], filter[2]))
-        })
-
-        params?.orderBy?.forEach(orderBy => {
-            compoundQuery = this.firestore.query(compoundQuery, this.firestore.orderBy(orderBy[0], orderBy[1]))
-        })
-
-        return compoundQuery
-    }
-
-    public getList(params?: QueryParams<SerializedT> & ListPaginationParams) {
-        if (!this.managerOptions.List) throw new Error('ListClass not defined')
-
-        const compoundQuery = this._getFilteredQuery(params)
-
-        const key = JSON.stringify(params || {})
-        if (this.listCache.has(key)) {
-            return this.listCache.get(key)!
-        }
-        const newList = new this.managerOptions.List(this.firestore, compoundQuery, {
-            readMode: this.managerOptions.readMode,
-            errorInterceptor: this.managerOptions.errorInterceptor,
-            ...params,
-        })
-        this.listCache.set(key, newList)
-        return newList
-    }
-
-    private async preventOverwriteOnCreate(docRef: FirestoreTypes.DocumentReference, createOptions?: CreateOptions) {
-        const doc = await this.firestore.getDoc(docRef)
-        const docExists = checkIfReferenceExists(doc)
-        if (docExists && this.managerOptions.preventOverwriteOnCreate && createOptions?.merge !== true) {
-            throw new Error(`Document already exists - ${doc.ref.path}`)
-        }
-        return docExists
-    }
-}

package/lib/FirestoreList.ts

@@ -1,96 +0,0 @@
-import { ListPaginationParams, LiveList, LiveListOptions } from '@data-weave/datamanager'
-import { DocumentData, Firestore, FirestoreReadMode, FirestoreTypes } from './firestoreTypes'
-
-export interface FirestoreListContext {
-    query: FirestoreTypes.Query<unknown>
-    readMode?: FirestoreReadMode
-    type: 'list'
-}
-
-export interface FirestoreListOptions<T> extends LiveListOptions<T> {
-    readMode?: FirestoreReadMode
-    errorInterceptor?: (error: unknown, ctx: FirestoreListContext) => void
-}
-
-export class FirestoreList<T extends DocumentData, S extends DocumentData> extends LiveList<T> {
-    private unsubscribeFromSnapshot: undefined | (() => void)
-
-    constructor(
-        private readonly firestore: Firestore,
-        private readonly query: FirestoreTypes.Query<T, S>,
-        private readonly options: FirestoreListOptions<T> & ListPaginationParams
-    ) {
-        super(options)
-    }
-
-    public async resolve() {
-        if (this.options?.readMode === 'realtime') {
-            let initialLoad = true
-            return new Promise<T[]>((resolve, reject) => {
-                this.unsubscribeFromSnapshot = this.firestore.onSnapshot(
-                    this.query,
-                    querySnapshot => {
-                        try {
-                            if (initialLoad) {
-                                initialLoad = false
-                                this.handleInitialDataChange(querySnapshot.docs)
-                            } else {
-                                this.handleSubsequentDataChanges(querySnapshot.docChanges())
-                            }
-                            // TODO: When calling ".resolve()" with realtime listener,
-                            // the snapshot data might be stale from cache.
-                            resolve(this.values)
-                        } catch (error) {
-                            this.onError(error)
-                            reject(error)
-                        }
-                    },
-                    error => {
-                        this.onError(error)
-                        reject(error)
-                    }
-                )
-            })
-        } else {
-            const snapshot = await this.firestore.getDocs(this.query)
-            this.handleInitialDataChange(snapshot.docs)
-            return this.values
-        }
-    }
-
-    protected handleInitialDataChange(values: FirestoreTypes.QueryDocumentSnapshot<T, S>[]) {
-        const newValues = values.map(v => v.data())
-        this.onUpdateAll(newValues)
-    }
-
-    protected handleSubsequentDataChanges(changes: FirestoreTypes.DocumentChange<T, S>[]) {
-        changes.forEach(change => {
-            if (change.type === 'added') {
-                this.onAddAtIndex(change.newIndex, change.doc.data())
-            } else if (change.type === 'modified') {
-                this.onUpdateAtIndex(change.newIndex, change.doc.data())
-            } else if (change.type === 'removed') {
-                this.onRemoveAtIndex(change.oldIndex)
-            }
-        })
-        // TODO: handle onUpdate in the parent class - make sure it's only called once after all changes are processed
-        this.onUpdate()
-    }
-
-    public unSubscribe() {
-        this.unsubscribeFromSnapshot?.()
-        this.setStale()
-    }
-
-    protected onError(error: unknown) {
-        // Try to provide useful collection details using internal properties
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        console.error(`FirestoreList Collection: ${(this.query as any)?._collectionPath?.id} error`, error)
-        this.options?.errorInterceptor?.(error, {
-            query: this.query,
-            readMode: this.options?.readMode,
-            type: 'list',
-        })
-        super.onError(error)
-    }
-}

package/lib/FirestoreMetadata.ts

@@ -1,59 +0,0 @@
-import { Metadata, WithoutId } from '@data-weave/datamanager'
-import {
-    DocumentData,
-    FirestoreQuery,
-    FirestoreTypes,
-    FirestoreWhere,
-    InternalFirestoreDataConverter,
-    WithFieldValue,
-} from './firestoreTypes'
-
-enum FIRESTORE_INTERAL_KEYS {
-    DELETED = '__deleted',
-    CREATED_AT = '__createdAt',
-    UPDATED_AT = '__updatedAt',
-}
-
-export enum FIRESTORE_KEYS {
-    DELETED = 'deleted',
-    CREATED_AT = 'createdAt',
-    UPDATED_AT = 'updatedAt',
-}
-
-export type FirestoreSerializedMetadata = {
-    [FIRESTORE_INTERAL_KEYS.DELETED]: boolean
-    [FIRESTORE_INTERAL_KEYS.CREATED_AT]: FirestoreTypes.Timestamp
-    [FIRESTORE_INTERAL_KEYS.UPDATED_AT]: FirestoreTypes.Timestamp
-}
-
-export class FirestoreMetadataConverter
-    implements InternalFirestoreDataConverter<Metadata, FirestoreSerializedMetadata>
-{
-    toFirestore(data: WithFieldValue<WithoutId<Metadata>>) {
-        return {
-            [FIRESTORE_INTERAL_KEYS.DELETED]: data[FIRESTORE_KEYS.DELETED],
-            // Cast: Firestore handles conversion from Date to Timestamp internally
-            [FIRESTORE_INTERAL_KEYS.CREATED_AT]: data[FIRESTORE_KEYS.CREATED_AT] as unknown as FirestoreTypes.Timestamp,
-            [FIRESTORE_INTERAL_KEYS.UPDATED_AT]: data[FIRESTORE_KEYS.UPDATED_AT] as unknown as FirestoreTypes.Timestamp,
-        }
-    }
-    fromFirestore(
-        snapshot: FirestoreTypes.QueryDocumentSnapshot<DocumentData, DocumentData>,
-        options: FirestoreTypes.SnapshotOptions
-    ) {
-        const data = snapshot.data(options) as FirestoreSerializedMetadata
-        return {
-            id: snapshot.ref.id,
-            // TODO: add warning in case data type is not as expected
-            createdAt: data[FIRESTORE_INTERAL_KEYS.CREATED_AT]?.toDate(),
-            updatedAt: data[FIRESTORE_INTERAL_KEYS.UPDATED_AT]?.toDate(),
-            deleted: data[FIRESTORE_INTERAL_KEYS.DELETED],
-        }
-    }
-}
-
-export const queryNotDeleted = <T extends DocumentData, SerializedT extends DocumentData>(
-    query: FirestoreTypes.Query<T, SerializedT>,
-    firestoreQuery: FirestoreQuery<T, SerializedT>,
-    firestoreWhere: FirestoreWhere
-) => firestoreQuery(query, firestoreWhere(FIRESTORE_INTERAL_KEYS.DELETED, '==', false))

package/lib/FirestoreReference.ts

@@ -1,92 +0,0 @@
-import { LiveReference, LiveReferenceOptions } from '@data-weave/datamanager'
-import { DocumentData, Firestore, FirestoreReadMode, FirestoreTypes } from './firestoreTypes'
-import { checkIfReferenceExists } from './utils'
-
-export interface FirestoreReferenceContext {
-    path: string
-    id: string
-    readMode?: FirestoreReadMode
-    snapshotOptions?: FirestoreTypes.SnapshotOptions
-    type: 'reference'
-}
-
-export interface FirestoreReferenceOptions<T> extends LiveReferenceOptions<T> {
-    readMode?: FirestoreReadMode
-    snapshotOptions?: FirestoreTypes.SnapshotOptions
-    errorInterceptor?: (error: unknown, ctx: FirestoreReferenceContext) => void
-}
-
-export class FirestoreReference<T extends DocumentData, S extends DocumentData> extends LiveReference<T> {
-    private unsubscribeFromSnapshot: undefined | (() => void)
-
-    constructor(
-        private readonly firestore: Firestore,
-        private readonly docRef: FirestoreTypes.DocumentReference<T, S>,
-        readonly options: FirestoreReferenceOptions<T>
-    ) {
-        super(options)
-    }
-
-    public async resolve(): Promise<T | undefined> {
-        if (this.options?.readMode === 'realtime') {
-            return new Promise<T | undefined>((res, reject) => {
-                this.unsubscribeFromSnapshot = this.firestore.onSnapshot(
-                    this.docRef,
-                    documentSnapshot => {
-                        try {
-                            this.onUpdate(this.parseDocumentSnapshot(documentSnapshot))
-                            // TODO: When calling ".resolve()" with realtime listener,
-                            // the snapshot data might be stale from cache.
-                            res(this.value)
-                        } catch (error) {
-                            this.onError(error)
-                            reject(error)
-                        }
-                    },
-                    error => {
-                        this.onError(error)
-                        reject(error)
-                    }
-                )
-            })
-        }
-        try {
-            const doc = await this.firestore.getDoc(this.docRef)
-            this.onUpdate(this.parseDocumentSnapshot(doc))
-        } catch (error) {
-            this.onError(error)
-            throw error
-        }
-        return this.value
-    }
-
-    public get id(): string {
-        return this.docRef.id
-    }
-
-    public get path(): string {
-        return this.docRef.path
-    }
-
-    protected onError(error: unknown): void {
-        console.error(`FirestoreReference error ${this.docRef.path}`, error)
-        this.options?.errorInterceptor?.(error, {
-            path: this.docRef.path,
-            id: this.docRef.id,
-            readMode: this.options?.readMode,
-            snapshotOptions: this.options?.snapshotOptions,
-            type: 'reference',
-        })
-        super.onError(error)
-    }
-
-    public unSubscribe() {
-        this.unsubscribeFromSnapshot?.()
-        this.setStale()
-    }
-
-    private parseDocumentSnapshot(docSnapshot: FirestoreTypes.DocumentSnapshot<T, S>): T | undefined {
-        if (!checkIfReferenceExists(docSnapshot)) throw new Error(`Document does not exist ${this.docRef.path}`)
-        return docSnapshot.data(this.options?.snapshotOptions)
-    }
-}