Firestore: deleteAllPersistentCacheIndexes() added, but hidden for now (#7587)

Author: dconeybe

.changeset/healthy-peas-heal.md

@@ -0,0 +1,6 @@
+---
+'@firebase/firestore': patch
+'firebase': patch
+---
+
+Implemented internal logic to delete all client-side indexes

packages/firestore/src/api.ts

@@ -205,6 +205,7 @@ export {
 export {
   PersistentCacheIndexManager,
   getPersistentCacheIndexManager,
+  deleteAllPersistentCacheIndexes,
   enablePersistentCacheIndexAutoCreation,
   disablePersistentCacheIndexAutoCreation
 } from './api/persistent_cache_index_manager';

packages/firestore/src/api/persistent_cache_index_manager.ts

@@ -16,6 +16,7 @@
  */
 
 import {
+  firestoreClientDeleteAllFieldIndexes,
   firestoreClientSetPersistentCacheIndexAutoCreationEnabled,
   FirestoreClient
 } from '../core/firestore_client';
@@ -99,6 +100,29 @@ export function disablePersistentCacheIndexAutoCreation(
   setPersistentCacheIndexAutoCreationEnabled(indexManager, false);
 }
 
+/**
+ * Removes all persistent cache indexes.
+ *
+ * Please note this function will also deletes indexes generated by
+ * `setIndexConfiguration()`, which is deprecated.
+ *
+ * TODO(CSI) Remove @internal to make the API publicly available.
+ * @internal
+ */
+export function deleteAllPersistentCacheIndexes(
+  indexManager: PersistentCacheIndexManager
+): void {
+  indexManager._client.verifyNotTerminated();
+
+  const promise = firestoreClientDeleteAllFieldIndexes(indexManager._client);
+
+  promise
+    .then(_ => logDebug('deleting all persistent cache indexes succeeded'))
+    .catch(error =>
+      logWarn('deleting all persistent cache indexes failed', error)
+    );
+}
+
 function setPersistentCacheIndexAutoCreationEnabled(
   indexManager: PersistentCacheIndexManager,
   isEnabled: boolean

packages/firestore/src/core/firestore_client.ts

@@ -26,6 +26,7 @@ import { User } from '../auth/user';
 import { LocalStore } from '../local/local_store';
 import {
   localStoreConfigureFieldIndexes,
+  localStoreDeleteAllFieldIndexes,
   localStoreExecuteQuery,
   localStoreGetNamedQuery,
   localStoreHandleUserChange,
@@ -841,3 +842,11 @@ export function firestoreClientSetPersistentCacheIndexAutoCreationEnabled(
     );
   });
 }
+
+export function firestoreClientDeleteAllFieldIndexes(
+  client: FirestoreClient
+): Promise<void> {
+  return client.asyncQueue.enqueue(async () => {
+    return localStoreDeleteAllFieldIndexes(await getLocalStore(client));
+  });
+}

packages/firestore/src/local/index_manager.ts

@@ -105,6 +105,11 @@ export interface IndexManager {
     index: FieldIndex
   ): PersistencePromise<void>;
 
+  /** Removes all field indexes and deletes all index values. */
+  deleteAllFieldIndexes(
+    transaction: PersistenceTransaction
+  ): PersistencePromise<void>;
+
   /** Creates a full matched field index which serves the given target. */
   createTargetIndexes(
     transaction: PersistenceTransaction,

packages/firestore/src/local/indexeddb_index_manager.ts

@@ -252,6 +252,19 @@ export class IndexedDbIndexManager implements IndexManager {
       );
   }
 
+  deleteAllFieldIndexes(
+    transaction: PersistenceTransaction
+  ): PersistencePromise<void> {
+    const indexes = indexConfigurationStore(transaction);
+    const entries = indexEntriesStore(transaction);
+    const states = indexStateStore(transaction);
+
+    return indexes
+      .deleteAll()
+      .next(() => entries.deleteAll())
+      .next(() => states.deleteAll());
+  }
+
   createTargetIndexes(
     transaction: PersistenceTransaction,
     target: Target

packages/firestore/src/local/local_store_impl.ts

@@ -1535,6 +1535,18 @@ export function localStoreSetIndexAutoCreationEnabled(
   localStoreImpl.queryEngine.indexAutoCreationEnabled = isEnabled;
 }
 
+export function localStoreDeleteAllFieldIndexes(
+  localStore: LocalStore
+): Promise<void> {
+  const localStoreImpl = debugCast(localStore, LocalStoreImpl);
+  const indexManager = localStoreImpl.indexManager;
+  return localStoreImpl.persistence.runTransaction(
+    'Delete All Indexes',
+    'readwrite',
+    transaction => indexManager.deleteAllFieldIndexes(transaction)
+  );
+}
+
 /**
  * Test-only hooks into the SDK for use exclusively by tests.
  */

packages/firestore/src/local/memory_index_manager.ts

@@ -66,6 +66,13 @@ export class MemoryIndexManager implements IndexManager {
     return PersistencePromise.resolve();
   }
 
+  deleteAllFieldIndexes(
+    transaction: PersistenceTransaction
+  ): PersistencePromise<void> {
+    // Field indices are not supported with memory persistence.
+    return PersistencePromise.resolve();
+  }
+
   createTargetIndexes(
     transaction: PersistenceTransaction,
     target: Target

packages/firestore/test/integration/api/persistent_cache_index_manager.test.ts

@@ -18,6 +18,7 @@
 import { expect } from 'chai';
 
 import {
+  deleteAllPersistentCacheIndexes,
   disablePersistentCacheIndexAutoCreation,
   doc,
   enablePersistentCacheIndexAutoCreation,
@@ -149,4 +150,66 @@ apiDescribe('PersistentCacheIndexManager', persistence => {
       });
     });
   });
