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

Author: XuechunHou

packages/firebase/index.d.ts

@@ -7763,7 +7763,7 @@ declare namespace firebase.firestore {
   export interface PersistenceSettings {
     /**
      * Whether to synchronize the in-memory state of multiple tabs. Setting this
-     * to 'true' in all open tabs enables shared access to local persistence,
+     * to `true` in all open tabs enables shared access to local persistence,
      * shared execution of queries and latency-compensated local document updates
      * across all connected instances.
      *
@@ -7775,14 +7775,27 @@ declare namespace firebase.firestore {
 
     /**
      * Whether to synchronize the in-memory state of multiple tabs. Setting this
-     * to 'true' in all open tabs enables shared access to local persistence,
+     * to `true` in all open tabs enables shared access to local persistence,
      * shared execution of queries and latency-compensated local document updates
      * across all connected instances.
      *
-     * @deprecated This setting is deprecated. To enabled synchronization between
+     * @deprecated This setting is deprecated. To enable synchronization between
      * multiple tabs, please use `synchronizeTabs: true` instead.
      */
     experimentalTabSynchronization?: boolean;
+
+    /**
+     * Whether to force enable persistence for the client. This cannot be used
+     * with `synchronizeTabs:true` and is primarily intended for use with Web
+     * Workers. Setting this to `true` will enable persistence, but cause other
+     * tabs using persistence to fail.
+     *
+     * This setting may be removed in a future release. If you find yourself
+     * using it for a specific use case or run into any issues, please tell us
+     * about it in
+     * https://github.com/firebase/firebase-js-sdk/issues/983.
+     */
+    experimentalForceOwningTab?: boolean;
   }
 
   export type LogLevel = 'debug' | 'error' | 'silent';

packages/firestore-types/index.d.ts

@@ -35,9 +35,16 @@ export interface Settings {
 export interface PersistenceSettings {
   synchronizeTabs?: boolean;
   experimentalTabSynchronization?: boolean;
+  experimentalForceOwningTab?: boolean;
 }
 
-export type LogLevel = 'debug' | 'error' | 'silent';
+export type LogLevel =
+  | 'debug'
+  | 'error'
+  | 'silent'
+  | 'warn'
+  | 'info'
+  | 'verbose';
 
 export function setLogLevel(logLevel: LogLevel): void;
 

packages/firestore/CHANGELOG.md

@@ -14,6 +14,9 @@
   in IndexedDB. Previously, these errors crashed the client.
 - [fixed] Fixed a source of IndexedDB-related crashes for tabs that receive 
   multi-tab notifications while the file system is locked.
+- [feature] Added an `experimentalForceOwningTab` setting that can be used to
+  enable persistence in environments without LocalStorage, which allows
+  persistence to be used in Web Workers (#983).
 
 # 1.10.2
 - [fixed] Temporarily reverted the use of window.crypto to generate document

packages/firestore/lite/index.node.ts

@@ -20,12 +20,24 @@ import { Firestore } from './src/api/database';
 import { version } from '../package.json';
 import { Component, ComponentType } from '@firebase/component';
 
+import '../src/platform_node/node_init';
+
 export {
   Firestore,
   initializeFirestore,
   getFirestore
 } from './src/api/database';
 
+// TOOD(firestorelite): Add tests when setDoc() is available
+export {
+  FieldValue,
+  deleteField,
+  increment,
+  arrayRemove,
+  arrayUnion,
+  serverTimestamp
+} from './src/api/field_value';
+
 export function registerFirestore(): void {
   _registerComponent(
     new Component(

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

@@ -0,0 +1,97 @@
+/**
+ * @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 '../../';
+
+import { validateAtLeastNumberOfArgs } from '../../../src/util/input_validation';
+import {
+  ArrayRemoveFieldValueImpl,
+  ArrayUnionFieldValueImpl,
+  DeleteFieldValueImpl,
+  NumericIncrementFieldValueImpl,
+  SerializableFieldValue,
+  ServerTimestampFieldValueImpl
+} from '../../../src/api/field_value';
+import { ParseContext } from '../../../src/api/user_data_reader';
+import { FieldTransform } from '../../../src/model/mutation';
+
+/** The public FieldValue class of the lite API. */
+export abstract class FieldValue extends SerializableFieldValue
+  implements firestore.FieldValue {}
+
+/**
+ * A delegate class that allows the FieldValue implementations returned by
+ * deleteField(), serverTimestamp(), arrayUnion(), arrayRemove() and
+ * increment() to be an instance of the lite FieldValue class declared above.
+ *
+ * We don't directly subclass `FieldValue` in the various field value
+ * implementations as the base FieldValue class differs between the lite, full
+ * and legacy SDK.
+ */
+class FieldValueDelegate extends FieldValue implements firestore.FieldValue {
+  readonly _methodName: string;
+
+  constructor(readonly _delegate: SerializableFieldValue) {
+    super();
+    this._methodName = _delegate._methodName;
+  }
+
+  _toFieldTransform(context: ParseContext): FieldTransform | null {
+    return this._delegate._toFieldTransform(context);
+  }
+
+  isEqual(other: firestore.FieldValue): boolean {
+    if (!(other instanceof FieldValueDelegate)) {
+      return false;
+    }
+    return this._delegate.isEqual(other._delegate);
+  }
+}
+
+export function deleteField(): firestore.FieldValue {
+  return new FieldValueDelegate(new DeleteFieldValueImpl('delete'));
+}
+
+export function serverTimestamp(): firestore.FieldValue {
+  return new FieldValueDelegate(
+    new ServerTimestampFieldValueImpl('serverTimestamp')
+  );
+}
+
+export function arrayUnion(...elements: unknown[]): firestore.FieldValue {
+  validateAtLeastNumberOfArgs('arrayUnion()', arguments, 1);
+  // NOTE: We don't actually parse the data until it's used in set() or
+  // update() since we'd need the Firestore instance to do this.
+  return new FieldValueDelegate(
+    new ArrayUnionFieldValueImpl('arrayUnion', elements)
+  );
+}
+
+export function arrayRemove(...elements: unknown[]): firestore.FieldValue {
+  validateAtLeastNumberOfArgs('arrayRemove()', arguments, 1);
+  // NOTE: We don't actually parse the data until it's used in set() or
+  // update() since we'd need the Firestore instance to do this.
+  return new FieldValueDelegate(
+    new ArrayRemoveFieldValueImpl('arrayRemove', elements)
+  );
+}
+
+export function increment(n: number): firestore.FieldValue {
+  return new FieldValueDelegate(
+    new NumericIncrementFieldValueImpl('increment', n)
+  );
+}

packages/firestore/lite/test/integration.test.ts

@@ -23,6 +23,8 @@ import {
   getFirestore,
   initializeFirestore
 } from '../src/api/database';
+import { expectEqual, expectNotEqual } from '../../test/util/helpers';
+import { FieldValue } from '../../src/api/field_value';
 
 describe('Firestore', () => {
   it('can provide setting', () => {
@@ -57,3 +59,21 @@ describe('Firestore', () => {
     );
   });
 });
+
+describe('FieldValue', () => {
+  it('support equality checking with isEqual()', () => {
+    expectEqual(FieldValue.delete(), FieldValue.delete());
+    expectEqual(FieldValue.serverTimestamp(), FieldValue.serverTimestamp());
+    expectNotEqual(FieldValue.delete(), FieldValue.serverTimestamp());
+    // TODO(firestorelite): Add test when field value is available
+    //expectNotEqual(FieldValue.delete(), documentId());
+  });
+
+  it('support instanceof checks', () => {
+    expect(FieldValue.delete()).to.be.an.instanceOf(FieldValue);
+    expect(FieldValue.serverTimestamp()).to.be.an.instanceOf(FieldValue);
+    expect(FieldValue.increment(1)).to.be.an.instanceOf(FieldValue);
+    expect(FieldValue.arrayUnion('a')).to.be.an.instanceOf(FieldValue);
+    expect(FieldValue.arrayRemove('a')).to.be.an.instanceOf(FieldValue);
+  });
+});

packages/firestore/src/api/database.ts

@@ -384,6 +384,7 @@ export class Firestore implements firestore.FirebaseFirestore, FirebaseService {
     }
 
     let synchronizeTabs = false;
+    let experimentalForceOwningTab = false;
 
     if (settings) {
       if (settings.experimentalTabSynchronization !== undefined) {
@@ -395,12 +396,24 @@ export class Firestore implements firestore.FirebaseFirestore, FirebaseService {
         settings.synchronizeTabs ??
         settings.experimentalTabSynchronization ??
         DEFAULT_SYNCHRONIZE_TABS;
+
+      experimentalForceOwningTab = settings.experimentalForceOwningTab
+        ? settings.experimentalForceOwningTab
+        : false;
+
+      if (synchronizeTabs && experimentalForceOwningTab) {
+        throw new FirestoreError(
+          Code.INVALID_ARGUMENT,
+          "The 'experimentalForceOwningTab' setting cannot be used with 'synchronizeTabs'."
+        );
+      }
     }
 
     return this.configureClient(this._componentProvider, {
       durable: true,
       cacheSizeBytes: this._settings.cacheSizeBytes,
-      synchronizeTabs
+      synchronizeTabs,
+      forceOwningTab: experimentalForceOwningTab
     });
   }
 
@@ -620,8 +633,16 @@ export class Firestore implements firestore.FirebaseFirestore, FirebaseService {
     switch (getLogLevel()) {
       case LogLevel.DEBUG:
         return 'debug';
+      case LogLevel.ERROR:
+        return 'error';
       case LogLevel.SILENT:
         return 'silent';
+      case LogLevel.WARN:
+        return 'warn';
+      case LogLevel.INFO:
+        return 'info';
+      case LogLevel.VERBOSE:
+        return 'verbose';
       default:
         // The default log level is error
         return 'error';
@@ -630,23 +651,13 @@ export class Firestore implements firestore.FirebaseFirestore, FirebaseService {
 
   static setLogLevel(level: firestore.LogLevel): void {
     validateExactNumberOfArgs('Firestore.setLogLevel', arguments, 1);
-    validateArgType('Firestore.setLogLevel', 'non-empty string', 1, level);
-    switch (level) {
-      case 'debug':
-        setLogLevel(LogLevel.DEBUG);
-        break;
-      case 'error':
-        setLogLevel(LogLevel.ERROR);
-        break;
-      case 'silent':
-        setLogLevel(LogLevel.SILENT);
-        break;
-      default:
-        throw new FirestoreError(
-          Code.INVALID_ARGUMENT,
-          'Invalid log level: ' + level
-        );
-    }
+    validateStringEnum(
+      'setLogLevel',
+      ['debug', 'error', 'silent', 'warn', 'info', 'verbose'],
+      1,
+      level
+    );
+    setLogLevel(level);
   }
 
   // Note: this is not a property because the minifier can't work correctly with