@expo/entity 0.34.0 → 0.36.0

package/src/internal/__tests__/EntityFieldTransformationUtils-test.ts

@@ -44,10 +44,10 @@ const blahEntityConfiguration = new EntityConfiguration<BlahT>({
 describe(getDatabaseFieldForEntityField, () => {
   it('returns correct mapping', () => {
     expect(getDatabaseFieldForEntityField(blahEntityConfiguration, 'cacheable')).toEqual(
-      'cacheable'
+      'cacheable',
     );
     expect(
-      getDatabaseFieldForEntityField(blahEntityConfiguration, 'uniqueButNotCacheable')
+      getDatabaseFieldForEntityField(blahEntityConfiguration, 'uniqueButNotCacheable'),
     ).toEqual('unique_but_not_cacheable');
   });
 });
@@ -59,7 +59,7 @@ describe(transformDatabaseObjectToFields, () => {
         id: 'blah',
         unique_but_not_cacheable: 'wat',
         who: 'why',
-      })
+      }),
     ).toEqual({
       id: 'blah',
       uniqueButNotCacheable: 'wat',
@@ -79,7 +79,7 @@ describe(transformDatabaseObjectToFields, () => {
     expect(
       transformDatabaseObjectToFields(blahEntityConfiguration, fieldTransformMap, {
         transform_read: 'wat',
-      })
+      }),
     ).toEqual({
       transformRead: 'wat-read-transformed',
     });
@@ -93,7 +93,7 @@ describe(transformFieldsToDatabaseObject, () => {
         id: 'blah',
         cacheable: 'wat',
         uniqueButNotCacheable: 'wat',
-      })
+      }),
     ).toEqual({
       id: 'blah',
       cacheable: 'wat',
@@ -114,7 +114,7 @@ describe(transformFieldsToDatabaseObject, () => {
     expect(
       transformFieldsToDatabaseObject(blahEntityConfiguration, fieldTransformMap, {
         transformWrite: 'wat',
-      })
+      }),
     ).toEqual({
       transform_write: 'wat-write-transformed',
     });
@@ -122,7 +122,7 @@ describe(transformFieldsToDatabaseObject, () => {
 });
 
 describe(transformCacheObjectToFields, () => {
-  it('does field read transformation', () => {
+  it('does field read transformation, keeping unknown fields for cache version inconsistencies', () => {
     const fieldTransformMap = new Map([
       [
         StringField.name,
@@ -136,16 +136,18 @@ describe(transformCacheObjectToFields, () => {
       transformCacheObjectToFields(blahEntityConfiguration, fieldTransformMap, {
         id: 'hello',
         transformRead: 'wat',
-      })
+        unknownField: 'who',
+      }),
     ).toEqual({
       id: 'hello',
       transformRead: 'wat-read-transformed-cache',
+      unknownField: 'who',
     });
   });
 });
 
 describe(transformFieldsToCacheObject, () => {
-  it('does field write transformation', () => {
+  it('does field write transformation, keeping unknown fields at runtime for cache version inconsistencies', () => {
     const fieldTransformMap = new Map([
       [
         StringField.name,
@@ -159,10 +161,12 @@ describe(transformFieldsToCacheObject, () => {
       transformFieldsToCacheObject(blahEntityConfiguration, fieldTransformMap, {
         id: 'hello',
         transformWrite: 'wat',
-      })
+        unknownField: 'who',
+      } as any),
     ).toEqual({
       id: 'hello',
       transformWrite: 'wat-write-transformed-cache',
+      unknownField: 'who',
     });
   });
 });

package/src/internal/__tests__/ReadThroughEntityCache-test.ts

@@ -23,7 +23,7 @@ const makeEntityConfiguration = (cacheIdField: boolean): EntityConfiguration<Bla
 const createIdFetcher =
   (ids: string[]) =>
   async <N extends keyof BlahFields>(
-    fetcherFieldValues: readonly NonNullable<BlahFields[N]>[]
+    fetcherFieldValues: readonly NonNullable<BlahFields[N]>[],
   ): Promise<ReadonlyMap<NonNullable<BlahFields[N]>, readonly Readonly<BlahFields>[]>> => {
     const results = new Map();
     fetcherFieldValues.forEach((v) => {
@@ -36,6 +36,22 @@ const createIdFetcher =
     return results;
   };
 
+const createFetcherNonUnique =
+  (ids: string[]) =>
+  async <N extends keyof BlahFields>(
+    fetcherFieldValues: readonly NonNullable<BlahFields[N]>[],
+  ): Promise<ReadonlyMap<NonNullable<BlahFields[N]>, readonly Readonly<BlahFields>[]>> => {
+    const results = new Map();
+    fetcherFieldValues.forEach((v) => {
+      if (ids.includes(v)) {
+        results.set(v, [{ id: v }, { id: v + '2' }]);
+      } else {
+        results.set(v, []);
+      }
+    });
+    return results;
+  };
+
 describe(ReadThroughEntityCache, () => {
   describe('readManyThroughAsync', () => {
     it('fetches from DB upon cache miss and caches the result', async () => {
@@ -48,7 +64,7 @@ describe(ReadThroughEntityCache, () => {
         new Map([
           ['wat', { status: CacheStatus.MISS }],
           ['who', { status: CacheStatus.MISS }],
-        ])
+        ]),
       );
 
       const result = await entityCache.readManyThroughAsync('id', ['wat', 'who'], fetcher);
@@ -61,16 +77,16 @@ describe(ReadThroughEntityCache, () => {
             new Map([
               ['wat', { id: 'wat' }],
               ['who', { id: 'who' }],
-            ])
-          )
-        )
+            ]),
+          ),
+        ),
       ).once();
       verify(cacheAdapterMock.cacheDBMissesAsync('id', deepEqual([]))).once();
       expect(result).toEqual(
         new Map([
           ['wat', [{ id: 'wat' }]],
           ['who', [{ id: 'who' }]],
-        ])
+        ]),
       );
     });
 
@@ -84,7 +100,7 @@ describe(ReadThroughEntityCache, () => {
         new Map([
           ['wat', { status: CacheStatus.HIT, item: { id: 'wat' } }],
           ['who', { status: CacheStatus.HIT, item: { id: 'who' } }],
-        ])
+        ]),
       );
 
       const result = await entityCache.readManyThroughAsync('id', ['wat', 'who'], fetcher);
@@ -97,16 +113,16 @@ describe(ReadThroughEntityCache, () => {
             new Map([
               ['wat', { id: 'wat' }],
               ['who', { id: 'who' }],
-            ])
-          )
-        )
+            ]),
+          ),
+        ),
       ).never();
       verify(cacheAdapterMock.cacheDBMissesAsync('id', deepEqual([]))).never();
       expect(result).toEqual(
         new Map([
           ['wat', [{ id: 'wat' }]],
           ['who', [{ id: 'who' }]],
-        ])
+        ]),
       );
     });
 
