deleteAllPersistentCacheIndexes() added

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,
   TestingHooks as FirestoreClientTestingHooks
@@ -101,6 +102,28 @@ 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.
+ */
+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)
+    );
+
+  testingHooksSpi?.notifyPersistentCacheDeleteAllIndexes(promise);
+}
+
 function setPersistentCacheIndexAutoCreationEnabled(
   indexManager: PersistentCacheIndexManager,
   isEnabled: boolean

packages/firestore/src/core/firestore_client.ts

@@ -27,6 +27,7 @@ import { IndexType } from '../local/index_manager';
 import { LocalStore } from '../local/local_store';
 import {
   localStoreConfigureFieldIndexes,
+  localStoreDeleteAllFieldIndexes,
   localStoreExecuteQuery,
   localStoreGetNamedQuery,
   localStoreHandleUserChange,
@@ -844,6 +845,14 @@ export function firestoreClientSetPersistentCacheIndexAutoCreationEnabled(
   });
 }
 
+export function firestoreClientDeleteAllFieldIndexes(
+  client: FirestoreClient
+): Promise<void> {
+  return client.asyncQueue.enqueue(async () => {
+    return localStoreDeleteAllFieldIndexes(await getLocalStore(client));
+  });
+}
+
 /**
  * Test-only hooks into the SDK for use exclusively by tests.
  */

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/src/util/testing_hooks.ts

@@ -89,6 +89,29 @@ export class TestingHooks {
     );
   }
 
+  /**
+   * Registers a callback to be notified when
+   * `deleteAllPersistentCacheIndexes()` is invoked.
+   *
+   * The relative order in which callbacks are notified is unspecified; do not
+   * rely on any particular ordering. If a given callback is registered multiple
+   * times then it will be notified multiple times, once per registration.
+   *
+   * @param callback the callback to invoke when
+   * `deleteAllPersistentCacheIndexes()` is invoked.
+   *
+   * @return a function that, when called, unregisters the given callback; only
+   * the first invocation of the returned function does anything; all subsequent
+   * invocations do nothing.
+   */
+  static onPersistentCacheDeleteAllIndexes(
+    callback: PersistentCacheDeleteAllIndexesCallback
+  ): Unsubscribe {
+    return TestingHooksSpiImpl.instance.onPersistentCacheDeleteAllIndexes(
+      callback
+    );
+  }
+
   /**
    * Determines the type of client-side index that will be used when executing the
    * given query against the local cache.
@@ -171,6 +194,22 @@ export type PersistentCacheIndexAutoCreationToggleCallback = (
   promise: Promise<void>
 ) => unknown;
 
+/**
+ * The signature of callbacks registered with
+ * `TestingHooks.onPersistentCacheDeleteAllIndexes()`.
+ *
+ * The `promise` argument will be fulfilled when the asynchronous work started
+ * by the call to `deleteAllPersistentCacheIndexes()` completes successfully, or
+ * will be rejected if it fails.
+ *
+ * The return value of the callback, if any, is ignored.
+ *
+ * @internal
+ */
+export type PersistentCacheDeleteAllIndexesCallback = (
+  promise: Promise<void>
+) => unknown;
+
 /**
  * The implementation of `TestingHooksSpi`.
  */
