Merge branch 'master' of https://github.com/firebase/firebase-js-sdk into api

sync head

Author: zwu52

.changeset/config.json

@@ -3,7 +3,7 @@
   "changelog": ["@changesets/changelog-github", { "repo": "firebase/firebase-js-sdk"}],
   "commit": false,
   "linked": [],
-  "access": "restricted",
+  "access": "public",
   "baseBranch": "master",
   "updateInternalDependencies": "patch",
   "ignore": [

.changeset/gorgeous-beers-build.md

@@ -0,0 +1,2 @@
+---
+---

.changeset/nasty-pigs-invite.md

@@ -0,0 +1,6 @@
+---
+"@firebase/functions": patch
+"firebase": patch
+---
+
+Clear timeout after a successful response or after the request is canceled. Fixes [issue 3289](https://github.com/firebase/firebase-js-sdk/issues/3289).

.changeset/perfect-terms-press.md

@@ -0,0 +1,3 @@
+---
+
+---

.changeset/strong-geckos-peel.md

@@ -0,0 +1,2 @@
+---
+---

.changeset/thick-rabbits-guess.md

@@ -0,0 +1,8 @@
+---
+"firebase": patch
+"@firebase/firestore": patch
+---
+
+[fixed] Removed a delay that may have prevented Firestore from immediately
+reestablishing a network connection if a connectivity change occurred while
+the app was in the background.

config/functions/package.json

@@ -8,6 +8,6 @@
   },
   "private": true,
   "engines": {
-    "node": "8"
+    "node": "10"
   }
 }

packages/firestore/exp/index.node.ts

@@ -54,7 +54,7 @@ export {
   parent
 } from '../lite/src/api/reference';
 