@@ -119,7 +135,7 @@ describe(ReadThroughEntityCache, () => {
       const fetcher = createIdFetcher(['wat', 'who']);
 
       when(cacheAdapterMock.loadManyAsync('id', deepEqual(['why']))).thenResolve(
-        new Map([['why', { status: CacheStatus.MISS }]])
+        new Map([['why', { status: CacheStatus.MISS }]]),
       );
 
       const result = await entityCache.readManyThroughAsync('id', ['why'], fetcher);
@@ -137,7 +153,7 @@ describe(ReadThroughEntityCache, () => {
       const fetcher = createIdFetcher([]);
 
       when(cacheAdapterMock.loadManyAsync('id', deepEqual(['why']))).thenResolve(
-        new Map([['why', { status: CacheStatus.NEGATIVE }]])
+        new Map([['why', { status: CacheStatus.NEGATIVE }]]),
       );
 
       const result = await entityCache.readManyThroughAsync('id', ['why'], fetcher);
@@ -154,31 +170,31 @@ describe(ReadThroughEntityCache, () => {
       const fetcher = createIdFetcher(['wat', 'who', 'why']);
 
       when(
-        cacheAdapterMock.loadManyAsync('id', deepEqual(['wat', 'who', 'why', 'how']))
+        cacheAdapterMock.loadManyAsync('id', deepEqual(['wat', 'who', 'why', 'how'])),
       ).thenResolve(
         new Map([
           ['wat', { status: CacheStatus.MISS }],
           ['who', { status: CacheStatus.NEGATIVE }],
           ['why', { status: CacheStatus.HIT, item: { id: 'why' } }],
           ['how', { status: CacheStatus.MISS }],
-        ])
+        ]),
       );
 
       const result = await entityCache.readManyThroughAsync(
         'id',
         ['wat', 'who', 'why', 'how'],
-        fetcher
+        fetcher,
       );
       verify(cacheAdapterMock.loadManyAsync('id', deepEqual(['wat', 'who', 'why', 'how']))).once();
       verify(
-        cacheAdapterMock.cacheManyAsync('id', deepEqual(new Map([['wat', { id: 'wat' }]])))
+        cacheAdapterMock.cacheManyAsync('id', deepEqual(new Map([['wat', { id: 'wat' }]]))),
       ).once();
       verify(cacheAdapterMock.cacheDBMissesAsync('id', deepEqual(['how']))).once();
       expect(result).toEqual(
         new Map([
           ['wat', [{ id: 'wat' }]],
           ['why', [{ id: 'why' }]],
-        ])
+        ]),
       );
     });
 