@@ -183,6 +222,11 @@ class TestingHooksSpiImpl implements TestingHooksSpi {
   private readonly persistentCacheIndexAutoCreationToggleCallbacksById =
     new Map<Symbol, PersistentCacheIndexAutoCreationToggleCallback>();
 
+  private readonly persistentCacheDeleteAllIndexesCallbacksById = new Map<
+    Symbol,
+    PersistentCacheDeleteAllIndexesCallback
+  >();
+
   private constructor() {}
 
   static get instance(): TestingHooksSpiImpl {
@@ -222,6 +266,21 @@ class TestingHooksSpiImpl implements TestingHooksSpi {
       this.persistentCacheIndexAutoCreationToggleCallbacksById
     );
   }
+
+  notifyPersistentCacheDeleteAllIndexes(promise: Promise<void>): void {
+    this.persistentCacheDeleteAllIndexesCallbacksById.forEach(callback =>
+      callback(promise)
+    );
+  }
+
+  onPersistentCacheDeleteAllIndexes(
+    callback: PersistentCacheDeleteAllIndexesCallback
+  ): Unsubscribe {
+    return registerCallback(
+      callback,
+      this.persistentCacheDeleteAllIndexesCallbacksById
+    );
+  }
 }
 
 function registerCallback<T>(

packages/firestore/src/util/testing_hooks_spi.ts

@@ -57,6 +57,13 @@ export interface TestingHooksSpi {
    * promise.
    */
   notifyPersistentCacheIndexAutoCreationToggle(promise: Promise<void>): void;
+
+  /**
+   * Invokes all callbacks registered with
+   * `TestingHooks.onPersistentCacheDeleteAllIndexes()` with the given
+   * promise.
+   */
+  notifyPersistentCacheDeleteAllIndexes(promise: Promise<void>): void;
 }
 
 /**

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

@@ -38,6 +38,7 @@ import {
 import {
   getQueryIndexType,
   setPersistentCacheIndexAutoCreationSettings,
+  verifyPersistentCacheDeleteAllIndexesSucceedsDuring,
   verifyPersistentCacheIndexAutoCreationToggleSucceedsDuring
 } from '../util/testing_hooks_util';
 
@@ -162,6 +163,42 @@ apiDescribe('PersistentCacheIndexManager', persistence => {
       }));
   });
 
+  describe.only('deleteAllPersistentCacheIndexes()', () => {
+    it('should return successfully', () =>
+      withTestDb(persistence, async db => {
+        const indexManager = getPersistentCacheIndexManager(db)!;
+        deleteAllPersistentCacheIndexes(indexManager);
+      }));
+
+    it('should be successful when auto-indexing is enabled', () =>
+      withTestDb(persistence, db => {
+        const indexManager = getPersistentCacheIndexManager(db)!;
+        enablePersistentCacheIndexAutoCreation(indexManager);
+        return verifyPersistentCacheDeleteAllIndexesSucceedsDuring(() =>
+          deleteAllPersistentCacheIndexes(indexManager)
+        );
+      }));
+
+    it('should be successful when auto-indexing is disabled', () =>
+      withTestDb(persistence, db => {
+        const indexManager = getPersistentCacheIndexManager(db)!;
+        enablePersistentCacheIndexAutoCreation(indexManager);
+        disablePersistentCacheIndexAutoCreation(indexManager);
+        return verifyPersistentCacheDeleteAllIndexesSucceedsDuring(() =>
+          deleteAllPersistentCacheIndexes(indexManager)
+        );
+      }));
+
+    it('should fail if invoked after terminate()', () =>
+      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.'
+        );
+      }));
+  });
+
   describe('Query execution', () => {
     it('Auto-indexing is disabled by default', () =>
       testIndexesGetAutoCreated({

packages/firestore/test/integration/util/testing_hooks_util.ts

@@ -138,6 +138,42 @@ export function verifyPersistentCacheIndexAutoCreationToggleSucceedsDuring(
   return promises[0];
 }
 
+/**
+ * Verifies than an invocation of `deleteAllPersistentCacheIndexes()` made
+ * during the execution of the given callback succeeds.
+ *
+ * @param callback The callback to invoke; this callback must invoke
+ * `deleteAllPersistentCacheIndexes()` exactly once; this callback is
+ * called synchronously by this function, and is called exactly once.
+ *
+ * @return a promise that is fulfilled when the asynchronous work started by
+ * `deleteAllPersistentCacheIndexes()` completes successfully, or is rejected
+ * if it fails.
+ */
+export function verifyPersistentCacheDeleteAllIndexesSucceedsDuring(
+  callback: () => void
+): Promise<void> {
+  const promises: Array<Promise<void>> = [];
+
+  const unregister = TestingHooks.onPersistentCacheDeleteAllIndexes(promise =>
+    promises.push(promise)
+  );
+
+  try {
+    callback();
+  } finally {
+    unregister();
+  }
+
+  expect(
+    promises,
+    'exactly one invocation of deleteAllPersistentCacheIndexes() should be ' +
+      'made by the callback'
+  ).to.have.length(1);
+
+  return promises[0];
+}
+
 /**
  * Determines the type of client-side index that will be used when executing the
  * given query against the local cache.