@data-weave/backend-firestore 0.4.2 → 0.4.3

package/lib/firestoreTypes.ts

@@ -1,251 +0,0 @@
-import { WithoutId } from '@data-weave/datamanager'
-import type FirestoreTypes from '@firebase/firestore'
-import type { FieldPath, WithFieldValue as FirestoreWithFieldValue, QueryConstraint } from '@firebase/firestore'
-import type { HttpsCallable, HttpsCallableOptions } from '@firebase/functions-types'
-import { FieldValue, Transaction } from '@google-cloud/firestore'
-import { injectable } from 'inversify'
-
-export type DocumentData = FirestoreTypes.DocumentData
-
-export { FieldValue, FirestoreTypes, Transaction }
-
-/**
- * Same as Partial but all fields are required to be included
- */
-type OptionallyUndefined<T> = { [P in keyof T]: T[P] | undefined }
-
-export declare interface InternalFirestoreDataConverter<
-    T extends DocumentData,
-    SerializedT extends DocumentData = DocumentData,
-> {
-    toFirestore(
-        modelObject: Partial<WithFieldValue<WithoutId<T>>>,
-        options?: FirestoreTypes.SetOptions
-    ): WithFieldValue<WithoutId<SerializedT>>
-    fromFirestore(
-        snapshot: FirestoreTypes.QueryDocumentSnapshot<T, SerializedT>,
-        options?: FirestoreTypes.SnapshotOptions
-    ): T
-}
-
-export type WithTimestamps<T> = {
-    [K in keyof T]: T[K] extends Date
-        ? FirestoreTypes.Timestamp
-        : T[K] extends Date | null
-          ? FirestoreTypes.Timestamp | null
-          : T[K] extends Date | undefined
-            ? FirestoreTypes.Timestamp | undefined
-            : T[K] extends Date | null | undefined
-              ? FirestoreTypes.Timestamp | null | undefined
-              : T[K] extends object
-                ? T[K] extends any[]
-                    ? T[K] extends (infer U)[]
-                        ? WithTimestamps<U>[]
-                        : T[K]
-                    : WithTimestamps<T[K]>
-                : T[K]
-}
-
-/**
- * Converts data between model and serialized data. Differs from InternalFirestoreDataConverter
- * by using `OptionallyUndefined` and `Required` to ensure that all fields are included in de/serialization
- * even if some model defined properties are optional.
- */
-export declare interface FirestoreDataConverter<ModelObject, SerializedModelObject = ModelObject> {
-    toFirestore(
-        modelObject: WithoutId<ModelObject>,
-        options?: FirestoreTypes.SetOptions
-    ): OptionallyUndefined<Required<WithoutId<WithFieldValue<SerializedModelObject>>>>
-    fromFirestore(
-        snapshot: FirestoreTypes.QueryDocumentSnapshot<WithTimestamps<SerializedModelObject>>,
-        options?: FirestoreTypes.SnapshotOptions
-    ): ModelObject
-}
-
-export type FirestoreQuery<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData> = (
-    reference: FirestoreTypes.Query<AppModelType, DbModelType>,
-    filter: any
-) => FirestoreTypes.Query<AppModelType, DbModelType>
-export type FirestoreWhere = (field: string | FieldPath, op: string, value: unknown) => any
-
-export type FirestoreReadMode = 'realtime' | 'static'
-
-export interface FirestoreReadOptions {
-    readonly transaction?: FirestoreTypes.Transaction
-}
-
-export interface FirestoreWriteOptions {
-    readonly transaction?: FirestoreTypes.Transaction
-    readonly batcher?: FirestoreTypes.WriteBatch
-}
-
-export interface FirebaseCreateOptions extends FirestoreWriteOptions {
-    id?: string
-    merge?: boolean
-}
-
-export declare type WithFieldValue<T> = {
-    [K in keyof T]: FirestoreWithFieldValue<T[K]> | FirestoreTypes.FieldValue
-}
-
-type GenNode<K extends string, IsRoot extends boolean> = IsRoot extends true ? `${K}` : `.${K}`
-
-export type FilterableFields<
-    T extends object,
-    IsRoot extends boolean = true,
-    K extends keyof T = keyof T,
-> = K extends string
-    ? // Handle firebase timestamp fields
-      T[K] extends FirestoreTypes.Timestamp
-        ? `${K}`
-        : // Handle Date fields
-          T[K] extends Date
-          ? `${K}`
-          : // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            T[K] extends any[]
-            ? GenNode<K, IsRoot>
-            : T[K] extends object
-              ? `${GenNode<K, IsRoot>}${FilterableFields<T[K], false>}`
-              : GenNode<K, IsRoot>
-    : never
-
-type GetValue<T, K extends string> = K extends `${infer L}.${infer R}`
-    ? L extends keyof T
-        ? GetValue<T[L], R>
-        : never
-    : K extends keyof T
-      ? T[K] extends Date
-          ? Date | FirestoreTypes.Timestamp
-          : T[K]
-      : K extends string
-        ? string | number | boolean
-        : never
-
-export type PrimitiveFilterOp = '<' | '<=' | '==' | '!=' | '>=' | '>'
-
-export type FilterBy<T extends object, Field extends string = FilterableFields<T>> = Field extends string
-    ? // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      GetValue<T, Field> extends any[]
-        ? [Field, 'array-contains', string] | [Field, 'array-contains-any', string[]]
-        : [Field, PrimitiveFilterOp, GetValue<T, Field>] | [Field, 'in', string[]]
-    : never
-
-export type OrderBy<T extends DocumentData, Fields extends string = FilterableFields<T>> = [
-    Fields,
-    FirestoreTypes.OrderByDirection,
-]
-
-export abstract class FieldValues {
-    public abstract serverTimestamp(): FirestoreTypes.FieldValue
-    public abstract delete(): FirestoreTypes.FieldValue
-    public abstract increment(n: number): FirestoreTypes.FieldValue
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    public abstract arrayUnion(...elements: any[]): FirestoreTypes.FieldValue
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    public abstract arrayRemove(...elements: any[]): FirestoreTypes.FieldValue
-}
-
-/**********
- *
- *
- * INJECTABLES
- *
- *
- * **********/
-
-export interface FirestoreAppSettings {
-    persistence?: boolean
-    cacheSizeBytes?: number
-    host?: string
-    ssl?: boolean
-    ignoreUndefinedProperties?: boolean
-    serverTimestampBehavior?: 'estimate' | 'previous' | 'none'
-}
-
-export abstract class FirestoreApp {
-    public abstract type?: string
-    public abstract toJSON?(): object
-    public abstract terminate?(): Promise<void>
-    public abstract settings?(settings: FirestoreAppSettings): void
-    public abstract useEmulator?(host: string, port: number): void
-    public abstract runTransaction?<T>(
-        updateFunction: (transaction: Transaction) => Promise<T>,
-        options?: FirestoreTypes.TransactionOptions
-    ): Promise<T>
-}
-
-@injectable()
-export abstract class Firestore {
-    public abstract app: FirestoreApp
-    public abstract collection(reference: FirestoreTypes.CollectionReference | FirestoreApp, path: string): any
-    public abstract getDocs<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(
-        reference: FirestoreTypes.Query<AppModelType, DbModelType>
-    ): Promise<FirestoreTypes.QuerySnapshot<AppModelType, DbModelType>>
-    public abstract getDoc<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(
-        reference: FirestoreTypes.DocumentReference<AppModelType, DbModelType>,
-        path?: string
-    ): Promise<FirestoreTypes.DocumentSnapshot<AppModelType, DbModelType>>
-    public abstract serverTimestamp(): FirestoreTypes.FieldValue
-    public abstract increment(n: number): FirestoreTypes.FieldValue
-    public abstract query<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(
-        reference: FirestoreTypes.Query<AppModelType, DbModelType>,
-        filter: any
-    ): FirestoreTypes.Query<AppModelType, DbModelType>
-    public abstract where(field: string | FieldPath, op: string, value: unknown): QueryConstraint
-    public abstract limit(limit: number): any
-    public abstract orderBy(orderBy: string, direction: FirestoreTypes.OrderByDirection): any
-    public abstract setDoc<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(
-        reference: FirestoreTypes.DocumentReference<AppModelType, DbModelType>,
-        data: any,
-        options?: FirestoreTypes.SetOptions
-    ): Promise<void>
-    public abstract updateDoc<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(
-        reference: FirestoreTypes.DocumentReference<AppModelType, DbModelType>,
-        data: any
-    ): Promise<void>
-    public abstract doc<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(
-        reference: FirestoreTypes.Query<AppModelType, DbModelType>,
-        path?: string
-    ): FirestoreTypes.DocumentReference<AppModelType, DbModelType>
-    public abstract deleteDoc<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(
-        reference: FirestoreTypes.DocumentReference<AppModelType, DbModelType>
-    ): Promise<void>
-    public abstract onSnapshot<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(
-        reference: FirestoreTypes.DocumentReference<AppModelType, DbModelType>,
-        onNext: (snapshot: FirestoreTypes.DocumentSnapshot<AppModelType, DbModelType>) => void,
-        onError?: (error: Error) => void
-    ): () => void
-    public abstract onSnapshot<AppModelType = DocumentData, DbModelType extends DocumentData = DocumentData>(
-        reference: FirestoreTypes.Query<AppModelType, DbModelType>,
-        onNext: (snapshot: FirestoreTypes.QuerySnapshot<AppModelType, DbModelType>) => void,
-        onError?: (error: Error) => void
-    ): () => void
-    public abstract runTransaction<T>(
-        firestore: FirestoreApp,
-        transaction: (transaction: Transaction) => Promise<T>,
-        options?: FirestoreTypes.TransactionOptions
-    ): Promise<T>
-}
-
-@injectable()
-export abstract class FirestoreSettings {
-    public abstract readMode: FirestoreReadMode
-}
-
-@injectable()
-export abstract class FirestoreFunctions {
-    public abstract httpsCallable(name: string, options?: HttpsCallableOptions): HttpsCallable
-    public abstract useEmulator(host: string, port: number): void
-    public abstract useFunctionsEmulator(origin: string): void
-}
-
-@injectable()
-export class DummyFirestoreFunctions implements FirestoreFunctions {
-    public httpsCallable(): HttpsCallable {
-        return () => {
-            throw new Error('httpsCallable not implemented - DummyFirestoreFunctions')
-        }
-    }
-    public useEmulator() {}
-    public useFunctionsEmulator() {}
-}