@@ -191,6 +207,46 @@ describe(ReadThroughEntityCache, () => {
       verify(cacheAdapterMock.loadManyAsync('id', anything())).never();
       expect(result).toEqual(new Map([['wat', [{ id: 'wat' }]]]));
     });
+
+    it('does not cache when DB returns multiple objects for what is supposed to be unique and returns empty', async () => {
+      const consoleSpy = jest.spyOn(console, 'warn');
+
+      const cacheAdapterMock = mock<IEntityCacheAdapter<BlahFields>>();
+      const cacheAdapter = instance(cacheAdapterMock);
+      const entityCache = new ReadThroughEntityCache(makeEntityConfiguration(true), cacheAdapter);
+      const fetcher = createFetcherNonUnique(['wat', 'who']);
+
+      when(cacheAdapterMock.loadManyAsync('id', deepEqual(['wat', 'who']))).thenResolve(
+        new Map([
+          ['wat', { status: CacheStatus.MISS }],
+          ['who', { status: CacheStatus.MISS }],
+        ]),
+      );
+
+      const result = await entityCache.readManyThroughAsync('id', ['wat', 'who'], fetcher);
+
+      verify(cacheAdapterMock.loadManyAsync('id', deepEqual(['wat', 'who']))).once();
+      verify(
+        cacheAdapterMock.cacheManyAsync(
+          'id',
+          deepEqual(
+            new Map([
+              ['wat', { id: 'wat' }],
+              ['who', { id: 'who' }],
+            ]),
+          ),
+        ),
+      ).never();
+      verify(cacheAdapterMock.cacheDBMissesAsync('id', deepEqual([]))).once();
+      expect(result).toEqual(new Map());
+
+      expect(consoleSpy).toHaveBeenCalledWith(
+        'unique key id in blah returned multiple rows for wat',
+      );
+      expect(consoleSpy).toHaveBeenCalledWith(
+        'unique key id in blah returned multiple rows for who',
+      );
+    });
   });
 
   describe('invalidateManyAsync', () => {

package/src/metrics/EntityMetricsUtils.ts

@@ -8,7 +8,7 @@ export const timeAndLogLoadEventAsync =
   (
     metricsAdapter: IEntityMetricsAdapter,
     loadType: EntityMetricsLoadType,
-    entityClassName: string
+    entityClassName: string,
   ) =>
   async <TFields>(promise: Promise<readonly Readonly<TFields>[]>) => {
     const startTime = Date.now();
@@ -29,10 +29,10 @@ export const timeAndLogLoadMapEventAsync =
   (
     metricsAdapter: IEntityMetricsAdapter,
     loadType: EntityMetricsLoadType,
-    entityClassName: string
+    entityClassName: string,
   ) =>
   async <TFields, N extends keyof TFields>(
-    promise: Promise<ReadonlyMap<NonNullable<TFields[N]>, readonly Readonly<TFields>[]>>
+    promise: Promise<ReadonlyMap<NonNullable<TFields[N]>, readonly Readonly<TFields>[]>>,
   ) => {
     const startTime = Date.now();
     const result = await promise;
@@ -54,7 +54,7 @@ export const timeAndLogMutationEventAsync =
   (
     metricsAdapter: IEntityMetricsAdapter,
     mutationType: EntityMetricsMutationType,
-    entityClassName: string
+    entityClassName: string,
   ) =>
   async <T>(promise: Promise<T>) => {
     const startTime = Date.now();

package/src/metrics/IEntityMetricsAdapter.ts

@@ -140,7 +140,7 @@ export default interface IEntityMetricsAdapter {
    * Called when a dataloader, cache, or database load is initiated via the standard
    * load methods (not equality conjunction or raw). Most commonly used for logging
    * a waterfall to determine dataloader and cache hit rates and ratios.
-   * @param fieldValueCount - count of field values being loaded for a field
+   * @param incrementLoadCountEvent - count of field values being loaded for a field
    */
   incrementDataManagerLoadCount(incrementLoadCountEvent: IncrementLoadCountEvent): void;
 }

package/src/rules/AlwaysAllowPrivacyPolicyRule.ts

@@ -12,13 +12,19 @@ export default class AlwaysAllowPrivacyPolicyRule<
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,
   TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
-  TSelectedFields extends keyof TFields = keyof TFields
+  TSelectedFields extends keyof TFields = keyof TFields,
 > extends PrivacyPolicyRule<TFields, TID, TViewerContext, TEntity, TSelectedFields> {
   async evaluateAsync(
     _viewerContext: TViewerContext,
     _queryContext: EntityQueryContext,
-    _evaluationContext: EntityPrivacyPolicyEvaluationContext,
-    _entity: TEntity
+    _evaluationContext: EntityPrivacyPolicyEvaluationContext<
+      TFields,
+      TID,
+      TViewerContext,
+      TEntity,
+      TSelectedFields
+    >,
+    _entity: TEntity,
   ): Promise<RuleEvaluationResult> {
     return RuleEvaluationResult.ALLOW;
   }

package/src/rules/AlwaysDenyPrivacyPolicyRule.ts

@@ -12,13 +12,19 @@ export default class AlwaysDenyPrivacyPolicyRule<
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,
   TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
-  TSelectedFields extends keyof TFields = keyof TFields
+  TSelectedFields extends keyof TFields = keyof TFields,
 > extends PrivacyPolicyRule<TFields, TID, TViewerContext, TEntity, TSelectedFields> {
   async evaluateAsync(
     _viewerContext: TViewerContext,
     _queryContext: EntityQueryContext,
-    _evaluationContext: EntityPrivacyPolicyEvaluationContext,
-    _entity: TEntity
+    _evaluationContext: EntityPrivacyPolicyEvaluationContext<
+      TFields,
+      TID,
+      TViewerContext,
+      TEntity,
+      TSelectedFields
+    >,
+    _entity: TEntity,
   ): Promise<RuleEvaluationResult> {
     return RuleEvaluationResult.DENY;
   }

package/src/rules/AlwaysSkipPrivacyPolicyRule.ts

@@ -12,13 +12,19 @@ export default class AlwaysSkipPrivacyPolicyRule<
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,
   TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
-  TSelectedFields extends keyof TFields = keyof TFields
+  TSelectedFields extends keyof TFields = keyof TFields,
 > extends PrivacyPolicyRule<TFields, TID, TViewerContext, TEntity, TSelectedFields> {
   async evaluateAsync(
     _viewerContext: TViewerContext,
     _queryContext: EntityQueryContext,
-    _evaluationContext: EntityPrivacyPolicyEvaluationContext,
-    _entity: TEntity
+    _evaluationContext: EntityPrivacyPolicyEvaluationContext<
+      TFields,
+      TID,
+      TViewerContext,
+      TEntity,
+      TSelectedFields
+    >,
+    _entity: TEntity,
   ): Promise<RuleEvaluationResult> {
     return RuleEvaluationResult.SKIP;
   }

package/src/rules/PrivacyPolicyRule.ts

@@ -41,12 +41,18 @@ export default abstract class PrivacyPolicyRule<
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,
   TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
-  TSelectedFields extends keyof TFields = keyof TFields
+  TSelectedFields extends keyof TFields = keyof TFields,
 > {
   abstract evaluateAsync(
     viewerContext: TViewerContext,
     queryContext: EntityQueryContext,
-    evaluationContext: EntityPrivacyPolicyEvaluationContext,
-    entity: TEntity
+    evaluationContext: EntityPrivacyPolicyEvaluationContext<
+      TFields,
+      TID,
+      TViewerContext,
+      TEntity,
+      TSelectedFields
+    >,
+    entity: TEntity,
   ): Promise<RuleEvaluationResult>;
 }

package/src/rules/__tests__/AlwaysAllowPrivacyPolicyRule-test.ts

@@ -11,7 +11,8 @@ describePrivacyPolicyRule(new AlwaysAllowPrivacyPolicyRule(), {
     {
       viewerContext: instance(mock(ViewerContext)),
       queryContext: instance(mock(EntityQueryContext)),
-      evaluationContext: instance(mock<EntityPrivacyPolicyEvaluationContext>()),
+      evaluationContext:
+        instance(mock<EntityPrivacyPolicyEvaluationContext<any, any, any, any, any>>()),
       entity: anything(),
     },
   ],

package/src/rules/__tests__/AlwaysDenyPrivacyPolicyRule-test.ts

@@ -11,7 +11,8 @@ describePrivacyPolicyRule(new AlwaysDenyPrivacyPolicyRule(), {
     {
       viewerContext: instance(mock(ViewerContext)),
       queryContext: instance(mock(EntityQueryContext)),
-      evaluationContext: instance(mock<EntityPrivacyPolicyEvaluationContext>()),
+      evaluationContext:
+        instance(mock<EntityPrivacyPolicyEvaluationContext<any, any, any, any, any>>()),
       entity: anything(),
     },
   ],

package/src/rules/__tests__/AlwaysSkipPrivacyPolicyRule-test.ts

@@ -11,7 +11,8 @@ describePrivacyPolicyRule(new AlwaysSkipPrivacyPolicyRule(), {
     {
       viewerContext: instance(mock(ViewerContext)),
       queryContext: instance(mock(EntityQueryContext)),
-      evaluationContext: instance(mock<EntityPrivacyPolicyEvaluationContext>()),
+      evaluationContext:
+        instance(mock<EntityPrivacyPolicyEvaluationContext<any, any, any, any, any>>()),
       entity: anything(),
     },
   ],

package/src/testfixtures/SimpleTestEntity.ts

@@ -1,9 +1,9 @@
-import TestViewerContext from './TestViewerContext';
 import Entity from '../Entity';
 import { EntityCompanionDefinition } from '../EntityCompanionProvider';
 import EntityConfiguration from '../EntityConfiguration';
 import { UUIDField } from '../EntityFields';
 import EntityPrivacyPolicy from '../EntityPrivacyPolicy';
+import ViewerContext from '../ViewerContext';
 import AlwaysAllowPrivacyPolicyRule from '../rules/AlwaysAllowPrivacyPolicyRule';
 
 export type SimpleTestFields = {
@@ -27,7 +27,7 @@ export const simpleTestEntityConfiguration = new EntityConfiguration<SimpleTestF
 export class SimpleTestEntityPrivacyPolicy extends EntityPrivacyPolicy<
   SimpleTestFields,
   string,
-  TestViewerContext,
+  ViewerContext,
   SimpleTestEntity,
   SimpleTestFieldSelection
 > {
@@ -35,7 +35,7 @@ export class SimpleTestEntityPrivacyPolicy extends EntityPrivacyPolicy<
     new AlwaysAllowPrivacyPolicyRule<
       SimpleTestFields,
       string,
-      TestViewerContext,
+      ViewerContext,
       SimpleTestEntity,
       SimpleTestFieldSelection
     >(),
@@ -44,7 +44,7 @@ export class SimpleTestEntityPrivacyPolicy extends EntityPrivacyPolicy<
     new AlwaysAllowPrivacyPolicyRule<
       SimpleTestFields,
       string,
-      TestViewerContext,
+      ViewerContext,
       SimpleTestEntity,
       SimpleTestFieldSelection
     >(),
@@ -53,7 +53,7 @@ export class SimpleTestEntityPrivacyPolicy extends EntityPrivacyPolicy<
     new AlwaysAllowPrivacyPolicyRule<
       SimpleTestFields,
       string,
-      TestViewerContext,
+      ViewerContext,
       SimpleTestEntity,
       SimpleTestFieldSelection
     >(),
@@ -62,7 +62,7 @@ export class SimpleTestEntityPrivacyPolicy extends EntityPrivacyPolicy<
     new AlwaysAllowPrivacyPolicyRule<
       SimpleTestFields,
       string,
-      TestViewerContext,
+      ViewerContext,
       SimpleTestEntity,
       SimpleTestFieldSelection
     >(),
@@ -72,13 +72,13 @@ export class SimpleTestEntityPrivacyPolicy extends EntityPrivacyPolicy<
 export default class SimpleTestEntity extends Entity<
   SimpleTestFields,
   string,
-  TestViewerContext,
+  ViewerContext,
   SimpleTestFieldSelection
 > {
   static defineCompanionDefinition(): EntityCompanionDefinition<
     SimpleTestFields,
     string,
-    TestViewerContext,
+    ViewerContext,
     SimpleTestEntity,
     SimpleTestEntityPrivacyPolicy,
     SimpleTestFieldSelection

package/src/testfixtures/TestEntity.ts

@@ -1,11 +1,11 @@
 import { result, Result } from '@expo/results';
 
-import TestViewerContext from './TestViewerContext';
 import Entity from '../Entity';
 import { EntityCompanionDefinition } from '../EntityCompanionProvider';
 import EntityConfiguration from '../EntityConfiguration';
 import { UUIDField, StringField, DateField, IntField } from '../EntityFields';
 import EntityPrivacyPolicy from '../EntityPrivacyPolicy';
+import ViewerContext from '../ViewerContext';
 import AlwaysAllowPrivacyPolicyRule from '../rules/AlwaysAllowPrivacyPolicyRule';
 
 export type TestFields = {
@@ -48,28 +48,28 @@ export const testEntityConfiguration = new EntityConfiguration<TestFields>({
 export class TestEntityPrivacyPolicy extends EntityPrivacyPolicy<
   TestFields,
   string,
-  TestViewerContext,
+  ViewerContext,
   TestEntity
 > {
   protected override readonly readRules = [
-    new AlwaysAllowPrivacyPolicyRule<TestFields, string, TestViewerContext, TestEntity>(),
+    new AlwaysAllowPrivacyPolicyRule<TestFields, string, ViewerContext, TestEntity>(),
   ];
   protected override readonly createRules = [
-    new AlwaysAllowPrivacyPolicyRule<TestFields, string, TestViewerContext, TestEntity>(),
+    new AlwaysAllowPrivacyPolicyRule<TestFields, string, ViewerContext, TestEntity>(),
   ];
   protected override readonly updateRules = [
-    new AlwaysAllowPrivacyPolicyRule<TestFields, string, TestViewerContext, TestEntity>(),
+    new AlwaysAllowPrivacyPolicyRule<TestFields, string, ViewerContext, TestEntity>(),
   ];
   protected override readonly deleteRules = [
-    new AlwaysAllowPrivacyPolicyRule<TestFields, string, TestViewerContext, TestEntity>(),
+    new AlwaysAllowPrivacyPolicyRule<TestFields, string, ViewerContext, TestEntity>(),
   ];
 }
 
-export default class TestEntity extends Entity<TestFields, string, TestViewerContext> {
+export default class TestEntity extends Entity<TestFields, string, ViewerContext> {
   static defineCompanionDefinition(): EntityCompanionDefinition<
     TestFields,
     string,
-    TestViewerContext,
+    ViewerContext,
     TestEntity,
     TestEntityPrivacyPolicy
   > {
@@ -84,10 +84,7 @@ export default class TestEntity extends Entity<TestFields, string, TestViewerCon
     return 'Hello World!';
   }
 
-  static async hello(
-    viewerContext: TestViewerContext,
-    testValue: string
-  ): Promise<Result<TestEntity>> {
+  static async hello(viewerContext: ViewerContext, testValue: string): Promise<Result<TestEntity>> {
     const fields = {
       customIdField: testValue,
       testIndexedField: 'hello',
@@ -102,19 +99,19 @@ export default class TestEntity extends Entity<TestFields, string, TestViewerCon
         id: testValue,
         databaseFields: fields,
         selectedFields: fields,
-      })
+      }),
     );
   }
 
-  static async returnError(_viewerContext: TestViewerContext): Promise<Result<TestEntity>> {
+  static async returnError(_viewerContext: ViewerContext): Promise<Result<TestEntity>> {
     return result(new Error('return entity'));
   }
 
-  static async throwError(_viewerContext: TestViewerContext): Promise<Result<TestEntity>> {
+  static async throwError(_viewerContext: ViewerContext): Promise<Result<TestEntity>> {
     throw new Error('threw entity');
   }
 
-  static async nonResult(_viewerContext: TestViewerContext, testValue: string): Promise<string> {
+  static async nonResult(_viewerContext: ViewerContext, testValue: string): Promise<string> {
     return testValue;
   }
 }

package/src/testfixtures/TestEntity2.ts

@@ -1,9 +1,9 @@
-import TestViewerContext from './TestViewerContext';
 import Entity from '../Entity';
 import { EntityCompanionDefinition } from '../EntityCompanionProvider';
 import EntityConfiguration from '../EntityConfiguration';
 import { UUIDField } from '../EntityFields';
 import EntityPrivacyPolicy from '../EntityPrivacyPolicy';
+import ViewerContext from '../ViewerContext';
 import AlwaysAllowPrivacyPolicyRule from '../rules/AlwaysAllowPrivacyPolicyRule';
 
 export type Test2Fields = {
@@ -29,28 +29,28 @@ export const testEntity2Configuration = new EntityConfiguration<Test2Fields>({
 export class TestEntity2PrivacyPolicy extends EntityPrivacyPolicy<
   Test2Fields,
   string,
-  TestViewerContext,
+  ViewerContext,
   TestEntity2
 > {
   protected override readonly readRules = [
-    new AlwaysAllowPrivacyPolicyRule<Test2Fields, string, TestViewerContext, TestEntity2>(),
+    new AlwaysAllowPrivacyPolicyRule<Test2Fields, string, ViewerContext, TestEntity2>(),
   ];
   protected override readonly createRules = [
-    new AlwaysAllowPrivacyPolicyRule<Test2Fields, string, TestViewerContext, TestEntity2>(),
+    new AlwaysAllowPrivacyPolicyRule<Test2Fields, string, ViewerContext, TestEntity2>(),
   ];
   protected override readonly updateRules = [
-    new AlwaysAllowPrivacyPolicyRule<Test2Fields, string, TestViewerContext, TestEntity2>(),
+    new AlwaysAllowPrivacyPolicyRule<Test2Fields, string, ViewerContext, TestEntity2>(),
   ];
   protected override readonly deleteRules = [
-    new AlwaysAllowPrivacyPolicyRule<Test2Fields, string, TestViewerContext, TestEntity2>(),
+    new AlwaysAllowPrivacyPolicyRule<Test2Fields, string, ViewerContext, TestEntity2>(),
   ];
 }
 
-export default class TestEntity2 extends Entity<Test2Fields, string, TestViewerContext> {
+export default class TestEntity2 extends Entity<Test2Fields, string, ViewerContext> {
   static defineCompanionDefinition(): EntityCompanionDefinition<
     Test2Fields,
     string,
-    TestViewerContext,
+    ViewerContext,
     TestEntity2,
     TestEntity2PrivacyPolicy
   > {