Provide CRUD methods for IndexManager

Author: schmidt-sebastian

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,45 @@ 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();
 
+  constructor(private readonly user: User) {}
+
   /**
    * Adds a new entry to the collection parent index.
    *
@@ -114,16 +134,40 @@ export class IndexedDbIndexManager implements IndexManager {
     transaction: PersistenceTransaction,
     index: FieldIndex
   ): PersistencePromise<void> {
-    // TODO(indexing): Implement
-    return PersistencePromise.resolve();
+    const indexes = indexConfigurationStore(transaction);
+    const dbIndex = toDbIndexConfiguration(index);
+    return indexes.put(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, '', new Uint8Array(), new Uint8Array(), ''],
+            [index.indexId + 1, '', new Uint8Array(), new Uint8Array(), ''],
+            /*lowerOpen=*/ false,
+            /*upperOpen=*/ true
+          )
+        )
+      );
   }
 
   getDocumentsMatchingTarget(
@@ -147,24 +191,87 @@ 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(indexEntries => {
+      const result: FieldIndex[] = [];
+      return PersistencePromise.forEach(
+        indexEntries,
+        (indexEntry: DbIndexConfiguration) => {
+          return states
+            .get([indexEntry.indexId!, this.user.uid || ''])
+            .next(indexState => {
+              result.push(fromDbIndexConfiguration(indexEntry, indexState!));
+            });
+        }
+      ).next(() => result);
+    });
   }
 
   getNextCollectionGroupToUpdate(
     transaction: PersistenceTransaction
   ): PersistencePromise<string | null> {
-    // TODO(indexing): Implement
-    return PersistencePromise.resolve<string | null>(null);
+    let nextIndexId: number | null = null;
+
+    const indexes = indexConfigurationStore(transaction);
+    const states = indexStateStore(transaction);
+    return states
+      .iterate(
+        {
+          index: DbIndexState.sequenceNumberIndex,
+          range: IDBKeyRange.upperBound([
+            this.user.uid || '',
+            Number.MAX_SAFE_INTEGER
+          ])
+        },
+        (_, state, controller) => {
+          controller.done();
+          nextIndexId = state.indexId;
+        }
+      )
+      .next(() =>
+        nextIndexId == null
+          ? PersistencePromise.resolve<string | null>(null)
+          : indexes
+              .get(nextIndexId)
+              .next(v => v!.collectionGroup as string | null)
+      );
   }
 
   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 +281,29 @@ 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.user.uid || '',
+            Number.MAX_SAFE_INTEGER
+          ])
+        },
+        (_, state, controller) => {
+          controller.done();
+          nextSequenceNumber = state.sequenceNumber + 1;
+        }
+      )
+      .next(() => nextSequenceNumber);
+  }
 }
 
 /**
@@ -188,3 +318,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);
+}

packages/firestore/src/local/indexeddb_schema.ts

@@ -708,13 +708,20 @@ export class DbIndexConfiguration {
 
   static keyPath = 'indexId';
 
+  static collectionGroupIndex = 'collectionGroupIndex';
+
+  static collectionGroupIndexPath = ['collectionGroup'];
+
   constructor(
-    /** The index id for this entry. */
-    public indexId: number,
+    /**
+     * The index id for this entry. Undefined for indexes that are not yet
+     * persisted.
+     */
+    public indexId: number | undefined,
     /** The collection group this index belongs to. */
     public collectionGroup: string,
     /** The fields to index for this index. */
-    public fields: [[name: string, kind: IndexKind]]
+    public fields: Array<[name: string, kind: IndexKind]>
   ) {}
 }
 
@@ -731,6 +738,16 @@ export class DbIndexState {
 
   static keyPath = ['indexId', 'uid'];
 
+  /**
+   * An index that provides access to documents in a collection sorted by last
+   * update time. Used by the backfiller.
+   *
+   * PORTING NOTE: iOS and Android maintain this index in-memory.
+   */
+  static sequenceNumberIndex = 'sequenceNumberIndex';
+
+  static sequenceNumberIndexPath = ['uid', 'sequenceNumber'];
+
   constructor(
     /** The index id for this entry. */
     public indexId: number,
@@ -767,7 +784,7 @@ export class DbIndexState {
 export type DbIndexEntryKey = [number, string, Uint8Array, Uint8Array, string];
 
 /** An object that stores the encoded entries for all documents and fields. */
-export class DbIndexEntries {
+export class DbIndexEntry {
   /** Name of the IndexedDb object store. */
   static store = 'indexEntries';
 
@@ -831,7 +848,7 @@ export const V12_STORES = [
   ...V11_STORES,
   DbIndexConfiguration.store,
   DbIndexState.store,
-  DbIndexEntries.store
+  DbIndexEntry.store
 ];
 
 /**

packages/firestore/src/local/indexeddb_schema_converter.ts

@@ -36,7 +36,7 @@ import {
   DbDocumentMutation,
   DbDocumentMutationKey,
   DbIndexConfiguration,
-  DbIndexEntries,
+  DbIndexEntry,
   DbIndexState,
   DbMutationBatch,
   DbMutationBatchKey,
@@ -175,7 +175,7 @@ export class SchemaConverter implements SimpleDbSchemaConverter {
 
     if (fromVersion < 12 && toVersion >= 12) {
       p = p.next(() => {
-        createFieldIndex(db);
+        createFieldIndex(db, txn);
       });
     }
 
@@ -515,14 +515,30 @@ function createNamedQueriesStore(db: IDBDatabase): void {
   });
 }
 
-function createFieldIndex(db: IDBDatabase): void {
-  db.createObjectStore(DbIndexConfiguration.store, {
-    keyPath: DbIndexConfiguration.keyPath
-  });
-  db.createObjectStore(DbIndexState.store, {
+function createFieldIndex(db: IDBDatabase, txn: IDBTransaction): void {
+  const indexConfigurationStore = db.createObjectStore(
+    DbIndexConfiguration.store,
+    {
+      keyPath: DbIndexConfiguration.keyPath,
+      autoIncrement: true
+    }
+  );
+  indexConfigurationStore.createIndex(
+    DbIndexConfiguration.collectionGroupIndex,
+    DbIndexConfiguration.collectionGroupIndexPath,
+    { unique: false }
+  );
+
+  const indexStateStore = db.createObjectStore(DbIndexState.store, {
     keyPath: DbIndexState.keyPath
   });
-  db.createObjectStore(DbIndexEntries.store, {
-    keyPath: DbIndexEntries.keyPath
+  indexStateStore.createIndex(
+    DbIndexState.sequenceNumberIndex,
+    DbIndexState.sequenceNumberIndexPath,
+    { unique: false }
+  );
+
+  db.createObjectStore(DbIndexEntry.store, {
+    keyPath: DbIndexEntry.keyPath
   });
 }