feat(database): add once option

posva · posva · commit 0c321fbf6366 · 2022-11-23T11:56:11.000+01:00
diff --git a/src/database/index.ts b/src/database/index.ts
@@ -81,22 +81,14 @@ export function _useDatabaseRef(
 
       if (Array.isArray(data.value)) {
         unbind = bindAsArray(
-          data,
+          data as Ref<any>,
           referenceValue,
           resolve,
           reject,
-          ops,
           options
         )
       } else {
-        unbind = bindAsObject(
-          data,
-          referenceValue,
-          resolve,
-          reject,
-          ops,
-          options
-        )
+        unbind = bindAsObject(data, referenceValue, resolve, reject, options)
       }
     })
 
diff --git a/src/database/subscribe.ts b/src/database/subscribe.ts
@@ -2,24 +2,27 @@ import {
   createRecordFromDatabaseSnapshot,
   indexForKey,
   DatabaseSnapshotSerializer,
+  VueDatabaseQueryData,
 } from './utils'
 import {
   noop,
   OperationsType,
   ResetOption,
   TODO,
   _DataSourceOptions,
+  _MaybeRef,
   _ResolveRejectFn,
 } from '../shared'
 import { ref, Ref, unref } from 'vue-demi'
-import type { Query, DatabaseReference } from 'firebase/database'
 import {
   onValue,
   onChildAdded,
   onChildChanged,
   onChildMoved,
   onChildRemoved,
+  get,
 } from 'firebase/database'
+import type { Query, DatabaseReference, DataSnapshot } from 'firebase/database'
 
 /**
  * Global option type when binding one database reference
@@ -68,28 +71,30 @@ export function bindAsObject(
   document: DatabaseReference | Query,
   resolve: _ResolveRejectFn,
   reject: _ResolveRejectFn,
-  ops: OperationsType,
-  extraOptions: _DatabaseRefOptions = DEFAULT_OPTIONS
+  extraOptions?: _DatabaseRefOptions
 ) {
-  const key = 'value'
   const options = Object.assign({}, DEFAULT_OPTIONS, extraOptions)
 
-  const unsubscribe = onValue(
-    document,
-    (snapshot) => {
-      const value = options.serialize(snapshot)
-      ops.set(target, key, value)
-      // resolve the promise
-      resolve(value)
-    },
-    reject
-  )
+  let unsubscribe = noop
+
+  function onValueCallback(snapshot: DataSnapshot) {
+    const value = options.serialize(snapshot)
+    target.value = value
+    // resolve the promise
+    resolve(value)
+  }
+
+  if (options.once) {
+    get(document).then(onValueCallback).catch(reject)
+  } else {
+    unsubscribe = onValue(document, onValueCallback, reject)
+  }
 
   return (reset?: ResetOption) => {
     unsubscribe()
     if (reset !== false) {
       const value = typeof reset === 'function' ? reset() : null
-      ops.set(target, key, value)
+      target.value = value
     }
   }
 }
@@ -101,85 +106,112 @@ export function bindAsObject(
  * @returns a function to be called to stop listening for changes
  */
 export function bindAsArray(
-  target: Ref<TODO>,
+  target: Ref<ReturnType<DatabaseSnapshotSerializer>[]>,
   collection: DatabaseReference | Query,
   resolve: _ResolveRejectFn,
   reject: _ResolveRejectFn,
-  ops: OperationsType,
-  extraOptions: _DatabaseRefOptions = DEFAULT_OPTIONS
+  extraOptions?: _DatabaseRefOptions
 ) {
   const options = Object.assign({}, DEFAULT_OPTIONS, extraOptions)
-  const key = 'value'
-
-  if (!options.wait) ops.set(target, key, [])
-  let arrayRef = ref(options.wait ? [] : target[key])
-
-  const removeChildAddedListener = onChildAdded(
-    collection,
-    (snapshot, prevKey) => {
-      const array = unref(arrayRef)
-      const index = prevKey ? indexForKey(array, prevKey) + 1 : 0
-      ops.add(array, index, options.serialize(snapshot))
-    },
-    reject
-  )
-
-  const removeChildRemovedListener = onChildRemoved(
-    collection,
-
-    (snapshot) => {
-      const array = unref(arrayRef)
-      ops.remove(array, indexForKey(array, snapshot.key))
-    },
-    reject
-  )
-
-  const removeChildChangedListener = onChildChanged(
-    collection,
-    (snapshot) => {
-      const array = unref(arrayRef)
-      ops.set(
-        array,
-        indexForKey(array, snapshot.key),
-        options.serialize(snapshot)
-      )
-    },
-    reject
-  )
-
-  const removeChildMovedListener = onChildMoved(
-    collection,
-    (snapshot, prevKey) => {
-      const array = unref(arrayRef)
-      const index = indexForKey(array, snapshot.key)
-      const oldRecord = ops.remove(array, index)[0]
-      const newIndex = prevKey ? indexForKey(array, prevKey) + 1 : 0
-      ops.add(array, newIndex, oldRecord)
-    },
-    reject
-  )
 
+  let arrayRef: _MaybeRef<ReturnType<DatabaseSnapshotSerializer>[]> =
+    options.wait ? [] : target
+  // by default we wait, if not, set the value to an empty array so it can be populated correctly
+  if (!options.wait) {
+    target.value = []
+  }
+
+  // setup the callbacks to noop for options.once
+  let removeChildAddedListener = noop
+  let removeChildChangedListener = noop
+  let removeChildRemovedListener = noop
+  let removeChildMovedListener = noop
   // in case the removeValueListener() is called before onValue returns
   let removeValueListener = noop
-  removeValueListener = onValue(
-    collection,
-    (data) => {
-      const array = unref(arrayRef)
-      if (options.wait) ops.set(target, key, array)
-      resolve(data)
-      removeValueListener()
-    },
-    reject
-  )
+
+  if (options.once) {
+    get(collection)
+      .then((data) => {
+        const array: ReturnType<DatabaseSnapshotSerializer>[] = []
+        data.forEach((snapshot) => {
+          array.push(options.serialize(snapshot))
+        })
+        resolve((target.value = array))
+      })
+      .catch(reject)
+  } else {
+    removeChildAddedListener = onChildAdded(
+      collection,
+      (snapshot, prevKey) => {
+        const array = unref(arrayRef)
+        const index = prevKey ? indexForKey(array, prevKey) + 1 : 0
+        array.splice(index, 0, options.serialize(snapshot))
+      },
+      reject
+    )
+
+    removeChildRemovedListener = onChildRemoved(
+      collection,
+
+      (snapshot) => {
+        const array = unref(arrayRef)
+        array.splice(indexForKey(array, snapshot.key), 1)
+      },
+      reject
+    )
+
+    removeChildChangedListener = onChildChanged(
+      collection,
+      (snapshot) => {
+        const array = unref(arrayRef)
+        array.splice(
+          indexForKey(array, snapshot.key),
+          1,
+          options.serialize(snapshot)
+        )
+      },
+      reject
+    )
+
+    removeChildMovedListener = onChildMoved(
+      collection,
+      (snapshot, prevKey) => {
+        const array = unref(arrayRef)
+        const index = indexForKey(array, snapshot.key)
+        const oldRecord = array.splice(index, 1)[0]
+        const newIndex = prevKey ? indexForKey(array, prevKey) + 1 : 0
+        array.splice(newIndex, 0, oldRecord)
+      },
+      reject
+    )
+
+    // we use this to know when the initial data has been loaded
+    removeValueListener = onValue(
+      collection,
+      () => {
+        const array = unref(arrayRef)
+        if (options.wait) {
+          target.value = array
+          // switch to the target so all changes happen into the target
+          arrayRef = target
+        }
+        resolve(array)
+        removeValueListener()
+      },
+      reject
+    )
+  }
 
   return (reset?: ResetOption) => {
+    removeValueListener()
     removeChildAddedListener()
     removeChildRemovedListener()
     removeChildChangedListener()
     removeChildMovedListener()
     if (reset !== false) {
       const value = typeof reset === 'function' ? reset() : []
-      ops.set(target, key, value)
+      // we trust the user to return an array
+      target.value = value as any
     }
   }
 }