-export { runTransaction, Transaction } from '../lite/src/api/transaction';
+export { runTransaction, Transaction } from './src/api/transaction';
 
 export {
   getDoc,

packages/firestore/exp/src/api/database.ts

@@ -33,11 +33,18 @@ import {
   MemoryComponentProvider
 } from '../../../src/core/component_provider';
 
-import { Firestore as LiteFirestore } from '../../../lite/src/api/database';
+import {
+  DEFAULT_FORCE_LONG_POLLING,
+  DEFAULT_HOST,
+  DEFAULT_SSL,
+  Firestore as LiteFirestore
+} from '../../../lite/src/api/database';
 import { cast } from '../../../lite/src/api/util';
 import { Code, FirestoreError } from '../../../src/util/error';
 import { Deferred } from '../../../src/util/promise';
 import { LruParams } from '../../../src/local/lru_garbage_collector';
+import { CACHE_SIZE_UNLIMITED } from '../../../src/api/database';
+import { DatabaseInfo } from '../../../src/core/database_info';
 
 /**
  * The root reference to the Firestore database and the entry point for the
@@ -46,25 +53,27 @@ import { LruParams } from '../../../src/local/lru_garbage_collector';
 export class Firestore extends LiteFirestore
   implements firestore.FirebaseFirestore, _FirebaseService {
   private readonly _queue = new AsyncQueue();
+  private readonly _firestoreClient: FirestoreClient;
   private readonly _persistenceKey: string;
   private _componentProvider: ComponentProvider = new MemoryComponentProvider();
 
   // Assigned via _getFirestoreClient()
-  private _firestoreClientPromise?: Promise<FirestoreClient>;
+  private _deferredInitialization?: Promise<void>;
 
   protected _persistenceSettings: PersistenceSettings = { durable: false };
   // We override the Settings property of the Lite SDK since the full Firestore
   // SDK supports more settings.
   protected _settings?: firestore.Settings;
 
-  _terminated: boolean = false;
+  private _terminated: boolean = false;
 
   constructor(
     app: FirebaseApp,
     authProvider: Provider<FirebaseAuthInternalName>
   ) {
     super(app, authProvider);
     this._persistenceKey = app.name;
+    this._firestoreClient = new FirestoreClient(this._credentials, this._queue);
   }
 
   _getSettings(): firestore.Settings {
@@ -75,26 +84,29 @@ export class Firestore extends LiteFirestore
   }
 
   _getFirestoreClient(): Promise<FirestoreClient> {
-    if (!this._firestoreClientPromise) {
+    if (this._terminated) {
+      throw new FirestoreError(
+        Code.FAILED_PRECONDITION,
+        'The client has already been terminated.'
+      );
+    }
+
+    if (!this._deferredInitialization) {
       const settings = this._getSettings();
       const databaseInfo = this._makeDatabaseInfo(
         settings.host,
         settings.ssl,
         settings.experimentalForceLongPolling
       );
 
-      const firestoreClient = new FirestoreClient(
+      this._deferredInitialization = this._firestoreClient.start(
         databaseInfo,
-        this._credentials,
-        this._queue
+        this._componentProvider,
+        this._persistenceSettings
       );
-
-      this._firestoreClientPromise = firestoreClient
-        .start(this._componentProvider, this._persistenceSettings)
-        .then(() => firestoreClient);
     }
 
-    return this._firestoreClientPromise;
+    return this._deferredInitialization.then(() => this._firestoreClient);
   }
 
   // TODO(firestorexp): Factor out MultiTabComponentProvider and remove
@@ -103,11 +115,11 @@ export class Firestore extends LiteFirestore
     persistenceProvider: ComponentProvider,
     synchronizeTabs: boolean
   ): Promise<void> {
-    if (this._firestoreClientPromise) {
+    if (this._deferredInitialization) {
       throw new FirestoreError(
         Code.FAILED_PRECONDITION,
         'Firestore has already been started and persistence can no longer ' +
-          'be enabled. You can only call enable persistence before calling ' +
+          'be enabled. You can only enable persistence before calling ' +
           'any other methods on a Firestore object.'
       );
     }
@@ -131,10 +143,10 @@ export class Firestore extends LiteFirestore
   }
 
   _clearPersistence(): Promise<void> {
-    if (this._firestoreClientPromise !== undefined && !this._terminated) {
+    if (this._deferredInitialization !== undefined && !this._terminated) {
       throw new FirestoreError(
         Code.FAILED_PRECONDITION,
-        'Persistence can only be cleared before the Firestore instance is ' +
+        'Persistence can only be cleared before a Firestore instance is ' +
           'initialized or after it is terminated.'
       );
     }
@@ -156,6 +168,30 @@ export class Firestore extends LiteFirestore
     });
     return deferred.promise;
   }
+
+  protected _makeDatabaseInfo(
+    host?: string,
+    ssl?: boolean,
+    forceLongPolling?: boolean
+  ): DatabaseInfo {
+    return new DatabaseInfo(
+      this._databaseId,
+      this._persistenceKey,
+      host ?? DEFAULT_HOST,
+      ssl ?? DEFAULT_SSL,
+      forceLongPolling ?? DEFAULT_FORCE_LONG_POLLING
+    );
+  }
+
+  _terminate(): Promise<void> {
+    this._terminated = true;
+    if (this._deferredInitialization) {
+      return this._deferredInitialization.then(() =>
+        this._firestoreClient.terminate()
+      );
+    }
+    return Promise.resolve();
+  }
 }
 
 export function initializeFirestore(
@@ -166,6 +202,18 @@ export function initializeFirestore(
     app,
     'firestore-exp'
   ).getImmediate() as Firestore;
+
+  if (
+    settings.cacheSizeBytes !== undefined &&
+    settings.cacheSizeBytes !== CACHE_SIZE_UNLIMITED &&
+    settings.cacheSizeBytes < LruParams.MINIMUM_CACHE_SIZE_BYTES
+  ) {
+    throw new FirestoreError(
+      Code.INVALID_ARGUMENT,
+      `cacheSizeBytes must be at least ${LruParams.MINIMUM_CACHE_SIZE_BYTES}`
+    );
+  }
+
   firestore._configureClient(settings);
   return firestore;
 }
@@ -233,8 +281,5 @@ export function terminate(
 ): Promise<void> {
   _removeServiceInstance(firestore.app, 'firestore/lite');
   const firestoreImpl = cast(firestore, Firestore);
-  firestoreImpl._terminated = true;
-  return firestoreImpl
-    ._getFirestoreClient()
-    .then(firestoreClient => firestoreClient.terminate());
+  return firestoreImpl._terminate();
 }

packages/firestore/exp/src/api/reference.ts

@@ -50,7 +50,7 @@ import {
 } from '../../../lite/src/api/reference';
 import { Document } from '../../../src/model/document';
 import { DeleteMutation, Precondition } from '../../../src/model/mutation';
-import { FieldPath } from '../../../src/api/field_path';
+import { FieldPath } from '../../../lite/src/api/field_path';
 import {
   CompleteFn,
   ErrorFn,
@@ -262,7 +262,7 @@ export function addDoc<T>(
   data: T
 ): Promise<firestore.DocumentReference<T>> {
   const collRef = cast<CollectionReference<T>>(reference, CollectionReference);
-  const firestore = cast(collRef, Firestore);
+  const firestore = cast(collRef.firestore, Firestore);
   const docRef = doc(collRef);
 
   const convertedValue = applyFirestoreDataConverter(collRef._converter, data);
@@ -404,7 +404,7 @@ export function onSnapshot<T>(
       );
   } else {
     const query = cast<Query<T>>(ref, Query);
-    const firestore = cast(query, Firestore);
+    const firestore = cast(query.firestore, Firestore);
 
     const observer: PartialObserver<ViewSnapshot> = {
       next: snapshot => {

packages/firestore/exp/src/api/snapshot.ts

@@ -76,7 +76,7 @@ export class DocumentSnapshot<T = firestore.DocumentData>
         this.metadata,
         /* converter= */ null
       );
