@expo/entity 0.42.0 → 0.44.0

package/src/AuthorizationResultBasedEntityMutator.ts

@@ -27,7 +27,93 @@ import { timeAndLogMutationEventAsync } from './metrics/EntityMetricsUtils';
 import IEntityMetricsAdapter, { EntityMetricsMutationType } from './metrics/IEntityMetricsAdapter';
 import { mapMapAsync } from './utils/collections/maps';
 
-abstract class AuthorizationResultBasedBaseMutator<
+/**
+ * Base class for entity mutators. Mutators are builder-like class instances that are
+ * responsible for creating, updating, and deleting entities, and for calling out to
+ * the loader at appropriate times to invalidate the cache(s). The loader is responsible
+ * for deciding which cache entries to invalidate for the entity being mutated.
+ *
+ * ## Notes on invalidation
+ *
+ * The primary goal of invalidation is to ensure that at any point in time, a load
+ * for an entity through a cache or layers of caches will return the most up-to-date
+ * value for that entity according to the source of truth stored in the database, and thus
+ * the read-through cache must be kept consistent (only current values are stored, others are invalidated).
+ *
+ * This is done by invalidating the cache for the entity being mutated at the end of the transaction
+ * in which the mutation is performed. This ensures that the cache is invalidated as close as possible
+ * to when the source-of-truth is updated in the database, as to reduce the likelihood of
+ * collisions with loads done at the same time on other machines.
+ *
+ * <blockquote>
+ *    The easiest way to demonstrate this reasoning is via some counter-examples.
+ *    For sake of demonstration, let's say we did invalidation immediately after the mutation instead of
+ *    at the end of the transaction.
+ *
+ *    Example 1:
+ *    - t=0. A transaction is started on machine A and within this transaction a new entity is created.
+ *           The cache for the entity is invalidated.
+ *    - t=1. Machine B tries to load the same entity outside of a transaction. It does not yet exist
+ *           so it negatively caches the entity.
+ *    - t=2. Machine A commits the transaction.
+ *    - t=3. Machine C tries to load the same entity outside of a transaction. It is negatively cached
+ *           so it returns null, even though it exists in the database.
+ *
+ *    One can see that it's strictly better to invalidate the transaction at t=2 as it would remove the
+ *    negative cache entry for the entity, thus leaving the cache consistent with the database.
+ *
+ *    Example 2:
+ *    - t=0. Entity A is created and read into the cache (everthing is consistent at this point in time).
+ *    - t=1. Machine A starts a transaction, reads entity A, updates it, and invalidates the cache.
+ *    - t=2. Machine B reads entity A outside of a transaction. Since the transaction from the step above
+ *           has not yet been committed, the changes within that transaction are not yet visible. It stores
+ *           the entity in the cache.
+ *    - t=3. Machine A commits the transaction.
+ *    - t=4. Machine C reads entity A outside of a transaction. It returns the entity from the cache which
+ *           is now inconsistent with the database.
+ *
+ *    Again, one can see that it's strictly better to invalidate the transaction at t=3 as it would remove the
+ *    stale cache entry for the entity, thus leaving the cache consistent with the database.
+ *
+ *    For deletions, one can imagine a similar series of events occurring.
+ * </blockquote>
+ *
+ * #### Invalidation as it pertains to transactions and nested transactions
+ *
+ * Invalidation becomes slightly more complex when nested transactions are considered. The general
+ * guiding principle here is that over-invalidation is strictly better than under-invalidation
+ * as far as consistency goes. This is because the database is the source of truth.
+ *
+ * For the visible-to-the-outside-world caches (cache adapters), the invalidations are done at the
+ * end of the outermost transaction (as discussed above), plus at the end of each nested transaction.
+ * While only the outermost transaction is strictly necessary for these cache adapter invalidations,
+ * the mental model of doing it at the end of each transaction, nested or otherwise, is easier to reason about.
+ *
+ * For the dataloader caches (per-transaction local caches), the invalidation is done multiple times
+ * (over-invalidation) to better ensure that the caches are always consistent with the database as read within
+ * the transaction or nested transaction.
+ * 1. Immediately after the mutation is performed (but before the transaction or nested transaction is committed).
+ * 2. At the end of the transaction (or nested transaction) itself.
+ * 3. At the end of the outermost transaction (if this is a nested transaction) and all of that transactions's nested transactions recursively.
+ *
+ * This over-invalidation is done because transaction isolation semantics are not consistent across all
+ * databases (some databases don't even have true nested transactions at all), meaning that whether
+ * a change made in a nested transaction is visible to the parent transaction(s) is not necessarily known.
+ * This means that the only way to ensure that the dataloader caches are consistent
+ * with the database is to invalidate them often, thus delegating consistency to the database. Invalidation
+ * of local caches is synchronous and immediate, so the performance impact of over-invalidation is negligible.
+ *
+ * #### Invalidation pitfalls
+ *
+ * One may have noticed that the above invalidation strategy still isn't perfect. Cache invalidation is hard.
+ * There still exists a very short moment in time between when invalidation occurs and when the transaction is committed,
+ * so dirty cache writes are still possible, especially in systems reading an object frequently and writing to the same object.
+ * For now, the entity framework does not attempt to provide a further solution to this problem since it is likely
+ * solutions will be case-specific. Some fun reads on the topic:
+ * - https://engineering.fb.com/2013/06/25/core-infra/tao-the-power-of-the-graph/
+ * - https://hazelcast.com/blog/a-hitchhikers-guide-to-caching-patterns/
+ */
+export abstract class AuthorizationResultBasedBaseMutator<
   TFields extends Record<string, any>,
   TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
   TViewerContext extends ViewerContext,
