@expo/entity 0.55.0 → 0.57.0

package/src/__tests__/EntityPrivacyPolicy-test.ts

@@ -11,6 +11,7 @@ import {
   EntityPrivacyPolicyEvaluationContext,
   EntityPrivacyPolicyEvaluationMode,
   EntityPrivacyPolicyEvaluator,
+  EntityPrivacyPolicyRuleEvaluationContext,
 } from '../EntityPrivacyPolicy';
 import { EntityQueryContext } from '../EntityQueryContext';
 import { ViewerContext } from '../ViewerContext';
@@ -273,6 +274,47 @@ class EmptyPolicy extends EntityPrivacyPolicy<BlahFields, 'id', ViewerContext, B
   protected override readonly deleteRules = [];
 }
 
+class ContextCapturingRule extends PrivacyPolicyRule<BlahFields, 'id', ViewerContext, BlahEntity> {
+  public capturedContext: EntityPrivacyPolicyRuleEvaluationContext<
+    BlahFields,
+    'id',
+    ViewerContext,
+    BlahEntity
+  > | null = null;
+
+  async evaluateAsync(
+    _viewerContext: ViewerContext,
+    _queryContext: EntityQueryContext,
+    evaluationContext: EntityPrivacyPolicyRuleEvaluationContext<
+      BlahFields,
+      'id',
+      ViewerContext,
+      BlahEntity
+    >,
+    _entity: BlahEntity,
+  ): Promise<RuleEvaluationResult> {
+    this.capturedContext = evaluationContext;
+    return RuleEvaluationResult.ALLOW;
+  }
+}
+
+class ContextCapturingPolicy extends EntityPrivacyPolicy<
+  BlahFields,
+  'id',
+  ViewerContext,
+  BlahEntity
+> {
+  public readonly createRule = new ContextCapturingRule();
+  public readonly readRule = new ContextCapturingRule();
+  public readonly updateRule = new ContextCapturingRule();
+  public readonly deleteRule = new ContextCapturingRule();
+
+  protected override readonly createRules = [this.createRule];
+  protected override readonly readRules = [this.readRule];
+  protected override readonly updateRules = [this.updateRule];
+  protected override readonly deleteRules = [this.deleteRule];
+}
+
 describe(EntityPrivacyPolicy, () => {
   describe(EntityPrivacyPolicyEvaluationMode.ENFORCE.toString(), () => {
     it('throws EntityNotAuthorizedError when deny', async () => {
@@ -718,4 +760,64 @@ describe(EntityPrivacyPolicy, () => {
       verify(metricsAdapterMock.logAuthorizationEvent(anything())).never();
     });
   });
+
+  describe('EntityPrivacyPolicyRuleEvaluationContext', () => {
+    it('passes correct authorization action to rules for each CRUD operation', async () => {
+      const viewerContext = instance(mock(ViewerContext));
+      const queryContext = instance(mock(EntityQueryContext));
+      const privacyPolicyEvaluationContext: EntityPrivacyPolicyEvaluationContext<
+        BlahFields,
+        'id',
+        ViewerContext,
+        BlahEntity
+      > = {
+        previousValue: null,
+        cascadingDeleteCause: null,
+      };
+      const metricsAdapter = instance(mock<IEntityMetricsAdapter>());
+      const entity = new BlahEntity({
+        viewerContext,
+        id: '1',
+        databaseFields: { id: '1' },
+        selectedFields: { id: '1' },
+      });
+      const policy = new ContextCapturingPolicy();
+
+      await policy.authorizeCreateAsync(
+        viewerContext,
+        queryContext,
+        privacyPolicyEvaluationContext,
+        entity,
+        metricsAdapter,
+      );
+      expect(policy.createRule.capturedContext?.action).toBe(EntityAuthorizationAction.CREATE);
+
+      await policy.authorizeReadAsync(
+        viewerContext,
+        queryContext,
+        privacyPolicyEvaluationContext,
+        entity,
+        metricsAdapter,
+      );
+      expect(policy.readRule.capturedContext?.action).toBe(EntityAuthorizationAction.READ);
+
+      await policy.authorizeUpdateAsync(
+        viewerContext,
+        queryContext,
+        privacyPolicyEvaluationContext,
+        entity,
+        metricsAdapter,
+      );
+      expect(policy.updateRule.capturedContext?.action).toBe(EntityAuthorizationAction.UPDATE);
+
+      await policy.authorizeDeleteAsync(
+        viewerContext,
+        queryContext,
+        privacyPolicyEvaluationContext,
+        entity,
+        metricsAdapter,
+      );
+      expect(policy.deleteRule.capturedContext?.action).toBe(EntityAuthorizationAction.DELETE);
+    });
+  });
 });

package/src/__tests__/EntityQueryContext-test.ts

@@ -49,7 +49,7 @@ describe(EntityQueryContext, () => {
         );
       });
 
-      await viewerContext.runInTransactionForDatabaseAdaptorFlavorAsync(
+      await viewerContext.runInTransactionForDatabaseAdapterFlavorAsync(
         'postgres',
         async (queryContext) => {
           queryContext.appendPostCommitCallback(postCommitCallback);
@@ -76,7 +76,7 @@ describe(EntityQueryContext, () => {
       const postCommitCallback = jest.fn(async (): Promise<void> => {});
 
       await expect(
-        viewerContext.runInTransactionForDatabaseAdaptorFlavorAsync(
+        viewerContext.runInTransactionForDatabaseAdapterFlavorAsync(
           'postgres',
           async (queryContext) => {
             queryContext.appendPostCommitCallback(postCommitCallback);
@@ -105,7 +105,7 @@ describe(EntityQueryContext, () => {
       const postCommitCallback = jest.fn(async (): Promise<void> => {});
       const postCommitNestedCallback = jest.fn(async (): Promise<void> => {});
 
-      await viewerContext.runInTransactionForDatabaseAdaptorFlavorAsync(
+      await viewerContext.runInTransactionForDatabaseAdapterFlavorAsync(
         'postgres',
         async (queryContext) => {
           queryContext.appendPostCommitCallback(postCommitCallback);
@@ -152,13 +152,13 @@ describe(EntityQueryContext, () => {
       const viewerContext = new ViewerContext(companionProvider);
 
       const queryContextProvider =
-        companionProvider.getQueryContextProviderForDatabaseAdaptorFlavor('postgres');
+        companionProvider.getQueryContextProviderForDatabaseAdapterFlavor('postgres');
       const queryContextProviderSpy = jest.spyOn(queryContextProvider, 'runInTransactionAsync');
 
       const transactionScopeFn = async (): Promise<any> => {};
       const transactionConfig = { isolationLevel: TransactionIsolationLevel.SERIALIZABLE };
 
-      await viewerContext.runInTransactionForDatabaseAdaptorFlavorAsync(
+      await viewerContext.runInTransactionForDatabaseAdapterFlavorAsync(
         'postgres',
         transactionScopeFn,
         transactionConfig,
@@ -171,7 +171,7 @@ describe(EntityQueryContext, () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new ViewerContext(companionProvider);
 
-      await viewerContext.runInTransactionForDatabaseAdaptorFlavorAsync(
+      await viewerContext.runInTransactionForDatabaseAdapterFlavorAsync(
         'postgres',
         async (queryContext) => {
           assert(queryContext.isInTransaction());
@@ -182,7 +182,7 @@ describe(EntityQueryContext, () => {
         { transactionalDataLoaderMode: TransactionalDataLoaderMode.DISABLED },
       );
 
-      await viewerContext.runInTransactionForDatabaseAdaptorFlavorAsync(
+      await viewerContext.runInTransactionForDatabaseAdapterFlavorAsync(
         'postgres',
         async (queryContext) => {
           assert(queryContext.isInTransaction());
@@ -193,7 +193,7 @@ describe(EntityQueryContext, () => {
         { transactionalDataLoaderMode: TransactionalDataLoaderMode.ENABLED_BATCH_ONLY },
       );
 
-      await viewerContext.runInTransactionForDatabaseAdaptorFlavorAsync(
+      await viewerContext.runInTransactionForDatabaseAdapterFlavorAsync(
         'postgres',
         async (queryContext) => {
           assert(queryContext.isInTransaction());
@@ -252,7 +252,7 @@ describe(EntityQueryContext, () => {
       );
       const viewerContext = new ViewerContext(companionProvider);
 
-      await viewerContext.runInTransactionForDatabaseAdaptorFlavorAsync(
+      await viewerContext.runInTransactionForDatabaseAdapterFlavorAsync(
         'postgres',
         async (queryContext) => {
           assert(queryContext.isInTransaction());
@@ -263,7 +263,7 @@ describe(EntityQueryContext, () => {
         { transactionalDataLoaderMode: TransactionalDataLoaderMode.DISABLED },
       );
 
-      await viewerContext.runInTransactionForDatabaseAdaptorFlavorAsync(
+      await viewerContext.runInTransactionForDatabaseAdapterFlavorAsync(
         'postgres',
         async (queryContext) => {
           assert(queryContext.isInTransaction());
@@ -274,7 +274,7 @@ describe(EntityQueryContext, () => {
         { transactionalDataLoaderMode: TransactionalDataLoaderMode.ENABLED_BATCH_ONLY },
       );
 
-      await viewerContext.runInTransactionForDatabaseAdaptorFlavorAsync(
+      await viewerContext.runInTransactionForDatabaseAdapterFlavorAsync(
         'postgres',
         async (queryContext) => {
           assert(queryContext.isInTransaction());

package/src/__tests__/EntitySecondaryCacheLoader-test.ts

@@ -46,7 +46,7 @@ describe(EntitySecondaryCacheLoader, () => {
 
       const secondaryCacheLoader = new TestSecondaryRedisCacheLoader(
         secondaryEntityCache,
-        SimpleTestEntity.loaderWithAuthorizationResults(vc1),
+        EntitySecondaryCacheLoader.getConstructionUtilsForEntityClass(SimpleTestEntity, vc1),
       );
 
       await secondaryCacheLoader.loadManyAsync([loadParams]);
@@ -70,8 +70,11 @@ describe(EntitySecondaryCacheLoader, () => {
       const secondaryEntityCache = instance(secondaryEntityCacheMock);
 
       const loader = SimpleTestEntity.loaderWithAuthorizationResults(vc1);
-      const spiedPrivacyPolicy = spy(loader.utils['privacyPolicy']);
-      const secondaryCacheLoader = new TestSecondaryRedisCacheLoader(secondaryEntityCache, loader);
+      const spiedPrivacyPolicy = spy(loader['constructionUtils']['privacyPolicy']);
+      const secondaryCacheLoader = new TestSecondaryRedisCacheLoader(
+        secondaryEntityCache,
+        EntitySecondaryCacheLoader.getConstructionUtilsForEntityClass(SimpleTestEntity, vc1),
+      );
 
       const result = await secondaryCacheLoader.loadManyAsync([loadParams]);
       expect(result.get(loadParams)?.enforceValue().getID()).toEqual(createdEntity.getID());
@@ -98,8 +101,10 @@ describe(EntitySecondaryCacheLoader, () => {
       const secondaryEntityCacheMock =
         mock<ISecondaryEntityCache<SimpleTestFields, TestLoadParams>>();
       const secondaryEntityCache = instance(secondaryEntityCacheMock);
-      const loader = SimpleTestEntity.loaderWithAuthorizationResults(vc1);
-      const secondaryCacheLoader = new TestSecondaryRedisCacheLoader(secondaryEntityCache, loader);
+      const secondaryCacheLoader = new TestSecondaryRedisCacheLoader(
+        secondaryEntityCache,
+        EntitySecondaryCacheLoader.getConstructionUtilsForEntityClass(SimpleTestEntity, vc1),
+      );
       await secondaryCacheLoader.invalidateManyAsync([loadParams]);
 
       verify(secondaryEntityCacheMock.invalidateManyAsync(deepEqual([loadParams]))).once();

package/src/__tests__/EntitySelfReferentialEdges-test.ts

@@ -250,7 +250,7 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE', () => {
       'cacheAdapter'
     ] as InMemoryFullCacheStubCacheAdapter<CategoryFields, 'id'>;
     const subCategoryCachedBefore = await categoryCacheAdapter.loadManyAsync(
-      new SingleFieldHolder('parent_category_id'),
+      new SingleFieldHolder<CategoryFields, 'id', 'parent_category_id'>('parent_category_id'),
       [new SingleFieldValueHolder(parentCategory.getID())],
     );
     expect(
@@ -258,7 +258,7 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE', () => {
     ).toEqual(CacheStatus.HIT);
 
     const subSubCategoryCachedBefore = await categoryCacheAdapter.loadManyAsync(
-      new SingleFieldHolder('parent_category_id'),
+      new SingleFieldHolder<CategoryFields, 'id', 'parent_category_id'>('parent_category_id'),
       [new SingleFieldValueHolder(subCategory.getID())],
     );
     expect(
@@ -268,7 +268,7 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE', () => {
     await CategoryEntity.deleter(parentCategory).deleteAsync();
 
     const subCategoryCachedAfter = await categoryCacheAdapter.loadManyAsync(
-      new SingleFieldHolder('parent_category_id'),
+      new SingleFieldHolder<CategoryFields, 'id', 'parent_category_id'>('parent_category_id'),
       [new SingleFieldValueHolder(parentCategory.getID())],
     );
     expect(
@@ -276,7 +276,7 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE', () => {
     ).toEqual(CacheStatus.MISS);
 
     const subSubCategoryCachedAfter = await categoryCacheAdapter.loadManyAsync(
-      new SingleFieldHolder('parent_category_id'),
+      new SingleFieldHolder<CategoryFields, 'id', 'parent_category_id'>('parent_category_id'),
       [new SingleFieldValueHolder(subCategory.getID())],
     );
     expect(
@@ -329,7 +329,7 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE', () => {
       'cacheAdapter'
     ] as InMemoryFullCacheStubCacheAdapter<CategoryFields, 'id'>;
     const categoriesCachedBefore = await categoryCacheAdapter.loadManyAsync(
-      new SingleFieldHolder('parent_category_id'),
+      new SingleFieldHolder<CategoryFields, 'id', 'parent_category_id'>('parent_category_id'),
       [
         new SingleFieldValueHolder(categoryA.getID()),
         new SingleFieldValueHolder(categoryB.getID()),
@@ -345,7 +345,7 @@ describe('EntityEdgeDeletionBehavior.CASCADE_DELETE_INVALIDATE_CACHE', () => {
     await CategoryEntity.deleter(categoryA).deleteAsync();
 
     const categoriesCachedAfter = await categoryCacheAdapter.loadManyAsync(
-      new SingleFieldHolder('parent_category_id'),
+      new SingleFieldHolder<CategoryFields, 'id', 'parent_category_id'>('parent_category_id'),
       [
         new SingleFieldValueHolder(categoryA.getID()),
         new SingleFieldValueHolder(categoryB.getID()),

package/src/__tests__/GenericEntityCacheAdapter-test.ts

@@ -22,7 +22,7 @@ describe(GenericEntityCacheAdapter, () => {
       const mockGenericCacher = mock<IEntityGenericCacher<BlahFields, 'id'>>();
       when(
         mockGenericCacher.makeCacheKeyForStorage(
-          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware(new SingleFieldHolder<BlahFields, 'id', 'id'>('id')),
           anything(),
         ),
       ).thenCall((fieldHolder, fieldValueHolder) => {
@@ -38,11 +38,14 @@ describe(GenericEntityCacheAdapter, () => {
 
       const cacheAdapter = new GenericEntityCacheAdapter(instance(mockGenericCacher));
 
-      const results = await cacheAdapter.loadManyAsync(new SingleFieldHolder('id'), [
-        new SingleFieldValueHolder('wat'),
-        new SingleFieldValueHolder('who'),
-        new SingleFieldValueHolder('why'),
-      ]);
+      const results = await cacheAdapter.loadManyAsync(
+        new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
+        [
+          new SingleFieldValueHolder('wat'),
+          new SingleFieldValueHolder('who'),
+          new SingleFieldValueHolder('why'),
+        ],
+      );
       expect(results.get(new SingleFieldValueHolder('wat'))).toMatchObject({
         status: CacheStatus.HIT,
         item: { id: 'wat' },
@@ -74,7 +77,7 @@ describe(GenericEntityCacheAdapter, () => {
       const mockGenericCacher = mock<IEntityGenericCacher<BlahFields, 'id'>>();
       when(
         mockGenericCacher.makeCacheKeyForStorage(
-          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware(new SingleFieldHolder<BlahFields, 'id', 'id'>('id')),
           anything(),
         ),
       ).thenCall((fieldHolder, fieldValueHolder) => {
@@ -85,7 +88,7 @@ describe(GenericEntityCacheAdapter, () => {
 
       const cacheAdapter = new GenericEntityCacheAdapter(instance(mockGenericCacher));
       await expect(
-        cacheAdapter.loadManyAsync(new SingleFieldHolder('id'), [
+        cacheAdapter.loadManyAsync(new SingleFieldHolder<BlahFields, 'id', 'id'>('id'), [
           new SingleFieldValueHolder('wat'),
         ]),
       ).rejects.toThrow(expectedError);
@@ -99,7 +102,7 @@ describe(GenericEntityCacheAdapter, () => {
       const mockGenericCacher = mock<IEntityGenericCacher<BlahFields, 'id'>>();
       when(
         mockGenericCacher.makeCacheKeyForStorage(
-          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware(new SingleFieldHolder<BlahFields, 'id', 'id'>('id')),
           anything(),
         ),
       ).thenCall((fieldHolder, fieldValueHolder) => {
@@ -108,7 +111,7 @@ describe(GenericEntityCacheAdapter, () => {
 
       const cacheAdapter = new GenericEntityCacheAdapter(instance(mockGenericCacher));
       await cacheAdapter.cacheManyAsync(
-        new SingleFieldHolder('id'),
+        new SingleFieldHolder<BlahFields, 'id', 'id'>('id'),
         new Map([[new SingleFieldValueHolder('wat'), { id: 'wat' }]]),
       );
 
@@ -123,7 +126,7 @@ describe(GenericEntityCacheAdapter, () => {
       const mockGenericCacher = mock<IEntityGenericCacher<BlahFields, 'id'>>();
       when(
         mockGenericCacher.makeCacheKeyForStorage(
-          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware(new SingleFieldHolder<BlahFields, 'id', 'id'>('id')),
           anything(),
         ),
       ).thenCall((fieldHolder, fieldValueHolder) => {
@@ -131,7 +134,7 @@ describe(GenericEntityCacheAdapter, () => {
       });
 
       const cacheAdapter = new GenericEntityCacheAdapter(instance(mockGenericCacher));
-      await cacheAdapter.cacheDBMissesAsync(new SingleFieldHolder('id'), [
+      await cacheAdapter.cacheDBMissesAsync(new SingleFieldHolder<BlahFields, 'id', 'id'>('id'), [
         new SingleFieldValueHolder('wat'),
       ]);
 
@@ -144,7 +147,7 @@ describe(GenericEntityCacheAdapter, () => {
       const mockGenericCacher = mock<IEntityGenericCacher<BlahFields, 'id'>>();
       when(
         mockGenericCacher.makeCacheKeysForInvalidation(
-          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware(new SingleFieldHolder<BlahFields, 'id', 'id'>('id')),
           anything(),
         ),
       ).thenCall((fieldHolder, fieldValueHolder) => {
@@ -152,7 +155,7 @@ describe(GenericEntityCacheAdapter, () => {
       });
 
       const cacheAdapter = new GenericEntityCacheAdapter(instance(mockGenericCacher));
-      await cacheAdapter.invalidateManyAsync(new SingleFieldHolder('id'), [
+      await cacheAdapter.invalidateManyAsync(new SingleFieldHolder<BlahFields, 'id', 'id'>('id'), [
         new SingleFieldValueHolder('wat'),
       ]);
 
@@ -163,7 +166,7 @@ describe(GenericEntityCacheAdapter, () => {
       const mockGenericCacher = mock<IEntityGenericCacher<BlahFields, 'id'>>();
       when(
         mockGenericCacher.makeCacheKeysForInvalidation(
-          deepEqualEntityAware(new SingleFieldHolder('id')),
+          deepEqualEntityAware(new SingleFieldHolder<BlahFields, 'id', 'id'>('id')),
           anything(),
         ),
       ).thenCall((fieldHolder, fieldValueHolder) => {

package/src/__tests__/GenericSecondaryEntityCache-test.ts

@@ -1,6 +1,8 @@
 import { describe, it, expect } from '@jest/globals';
 import nullthrows from 'nullthrows';
 
+import { AuthorizationResultBasedEntityLoader } from '../AuthorizationResultBasedEntityLoader';
+import { EntityConstructionUtils } from '../EntityConstructionUtils';
 import { EntitySecondaryCacheLoader } from '../EntitySecondaryCacheLoader';
 import { GenericSecondaryEntityCache } from '../GenericSecondaryEntityCache';
 import { IEntityGenericCacher } from '../IEntityGenericCacher';
@@ -100,6 +102,28 @@ class TestSecondaryCacheLoader extends EntitySecondaryCacheLoader<
 > {
   public databaseLoadCount = 0;
 
+  constructor(
+    secondaryEntityCache: TestSecondaryEntityCache<TestFields, 'customIdField', TestLoadParams>,
+    constructionUtils: EntityConstructionUtils<
+      TestFields,
+      'customIdField',
+      ViewerContext,
+      TestEntity,
+      TestEntityPrivacyPolicy,
+      keyof TestFields
+    >,
+    private readonly entityLoader: AuthorizationResultBasedEntityLoader<
+      TestFields,
+      'customIdField',
+      ViewerContext,
+      TestEntity,
+      TestEntityPrivacyPolicy,
+      keyof TestFields
+    >,
+  ) {
+    super(secondaryEntityCache, constructionUtils);
+  }
+
   protected override async fetchObjectsFromDatabaseAsync(
     loadParamsArray: readonly Readonly<TestLoadParams>[],
   ): Promise<ReadonlyMap<Readonly<Readonly<TestLoadParams>>, Readonly<TestFields> | null>> {
@@ -108,11 +132,7 @@ class TestSecondaryCacheLoader extends EntitySecondaryCacheLoader<
     const emptyMap = new Map(loadParamsArray.map((p) => [p, null]));
     return await mapMapAsync(emptyMap, async (_value, loadParams) => {
       return (
-        (
-          await this.entityLoader.loadManyByFieldEqualityConjunctionAsync([
-            { fieldName: 'intField', fieldValue: loadParams.intValue },
-          ])
-        )[0]
+        (await this.entityLoader.loadManyByFieldEqualingAsync('intField', loadParams.intValue))[0]
           ?.enforceValue()
           ?.getAllFields() ?? null
       );
@@ -133,6 +153,7 @@ describe(GenericSecondaryEntityCache, () => {
         new TestGenericCacher(),
         (params) => `intValue.${params.intValue}`,
       ),
+      EntitySecondaryCacheLoader.getConstructionUtilsForEntityClass(TestEntity, viewerContext),
       TestEntity.loaderWithAuthorizationResults(viewerContext),
     );
 
@@ -169,6 +190,7 @@ describe(GenericSecondaryEntityCache, () => {
         new TestGenericCacher(),
         (params) => `intValue.${params.intValue}`,
       ),
+      EntitySecondaryCacheLoader.getConstructionUtilsForEntityClass(TestEntity, viewerContext),
       TestEntity.loaderWithAuthorizationResults(viewerContext),
     );
 

package/src/__tests__/ReadonlyEntity-test.ts

@@ -5,7 +5,7 @@ import { AuthorizationResultBasedEntityAssociationLoader } from '../Authorizatio
 import { AuthorizationResultBasedEntityLoader } from '../AuthorizationResultBasedEntityLoader';
 import { EnforcingEntityAssociationLoader } from '../EnforcingEntityAssociationLoader';
 import { EnforcingEntityLoader } from '../EnforcingEntityLoader';
-import { EntityLoaderUtils } from '../EntityLoaderUtils';
+import { EntityInvalidationUtils } from '../EntityInvalidationUtils';
 import { ReadonlyEntity } from '../ReadonlyEntity';
 import { ViewerContext } from '../ViewerContext';
 import { SimpleTestEntity } from '../utils/__testfixtures__/SimpleTestEntity';
@@ -214,11 +214,13 @@ describe(ReadonlyEntity, () => {
     });
   });
 
-  describe('loaderUtils', () => {
-    it('creates a new EntityLoaderUtils', async () => {
+  describe('invalidationUtils', () => {
+    it('creates a new 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__/ViewerContext-test.ts

@@ -5,22 +5,22 @@ import { ViewerContext } from '../ViewerContext';
 import { createUnitTestEntityCompanionProvider } from '../utils/__testfixtures__/createUnitTestEntityCompanionProvider';
 
 describe(ViewerContext, () => {
-  describe('getQueryContextForDatabaseAdaptorFlavor', () => {
+  describe('getQueryContextForDatabaseAdapterFlavor', () => {
     it('creates a new regular query context', () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new ViewerContext(companionProvider);
-      const queryContext = viewerContext.getQueryContextForDatabaseAdaptorFlavor('postgres');
+      const queryContext = viewerContext.getQueryContextForDatabaseAdapterFlavor('postgres');
       expect(queryContext).toBeInstanceOf(EntityQueryContext);
       expect(queryContext.isInTransaction()).toBe(false);
     });
   });
 
-  describe('runInTransactionForDatabaseAdaptorFlavorAsync', () => {
+  describe('runInTransactionForDatabaseAdapterFlavorAsync', () => {
     it('creates a new transactional query context', async () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new ViewerContext(companionProvider);
       const didCreateTransaction =
-        await viewerContext.runInTransactionForDatabaseAdaptorFlavorAsync(
+        await viewerContext.runInTransactionForDatabaseAdapterFlavorAsync(
           'postgres',
           async (queryContext) => {
             return queryContext.isInTransaction();

package/src/__tests__/ViewerScopedEntityCompanion-test.ts

@@ -33,5 +33,6 @@ describe(ViewerScopedEntityCompanion, () => {
     expect(viewerScopedEntityCompanion.getMutatorFactory()).toBeInstanceOf(
       ViewerScopedEntityMutatorFactory,
     );
+    expect(viewerScopedEntityCompanion.getMetricsAdapter()).toBeDefined();
   });
 });

package/src/__tests__/cases/TwoEntitySameTableDisjointRows-test.ts

@@ -50,23 +50,6 @@ describe('Two entities backed by the same table', () => {
     expect(failedManyResults[0]!.enforceError().message).toEqual(
       'OneTestEntity must be instantiated with one data',
     );
-
-    const fieldEqualityConjunctionResults = await OneTestEntity.loaderWithAuthorizationResults(
-      viewerContext,
-    ).loadManyByFieldEqualityConjunctionAsync([
-      {
-        fieldName: 'common_other_field',
-        fieldValue: 'wat',
-      },
-    ]);
-    const successfulfieldEqualityConjunctionResultsResults = successfulResults(
-      fieldEqualityConjunctionResults,
-    );
-    const failedfieldEqualityConjunctionResultsResults = failedResults(
-      fieldEqualityConjunctionResults,
-    );
-    expect(successfulfieldEqualityConjunctionResultsResults).toHaveLength(1);
-    expect(failedfieldEqualityConjunctionResultsResults).toHaveLength(1);
   });
 });
 

package/src/errors/EntityDatabaseAdapterError.ts

@@ -231,3 +231,17 @@ export class EntityDatabaseAdapterExcessiveDeleteResultError extends EntityDatab
     return EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EXCESSIVE_DELETE_RESULT;
   }
 }
+
+export class EntityDatabaseAdapterPaginationCursorInvalidError extends EntityDatabaseAdapterError {
+  static {
+    this.prototype.name = 'EntityDatabaseAdapterPaginationCursorError';
+  }
+
+  get state(): EntityErrorState.PERMANENT {
+    return EntityErrorState.PERMANENT;
+  }
+
+  get code(): EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_PAGINATION_CURSOR_INVALID {
+    return EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_PAGINATION_CURSOR_INVALID;
+  }
+}

package/src/errors/EntityError.ts

@@ -27,6 +27,7 @@ export enum EntityErrorCode {
   ERR_ENTITY_DATABASE_ADAPTER_EMPTY_UPDATE_RESULT = 'ERR_ENTITY_DATABASE_ADAPTER_EMPTY_UPDATE_RESULT',
   ERR_ENTITY_DATABASE_ADAPTER_EXCESSIVE_DELETE_RESULT = 'ERR_ENTITY_DATABASE_ADAPTER_EXCESSIVE_DELETE_RESULT',
   ERR_ENTITY_CACHE_ADAPTER_TRANSIENT = 'ERR_ENTITY_CACHE_ADAPTER_TRANSIENT',
+  ERR_ENTITY_DATABASE_ADAPTER_PAGINATION_CURSOR_INVALID = 'ERR_ENTITY_DATABASE_ADAPTER_PAGINATION_CURSOR_INVALID',
 }
 
 /**

package/src/errors/__tests__/EntityDatabaseAdapterError-test.ts

@@ -11,6 +11,7 @@ import {
   EntityDatabaseAdapterExclusionConstraintError,
   EntityDatabaseAdapterForeignKeyConstraintError,
   EntityDatabaseAdapterNotNullConstraintError,
+  EntityDatabaseAdapterPaginationCursorInvalidError,
   EntityDatabaseAdapterTransientError,
   EntityDatabaseAdapterUniqueConstraintError,
   EntityDatabaseAdapterUnknownError,
@@ -82,5 +83,13 @@ describe(EntityDatabaseAdapterError, () => {
     expect(excessiveDeleteError.code).toBe(
       EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_EXCESSIVE_DELETE_RESULT,
     );
+
+    const paginationCursorInvalidError = new EntityDatabaseAdapterPaginationCursorInvalidError(
+      'test',
+    );
+    expect(paginationCursorInvalidError.state).toBe(EntityErrorState.PERMANENT);
+    expect(paginationCursorInvalidError.code).toBe(
+      EntityErrorCode.ERR_ENTITY_DATABASE_ADAPTER_PAGINATION_CURSOR_INVALID,
+    );
   });
 });

package/src/errors/__tests__/EntityError-test.ts

@@ -1,5 +1,8 @@
 import { describe, expect, it } from '@jest/globals';
+import { instance, mock } from 'ts-mockito';
 
+import { ViewerContext } from '../../ViewerContext';
+import { SimpleTestEntity } from '../../utils/__testfixtures__/SimpleTestEntity';
 import { EntityCacheAdapterTransientError } from '../EntityCacheAdapterError';
 import { EntityErrorCode, EntityErrorState } from '../EntityError';
 import { EntityInvalidFieldValueError } from '../EntityInvalidFieldValueError';
@@ -14,16 +17,21 @@ describe('EntityError subclasses', () => {
   });
 
   it('EntityNotAuthorizedError has correct state and code', () => {
-    const mockEntity = { constructor: { name: 'TestEntity' }, toString: () => 'TestEntity' } as any;
-    const mockViewerContext = { toString: () => 'TestViewer' } as any;
-    const error = new EntityNotAuthorizedError(mockEntity, mockViewerContext, 0, 0);
+    const viewerContext = instance(mock(ViewerContext));
+    const data = { id: '1' };
+    const testEntity = new SimpleTestEntity({
+      viewerContext,
+      id: 'what',
+      databaseFields: data,
+      selectedFields: data,
+    });
+    const error = new EntityNotAuthorizedError(testEntity, viewerContext, 0, 0);
     expect(error.state).toBe(EntityErrorState.PERMANENT);
     expect(error.code).toBe(EntityErrorCode.ERR_ENTITY_NOT_AUTHORIZED);
   });
 
   it('EntityInvalidFieldValueError has correct state and code', () => {
-    const mockEntityClass = { name: 'TestEntity' } as any;
-    const error = new EntityInvalidFieldValueError(mockEntityClass, 'testField', 'badValue');
+    const error = new EntityInvalidFieldValueError(SimpleTestEntity, 'id', 'badValue');
     expect(error.state).toBe(EntityErrorState.PERMANENT);
     expect(error.code).toBe(EntityErrorCode.ERR_ENTITY_INVALID_FIELD_VALUE);
   });