@expo/entity 0.55.0 → 0.57.0

package/src/__tests__/EnforcingEntityLoader-test.ts

@@ -439,139 +439,6 @@ describe(EnforcingEntityLoader, () => {
     });
   });
 
-  describe('loadFirstByFieldEqualityConjunction', () => {
-    it('throws when result is unsuccessful', async () => {
-      const nonEnforcingEntityLoaderMock = mock<
-        AuthorizationResultBasedEntityLoader<any, any, any, any, any, any>
-      >(AuthorizationResultBasedEntityLoader);
-      const rejection = new Error();
-      when(
-        nonEnforcingEntityLoaderMock.loadFirstByFieldEqualityConjunctionAsync(
-          anything(),
-          anything(),
-        ),
-      ).thenResolve(result(rejection));
-      const nonEnforcingEntityLoader = instance(nonEnforcingEntityLoaderMock);
-      const enforcingEntityLoader = new EnforcingEntityLoader(nonEnforcingEntityLoader);
-      await expect(
-        enforcingEntityLoader.loadFirstByFieldEqualityConjunctionAsync(anything(), anything()),
-      ).rejects.toThrow(rejection);
-    });
-
-    it('returns value when result is successful', async () => {
-      const nonEnforcingEntityLoaderMock = mock<
-        AuthorizationResultBasedEntityLoader<any, any, any, any, any, any>
-      >(AuthorizationResultBasedEntityLoader);
-      const resolved = {};
-      when(
-        nonEnforcingEntityLoaderMock.loadFirstByFieldEqualityConjunctionAsync(
-          anything(),
-          anything(),
-        ),
-      ).thenResolve(result(resolved));
-      const nonEnforcingEntityLoader = instance(nonEnforcingEntityLoaderMock);
-      const enforcingEntityLoader = new EnforcingEntityLoader(nonEnforcingEntityLoader);
-      await expect(
-        enforcingEntityLoader.loadFirstByFieldEqualityConjunctionAsync(anything(), anything()),
-      ).resolves.toEqual(resolved);
-    });
-
-    it('returns null when the query is successful but no rows match', async () => {
-      const nonEnforcingEntityLoaderMock = mock<
-        AuthorizationResultBasedEntityLoader<any, any, any, any, any, any>
-      >(AuthorizationResultBasedEntityLoader);
-      when(
-        nonEnforcingEntityLoaderMock.loadFirstByFieldEqualityConjunctionAsync(
-          anything(),
-          anything(),
-        ),
-      ).thenResolve(null);
-      const nonEnforcingEntityLoader = instance(nonEnforcingEntityLoaderMock);
-      const enforcingEntityLoader = new EnforcingEntityLoader(nonEnforcingEntityLoader);
-      await expect(
-        enforcingEntityLoader.loadFirstByFieldEqualityConjunctionAsync(anything(), anything()),
-      ).resolves.toBeNull();
-    });
-  });
-
-  describe('loadManyByFieldEqualityConjunction', () => {
-    it('throws when result is unsuccessful', async () => {
-      const nonEnforcingEntityLoaderMock = mock<
-        AuthorizationResultBasedEntityLoader<any, any, any, any, any, any>
-      >(AuthorizationResultBasedEntityLoader);
-      const rejection = new Error();
-      when(
-        nonEnforcingEntityLoaderMock.loadManyByFieldEqualityConjunctionAsync(
-          anything(),
-          anything(),
-        ),
-      ).thenResolve([result(rejection)]);
-      const nonEnforcingEntityLoader = instance(nonEnforcingEntityLoaderMock);
-      const enforcingEntityLoader = new EnforcingEntityLoader(nonEnforcingEntityLoader);
-      await expect(
-        enforcingEntityLoader.loadManyByFieldEqualityConjunctionAsync(anything(), anything()),
-      ).rejects.toThrow(rejection);
-    });
-
-    it('returns value when result is successful', async () => {
-      const nonEnforcingEntityLoaderMock = mock<
-        AuthorizationResultBasedEntityLoader<any, any, any, any, any, any>
-      >(AuthorizationResultBasedEntityLoader);
-      const resolved = {};
-      when(
-        nonEnforcingEntityLoaderMock.loadManyByFieldEqualityConjunctionAsync(
-          anything(),
-          anything(),
-        ),
-      ).thenResolve([result(resolved)]);
-      const nonEnforcingEntityLoader = instance(nonEnforcingEntityLoaderMock);
-      const enforcingEntityLoader = new EnforcingEntityLoader(nonEnforcingEntityLoader);
-      await expect(
-        enforcingEntityLoader.loadManyByFieldEqualityConjunctionAsync(anything(), anything()),
-      ).resolves.toEqual([resolved]);
-    });
-  });
-
-  describe('loadManyByRawWhereClause', () => {
-    it('throws when result is unsuccessful', async () => {
-      const nonEnforcingEntityLoaderMock = mock<
-        AuthorizationResultBasedEntityLoader<any, any, any, any, any, any>
-      >(AuthorizationResultBasedEntityLoader);
-      const rejection = new Error();
-      when(
-        nonEnforcingEntityLoaderMock.loadManyByRawWhereClauseAsync(
-          anything(),
-          anything(),
-          anything(),
-        ),
-      ).thenResolve([result(rejection)]);
-      const nonEnforcingEntityLoader = instance(nonEnforcingEntityLoaderMock);
-      const enforcingEntityLoader = new EnforcingEntityLoader(nonEnforcingEntityLoader);
-      await expect(
-        enforcingEntityLoader.loadManyByRawWhereClauseAsync(anything(), anything(), anything()),
-      ).rejects.toThrow(rejection);
-    });
-
-    it('returns value when result is successful', async () => {
-      const nonEnforcingEntityLoaderMock = mock<
-        AuthorizationResultBasedEntityLoader<any, any, any, any, any, any>
-      >(AuthorizationResultBasedEntityLoader);
-      const resolved = {};
-      when(
-        nonEnforcingEntityLoaderMock.loadManyByRawWhereClauseAsync(
-          anything(),
-          anything(),
-          anything(),
-        ),
-      ).thenResolve([result(resolved)]);
-      const nonEnforcingEntityLoader = instance(nonEnforcingEntityLoaderMock);
-      const enforcingEntityLoader = new EnforcingEntityLoader(nonEnforcingEntityLoader);
-      await expect(
-        enforcingEntityLoader.loadManyByRawWhereClauseAsync(anything(), anything(), anything()),
-      ).resolves.toEqual([resolved]);
-    });
-  });
-
   it('has the same method names as EntityLoader', () => {
     const enforcingLoaderProperties = Object.getOwnPropertyNames(EnforcingEntityLoader.prototype);
     const nonEnforcingLoaderProperties = Object.getOwnPropertyNames(
@@ -580,7 +447,8 @@ describe(EnforcingEntityLoader, () => {
 
     // ensure known differences still exist for sanity check
     const knownLoaderOnlyDifferences = [
-      'validateFieldAndValues',
+      'loadOneByFieldEqualingAsync', // private method used in EntityPrivacyUtils that is not intended to be part of the public API of AuthorizationResultBasedEntityLoader, and has no equivalent in EnforcingEntityLoader
+      'validateFieldAndValueAndConvertToHolders',
       'validateFieldAndValuesAndConvertToHolders',
       'validateCompositeFieldAndValuesAndConvertToHolders',
       'constructAndAuthorizeEntitiesFromCompositeFieldValueHolderMapAsync',

package/src/__tests__/EntityCompanion-test.ts

@@ -78,4 +78,22 @@ describe(EntityCompanion, () => {
       afterCommit: [localTriggers!.afterCommit![0]],
     });
   });
+  it('returns correct metrics adapter', () => {
+    const entityCompanionProvider = instance(mock<EntityCompanionProvider>());
+
+    const tableDataCoordinatorMock = mock<EntityTableDataCoordinator<TestMTFields, 'id'>>();
+    when(tableDataCoordinatorMock.entityConfiguration).thenReturn(testEntityMTConfiguration);
+
+    const metricsAdapterMock = mock<IEntityMetricsAdapter>();
+    const metricsAdapterInstance = instance(metricsAdapterMock);
+
+    const companion = new EntityCompanion(
+      entityCompanionProvider,
+      TestEntityWithMutationTriggers.defineCompanionDefinition(),
+      instance(tableDataCoordinatorMock),
+      metricsAdapterInstance,
+    );
+
+    expect(companion.getMetricsAdapter()).toBe(metricsAdapterInstance);
+  });
 });

package/src/__tests__/EntityConfiguration-test.ts

@@ -46,8 +46,8 @@ describe(EntityConfiguration, () => {
       expect(blahEntityConfiguration.databaseAdapterFlavor).toEqual('postgres');
       expect(blahEntityConfiguration.cacheAdapterFlavor).toEqual('redis');
       expect(blahEntityConfiguration.compositeFieldInfo.getAllCompositeFieldHolders()).toEqual([
-        new CompositeFieldHolder(['id', 'cacheable']),
-        new CompositeFieldHolder(['id', 'uniqueButNotCacheable']),
+        new CompositeFieldHolder<BlahT, 'id'>(['id', 'cacheable']),
+        new CompositeFieldHolder<BlahT, 'id'>(['id', 'uniqueButNotCacheable']),
       ]);
     });
 
@@ -175,7 +175,7 @@ describe(EntityConfiguration, () => {
       ])('disallows %p as field key', (keyName) => {
         expect(
           () =>
-            new EntityConfiguration<any, 'id'>({
+            new EntityConfiguration<{ id: string }, 'id'>({
               idField: 'id',
               tableName: 'blah_table',
               schema: {
@@ -186,7 +186,7 @@ describe(EntityConfiguration, () => {
                 [keyName]: new StringField({
                   columnName: 'any',
                 }),
-              } as any,
+              },
               databaseAdapterFlavor: 'postgres',
               cacheAdapterFlavor: 'redis',
             }),

package/src/__tests__/EntityDatabaseAdapter-test.ts

@@ -1,11 +1,7 @@
 import { describe, expect, it } from '@jest/globals';
 import { instance, mock } from 'ts-mockito';
 
-import {
-  EntityDatabaseAdapter,
-  TableFieldMultiValueEqualityCondition,
-  TableFieldSingleValueEqualityCondition,
-} from '../EntityDatabaseAdapter';
+import { EntityDatabaseAdapter } from '../EntityDatabaseAdapter';
 import { EntityQueryContext } from '../EntityQueryContext';
 import {
   EntityDatabaseAdapterEmptyInsertResultError,
@@ -21,33 +17,29 @@ import { TestFields, testEntityConfiguration } from '../utils/__testfixtures__/T
 
 class TestEntityDatabaseAdapter extends EntityDatabaseAdapter<TestFields, 'customIdField'> {
   private readonly fetchResults: object[];
+  private readonly fetchOneResult: object | null;
   private readonly insertResults: object[];
   private readonly updateResults: object[];
-  private readonly fetchEqualityConditionResults: object[];
-  private readonly fetchRawWhereResults: object[];
   private readonly deleteCount: number;
 
   constructor({
     fetchResults = [],
+    fetchOneResult = null,
     insertResults = [],
     updateResults = [],
-    fetchEqualityConditionResults = [],
-    fetchRawWhereResults = [],
     deleteCount = 0,
   }: {
     fetchResults?: object[];
+    fetchOneResult?: object | null;
     insertResults?: object[];
     updateResults?: object[];
-    fetchEqualityConditionResults?: object[];
-    fetchRawWhereResults?: object[];
     deleteCount?: number;
   }) {
     super(testEntityConfiguration);
     this.fetchResults = fetchResults;
+    this.fetchOneResult = fetchOneResult;
     this.insertResults = insertResults;
     this.updateResults = updateResults;
-    this.fetchEqualityConditionResults = fetchEqualityConditionResults;
-    this.fetchRawWhereResults = fetchRawWhereResults;
     this.deleteCount = deleteCount;
   }
 
@@ -64,22 +56,13 @@ class TestEntityDatabaseAdapter extends EntityDatabaseAdapter<TestFields, 'custo
     return this.fetchResults;
   }
 
-  protected async fetchManyByRawWhereClauseInternalAsync(
-    _queryInterface: any,
-    _tableName: string,
-    _rawWhereClause: string,
-    _bindings: object | any[],
-  ): Promise<object[]> {
-    return this.fetchRawWhereResults;
-  }
-
-  protected async fetchManyByFieldEqualityConjunctionInternalAsync(
+  protected async fetchOneWhereInternalAsync(
     _queryInterface: any,
     _tableName: string,
-    _tableFieldSingleValueEqualityOperands: TableFieldSingleValueEqualityCondition[],
-    _tableFieldMultiValueEqualityOperands: TableFieldMultiValueEqualityCondition[],
-  ): Promise<object[]> {
-    return this.fetchEqualityConditionResults;
+    _tableColumns: readonly string[],
+    _tableTuple: readonly any[],
+  ): Promise<object | null> {
+    return this.fetchOneResult;
   }
 
   protected async insertInternalAsync(
@@ -117,7 +100,7 @@ describe(EntityDatabaseAdapter, () => {
       const adapter = new TestEntityDatabaseAdapter({ fetchResults: [{ string_field: 'hello' }] });
       const result = await adapter.fetchManyWhereAsync(
         queryContext,
-        new SingleFieldHolder('stringField'),
+        new SingleFieldHolder<TestFields, 'customIdField', 'stringField'>('stringField'),
         [new SingleFieldValueHolder('hello')],
       );
       expect(result.get(new SingleFieldValueHolder('hello'))).toEqual([{ stringField: 'hello' }]);
@@ -130,7 +113,7 @@ describe(EntityDatabaseAdapter, () => {
       });
       const result = await adapter.fetchManyWhereAsync(
         queryContext,
-        new SingleFieldHolder('stringField'),
+        new SingleFieldHolder<TestFields, 'customIdField', 'stringField'>('stringField'),
         [new SingleFieldValueHolder('hello'), new SingleFieldValueHolder('wat')],
       );
       expect(result.get(new SingleFieldValueHolder('hello'))).toEqual([{ stringField: 'hello' }]);
@@ -170,7 +153,7 @@ describe(EntityDatabaseAdapter, () => {
       const adapter = new TestEntityDatabaseAdapter({});
       const result = await adapter.fetchManyWhereAsync(
         queryContext,
-        new SingleFieldHolder('stringField'),
+        new SingleFieldHolder<TestFields, 'customIdField', 'stringField'>('stringField'),
         [new SingleFieldValueHolder('what'), new SingleFieldValueHolder('who')],
       );
       expect(Array.from(result.keys()).map((v) => v.fieldValue)).toEqual(['what', 'who']);
@@ -182,9 +165,11 @@ describe(EntityDatabaseAdapter, () => {
         fetchResults: [{ string_field: null }],
       });
       await expect(
-        adapter.fetchManyWhereAsync(queryContext, new SingleFieldHolder('stringField'), [
-          new SingleFieldValueHolder('hello'),
-        ]),
+        adapter.fetchManyWhereAsync(
+          queryContext,
+          new SingleFieldHolder<TestFields, 'customIdField', 'stringField'>('stringField'),
+          [new SingleFieldValueHolder('hello')],
+        ),
       ).rejects.toThrow(
         'One or more fields from the object is invalid for key SingleField(stringField); {"stringField":null}. This may indicate a faulty database adapter implementation.',
       );
@@ -196,9 +181,11 @@ describe(EntityDatabaseAdapter, () => {
         fetchResults: [{ string_field: undefined }],
       });
       await expect(
-        adapter.fetchManyWhereAsync(queryContext, new SingleFieldHolder('stringField'), [
-          new SingleFieldValueHolder('hello'),
-        ]),
+        adapter.fetchManyWhereAsync(
+          queryContext,
+          new SingleFieldHolder<TestFields, 'customIdField', 'stringField'>('stringField'),
+          [new SingleFieldValueHolder('hello')],
+        ),
       ).rejects.toThrow(
         'One or more fields from the object is invalid for key SingleField(stringField); {}. This may indicate a faulty database adapter implementation.',
       );
@@ -237,40 +224,18 @@ describe(EntityDatabaseAdapter, () => {
     });
   });
 
-  describe('fetchManyByFieldEqualityConjunction', () => {
-    it('transforms object', async () => {
-      const queryContext = instance(mock(EntityQueryContext));
-      const adapter = new TestEntityDatabaseAdapter({
-        fetchEqualityConditionResults: [{ string_field: 'hello' }],
-      });
-      const results = await adapter.fetchManyByFieldEqualityConjunctionAsync(queryContext, [], {});
-      expect(results).toEqual([{ stringField: 'hello' }]);
-    });
-  });
-
-  describe('fetchManyWithRawWhereClause', () => {
-    it('transforms object', async () => {
-      const queryContext = instance(mock(EntityQueryContext));
-      const adapter = new TestEntityDatabaseAdapter({
-        fetchRawWhereResults: [{ string_field: 'hello' }],
-      });
-      const results = await adapter.fetchManyByRawWhereClauseAsync(queryContext, 'hello', [], {});
-      expect(results).toEqual([{ stringField: 'hello' }]);
-    });
-  });
-
   describe('insertAsync', () => {
     it('transforms object', async () => {
       const queryContext = instance(mock(EntityQueryContext));
       const adapter = new TestEntityDatabaseAdapter({ insertResults: [{ string_field: 'hello' }] });
-      const result = await adapter.insertAsync(queryContext, {} as any);
+      const result = await adapter.insertAsync(queryContext, {});
       expect(result).toEqual({ stringField: 'hello' });
     });
 
     it('throws when insert result count zero', async () => {
       const queryContext = instance(mock(EntityQueryContext));
       const adapter = new TestEntityDatabaseAdapter({ insertResults: [] });
-      await expect(adapter.insertAsync(queryContext, {} as any)).rejects.toThrow(
+      await expect(adapter.insertAsync(queryContext, {})).rejects.toThrow(
         EntityDatabaseAdapterEmptyInsertResultError,
       );
     });
@@ -280,7 +245,7 @@ describe(EntityDatabaseAdapter, () => {
       const adapter = new TestEntityDatabaseAdapter({
         insertResults: [{ string_field: 'hello' }, { string_field: 'hello2' }],
       });
-      await expect(adapter.insertAsync(queryContext, {} as any)).rejects.toThrow(
+      await expect(adapter.insertAsync(queryContext, {})).rejects.toThrow(
         EntityDatabaseAdapterExcessiveInsertResultError,
       );
     });
@@ -290,16 +255,16 @@ describe(EntityDatabaseAdapter, () => {
     it('transforms object', async () => {
       const queryContext = instance(mock(EntityQueryContext));
       const adapter = new TestEntityDatabaseAdapter({ updateResults: [{ string_field: 'hello' }] });
-      const result = await adapter.updateAsync(queryContext, 'customIdField', 'wat', {} as any);
+      const result = await adapter.updateAsync(queryContext, 'customIdField', 'wat', {});
       expect(result).toEqual({ stringField: 'hello' });
     });
 
     it('throws when update result count zero', async () => {
       const queryContext = instance(mock(EntityQueryContext));
       const adapter = new TestEntityDatabaseAdapter({ updateResults: [] });
-      await expect(
-        adapter.updateAsync(queryContext, 'customIdField', 'wat', {} as any),
-      ).rejects.toThrow(EntityDatabaseAdapterEmptyUpdateResultError);
+      await expect(adapter.updateAsync(queryContext, 'customIdField', 'wat', {})).rejects.toThrow(
+        EntityDatabaseAdapterEmptyUpdateResultError,
+      );
     });
 
     it('throws when update result count greater than 1', async () => {
@@ -307,9 +272,9 @@ describe(EntityDatabaseAdapter, () => {
       const adapter = new TestEntityDatabaseAdapter({
         updateResults: [{ string_field: 'hello' }, { string_field: 'hello2' }],
       });
-      await expect(
-        adapter.updateAsync(queryContext, 'customIdField', 'wat', {} as any),
-      ).rejects.toThrow(EntityDatabaseAdapterExcessiveUpdateResultError);
+      await expect(adapter.updateAsync(queryContext, 'customIdField', 'wat', {})).rejects.toThrow(
+        EntityDatabaseAdapterExcessiveUpdateResultError,
+      );
     });
   });
 

package/src/__tests__/EntityEdges-test.ts

@@ -772,7 +772,7 @@ describe('EntityMutator.processEntityDeletionForInboundEdgesAsync', () => {
         'id'
       >;
       const childCachedBefore = await childCacheAdapter.loadManyAsync(
-        new SingleFieldHolder('parent_id'),
+        new SingleFieldHolder<ChildFields, 'id', 'parent_id'>('parent_id'),
         [new SingleFieldValueHolder(parent.getID())],
       );
       expect(childCachedBefore.get(new SingleFieldValueHolder(parent.getID()))?.status).toEqual(
@@ -783,9 +783,9 @@ describe('EntityMutator.processEntityDeletionForInboundEdgesAsync', () => {
         GrandChildEntity,
       )['entityCompanion']['tableDataCoordinator'][
         'cacheAdapter'
-      ] as InMemoryFullCacheStubCacheAdapter<ChildFields, 'id'>;
+      ] as InMemoryFullCacheStubCacheAdapter<GrandChildFields, 'id'>;
       const grandChildCachedBefore = await grandChildCacheAdapter.loadManyAsync(
-        new SingleFieldHolder('parent_id'),
+        new SingleFieldHolder<GrandChildFields, 'id', 'parent_id'>('parent_id'),
         [new SingleFieldValueHolder(child.getID())],
       );
       expect(grandChildCachedBefore.get(new SingleFieldValueHolder(child.getID()))?.status).toEqual(
@@ -797,7 +797,7 @@ describe('EntityMutator.processEntityDeletionForInboundEdgesAsync', () => {
       privacyPolicyEvaluationRecords.shouldRecord = false;
 
       const childCachedAfter = await childCacheAdapter.loadManyAsync(
-        new SingleFieldHolder('parent_id'),
+        new SingleFieldHolder<ChildFields, 'id', 'parent_id'>('parent_id'),
         [new SingleFieldValueHolder(parent.getID())],
       );
       expect(childCachedAfter.get(new SingleFieldValueHolder(parent.getID()))?.status).toEqual(
@@ -805,7 +805,7 @@ describe('EntityMutator.processEntityDeletionForInboundEdgesAsync', () => {
       );
 
       const grandChildCachedAfter = await grandChildCacheAdapter.loadManyAsync(
-        new SingleFieldHolder('parent_id'),
+        new SingleFieldHolder<GrandChildFields, 'id', 'parent_id'>('parent_id'),
         [new SingleFieldValueHolder(child.getID())],
       );
       expect(grandChildCachedAfter.get(new SingleFieldValueHolder(child.getID()))?.status).toEqual(
@@ -922,7 +922,7 @@ describe('EntityMutator.processEntityDeletionForInboundEdgesAsync', () => {
         'id'
       >;
       const childCachedBefore = await childCacheAdapter.loadManyAsync(
-        new SingleFieldHolder('parent_id'),
+        new SingleFieldHolder<ChildFields, 'id', 'parent_id'>('parent_id'),
         [new SingleFieldValueHolder(parent.getID())],
       );
       expect(childCachedBefore.get(new SingleFieldValueHolder(parent.getID()))?.status).toEqual(
@@ -933,9 +933,9 @@ describe('EntityMutator.processEntityDeletionForInboundEdgesAsync', () => {
         GrandChildEntity,
       )['entityCompanion']['tableDataCoordinator'][
         'cacheAdapter'
-      ] as InMemoryFullCacheStubCacheAdapter<ChildFields, 'id'>;
+      ] as InMemoryFullCacheStubCacheAdapter<GrandChildFields, 'id'>;
       const grandChildCachedBefore = await grandChildCacheAdapter.loadManyAsync(
-        new SingleFieldHolder('parent_id'),
+        new SingleFieldHolder<GrandChildFields, 'id', 'parent_id'>('parent_id'),
         [new SingleFieldValueHolder(child.getID())],
       );
       expect(grandChildCachedBefore.get(new SingleFieldValueHolder(child.getID()))?.status).toEqual(
@@ -947,7 +947,7 @@ describe('EntityMutator.processEntityDeletionForInboundEdgesAsync', () => {
       privacyPolicyEvaluationRecords.shouldRecord = false;
 
       const childCachedAfter = await childCacheAdapter.loadManyAsync(
-        new SingleFieldHolder('parent_id'),
+        new SingleFieldHolder<ChildFields, 'id', 'parent_id'>('parent_id'),
         [new SingleFieldValueHolder(parent.getID())],
       );
       expect(childCachedAfter.get(new SingleFieldValueHolder(parent.getID()))?.status).toEqual(
@@ -955,7 +955,7 @@ describe('EntityMutator.processEntityDeletionForInboundEdgesAsync', () => {
       );
 
       const grandChildCachedAfter = await grandChildCacheAdapter.loadManyAsync(
-        new SingleFieldHolder('parent_id'),
+        new SingleFieldHolder<GrandChildFields, 'id', 'parent_id'>('parent_id'),
         [new SingleFieldValueHolder(child.getID())],
       );
       expect(grandChildCachedAfter.get(new SingleFieldValueHolder(child.getID()))?.status).toEqual(

package/src/__tests__/EntityLoader-test.ts

@@ -2,8 +2,8 @@ import { describe, expect, it } from '@jest/globals';
 
 import { AuthorizationResultBasedEntityLoader } from '../AuthorizationResultBasedEntityLoader';
 import { EnforcingEntityLoader } from '../EnforcingEntityLoader';
+import { EntityInvalidationUtils } from '../EntityInvalidationUtils';
 import { EntityLoader } from '../EntityLoader';
-import { EntityLoaderUtils } from '../EntityLoaderUtils';
 import { ViewerContext } from '../ViewerContext';
 import { SimpleTestEntity } from '../utils/__testfixtures__/SimpleTestEntity';
 import { createUnitTestEntityCompanionProvider } from '../utils/__testfixtures__/createUnitTestEntityCompanionProvider';
@@ -27,11 +27,13 @@ describe(EntityLoader, () => {
     });
   });
 
-  describe('utils', () => {
-    it('returns a instance of EntityLoaderUtils', async () => {
+  describe('invalidationUtils', () => {
+    it('returns a instance of EntityInvalidationUtils', async () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new ViewerContext(companionProvider);
-      expect(SimpleTestEntity.loaderUtils(viewerContext)).toBeInstanceOf(EntityLoaderUtils);
+      expect(SimpleTestEntity.invalidationUtils(viewerContext)).toBeInstanceOf(
+        EntityInvalidationUtils,
+      );
     });
   });
 });

package/src/__tests__/EntityMutator-test.ts

@@ -16,9 +16,9 @@ import { v4 as uuidv4 } from 'uuid';
 import { AuthorizationResultBasedEntityLoader } from '../AuthorizationResultBasedEntityLoader';
 import { EntityCompanionProvider } from '../EntityCompanionProvider';
 import { EntityConfiguration } from '../EntityConfiguration';
+import { EntityConstructionUtils } from '../EntityConstructionUtils';
 import { EntityDatabaseAdapter } from '../EntityDatabaseAdapter';
 import { EntityLoaderFactory } from '../EntityLoaderFactory';
-import { EntityLoaderUtils } from '../EntityLoaderUtils';
 import {
   EntityCascadingDeletionInfo,
   EntityMutationType,
@@ -370,10 +370,10 @@ const createEntityMutatorFactory = (
     ),
   );
   const customStubDatabaseAdapterProvider: IEntityDatabaseAdapterProvider = {
-    getDatabaseAdapter<TFields extends Record<'customIdField', any>>(
-      _entityConfiguration: EntityConfiguration<TFields, 'customIdField'>,
-    ): EntityDatabaseAdapter<TFields, 'customIdField'> {
-      return databaseAdapter as any as EntityDatabaseAdapter<TFields, 'customIdField'>;
+    getDatabaseAdapter<TFields extends Record<string, any>, TIDField extends keyof TFields>(
+      _entityConfiguration: EntityConfiguration<TFields, TIDField>,
+    ): EntityDatabaseAdapter<TFields, TIDField> {
+      return databaseAdapter as any as EntityDatabaseAdapter<TFields, TIDField>;
     },
   };
   const metricsAdapter = new NoOpEntityMetricsAdapter();
@@ -1499,9 +1499,9 @@ describe(EntityMutatorFactory, () => {
         keyof SimpleTestFields
       >
     >(AuthorizationResultBasedEntityLoader);
-    const entityLoaderUtilsMock =
+    const entityConstructionUtilsMock =
       mock<
-        EntityLoaderUtils<
+        EntityConstructionUtils<
           SimpleTestFields,
           'id',
           ViewerContext,
@@ -1509,9 +1509,8 @@ describe(EntityMutatorFactory, () => {
           SimpleTestEntityPrivacyPolicy,
           keyof SimpleTestFields
         >
-      >(EntityLoaderUtils);
-    when(entityLoaderUtilsMock.constructEntity(anything())).thenReturn(fakeEntity);
-    when(entityLoaderMock.utils).thenReturn(instance(entityLoaderUtilsMock));
+      >(EntityConstructionUtils);
+    when(entityConstructionUtilsMock.constructEntity(anything())).thenReturn(fakeEntity);
     const entityLoader = instance(entityLoaderMock);
 
     const entityLoaderFactoryMock =
@@ -1532,6 +1531,13 @@ describe(EntityMutatorFactory, () => {
         anything(),
       ),
     ).thenReturn(entityLoader);
+    when(
+      entityLoaderFactoryMock.constructionUtils(
+        viewerContext,
+        anyOfClass(EntityTransactionalQueryContext),
+        anything(),
+      ),
+    ).thenReturn(instance(entityConstructionUtilsMock));
     const entityLoaderFactory = instance(entityLoaderFactoryMock);
 
     const rejectionError = new Error();
@@ -1634,9 +1640,9 @@ describe(EntityMutatorFactory, () => {
         keyof SimpleTestFields
       >
     >(AuthorizationResultBasedEntityLoader);
-    const entityLoaderUtilsMock =
+    const entityConstructionUtilsMock =
       mock<
-        EntityLoaderUtils<
+        EntityConstructionUtils<
           SimpleTestFields,
           'id',
           ViewerContext,
@@ -1644,9 +1650,8 @@ describe(EntityMutatorFactory, () => {
           SimpleTestEntityPrivacyPolicy,
           keyof SimpleTestFields
         >
-      >(EntityLoaderUtils);
-    when(entityLoaderUtilsMock.constructEntity(anything())).thenReturn(fakeEntity);
-    when(entityLoaderMock.utils).thenReturn(instance(entityLoaderUtilsMock));
+      >(EntityConstructionUtils);
+    when(entityConstructionUtilsMock.constructEntity(anything())).thenReturn(fakeEntity);
     const entityLoader = instance(entityLoaderMock);
 
     const entityLoaderFactoryMock =
@@ -1667,6 +1672,13 @@ describe(EntityMutatorFactory, () => {
         anything(),
       ),
     ).thenReturn(entityLoader);
+    when(
+      entityLoaderFactoryMock.constructionUtils(
+        viewerContext,
+        anyOfClass(EntityTransactionalQueryContext),
+        anything(),
+      ),
+    ).thenReturn(instance(entityConstructionUtilsMock));
     const entityLoaderFactory = instance(entityLoaderFactoryMock);
 
     const rejectionError = new Error();