@@ -224,6 +310,7 @@ export class AuthorizationResultBasedCreateMutator<
       this.metricsAdapter,
       EntityMetricsMutationType.CREATE,
       this.entityClass.name,
+      this.queryContext,
     )(this.createInTransactionAsync());
   }
 
@@ -282,9 +369,14 @@ export class AuthorizationResultBasedCreateMutator<
 
     const insertResult = await this.databaseAdapter.insertAsync(queryContext, this.fieldsForEntity);
 
-    queryContext.appendPostCommitInvalidationCallback(
-      entityLoader.utils.invalidateFieldsAsync.bind(entityLoader, insertResult),
-    );
+    // Invalidate all caches for the new entity so that any previously-negatively-cached loads
+    // are removed from the caches.
+    queryContext.appendPostCommitInvalidationCallback(async () => {
+      entityLoader.utils.invalidateFieldsForTransaction(queryContext, insertResult);
+      await entityLoader.utils.invalidateFieldsAsync(insertResult);
+    });
+
+    entityLoader.utils.invalidateFieldsForTransaction(queryContext, insertResult);
 
     const unauthorizedEntityAfterInsert = entityLoader.utils.constructEntity(insertResult);
     const newEntity = await enforceAsyncResult(
@@ -423,6 +515,7 @@ export class AuthorizationResultBasedUpdateMutator<
       this.metricsAdapter,
       EntityMetricsMutationType.UPDATE,
       this.entityClass.name,
+      this.queryContext,
     )(this.updateInTransactionAsync(false, null));
   }
 
@@ -499,15 +592,31 @@ export class AuthorizationResultBasedUpdateMutator<
       );
     }
 