diff --git a/src/database/utils.ts b/src/database/utils.ts
@@ -1,15 +1,16 @@
+import { isObject } from '../shared'
 import type { DataSnapshot } from 'firebase/database'
-import { isObject, _RefWithState } from '../shared'
+import type { _RefWithState } from '../shared'
 
 /**
- * Convert firebase Database snapshot into a bindable data record.
+ * Convert firebase Database snapshot of a ref **that exists** into a bindable data record.
  *
  * @param snapshot
  * @return
  */
 export function createRecordFromDatabaseSnapshot(
   snapshot: DataSnapshot
-): VueDatabaseDocumentData<unknown> {
+): NonNullable<VueDatabaseDocumentData<unknown>> {
   const value: unknown = snapshot.val()
   const res: unknown = isObject(value)
     ? value
@@ -22,7 +23,9 @@ export function createRecordFromDatabaseSnapshot(
   return res
 }
 
-export type DatabaseSnapshotSerializer = typeof createRecordFromDatabaseSnapshot
+export interface DatabaseSnapshotSerializer<T = unknown> {
+  (snapshot: DataSnapshot): NonNullable<VueDatabaseDocumentData<T>>
+}
 
 /**
  * Find the index for an object with given key.
@@ -32,7 +35,7 @@ export type DatabaseSnapshotSerializer = typeof createRecordFromDatabaseSnapshot
  * @return the index where the key was found
  */
 export function indexForKey(
-  array: VueDatabaseQueryData,
+  array: NonNullable<VueDatabaseDocumentData>[],
   key: string | null | number
 ): number {
   for (let i = 0; i < array.length; i++) {
@@ -60,5 +63,5 @@ export type VueDatabaseDocumentData<T = unknown> =
  * Same as VueDatabaseDocumentData but for a query.
  */
 export type VueDatabaseQueryData<T = unknown> = Array<
-  Exclude<VueDatabaseDocumentData<T>, null>
+  NonNullable<VueDatabaseDocumentData<T>>
 >
