react-native-firebase-compiled/es5/modules/firestore/index.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.statics = exports.default = exports.NAMESPACE = exports.MODULE_NAME = void 0;

var _reactNative = require("react-native");

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

var _ModuleBase = _interopRequireDefault(require("../../utils/ModuleBase"));

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

var _DocumentReference = _interopRequireDefault(require("./DocumentReference"));

var _FieldPath = _interopRequireDefault(require("./FieldPath"));

var _FieldValue = _interopRequireDefault(require("./FieldValue"));

var _GeoPoint = _interopRequireDefault(require("./GeoPoint"));

var _Blob = _interopRequireDefault(require("./Blob"));

var _Path = _interopRequireDefault(require("./Path"));

var _WriteBatch = _interopRequireDefault(require("./WriteBatch"));

var _TransactionHandler = _interopRequireDefault(require("./TransactionHandler"));

var _Transaction = _interopRequireDefault(require("./Transaction"));

var _utils = 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; }

const NATIVE_EVENTS = ['firestore_transaction_event', 'firestore_document_sync_event', 'firestore_collection_sync_event'];
const LogLevels = ['debug', 'error', 'silent'];
const MODULE_NAME = 'RNFirebaseFirestore';
exports.MODULE_NAME = MODULE_NAME;
const NAMESPACE = 'firestore';
/**
 * @class Firestore
 */

exports.NAMESPACE = NAMESPACE;

class Firestore extends _ModuleBase.default {
  constructor(app) {
    super(app, {
      events: NATIVE_EVENTS,
      moduleName: MODULE_NAME,
      hasMultiAppSupport: true,
      hasCustomUrlSupport: false,
      namespace: NAMESPACE
    });

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

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

    this._referencePath = new _Path.default([]);
    this._transactionHandler = new _TransactionHandler.default(this);

    _events.SharedEventEmitter.addListener( // sub to internal native event - this fans out to
    // public event name: onCollectionSnapshot
    (0, _events.getAppEventName)(this, 'firestore_collection_sync_event'), this._onCollectionSyncEvent.bind(this));

    _events.SharedEventEmitter.addListener( // sub to internal native event - this fans out to
    // public event name: onDocumentSnapshot
    (0, _events.getAppEventName)(this, 'firestore_document_sync_event'), this._onDocumentSyncEvent.bind(this));
  }
  /**
   * -------------
   *  PUBLIC API
   * -------------
   */

  /**
   * Creates a write batch, used for performing multiple writes as a single atomic operation.
   *
   * @returns {WriteBatch}
   */


  batch() {
    return new _WriteBatch.default(this);
  }
  /**
   * Gets a CollectionReference instance that refers to the collection at the specified path.
   *
   * @param collectionPath
   * @returns {CollectionReference}
   */


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

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

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

  disableNetwork() {
    return (0, _native.getNativeModule)(this).disableNetwork();
  }
  /**
   * Gets a DocumentReference instance that refers to the document at the specified path.
   *
   * @param documentPath
   * @returns {DocumentReference}
   */


  doc(documentPath) {
    const path = this._referencePath.child(documentPath);

    if (!path.isDocument) {
      throw new Error('Argument "documentPath" must point to a document.');
    }

    return new _DocumentReference.default(this, path);
  }

  enableNetwork() {
    return (0, _native.getNativeModule)(this).enableNetwork();
  }
  /**
   * Executes the given updateFunction and then attempts to commit the
   * changes applied within the transaction. If any document read within
   * the transaction has changed, Cloud Firestore retries the updateFunction.
   *
   * If it fails to commit after 5 attempts, the transaction fails.
   *
   * @param updateFunction
   * @returns {void|Promise<any>}
   */


  runTransaction(updateFunction) {
    return this._transactionHandler._add(updateFunction);
  }

  settings(settings) {
    if (!(0, _utils.isObject)(settings)) {
      return Promise.reject(new Error('Firestore.settings failed: settings must be an object.'));
    }

    if ((0, _utils.hop)(settings, 'host') && !(0, _utils.isString)(settings.host)) {
      return Promise.reject(new Error('Firestore.settings failed: settings.host must be a string.'));
    }

    if ((0, _utils.hop)(settings, 'persistence') && !(0, _utils.isBoolean)(settings.persistence)) {
      return Promise.reject(new Error('Firestore.settings failed: settings.persistence must be boolean.'));
    }

    if ((0, _utils.hop)(settings, 'ssl') && !(0, _utils.isBoolean)(settings.ssl)) {
      return Promise.reject(new Error('Firestore.settings failed: settings.ssl must be boolean.'));
    }

    if ((0, _utils.hop)(settings, 'timestampsInSnapshots') && !(0, _utils.isBoolean)(settings.timestampsInSnapshots)) {
      return Promise.reject(new Error('Firestore.settings failed: settings.timestampsInSnapshots must be boolean.'));
    }

    return (0, _native.getNativeModule)(this).settings(settings);
  }
  /**
   * -------------
   *  UNSUPPORTED
   * -------------
   */


  enablePersistence() {
    console.warn('Due to restrictions in the native SDK, persistence must be configured in firebase.firestore().settings()');
    return Promise.resolve();
  }
  /**
   * -------------
   *   INTERNALS
   * -------------
   */

  /**
   * Internal collection sync listener
   *
   * @param event
   * @private
   */


  _onCollectionSyncEvent(event) {
    if (event.error) {
      _events.SharedEventEmitter.emit((0, _events.getAppEventName)(this, `onQuerySnapshotError:${event.listenerId}`), event.error);
    } else {
      _events.SharedEventEmitter.emit((0, _events.getAppEventName)(this, `onQuerySnapshot:${event.listenerId}`), event.querySnapshot);
    }
  }
  /**
   * Internal document sync listener
   *
   * @param event
   * @private
   */


  _onDocumentSyncEvent(event) {
    if (event.error) {
      _events.SharedEventEmitter.emit((0, _events.getAppEventName)(this, `onDocumentSnapshotError:${event.listenerId}`), event.error);
    } else {
      _events.SharedEventEmitter.emit((0, _events.getAppEventName)(this, `onDocumentSnapshot:${event.listenerId}`), event.documentSnapshot);
    }
  }

}

exports.default = Firestore;
const statics = {
  Blob: _Blob.default,
  FieldPath: _FieldPath.default,
  FieldValue: _FieldValue.default,
  GeoPoint: _GeoPoint.default,

  enableLogging(enabled) {
    // DEPRECATED: Remove method in v4.1.0
    console.warn('firebase.firestore.enableLogging is deprecated, use firebase.firestore().setLogLevel instead.');
    this.setLogLevel(enabled ? 'debug' : 'silent');
  },

  setLogLevel(logLevel) {
    if (LogLevels.indexOf(logLevel) === -1) {
      throw new Error('Argument `logLevel` must be one of: `debug`, `error`, `silent`');
    }

    if (_reactNative.NativeModules[MODULE_NAME]) {
      _reactNative.NativeModules[MODULE_NAME].setLogLevel(logLevel);
    }
  }

};
exports.statics = statics;