-    queryContext.appendPostCommitInvalidationCallback(
-      entityLoader.utils.invalidateFieldsAsync.bind(
-        entityLoader,
+    // Invalidate all caches for the entity being updated so that any previously-cached loads
+    // are consistent. This means:
+    // - any query that returned this entity (pre-update) in the past should no longer have that entity in cache for that query.
+    // - any query that will return this entity (post-update) that would not have returned the entity in the past should not
+    //   be negatively cached for the entity.
+    // To do this we simply invalidate all of the entity's caches for both the previous version of the entity and the upcoming
+    // version of the entity.
+
+    queryContext.appendPostCommitInvalidationCallback(async () => {
+      entityLoader.utils.invalidateFieldsForTransaction(
+        queryContext,
         this.originalEntity.getAllDatabaseFields(),
-      ),
-    );
-    queryContext.appendPostCommitInvalidationCallback(
-      entityLoader.utils.invalidateFieldsAsync.bind(entityLoader, this.fieldsForEntity),
+      );
+      entityLoader.utils.invalidateFieldsForTransaction(queryContext, this.fieldsForEntity);
+      await Promise.all([
+        entityLoader.utils.invalidateFieldsAsync(this.originalEntity.getAllDatabaseFields()),
+        entityLoader.utils.invalidateFieldsAsync(this.fieldsForEntity),
+      ]);
+    });
+
+    entityLoader.utils.invalidateFieldsForTransaction(
+      queryContext,
+      this.originalEntity.getAllDatabaseFields(),
     );
+    entityLoader.utils.invalidateFieldsForTransaction(queryContext, this.fieldsForEntity);
 
     const updatedEntity = await enforceAsyncResult(
       entityLoader.loadByIDAsync(entityAboutToBeUpdated.getID()),
@@ -639,6 +748,7 @@ export class AuthorizationResultBasedDeleteMutator<
       this.metricsAdapter,
       EntityMetricsMutationType.DELETE,
       this.entityClass.name,
+      this.queryContext,
     )(this.deleteInTransactionAsync(new Set(), false, null));
   }
 
@@ -708,11 +818,19 @@ export class AuthorizationResultBasedDeleteMutator<
       previousValue: null,
       cascadingDeleteCause,
     });