+
+  describe('delete all persistent cache indexes', () => {
+    it('deleteAllPersistentCacheIndexes() on new instance should succeed', () =>
+      withTestDb(persistence, async db => {
+        const indexManager = getPersistentCacheIndexManager(db)!;
+        deleteAllPersistentCacheIndexes(indexManager);
+      }));
+
+    it('deleteAllPersistentCacheIndexes() should be successful when auto-indexing is enabled', () =>
+      withTestDb(persistence, async db => {
+        const indexManager = getPersistentCacheIndexManager(db)!;
+        enablePersistentCacheIndexAutoCreation(indexManager);
+        deleteAllPersistentCacheIndexes(indexManager);
+      }));
+
+    it('deleteAllPersistentCacheIndexes() should be successful when auto-indexing is disabled', () =>
+      withTestDb(persistence, async db => {
+        const indexManager = getPersistentCacheIndexManager(db)!;
+        enablePersistentCacheIndexAutoCreation(indexManager);
+        disablePersistentCacheIndexAutoCreation(indexManager);
+        deleteAllPersistentCacheIndexes(indexManager);
+      }));
+
+    it('deleteAllPersistentCacheIndexes() after terminate() should throw', () =>
+      withTestDb(persistence, async db => {
+        const indexManager = getPersistentCacheIndexManager(db)!;
+        terminate(db).catch(e => expect.fail(`terminate() failed: ${e}`));
+        expect(() => deleteAllPersistentCacheIndexes(indexManager)).to.throw(
+          'The client has already been terminated.'
+        );
+      }));
+
+    it('query returns correct results when auto-created index has been deleted', () => {
+      const testDocs = partitionedTestDocs({
+        matching: { documentData: { match: true }, documentCount: 1 },
+        nonmatching: { documentData: { match: false }, documentCount: 100 }
+      });
+      return withTestCollection(persistence, testDocs, async (coll, db) => {
+        const indexManager = getPersistentCacheIndexManager(db)!;
+        enablePersistentCacheIndexAutoCreation(indexManager);
+
+        // Populate the local cache with the entire collection's contents.
+        await getDocs(coll);
+
+        // Run a query that matches only one of the documents in the collection;
+        // this should cause an index to be auto-created.
+        const query_ = query(coll, where('match', '==', true));
+        const snapshot1 = await getDocsFromCache(query_);
+        expect(snapshot1.size).to.equal(1);
+
+        // Delete the index
+        deleteAllPersistentCacheIndexes(indexManager);
+
+        // Run the query that matches only one of the documents again, which
+        // should _still_ return the one and only document that matches. Since
+        // the public API surface does not reveal whether an index was used,
+        // there isn't anything else that can be verified.
+        const snapshot2 = await getDocsFromCache(query_);
+        expect(snapshot2.size).to.equal(1);
+      });
+    });
+  });
 });

packages/firestore/test/unit/local/index_manager.test.ts

@@ -1734,6 +1734,21 @@ describe('IndexedDbIndexManager', async () => {
     await validateIsFullIndex(query_);
   });
 
+  it('deleteAllFieldIndexes() deletes all indexes', async () => {
+    // Create some indexes.
+    const query1 = queryWithAddedFilter(query('coll'), filter('a', '==', 42));
+    await indexManager.createTargetIndexes(queryToTarget(query1));
+    await validateIsFullIndex(query1);
+    const query2 = queryWithAddedFilter(query('coll'), filter('b', '==', 42));
+    await indexManager.createTargetIndexes(queryToTarget(query2));
+    await validateIsFullIndex(query2);
+
+    // Verify that deleteAllFieldIndexes() deletes the indexes.
+    await indexManager.deleteAllFieldIndexes();
+    await validateIsNoneIndex(query1);
+    await validateIsNoneIndex(query2);
+  });
+
   async function validateIsPartialIndex(query: Query): Promise<void> {
     await validateIndexType(query, IndexType.PARTIAL);
   }