Merge

Author: schmidt-sebastian

.changeset/green-parents-compare.md

@@ -0,0 +1,5 @@
+---
+"@firebase/firestore": patch
+---
+
+On browsers that support IndexedDB V3, we now invoke `transaction.commit()` to speed up data processing.

.changeset/lemon-ravens-sneeze.md

@@ -0,0 +1,5 @@
+---
+"@firebase/firestore": patch
+---
+
+Queries are now send to the backend before the SDK starts local processing, which reduces overall Query latency.

packages/firestore-compat/tools/console.build.js

@@ -57,19 +57,15 @@ const es5OutputOptions = {
   format: 'iife'
 };
 
-const PREFIX = `
-goog.module('firestore');
-exports = eval(`;
-
-const POSTFIX = ` + '${EXPORTNAME};');`;
+const POSTFIX = `window['${EXPORTNAME}']=${EXPORTNAME};`;
 
 async function build() {
   const es5Bundle = await rollup.rollup(es5InputOptions);
   const {
     output: [{ code }]
   } = await es5Bundle.generate(es5OutputOptions);
 
-  const output = `${PREFIX}${JSON.stringify(String(code))}${POSTFIX}`;
+  const output = `${String(code)}${POSTFIX}`;
 
   if (!fs.existsSync(OUTPUT_FOLDER)) {
     fs.mkdirSync(OUTPUT_FOLDER);

packages/firestore/src/core/sync_engine_impl.ts

@@ -314,6 +314,9 @@ export async function syncEngineListen(
       syncEngineImpl.localStore,
       queryToTarget(query)
     );
+    if (syncEngineImpl.isPrimaryClient) {
+      remoteStoreListen(syncEngineImpl.remoteStore, targetData);
+    }
 
     const status = syncEngineImpl.sharedClientState.addLocalQueryTarget(
       targetData.targetId
@@ -325,9 +328,6 @@ export async function syncEngineListen(
       targetId,
       status === 'current'
     );
-    if (syncEngineImpl.isPrimaryClient) {
-      remoteStoreListen(syncEngineImpl.remoteStore, targetData);
-    }
   }
 
   return viewSnapshot;

packages/firestore/src/local/indexeddb_index_manager.ts

@@ -15,6 +15,7 @@
  * limitations under the License.
  */
 
+import { User } from '../auth/user';
 import { Target } from '../core/target';
 import {
   documentKeySet,
@@ -31,26 +32,49 @@ import {
   encodeResourcePath
 } from './encoded_resource_path';
 import { IndexManager } from './index_manager';
-import { DbCollectionParent, DbCollectionParentKey } from './indexeddb_schema';
+import {
+  DbCollectionParent,
+  DbCollectionParentKey,
+  DbIndexConfiguration,
+  DbIndexConfigurationKey,
+  DbIndexEntry,
+  DbIndexEntryKey,
+  DbIndexState,
+  DbIndexStateKey
+} from './indexeddb_schema';
 import { getStore } from './indexeddb_transaction';
+import {
+  fromDbIndexConfiguration,
+  toDbIndexConfiguration,
+  toDbIndexState
+} from './local_serializer';
 import { MemoryCollectionParentIndex } from './memory_index_manager';
 import { PersistencePromise } from './persistence_promise';
 import { PersistenceTransaction } from './persistence_transaction';
 import { SimpleDbStore } from './simple_db';
 
 /**
  * A persisted implementation of IndexManager.
+ *
+ * PORTING NOTE: Unlike iOS and Android, the Web SDK does not memoize index
+ * data as it supports multi-tab access.
  */
 export class IndexedDbIndexManager implements IndexManager {
   /**
    * An in-memory copy of the index entries we've already written since the SDK
    * launched. Used to avoid re-writing the same entry repeatedly.
    *
-   * This is *NOT* a complete cache of what's in persistence and so can never be used to
-   * satisfy reads.
+   * This is *NOT* a complete cache of what's in persistence and so can never be
+   * used to satisfy reads.
    */
   private collectionParentsCache = new MemoryCollectionParentIndex();
 
+  private uid: string;
+
+  constructor(private user: User) {
+    this.uid = user.uid || '';
+  }
+
   /**
    * Adds a new entry to the collection parent index.
    *
@@ -114,16 +138,43 @@ export class IndexedDbIndexManager implements IndexManager {
     transaction: PersistenceTransaction,
     index: FieldIndex
   ): PersistencePromise<void> {
-    // TODO(indexing): Implement
-    return PersistencePromise.resolve();
+    // TODO(indexing): Verify that the auto-incrementing index ID works in
+    // Safari & Firefox.
+    const indexes = indexConfigurationStore(transaction);
+    const dbIndex = toDbIndexConfiguration(index);
+    delete dbIndex.indexId; // `indexId` is auto-populated by IndexedDb
+    return indexes.add(dbIndex).next();
   }
 
   deleteFieldIndex(
     transaction: PersistenceTransaction,
     index: FieldIndex
   ): PersistencePromise<void> {
-    // TODO(indexing): Implement
-    return PersistencePromise.resolve();
+    const indexes = indexConfigurationStore(transaction);
+    const states = indexStateStore(transaction);
+    const entries = indexEntriesStore(transaction);
+    return indexes
+      .delete(index.indexId)
+      .next(() =>
+        states.delete(
+          IDBKeyRange.bound(
+            [index.indexId],
+            [index.indexId + 1],
+            /*lowerOpen=*/ false,
+            /*upperOpen=*/ true
+          )
+        )
+      )
+      .next(() =>
+        entries.delete(
+          IDBKeyRange.bound(
+            [index.indexId],
+            [index.indexId + 1],
+            /*lowerOpen=*/ false,
+            /*upperOpen=*/ true
+          )
+        )
+      );
   }
 
   getDocumentsMatchingTarget(
@@ -147,24 +198,71 @@ export class IndexedDbIndexManager implements IndexManager {
     transaction: PersistenceTransaction,
     collectionGroup?: string
   ): PersistencePromise<FieldIndex[]> {
-    // TODO(indexing): Implement
-    return PersistencePromise.resolve<FieldIndex[]>([]);
+    const indexes = indexConfigurationStore(transaction);
+    const states = indexStateStore(transaction);
+
+    return (
+      collectionGroup
+        ? indexes.loadAll(
+            DbIndexConfiguration.collectionGroupIndex,
+            IDBKeyRange.bound(collectionGroup, collectionGroup)
+          )
+        : indexes.loadAll()
+    ).next(indexConfigs => {
+      const result: FieldIndex[] = [];
+      return PersistencePromise.forEach(
+        indexConfigs,
+        (indexConfig: DbIndexConfiguration) => {
+          return states
+            .get([indexConfig.indexId!, this.uid])
+            .next(indexState => {
+              result.push(fromDbIndexConfiguration(indexConfig, indexState));
+            });
+        }
+      ).next(() => result);
+    });
   }
 
   getNextCollectionGroupToUpdate(
     transaction: PersistenceTransaction
   ): PersistencePromise<string | null> {
-    // TODO(indexing): Implement
-    return PersistencePromise.resolve<string | null>(null);
+    return this.getFieldIndexes(transaction).next(indexes => {
+      if (indexes.length === 0) {
+        return null;
+      }
+      indexes.sort(
+        (l, r) => l.indexState.sequenceNumber - r.indexState.sequenceNumber
+      );
+      return indexes[0].collectionGroup;
+    });
   }
 
   updateCollectionGroup(
     transaction: PersistenceTransaction,
     collectionGroup: string,
     offset: IndexOffset
   ): PersistencePromise<void> {
-    // TODO(indexing): Implement
-    return PersistencePromise.resolve();
+    const indexes = indexConfigurationStore(transaction);
+    const states = indexStateStore(transaction);
+    return this.getNextSequenceNumber(transaction).next(nextSequenceNumber =>
+      indexes
+        .loadAll(
+          DbIndexConfiguration.collectionGroupIndex,
+          IDBKeyRange.bound(collectionGroup, collectionGroup)
+        )
+        .next(configs =>
+          PersistencePromise.forEach(configs, (config: DbIndexConfiguration) =>
+            states.put(
+              toDbIndexState(
+                config.indexId!,
+                this.user,
+                nextSequenceNumber,
+                offset
+              )
+            )
+          )
+        )
+    );
   }
 
   updateIndexEntries(
@@ -174,6 +272,26 @@ export class IndexedDbIndexManager implements IndexManager {
     // TODO(indexing): Implement
     return PersistencePromise.resolve();
   }
+
+  private getNextSequenceNumber(
+    transaction: PersistenceTransaction
+  ): PersistencePromise<number> {
+    let nextSequenceNumber = 1;
+    const states = indexStateStore(transaction);
+    return states
+      .iterate(
+        {
+          index: DbIndexState.sequenceNumberIndex,
+          reverse: true,
+          range: IDBKeyRange.upperBound([this.uid, Number.MAX_SAFE_INTEGER])
+        },
+        (_, state, controller) => {
+          controller.done();
+          nextSequenceNumber = state.sequenceNumber + 1;
+        }
+      )
+      .next(() => nextSequenceNumber);
+  }
 }
 
 /**
@@ -188,3 +306,33 @@ function collectionParentsStore(
     DbCollectionParent.store
   );
 }
+
+/**
+ * Helper to get a typed SimpleDbStore for the index entry object store.
+ */
+function indexEntriesStore(
+  txn: PersistenceTransaction
+): SimpleDbStore<DbIndexEntryKey, DbIndexEntry> {
+  return getStore<DbIndexEntryKey, DbIndexEntry>(txn, DbIndexEntry.store);
+}
+
+/**
+ * Helper to get a typed SimpleDbStore for the index configuration object store.
+ */
+function indexConfigurationStore(
+  txn: PersistenceTransaction
+): SimpleDbStore<DbIndexConfigurationKey, DbIndexConfiguration> {
+  return getStore<DbIndexConfigurationKey, DbIndexConfiguration>(
+    txn,
+    DbIndexConfiguration.store
+  );
+}
+
+/**
+ * Helper to get a typed SimpleDbStore for the index state object store.
+ */
+function indexStateStore(
+  txn: PersistenceTransaction
+): SimpleDbStore<DbIndexStateKey, DbIndexState> {
+  return getStore<DbIndexStateKey, DbIndexState>(txn, DbIndexState.store);
+}