-    queryContext.appendPostCommitInvalidationCallback(
-      entityLoader.utils.invalidateFieldsAsync.bind(
-        entityLoader,
+
+    // Invalidate all caches for the entity so that any previously-cached loads
+    // are removed from the caches.
+    queryContext.appendPostCommitInvalidationCallback(async () => {
+      entityLoader.utils.invalidateFieldsForTransaction(
+        queryContext,
         this.entity.getAllDatabaseFields(),
-      ),
+      );
+      await entityLoader.utils.invalidateFieldsAsync(this.entity.getAllDatabaseFields());
+    });
+    entityLoader.utils.invalidateFieldsForTransaction(
+      queryContext,
+      this.entity.getAllDatabaseFields(),
     );
 
     await this.executeMutationTriggersAsync(

package/src/EntityFieldDefinition.ts

@@ -177,7 +177,7 @@ export abstract class EntityFieldDefinition<T, TRequireExplicitCache extends boo
 
   // @ts-expect-error this is to ensure that different constructor requirements produce incompatible
   // objects in the eyes of the type system
-  private readonly cacheRawSentinel: TRequireExplicitCache;
+  protected readonly _cacheRawSentinel: TRequireExplicitCache;
 
   /**
    * @param options - options for this field definition

package/src/EntityLoaderUtils.ts

@@ -4,11 +4,12 @@ import nullthrows from 'nullthrows';
 import { IEntityClass } from './Entity';
 import EntityConfiguration from './EntityConfiguration';
 import EntityPrivacyPolicy, { EntityPrivacyPolicyEvaluationContext } from './EntityPrivacyPolicy';
-import { EntityQueryContext } from './EntityQueryContext';
+import { EntityQueryContext, EntityTransactionalQueryContext } from './EntityQueryContext';
 import ReadonlyEntity from './ReadonlyEntity';
 import ViewerContext from './ViewerContext';
 import { pick } from './entityUtils';
 import EntityDataManager from './internal/EntityDataManager';
+import { LoadPair } from './internal/EntityLoadInterfaces';
 import { SingleFieldHolder, SingleFieldValueHolder } from './internal/SingleFieldHolder';
 import IEntityMetricsAdapter from './metrics/IEntityMetricsAdapter';
 import { mapMapAsync } from './utils/collections/maps';
@@ -56,11 +57,9 @@ export default class EntityLoaderUtils<
     protected readonly metricsAdapter: IEntityMetricsAdapter,
   ) {}
 
-  /**
-   * Invalidate all caches for an entity's fields. Exposed primarily for internal use by EntityMutator.
-   * @param objectFields - entity data object to be invalidated
-   */
-  async invalidateFieldsAsync(objectFields: Readonly<TFields>): Promise<void> {
+  private getKeyValuePairsFromObjectFields(
+    objectFields: Readonly<TFields>,
+  ): readonly LoadPair<TFields, TIDField, any, any, any>[] {
     const keys = Object.keys(objectFields) as (keyof TFields)[];
     const singleFieldKeyValues = keys
       .map((fieldName: keyof TFields) => {
@@ -85,22 +84,54 @@ export default class EntityLoaderUtils<
           : null;
       })
       .filter((kv) => kv !== null);
+    return [...singleFieldKeyValues, ...compositeFieldKeyValues];
+  }
+
+  /**
+   * Invalidate all caches and local dataloaders for an entity's fields. Exposed primarily for internal use by EntityMutator.
+   * @param objectFields - entity data object to be invalidated
+   */
+  public async invalidateFieldsAsync(objectFields: Readonly<TFields>): Promise<void> {
+    await this.dataManager.invalidateKeyValuePairsAsync(
+      this.getKeyValuePairsFromObjectFields(objectFields),
+    );
+  }
 
-    await this.dataManager.invalidateKeyValuePairsAsync([
-      ...singleFieldKeyValues,
-      ...compositeFieldKeyValues,
-    ]);
+  /**
+   * Invalidate all local dataloaders specific to a transaction for an entity's fields. Exposed primarily for internal use by EntityMutator.
+   * @param objectFields - entity data object to be invalidated
+   */
+  public invalidateFieldsForTransaction(
+    queryContext: EntityTransactionalQueryContext,
+    objectFields: Readonly<TFields>,
+  ): void {
+    this.dataManager.invalidateKeyValuePairsForTransaction(
+      queryContext,
+      this.getKeyValuePairsFromObjectFields(objectFields),
+    );
   }
 
   /**
-   * Invalidate all caches for an entity. One potential use case would be to keep the entity
+   * Invalidate all caches and local dataloaders for an entity. One potential use case would be to keep the entity
    * framework in sync with changes made to data outside of the framework.
    * @param entity - entity to be invalidated
    */
-  async invalidateEntityAsync(entity: TEntity): Promise<void> {
+  public async invalidateEntityAsync(entity: TEntity): Promise<void> {
     await this.invalidateFieldsAsync(entity.getAllDatabaseFields());
   }
 
+  /**
+   * Invalidate all local dataloaders specific to a transaction for an entity. One potential use case would be to keep the entity
+   * framework in sync with changes made to data outside of the framework.
+   * @param entity - entity to be invalidated
+   */
+  public invalidateEntityForTransaction(
+    queryContext: EntityTransactionalQueryContext,
+    entity: TEntity,
+  ): void {
+    this.invalidateFieldsForTransaction(queryContext, entity.getAllDatabaseFields());
+  }
+
   /**
    * Construct an entity from a fields object (applying field selection if applicable),
    * checking that the ID field is specified.

package/src/EntityQueryContext.ts

@@ -14,8 +14,15 @@ export enum TransactionIsolationLevel {
   SERIALIZABLE = 'SERIALIZABLE',
 }
 
+export enum TransactionalDataLoaderMode {
+  ENABLED = 'ENABLED',
+  ENABLED_BATCH_ONLY = 'ENABLED_BATCH_ONLY',
+  DISABLED = 'DISABLED',
+}
+
 export type TransactionConfig = {
   isolationLevel?: TransactionIsolationLevel;
+  transactionalDataLoaderMode?: TransactionalDataLoaderMode;
 };
 
 /**
@@ -28,7 +35,7 @@ export type TransactionConfig = {
 export abstract class EntityQueryContext {
   constructor(private readonly queryInterface: any) {}
 
-  abstract isInTransaction(): boolean;
+  abstract isInTransaction(): this is EntityTransactionalQueryContext;
 
   getQueryInterface(): any {
     return this.queryInterface;
@@ -54,7 +61,7 @@ export class EntityNonTransactionalQueryContext extends EntityQueryContext {
     super(queryInterface);
   }
 
-  isInTransaction(): boolean {
+  override isInTransaction(): this is EntityTransactionalQueryContext {
     return false;
   }
 
@@ -75,6 +82,11 @@ export class EntityNonTransactionalQueryContext extends EntityQueryContext {
  * dependent triggers and validators will run within the transaction.
  */
 export class EntityTransactionalQueryContext extends EntityQueryContext {
+  /**
+   * @internal
+   */
+  public readonly childQueryContexts: EntityNestedTransactionalQueryContext[] = [];
+
   private readonly postCommitInvalidationCallbacks: PostCommitCallback[] = [];
   private readonly postCommitCallbacks: PostCommitCallback[] = [];
 
@@ -83,6 +95,11 @@ export class EntityTransactionalQueryContext extends EntityQueryContext {
   constructor(
     queryInterface: any,
     private readonly entityQueryContextProvider: EntityQueryContextProvider,
+    /**
+     * @internal
+     */
+    readonly transactionId: string,
+    public readonly transactionalDataLoaderMode: TransactionalDataLoaderMode,
   ) {
     super(queryInterface);
   }
@@ -121,6 +138,9 @@ export class EntityTransactionalQueryContext extends EntityQueryContext {
     this.postCommitCallbacks.push(callback);
   }
 
+  /**
+   * @internal
+   */
   public async runPreCommitCallbacksAsync(): Promise<void> {
     const callbacks = [...this.preCommitCallbacks]
       .sort((a, b) => a.order - b.order)
@@ -132,6 +152,9 @@ export class EntityTransactionalQueryContext extends EntityQueryContext {
     }
   }
 
+  /**
+   * @internal
+   */
   public async runPostCommitCallbacksAsync(): Promise<void> {
     const invalidationCallbacks = [...this.postCommitInvalidationCallbacks];
     this.postCommitInvalidationCallbacks.length = 0;
@@ -142,10 +165,14 @@ export class EntityTransactionalQueryContext extends EntityQueryContext {
     await Promise.all(callbacks.map((callback) => callback()));
   }
 
-  isInTransaction(): boolean {
+  override isInTransaction(): this is EntityTransactionalQueryContext {
     return true;
   }
 
+  isInNestedTransaction(): this is EntityNestedTransactionalQueryContext {
+    return false;
+  }
+
   async runInTransactionIfNotInTransactionAsync<T>(
     transactionScope: (queryContext: EntityTransactionalQueryContext) => Promise<T>,
     transactionConfig?: TransactionConfig,
@@ -181,31 +208,59 @@ export class EntityNestedTransactionalQueryContext extends EntityTransactionalQu
 
   constructor(
     queryInterface: any,
-    private readonly parentQueryContext: EntityTransactionalQueryContext,
+    /**
+     * @internal
+     */
+    readonly parentQueryContext: EntityTransactionalQueryContext,
     entityQueryContextProvider: EntityQueryContextProvider,
+    transactionId: string,
+    transactionalDataLoaderMode: TransactionalDataLoaderMode,
   ) {
-    super(queryInterface, entityQueryContextProvider);
+    super(queryInterface, entityQueryContextProvider, transactionId, transactionalDataLoaderMode);
+    parentQueryContext.childQueryContexts.push(this);
   }
 
-  public override appendPostCommitCallback(callback: PostCommitCallback): void {
-    this.postCommitInvalidationCallbacksToTransfer.push(callback);
+  override isInNestedTransaction(): this is EntityNestedTransactionalQueryContext {
+    return true;
   }
 
-  public override appendPostCommitInvalidationCallback(callback: PostCommitCallback): void {
+  public override appendPostCommitCallback(callback: PostCommitCallback): void {
+    // explicitly do not add to the super-class's post-commit callbacks
+    // instead, we will add them to the parent transaction's post-commit callbacks
+    // after the nested transaction has been committed
     this.postCommitCallbacksToTransfer.push(callback);
   }
 
-  public override runPostCommitCallbacksAsync(): Promise<void> {
-    throw new Error(
-      'Must not call runPostCommitCallbacksAsync on EntityNestedTransactionalQueryContext',
-    );
+  public override appendPostCommitInvalidationCallback(callback: PostCommitCallback): void {
+    super.appendPostCommitInvalidationCallback(callback);
+    this.postCommitInvalidationCallbacksToTransfer.push(callback);
   }
 
-  public transferPostCommitCallbacksToParent(): void {
+  /**
+   * The behavior of callbacks for nested transactions are a bit different than for normal
+   * transactions.
+   * - Post-commit (non-invalidation) callbacks are run at the end of the outermost transaction
+   *   since they often contain side-effects that only should run if the transaction doesn't roll back.
+   *   The outermost transaction has the final say on the commit state of itself and all sub-transactions.
+   * - Invalidation callbacks are run at the end of both the nested transaction iteself but also transferred
+   *   to the parent transaction to be run at the end of it (and recurse upwards, accumulating invalations).
+   *   This is to ensure the dataloader cache is never stale no matter the DBMS transaction isolation
+   *   semantics. See the note in `AuthorizationResultBasedBaseMutator` for more details.
+   *
+   * @internal
+   */
+  public override async runPostCommitCallbacksAsync(): Promise<void> {
+    // run the post-commit callbacks for the nested transaction now
+    // (this technically also would run regular post-commit callbacks, but they are empty)
+    await super.runPostCommitCallbacksAsync();
+
+    // transfer a copy of the post-commit invalidation callbacks to the parent transaction
+    // to also be run at the end of it (or recurse in the case of the parent transaction being nested as well)
     for (const callback of this.postCommitInvalidationCallbacksToTransfer) {
       this.parentQueryContext.appendPostCommitInvalidationCallback(callback);
     }
 
+    // transfer post-commit callbacks to patent
     for (const callback of this.postCommitCallbacksToTransfer) {
       this.parentQueryContext.appendPostCommitCallback(callback);
     }

package/src/EntityQueryContextProvider.ts

@@ -1,8 +1,11 @@
+import { randomUUID } from 'node:crypto';
+
 import {
   EntityTransactionalQueryContext,
   EntityNonTransactionalQueryContext,
   EntityNestedTransactionalQueryContext,
   TransactionConfig,
+  TransactionalDataLoaderMode,
 } from './EntityQueryContext';
 
 /**
@@ -21,6 +24,13 @@ export default abstract class EntityQueryContextProvider {
    */
   protected abstract getQueryInterface(): any;
 
+  /**
+   * @returns true if the transactional dataloader should be disabled for all transactions.
+   */
+  protected defaultTransactionalDataLoaderMode(): TransactionalDataLoaderMode {
+    return TransactionalDataLoaderMode.ENABLED;
+  }
+
   /**
    * Vend a transaction runner for use in runInTransactionAsync.
    */
@@ -43,7 +53,12 @@ export default abstract class EntityQueryContextProvider {
     const [returnedValue, queryContext] = await this.createTransactionRunner<
       [T, EntityTransactionalQueryContext]
     >(transactionConfig)(async (queryInterface) => {
-      const queryContext = new EntityTransactionalQueryContext(queryInterface, this);
+      const queryContext = new EntityTransactionalQueryContext(
+        queryInterface,
+        this,
+        randomUUID(),
+        transactionConfig?.transactionalDataLoaderMode ?? this.defaultTransactionalDataLoaderMode(),
+      );
       const result = await transactionScope(queryContext);
       await queryContext.runPreCommitCallbacksAsync();
       return [result, queryContext];
@@ -69,13 +84,15 @@ export default abstract class EntityQueryContextProvider {
         innerQueryInterface,
         outerQueryContext,
         this,
+        randomUUID(),
+        outerQueryContext.transactionalDataLoaderMode,
       );
       const result = await transactionScope(innerQueryContext);
       await innerQueryContext.runPreCommitCallbacksAsync();
       return [result, innerQueryContext];
     });
-    // post-commit callbacks are appended to parent transaction instead of run, but only after the transaction has succeeded
-    innerQueryContext.transferPostCommitCallbacksToParent();
+    // behavior of this call differs for nested transaction query contexts from regular transaction query contexts
+    await innerQueryContext.runPostCommitCallbacksAsync();
     return returnedValue;
   }
 }

package/src/IEntityGenericCacher.ts

@@ -59,8 +59,8 @@ export default interface IEntityGenericCacher<
    * from makeCacheKeyForStorage because invalidation can optionally be configured to invalidate a larger set of keys than
    * the one for just the current cache version, which can be useful for things like push safety.
    *
-   * @param key - load key of the cache key
-   * @param values - load values of the cache key
+   * @param key - load key for the cache keys
+   * @param value - load value for the cache keys
    */
   makeCacheKeysForInvalidation<
     TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,

package/src/__tests__/AuthorizationResultBasedEntityLoader-test.ts

@@ -890,6 +890,104 @@ describe(AuthorizationResultBasedEntityLoader, () => {
     ).once();
   });
 
+  it('invalidates upon invalidate by entity within transaction', async () => {
+    const viewerContext = instance(mock(ViewerContext));
+    const privacyPolicyEvaluationContext =
+      instance(
+        mock<
+          EntityPrivacyPolicyEvaluationContext<
+            TestFields,
+            'customIdField',
+            ViewerContext,
+            TestEntity
+          >
+        >(),
+      );
+    const metricsAdapter = instance(mock<IEntityMetricsAdapter>());
+
+    const privacyPolicy = instance(mock(TestEntityPrivacyPolicy));
+    const dataManagerMock = mock<EntityDataManager<TestFields, 'customIdField'>>();
+    const dataManagerInstance = instance(dataManagerMock);
+
+    const id1 = uuidv4();
+    const entityMock = mock(TestEntity);
+    const date = new Date();
+
+    when(entityMock.getAllDatabaseFields()).thenReturn({
+      customIdField: id1,
+      testIndexedField: 'h1',
+      intField: 5,
+      stringField: 'huh',
+      dateField: date,
+      nullableField: null,
+    });
+    const entityInstance = instance(entityMock);
+
+    await new StubQueryContextProvider().runInTransactionAsync(async (queryContext) => {
+      const utils = new EntityLoaderUtils(
+        viewerContext,
+        queryContext,
+        privacyPolicyEvaluationContext,
+        testEntityConfiguration,
+        TestEntity,
+        /* entitySelectedFields */ undefined,
+        privacyPolicy,
+        dataManagerInstance,
+        metricsAdapter,
+      );
+      const entityLoader = new AuthorizationResultBasedEntityLoader(
+        queryContext,
+        testEntityConfiguration,
+        TestEntity,
+        dataManagerInstance,
+        metricsAdapter,
+        utils,
+      );
+      entityLoader.utils.invalidateEntityForTransaction(queryContext, entityInstance);
+
+      verify(
+        dataManagerMock.invalidateKeyValuePairsForTransaction(queryContext, anything()),
+      ).once();
+      verify(
+        dataManagerMock.invalidateKeyValuePairsForTransaction(
+          queryContext,
+          deepEqualEntityAware([
+            [
+              new SingleFieldHolder<TestFields, 'customIdField', 'customIdField'>('customIdField'),
+              new SingleFieldValueHolder<TestFields, 'customIdField'>(id1),
+            ],
+            [
+              new SingleFieldHolder<TestFields, 'customIdField', 'testIndexedField'>(
+                'testIndexedField',
+              ),
+              new SingleFieldValueHolder<TestFields, 'testIndexedField'>('h1'),
+            ],
+            [
+              new SingleFieldHolder<TestFields, 'customIdField', 'intField'>('intField'),
+              new SingleFieldValueHolder<TestFields, 'intField'>(5),
+            ],
+            [
+              new SingleFieldHolder<TestFields, 'customIdField', 'stringField'>('stringField'),
+              new SingleFieldValueHolder<TestFields, 'stringField'>('huh'),
+            ],
+            [
+              new SingleFieldHolder<TestFields, 'customIdField', 'dateField'>('dateField'),
+              new SingleFieldValueHolder<TestFields, 'dateField'>(date),
+            ],
+            [
+              new CompositeFieldHolder(['stringField', 'intField']),
+              new CompositeFieldValueHolder({ stringField: 'huh', intField: 5 }),
+            ],
+            [
+              new CompositeFieldHolder(['stringField', 'testIndexedField']),
+              new CompositeFieldValueHolder({ stringField: 'huh', testIndexedField: 'h1' }),
+            ],
+          ]),
+        ),
+      ).once();
+    });
+  });
+
   it('returns error result when not allowed', async () => {
     const viewerContext = instance(mock(ViewerContext));
     const privacyPolicyEvaluationContext =