package/lib/index.ts

@@ -1,6 +0,0 @@
-export * from './FirestoreDataManager'
-export * from './FirestoreList'
-export * from './FirestoreMetadata'
-export * from './FirestoreReference'
-export * from './firestoreTypes'
-export * from './utils'

package/lib/utils.ts

@@ -1,113 +0,0 @@
-import { WithoutId } from '@data-weave/datamanager'
-import {
-    DocumentData,
-    Firestore,
-    FirestoreTypes,
-    InternalFirestoreDataConverter,
-    Transaction,
-    WithFieldValue,
-} from './firestoreTypes'
-
-import {
-    Firestore as FirebaseFirestore,
-    collection,
-    deleteDoc,
-    doc,
-    getDoc,
-    getDocs,
-    increment,
-    limit,
-    onSnapshot,
-    orderBy,
-    query,
-    runTransaction,
-    serverTimestamp,
-    setDoc,
-    updateDoc,
-    where,
-} from 'firebase/firestore'
-
-export class MergeConverters<
-    T extends DocumentData,
-    SerializedT extends DocumentData,
-    G extends DocumentData,
-    SerializedG extends DocumentData,
-> implements InternalFirestoreDataConverter<T & G, SerializedT & SerializedG>
-{
-    constructor(
-        private converter1: InternalFirestoreDataConverter<T, SerializedT>,
-        private converter2: InternalFirestoreDataConverter<G, SerializedG>
-    ) {}
-
-    toFirestore(
-        modelObject: WithoutId<Partial<WithFieldValue<T>>> & WithoutId<Partial<WithFieldValue<G>>>,
-        options?: FirestoreTypes.SetOptions
-    ) {
-        if (options) {
-            return {
-                ...this.converter1.toFirestore(modelObject, options),
-                ...this.converter2.toFirestore(modelObject, options),
-            }
-        } else {
-            return {
-                ...this.converter1.toFirestore(modelObject),
-                ...this.converter2.toFirestore(modelObject),
-            }
-        }
-    }
-
-    fromFirestore(
-        snapshot: FirestoreTypes.QueryDocumentSnapshot<T & G, SerializedT & SerializedG>,
-        options: FirestoreTypes.SnapshotOptions
-    ) {
-        return {
-            ...this.converter1.fromFirestore(snapshot, options),
-            ...this.converter2.fromFirestore(snapshot, options),
-        }
-    }
-}
-
-export function createModularFirestoreAdapter(firestore: FirebaseFirestore): Firestore {
-    return {
-        app: firestore,
-        collection,
-        getDocs,
-        getDoc,
-        serverTimestamp,
-        query,
-        where,
-        limit,
-        orderBy,
-        setDoc,
-        updateDoc,
-        deleteDoc,
-        doc,
-        onSnapshot,
-        increment,
-        // TODO: fix this
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        runTransaction: runTransaction as any,
-    }
-}
-
-// Value can be anything
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const isFieldValue = (value: any): value is FirestoreTypes.FieldValue => {
-    return value !== undefined && typeof value._toFieldTransform === 'function'
-}
-
-// Modular firestore uses exists, namespaced uses exists()
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const checkIfReferenceExists = (value: any): boolean => {
-    if (value == null) return false
-    if (typeof value.exists === 'function') return value.exists()
-    return value.exists
-}
-
-export const withTransaction = (
-    firestore: Firestore,
-    transaction: (transaction: Transaction) => Promise<void>,
-    options?: FirestoreTypes.TransactionOptions
-) => {
-    return firestore.runTransaction!(firestore.app, transaction, options)
-}