react-native-firebase-compiled/es5/modules/firestore/DocumentReference.js

A well tested, feature rich Firebase implementation for React Native, supporting iOS & Android. Individual module support for Admob, Analytics, Auth, Crash Reporting, Cloud Firestore, Database, Dynamic Links, Functions, Messaging (FCM), Remote Config, Sto

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

var _CollectionReference = _interopRequireDefault(require("./CollectionReference"));

var _DocumentSnapshot = _interopRequireDefault(require("./DocumentSnapshot"));

var _utils = require("./utils");

var _serialize = require("./utils/serialize");

var _events = require("../../utils/events");

var _log = require("../../utils/log");

var _utils2 = require("../../utils");

var _native = require("../../utils/native");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

/**
 * @class DocumentReference
 */
class DocumentReference {
  constructor(firestore, documentPath) {
    _defineProperty(this, "_documentPath", void 0);

    _defineProperty(this, "_firestore", void 0);

    this._documentPath = documentPath;
    this._firestore = firestore;
  }

  get firestore() {
    return this._firestore;
  }

  get id() {
    return this._documentPath.id;
  }

  get parent() {
    const parentPath = this._documentPath.parent(); // $FlowExpectedError: parentPath can never be null


    return new _CollectionReference.default(this._firestore, parentPath);
  }

  get path() {
    return this._documentPath.relativeName;
  }

  collection(collectionPath) {
    const path = this._documentPath.child(collectionPath);

    if (!path.isCollection) {
      throw new Error('Argument "collectionPath" must point to a collection.');
    }

    return new _CollectionReference.default(this._firestore, path);
  }

  delete() {
    return (0, _native.getNativeModule)(this._firestore).documentDelete(this.path);
  }

  get(options) {
    if (options) {
      if (!(0, _utils2.isObject)(options)) {
        return Promise.reject(new Error('DocumentReference.get failed: First argument must be an object.'));
      }

      if (options.source && options.source !== 'default' && options.source !== 'server' && options.source !== 'cache') {
        return Promise.reject(new Error('DocumentReference.get failed: GetOptions.source must be one of `default`, `server` or `cache`.'));
      }
    }

    return (0, _native.getNativeModule)(this._firestore).documentGet(this.path, options).then(result => new _DocumentSnapshot.default(this._firestore, result));
  }

  onSnapshot(optionsOrObserverOrOnNext, observerOrOnNextOrOnError, onError) {
    let observer;
    let docListenOptions = {}; // Called with: onNext, ?onError

    if ((0, _utils2.isFunction)(optionsOrObserverOrOnNext)) {
      if (observerOrOnNextOrOnError && !(0, _utils2.isFunction)(observerOrOnNextOrOnError)) {
        throw new Error('DocumentReference.onSnapshot failed: Second argument must be a valid function.');
      } // $FlowExpectedError: Not coping with the overloaded method signature


      observer = {
        next: optionsOrObserverOrOnNext,
        error: observerOrOnNextOrOnError
      };
    } else if (optionsOrObserverOrOnNext && (0, _utils2.isObject)(optionsOrObserverOrOnNext)) {
      // Called with: Observer
      if (optionsOrObserverOrOnNext.next) {
        if ((0, _utils2.isFunction)(optionsOrObserverOrOnNext.next)) {
          if (optionsOrObserverOrOnNext.error && !(0, _utils2.isFunction)(optionsOrObserverOrOnNext.error)) {
            throw new Error('DocumentReference.onSnapshot failed: Observer.error must be a valid function.');
          } // $FlowExpectedError: Not coping with the overloaded method signature


          observer = {
            next: optionsOrObserverOrOnNext.next,
            error: optionsOrObserverOrOnNext.error
          };
        } else {
          throw new Error('DocumentReference.onSnapshot failed: Observer.next must be a valid function.');
        }
      } else if (Object.prototype.hasOwnProperty.call(optionsOrObserverOrOnNext, 'includeMetadataChanges')) {
        docListenOptions = optionsOrObserverOrOnNext; // Called with: Options, onNext, ?onError

        if ((0, _utils2.isFunction)(observerOrOnNextOrOnError)) {
          if (onError && !(0, _utils2.isFunction)(onError)) {
            throw new Error('DocumentReference.onSnapshot failed: Third argument must be a valid function.');
          } // $FlowExpectedError: Not coping with the overloaded method signature


          observer = {
            next: observerOrOnNextOrOnError,
            error: onError
          }; // Called with Options, Observer
        } else if (observerOrOnNextOrOnError && (0, _utils2.isObject)(observerOrOnNextOrOnError) && observerOrOnNextOrOnError.next) {
          if ((0, _utils2.isFunction)(observerOrOnNextOrOnError.next)) {
            if (observerOrOnNextOrOnError.error && !(0, _utils2.isFunction)(observerOrOnNextOrOnError.error)) {
              throw new Error('DocumentReference.onSnapshot failed: Observer.error must be a valid function.');
            }

            observer = {
              next: observerOrOnNextOrOnError.next,
              error: observerOrOnNextOrOnError.error
            };
          } else {
            throw new Error('DocumentReference.onSnapshot failed: Observer.next must be a valid function.');
          }
        } else {
          throw new Error('DocumentReference.onSnapshot failed: Second argument must be a function or observer.');
        }
      } else {
        throw new Error('DocumentReference.onSnapshot failed: First argument must be a function, observer or options.');
      }
    } else {
      throw new Error('DocumentReference.onSnapshot failed: Called with invalid arguments.');
    }

    const listenerId = (0, _utils2.firestoreAutoId)();

    const listener = nativeDocumentSnapshot => {
      const documentSnapshot = new _DocumentSnapshot.default(this.firestore, nativeDocumentSnapshot);
      observer.next(documentSnapshot);
    }; // Listen to snapshot events


    _events.SharedEventEmitter.addListener((0, _events.getAppEventName)(this._firestore, `onDocumentSnapshot:${listenerId}`), listener); // Listen for snapshot error events


    if (observer.error) {
      _events.SharedEventEmitter.addListener((0, _events.getAppEventName)(this._firestore, `onDocumentSnapshotError:${listenerId}`), observer.error);
    } // Add the native listener


    (0, _native.getNativeModule)(this._firestore).documentOnSnapshot(this.path, listenerId, docListenOptions); // Return an unsubscribe method

    return this._offDocumentSnapshot.bind(this, listenerId, listener);
  }

  set(data, options) {
    const nativeData = (0, _serialize.buildNativeMap)(data);
    return (0, _native.getNativeModule)(this._firestore).documentSet(this.path, nativeData, options);
  }

  update(...args) {
    const data = (0, _utils.parseUpdateArgs)(args, 'DocumentReference.update');
    const nativeData = (0, _serialize.buildNativeMap)(data);
    return (0, _native.getNativeModule)(this._firestore).documentUpdate(this.path, nativeData);
  }
  /**
   * INTERNALS
   */

  /**
   * Remove document snapshot listener
   * @param listener
   */


  _offDocumentSnapshot(listenerId, listener) {
    (0, _log.getLogger)(this._firestore).info('Removing onDocumentSnapshot listener');

    _events.SharedEventEmitter.removeListener((0, _events.getAppEventName)(this._firestore, `onDocumentSnapshot:${listenerId}`), listener);

    _events.SharedEventEmitter.removeListener((0, _events.getAppEventName)(this._firestore, `onDocumentSnapshotError:${listenerId}`), listener);

    (0, _native.getNativeModule)(this._firestore).documentOffSnapshot(this.path, listenerId);
  }

}

exports.default = DocumentReference;