-      return this._converter.fromFirestore(snapshot);
+      return this._converter.fromFirestore(snapshot, options);
     } else {
       const userDataWriter = new UserDataWriter(
         this._firestoreImpl._databaseId,

packages/firestore/exp/src/api/transaction.ts

@@ -0,0 +1,81 @@
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import * as firestore from '../../index';
+
+import { Transaction as LiteTransaction } from '../../../lite/src/api/transaction';
+import { DocumentSnapshot } from './snapshot';
+import { TransactionRunner } from '../../../src/core/transaction_runner';
+import { AsyncQueue } from '../../../src/util/async_queue';
+import { cast } from '../../../lite/src/api/util';
+import { Firestore } from './database';
+import { Deferred } from '../../../src/util/promise';
+import { SnapshotMetadata } from '../../../src/api/database';
+import { Transaction as InternalTransaction } from '../../../src/core/transaction';
+import { validateReference } from '../../../lite/src/api/write_batch';
+
+export class Transaction extends LiteTransaction
+  implements firestore.Transaction {
+  // This class implements the same logic as the Transaction API in the Lite SDK
+  // but is subclassed in order to return its own DocumentSnapshot types.
+
+  constructor(
+    protected readonly _firestore: Firestore,
+    _transaction: InternalTransaction
+  ) {
+    super(_firestore, _transaction);
+  }
+
+  get<T>(
+    documentRef: firestore.DocumentReference<T>
+  ): Promise<DocumentSnapshot<T>> {
+    const ref = validateReference<T>(documentRef, this._firestore);
+    return super
+      .get(documentRef)
+      .then(
+        liteDocumentSnapshot =>
+          new DocumentSnapshot(
+            this._firestore,
+            ref._key,
+            liteDocumentSnapshot._document,
+            new SnapshotMetadata(
+              /* hasPendingWrites= */ false,
+              /* fromCache= */ false
+            ),
+            ref._converter
+          )
+      );
+  }
+}
+
+export function runTransaction<T>(
+  firestore: firestore.FirebaseFirestore,
+  updateFunction: (transaction: firestore.Transaction) => Promise<T>
+): Promise<T> {
+  const firestoreClient = cast(firestore, Firestore);
+  return firestoreClient._getDatastore().then(async datastore => {
+    const deferred = new Deferred<T>();
+    new TransactionRunner<T>(
+      new AsyncQueue(),
+      datastore,
+      internalTransaction =>
+        updateFunction(new Transaction(firestoreClient, internalTransaction)),
+      deferred
+    ).run();
+    return deferred.promise;
+  });
+}

packages/firestore/lite/src/api/database.ts

@@ -39,9 +39,9 @@ import { cast } from './util';
 import { Settings } from '../../';
 
 // settings() defaults:
-const DEFAULT_HOST = 'firestore.googleapis.com';
-const DEFAULT_SSL = true;
-const DEFAULT_FORCE_LONG_POLLING = false; // Used by full SDK
+export const DEFAULT_HOST = 'firestore.googleapis.com';
+export const DEFAULT_SSL = true;
+export const DEFAULT_FORCE_LONG_POLLING = false; // Used by full SDK
 
 /**
  * The root reference to the Firestore Lite database.
@@ -101,17 +101,13 @@ export class Firestore
     return this._datastorePromise;
   }
 
-  protected _makeDatabaseInfo(
-    host?: string,
-    ssl?: boolean,
-    forceLongPolling?: boolean
-  ): DatabaseInfo {
+  protected _makeDatabaseInfo(host?: string, ssl?: boolean): DatabaseInfo {
     return new DatabaseInfo(
       this._databaseId,
       /* persistenceKey= */ 'unsupported',
       host ?? DEFAULT_HOST,
       ssl ?? DEFAULT_SSL,
-      forceLongPolling ?? DEFAULT_FORCE_LONG_POLLING
+      DEFAULT_FORCE_LONG_POLLING
     );
   }
 

packages/firestore/lite/src/api/field_value.ts

@@ -63,7 +63,7 @@ class FieldValueDelegate extends FieldValue implements firestore.FieldValue {
 }
 
 export function deleteField(): firestore.FieldValue {
-  return new FieldValueDelegate(new DeleteFieldValueImpl('delete'));
+  return new FieldValueDelegate(new DeleteFieldValueImpl('deleteField'));
 }
 
 export function serverTimestamp(): firestore.FieldValue {

packages/firestore/lite/src/api/reference.ts

@@ -291,7 +291,7 @@ export function collection(
   parent: firestore.FirebaseFirestore | firestore.DocumentReference<unknown>,
   relativePath: string
 ): CollectionReference<firestore.DocumentData> {
-  validateArgType('doc', 'non-empty string', 2, relativePath);
+  validateArgType('collection', 'non-empty string', 2, relativePath);
   const path = ResourcePath.fromString(relativePath);
   if (parent instanceof Firestore) {
     validateCollectionPath(path);