@expo/entity 0.31.0 → 0.32.0

package/src/__tests__/ReadonlyEntity-test.ts

@@ -15,7 +15,12 @@ describe(ReadonlyEntity, () => {
       const data = {
         id: 'what',
       };
-      const testEntity = new SimpleTestEntity(viewerContext, data);
+      const testEntity = new SimpleTestEntity({
+        viewerContext,
+        id: 'what',
+        databaseFields: data,
+        selectedFields: data,
+      });
       expect(testEntity.getID()).toEqual('what');
     });
   });
@@ -26,7 +31,12 @@ describe(ReadonlyEntity, () => {
       const data = {
         id: 'what',
       };
-      const testEntity = new SimpleTestEntity(viewerContext, data);
+      const testEntity = new SimpleTestEntity({
+        viewerContext,
+        id: 'what',
+        databaseFields: data,
+        selectedFields: data,
+      });
       expect(testEntity.toString()).toEqual('SimpleTestEntity[what]');
     });
   });
@@ -34,11 +44,25 @@ describe(ReadonlyEntity, () => {
   describe('getUniqueIdentifier', () => {
     it('returns a different value for two different entities of the same type', () => {
       const viewerContext = instance(mock(ViewerContext));
-      const testEntity = new SimpleTestEntity(viewerContext, {
+      const testEntity = new SimpleTestEntity({
+        viewerContext,
         id: '1',
+        databaseFields: {
+          id: '1',
+        },
+        selectedFields: {
+          id: '1',
+        },
       });
-      const testEntity2 = new SimpleTestEntity(viewerContext, {
+      const testEntity2 = new SimpleTestEntity({
+        viewerContext,
         id: '2',
+        databaseFields: {
+          id: '2',
+        },
+        selectedFields: {
+          id: '2',
+        },
       });
       expect(testEntity.getUniqueIdentifier()).not.toEqual(testEntity2.getUniqueIdentifier());
     });
@@ -47,22 +71,43 @@ describe(ReadonlyEntity, () => {
       const viewerContext = instance(mock(ViewerContext));
       const viewerContext2 = instance(mock(ViewerContext));
       const data = { id: '1' };
-      const testEntity = new SimpleTestEntity(viewerContext, data);
-      const testEntity2 = new SimpleTestEntity(viewerContext2, data);
+      const testEntity = new SimpleTestEntity({
+        viewerContext,
+        id: '1',
+        databaseFields: data,
+        selectedFields: data,
+      });
+      const testEntity2 = new SimpleTestEntity({
+        viewerContext: viewerContext2,
+        id: '1',
+        databaseFields: data,
+        selectedFields: data,
+      });
       expect(testEntity.getUniqueIdentifier()).toEqual(testEntity2.getUniqueIdentifier());
     });
 
     it('returns a different value for different entities even if same ID', () => {
       const viewerContext = instance(mock(ViewerContext));
       const data = { id: '1' };
-      const testEntity = new SimpleTestEntity(viewerContext, data);
-      const testEntity2 = new TestEntity(viewerContext, {
+      const testEntity = new SimpleTestEntity({
+        viewerContext,
+        id: 'what',
+        databaseFields: data,
+        selectedFields: data,
+      });
+      const data2 = {
         customIdField: '1',
         testIndexedField: '2',
         stringField: '3',
         intField: 4,
         dateField: new Date(),
         nullableField: null,
+      };
+      const testEntity2 = new TestEntity({
+        viewerContext,
+        id: '1',
+        databaseFields: data2,
+        selectedFields: data2,
       });
       expect(testEntity.getUniqueIdentifier()).not.toEqual(testEntity2.getUniqueIdentifier());
     });
@@ -72,16 +117,27 @@ describe(ReadonlyEntity, () => {
     const viewerContext = instance(mock(ViewerContext));
     const dataWithoutID = {};
     expect(() => {
-      new SimpleTestEntity(viewerContext, dataWithoutID as any); // eslint-disable-line no-new
+      // eslint-disable-next-line no-new
+      new SimpleTestEntity({
+        viewerContext,
+        id: undefined as any,
+        databaseFields: dataWithoutID as any,
+        selectedFields: dataWithoutID as any,
+      });
     }).toThrow();
   });
 
-  it('returns correct viewerContext from instantiation', () => {
+  it('returns correct viewerCo}ntext from instantiation', () => {
     const viewerContext = instance(mock(ViewerContext));
     const data = {
       id: 'what',
     };
-    const testEntity = new SimpleTestEntity(viewerContext, data);
+    const testEntity = new SimpleTestEntity({
+      viewerContext,
+      id: 'what',
+      databaseFields: data,
+      selectedFields: data,
+    });
     expect(testEntity.getViewerContext()).toBe(viewerContext);
   });
 
@@ -90,7 +146,12 @@ describe(ReadonlyEntity, () => {
     const data = {
       id: 'what',
     };
-    const testEntity = new SimpleTestEntity(viewerContext, data);
+    const testEntity = new SimpleTestEntity({
+      viewerContext,
+      id: 'what',
+      databaseFields: data,
+      selectedFields: data,
+    });
     expect(testEntity.getField('id')).toEqual('what');
     expect(testEntity.getAllFields()).toEqual(data);
   });
@@ -102,7 +163,12 @@ describe(ReadonlyEntity, () => {
       const data = {
         id: 'what',
       };
-      const testEntity = new SimpleTestEntity(viewerContext, data);
+      const testEntity = new SimpleTestEntity({
+        viewerContext,
+        id: 'what',
+        databaseFields: data,
+        selectedFields: data,
+      });
       expect(testEntity.associationLoader()).toBeInstanceOf(EntityAssociationLoader);
     });
   });

package/src/__tests__/ViewerScopedEntityCompanionProvider-test.ts

@@ -4,7 +4,7 @@ import EntityCompanionProvider from '../EntityCompanionProvider';
 import ViewerContext from '../ViewerContext';
 import ViewerScopedEntityCompanion from '../ViewerScopedEntityCompanion';
 import ViewerScopedEntityCompanionProvider from '../ViewerScopedEntityCompanionProvider';
-import TestEntity, { testEntityCompanion } from '../testfixtures/TestEntity';
+import TestEntity from '../testfixtures/TestEntity';
 
 describe(ViewerScopedEntityCompanionProvider, () => {
   it('returns viewer scoped entity companion', () => {
@@ -15,10 +15,7 @@ describe(ViewerScopedEntityCompanionProvider, () => {
       vc
     );
     expect(
-      viewerScopedEntityCompanionProvider.getViewerScopedCompanionForEntity(
-        TestEntity,
-        testEntityCompanion
-      )
+      viewerScopedEntityCompanionProvider.getViewerScopedCompanionForEntity(TestEntity)
     ).toBeInstanceOf(ViewerScopedEntityCompanion);
   });
 });

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

@@ -122,14 +122,19 @@ class TestEntityPrivacyPolicy extends EntityPrivacyPolicy<any, string, ViewerCon
 }
 
 class OneTestEntity extends Entity<TestFields, string, ViewerContext, OneTestFields> {
-  constructor(viewerContext: ViewerContext, rawFields: Readonly<TestFields>) {
-    if (rawFields.entity_type !== EntityType.ONE) {
+  constructor(constructorParams: {
+    viewerContext: ViewerContext;
+    id: string;
+    databaseFields: Readonly<TestFields>;
+    selectedFields: Readonly<Pick<TestFields, OneTestFields>>;
+  }) {
+    if (constructorParams.selectedFields.entity_type !== EntityType.ONE) {
       throw new Error('OneTestEntity must be instantiated with one data');
     }
-    super(viewerContext, rawFields);
+    super(constructorParams);
   }
 
-  static getCompanionDefinition(): EntityCompanionDefinition<
+  static defineCompanionDefinition(): EntityCompanionDefinition<
     TestFields,
     string,
     ViewerContext,
@@ -137,19 +142,29 @@ class OneTestEntity extends Entity<TestFields, string, ViewerContext, OneTestFie
     TestEntityPrivacyPolicy,
     OneTestFields
   > {
-    return oneTestEntityCompanion;
+    return {
+      entityClass: OneTestEntity,
+      entityConfiguration: testEntityConfiguration,
+      privacyPolicyClass: TestEntityPrivacyPolicy,
+      entitySelectedFields: ['id', 'entity_type', 'common_other_field'],
+    };
   }
 }
 
 class TwoTestEntity extends Entity<TestFields, string, ViewerContext, TwoTestFields> {
-  constructor(viewerContext: ViewerContext, rawFields: Readonly<TestFields>) {
-    if (rawFields.entity_type !== EntityType.TWO) {
+  constructor(constructorParams: {
+    viewerContext: ViewerContext;
+    id: string;
+    databaseFields: Readonly<TestFields>;
+    selectedFields: Readonly<Pick<TestFields, TwoTestFields>>;
+  }) {
+    if (constructorParams.selectedFields.entity_type !== EntityType.TWO) {
       throw new Error('TwoTestEntity must be instantiated with two data');
     }
-    super(viewerContext, rawFields);
+    super(constructorParams);
   }
 
-  static getCompanionDefinition(): EntityCompanionDefinition<
+  static defineCompanionDefinition(): EntityCompanionDefinition<
     TestFields,
     string,
     ViewerContext,
@@ -157,20 +172,11 @@ class TwoTestEntity extends Entity<TestFields, string, ViewerContext, TwoTestFie
     TestEntityPrivacyPolicy,
     TwoTestFields
   > {
-    return twoTestEntityCompanion;
+    return {
+      entityClass: TwoTestEntity,
+      entityConfiguration: testEntityConfiguration,
+      privacyPolicyClass: TestEntityPrivacyPolicy,
+      entitySelectedFields: ['id', 'other_field', 'common_other_field', 'entity_type'],
+    };
   }
 }
-
-const oneTestEntityCompanion = new EntityCompanionDefinition({
-  entityClass: OneTestEntity,
-  entityConfiguration: testEntityConfiguration,
-  privacyPolicyClass: TestEntityPrivacyPolicy,
-  entitySelectedFields: ['id', 'entity_type', 'common_other_field'],
-});
-
-const twoTestEntityCompanion = new EntityCompanionDefinition({
-  entityClass: TwoTestEntity,
-  entityConfiguration: testEntityConfiguration,
-  privacyPolicyClass: TestEntityPrivacyPolicy,
-  entitySelectedFields: ['id', 'other_field', 'common_other_field', 'entity_type'],
-});

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

@@ -130,7 +130,7 @@ class TestEntityPrivacyPolicy extends EntityPrivacyPolicy<any, string, ViewerCon
 }
 
 class OneTestEntity extends Entity<TestFields, string, ViewerContext, OneTestFields> {
-  static getCompanionDefinition(): EntityCompanionDefinition<
+  static defineCompanionDefinition(): EntityCompanionDefinition<
     TestFields,
     string,
     ViewerContext,
@@ -138,12 +138,17 @@ class OneTestEntity extends Entity<TestFields, string, ViewerContext, OneTestFie
     TestEntityPrivacyPolicy,
     OneTestFields
   > {
-    return oneTestEntityCompanion;
+    return {
+      entityClass: OneTestEntity,
+      entityConfiguration: testEntityConfiguration,
+      privacyPolicyClass: TestEntityPrivacyPolicy,
+      entitySelectedFields: ['id', 'fake_field'],
+    };
   }
 }
 
 class TwoTestEntity extends Entity<TestFields, string, ViewerContext, TwoTestFields> {
-  static getCompanionDefinition(): EntityCompanionDefinition<
+  static defineCompanionDefinition(): EntityCompanionDefinition<
     TestFields,
     string,
     ViewerContext,
@@ -151,20 +156,11 @@ class TwoTestEntity extends Entity<TestFields, string, ViewerContext, TwoTestFie
     TestEntityPrivacyPolicy,
     TwoTestFields
   > {
-    return twoTestEntityCompanion;
+    return {
+      entityClass: TwoTestEntity,
+      entityConfiguration: testEntityConfiguration,
+      privacyPolicyClass: TestEntityPrivacyPolicy,
+      entitySelectedFields: ['id', 'other_field', 'fake_field'],
+    };
   }
 }
-
-const oneTestEntityCompanion = new EntityCompanionDefinition({
-  entityClass: OneTestEntity,
-  entityConfiguration: testEntityConfiguration,
-  privacyPolicyClass: TestEntityPrivacyPolicy,
-  entitySelectedFields: ['id', 'fake_field'],
-});
-
-const twoTestEntityCompanion = new EntityCompanionDefinition({
-  entityClass: TwoTestEntity,
-  entityConfiguration: testEntityConfiguration,
-  privacyPolicyClass: TestEntityPrivacyPolicy,
-  entitySelectedFields: ['id', 'other_field', 'fake_field'],
-});

package/src/errors/EntityInvalidFieldValueError.ts

@@ -1,11 +1,11 @@
+import EntityError, { EntityErrorCode, EntityErrorState } from './EntityError';
 import { IEntityClass } from '../Entity';
 import EntityPrivacyPolicy from '../EntityPrivacyPolicy';
 import ReadonlyEntity from '../ReadonlyEntity';
 import ViewerContext from '../ViewerContext';
-import EntityError, { EntityErrorCode, EntityErrorState } from './EntityError';
 
 export default class EntityInvalidFieldValueError<
-  TFields,
+  TFields extends object,
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,
   TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,

package/src/errors/EntityNotAuthorizedError.ts

@@ -1,10 +1,10 @@
+import EntityError, { EntityErrorCode, EntityErrorState } from './EntityError';
 import { EntityAuthorizationAction } from '../EntityPrivacyPolicy';
 import ReadonlyEntity from '../ReadonlyEntity';
 import ViewerContext from '../ViewerContext';
-import EntityError, { EntityErrorCode, EntityErrorState } from './EntityError';
 
 export default class EntityNotAuthorizedError<
-  TFields,
+  TFields extends object,
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,
   TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,

package/src/errors/EntityNotFoundError.ts

@@ -1,11 +1,11 @@
+import EntityError, { EntityErrorCode, EntityErrorState } from './EntityError';
 import { IEntityClass } from '../Entity';
 import EntityPrivacyPolicy from '../EntityPrivacyPolicy';
 import ReadonlyEntity from '../ReadonlyEntity';
 import ViewerContext from '../ViewerContext';
-import EntityError, { EntityErrorCode, EntityErrorState } from './EntityError';
 
 export default class EntityNotFoundError<
-  TFields,
+  TFields extends object,
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,
   TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,

package/src/index.ts

@@ -12,7 +12,8 @@ export { default as Entity } from './Entity';
 export * from './Entity';
 export { default as EntityAssociationLoader } from './EntityAssociationLoader';
 export * from './EntityAssociationLoader';
-export { default as EntityCacheAdapter } from './EntityCacheAdapter';
+export { default as IEntityCacheAdapter } from './IEntityCacheAdapter';
+export { default as GenericEntityCacheAdapter } from './GenericEntityCacheAdapter';
 export { default as EntityCompanion } from './EntityCompanion';
 export * from './EntityCompanion';
 export { default as EntityCompanionProvider } from './EntityCompanionProvider';

package/src/internal/EntityDataManager.ts

@@ -1,5 +1,6 @@
 import DataLoader from 'dataloader';
 
+import ReadThroughEntityCache from './ReadThroughEntityCache';
 import EntityDatabaseAdapter, {
   FieldEqualityCondition,
   QuerySelectionModifiers,
@@ -17,7 +18,6 @@ import IEntityMetricsAdapter, {
   IncrementLoadCountEventType,
 } from '../metrics/IEntityMetricsAdapter';
 import { computeIfAbsent, zipToMap } from '../utils/collections/maps';
-import ReadThroughEntityCache from './ReadThroughEntityCache';
 
 /**
  * A data manager is responsible for orchestrating multiple sources of entity

package/src/internal/EntityTableDataCoordinator.ts

@@ -1,12 +1,12 @@
-import EntityCacheAdapter from '../EntityCacheAdapter';
+import EntityDataManager from './EntityDataManager';
+import ReadThroughEntityCache from './ReadThroughEntityCache';
 import EntityConfiguration from '../EntityConfiguration';
 import EntityDatabaseAdapter from '../EntityDatabaseAdapter';
 import EntityQueryContextProvider from '../EntityQueryContextProvider';
+import IEntityCacheAdapter from '../IEntityCacheAdapter';
 import IEntityCacheAdapterProvider from '../IEntityCacheAdapterProvider';
 import IEntityDatabaseAdapterProvider from '../IEntityDatabaseAdapterProvider';
 import IEntityMetricsAdapter from '../metrics/IEntityMetricsAdapter';
-import EntityDataManager from './EntityDataManager';
-import ReadThroughEntityCache from './ReadThroughEntityCache';
 
 /**
  * Responsible for orchestrating fetching and caching of entity data from a
@@ -15,7 +15,7 @@ import ReadThroughEntityCache from './ReadThroughEntityCache';
  */
 export default class EntityTableDataCoordinator<TFields> {
   readonly databaseAdapter: EntityDatabaseAdapter<TFields>;
-  readonly cacheAdapter: EntityCacheAdapter<TFields>;
+  readonly cacheAdapter: IEntityCacheAdapter<TFields>;
   readonly dataManager: EntityDataManager<TFields>;
 
   constructor(

package/src/internal/ReadThroughEntityCache.ts

@@ -1,7 +1,7 @@
 import invariant from 'invariant';
 
-import EntityCacheAdapter from '../EntityCacheAdapter';
 import EntityConfiguration from '../EntityConfiguration';
+import IEntityCacheAdapter from '../IEntityCacheAdapter';
 import { filterMap } from '../utils/collections/maps';
 
 export enum CacheStatus {
@@ -29,7 +29,7 @@ export type CacheLoadResult<TFields> =
 export default class ReadThroughEntityCache<TFields> {
   constructor(
     private readonly entityConfiguration: EntityConfiguration<TFields>,
-    private readonly entityCacheAdapter: EntityCacheAdapter<TFields>
+    private readonly entityCacheAdapter: IEntityCacheAdapter<TFields>
   ) {}
 
   private isFieldCacheable<N extends keyof TFields>(fieldName: N): boolean {

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

@@ -385,7 +385,8 @@ describe(EntityDataManager, () => {
         return await entityDataManager.loadManyByFieldEqualingAsync(queryContext, 'customIdField', [
           '1',
         ]);
-      }
+      },
+      {}
     );
 
     expect(entityDatas.get('1')).toHaveLength(1);

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

@@ -1,8 +1,8 @@
 import { verify, deepEqual, mock, instance, when, anything } from 'ts-mockito';
 
-import EntityCacheAdapter from '../../EntityCacheAdapter';
 import EntityConfiguration from '../../EntityConfiguration';
 import { UUIDField } from '../../EntityFields';
+import IEntityCacheAdapter from '../../IEntityCacheAdapter';
 import ReadThroughEntityCache, { CacheStatus } from '../ReadThroughEntityCache';
 
 type BlahFields = {
@@ -39,7 +39,7 @@ const createIdFetcher =
 describe(ReadThroughEntityCache, () => {
   describe('readManyThroughAsync', () => {
     it('fetches from DB upon cache miss and caches the result', async () => {
-      const cacheAdapterMock = mock<EntityCacheAdapter<BlahFields>>();
+      const cacheAdapterMock = mock<IEntityCacheAdapter<BlahFields>>();
       const cacheAdapter = instance(cacheAdapterMock);
       const entityCache = new ReadThroughEntityCache(makeEntityConfiguration(true), cacheAdapter);
       const fetcher = createIdFetcher(['wat', 'who']);
@@ -75,7 +75,7 @@ describe(ReadThroughEntityCache, () => {
     });
 
     it('does not fetch from the DB or cache results when all cache fetches are hits', async () => {
-      const cacheAdapterMock = mock<EntityCacheAdapter<BlahFields>>();
+      const cacheAdapterMock = mock<IEntityCacheAdapter<BlahFields>>();
       const cacheAdapter = instance(cacheAdapterMock);
       const entityCache = new ReadThroughEntityCache(makeEntityConfiguration(true), cacheAdapter);
       const fetcher = createIdFetcher(['wat', 'who']);
@@ -111,7 +111,7 @@ describe(ReadThroughEntityCache, () => {
     });
 
     it('negatively caches db misses', async () => {
-      const cacheAdapterMock = mock<EntityCacheAdapter<BlahFields>>();
+      const cacheAdapterMock = mock<IEntityCacheAdapter<BlahFields>>();
       const cacheAdapter = instance(cacheAdapterMock);
       const entityCache = new ReadThroughEntityCache(makeEntityConfiguration(true), cacheAdapter);
 
@@ -131,7 +131,7 @@ describe(ReadThroughEntityCache, () => {
     });
 
     it('does not return or fetch negatively cached results from DB', async () => {
-      const cacheAdapterMock = mock<EntityCacheAdapter<BlahFields>>();
+      const cacheAdapterMock = mock<IEntityCacheAdapter<BlahFields>>();
       const cacheAdapter = instance(cacheAdapterMock);
       const entityCache = new ReadThroughEntityCache(makeEntityConfiguration(true), cacheAdapter);
       const fetcher = createIdFetcher([]);
@@ -148,7 +148,7 @@ describe(ReadThroughEntityCache, () => {
     });
 
     it('does a mix and match of hit, miss, and negative', async () => {
-      const cacheAdapterMock = mock<EntityCacheAdapter<BlahFields>>();
+      const cacheAdapterMock = mock<IEntityCacheAdapter<BlahFields>>();
       const cacheAdapter = instance(cacheAdapterMock);
       const entityCache = new ReadThroughEntityCache(makeEntityConfiguration(true), cacheAdapter);
       const fetcher = createIdFetcher(['wat', 'who', 'why']);
@@ -183,7 +183,7 @@ describe(ReadThroughEntityCache, () => {
     });
 
     it('does not call into cache for field that is not cacheable', async () => {
-      const cacheAdapterMock = mock<EntityCacheAdapter<BlahFields>>();
+      const cacheAdapterMock = mock<IEntityCacheAdapter<BlahFields>>();
       const cacheAdapter = instance(cacheAdapterMock);
       const entityCache = new ReadThroughEntityCache(makeEntityConfiguration(false), cacheAdapter);
       const fetcher = createIdFetcher(['wat']);
@@ -195,7 +195,7 @@ describe(ReadThroughEntityCache, () => {
 
   describe('invalidateManyAsync', () => {
     it('calls cache adapter invalidate', async () => {
-      const cacheAdapterMock = mock<EntityCacheAdapter<BlahFields>>();
+      const cacheAdapterMock = mock<IEntityCacheAdapter<BlahFields>>();
       const cacheAdapter = instance(cacheAdapterMock);
       const entityCache = new ReadThroughEntityCache(makeEntityConfiguration(true), cacheAdapter);
       await entityCache.invalidateManyAsync('id', ['wat']);

package/src/metrics/EntityMetricsUtils.ts

@@ -1,8 +1,8 @@
-import { reduceMap } from '../utils/collections/maps';
 import IEntityMetricsAdapter, {
   EntityMetricsLoadType,
   EntityMetricsMutationType,
 } from './IEntityMetricsAdapter';
+import { reduceMap } from '../utils/collections/maps';
 
 export const timeAndLogLoadEventAsync =
   (

package/src/rules/AlwaysAllowPrivacyPolicyRule.ts

@@ -1,14 +1,14 @@
+import PrivacyPolicyRule, { RuleEvaluationResult } from './PrivacyPolicyRule';
 import { EntityPrivacyPolicyEvaluationContext } from '../EntityPrivacyPolicy';
 import { EntityQueryContext } from '../EntityQueryContext';
 import ReadonlyEntity from '../ReadonlyEntity';
 import ViewerContext from '../ViewerContext';
-import PrivacyPolicyRule, { RuleEvaluationResult } from './PrivacyPolicyRule';
 
 /**
  * Privacy policy rule that always allows.
  */
 export default class AlwaysAllowPrivacyPolicyRule<
-  TFields,
+  TFields extends object,
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,
   TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,

package/src/rules/AlwaysDenyPrivacyPolicyRule.ts

@@ -1,14 +1,14 @@
+import PrivacyPolicyRule, { RuleEvaluationResult } from './PrivacyPolicyRule';
 import { EntityPrivacyPolicyEvaluationContext } from '../EntityPrivacyPolicy';
 import { EntityQueryContext } from '../EntityQueryContext';
 import ReadonlyEntity from '../ReadonlyEntity';
 import ViewerContext from '../ViewerContext';
-import PrivacyPolicyRule, { RuleEvaluationResult } from './PrivacyPolicyRule';
 
 /**
  * Privacy policy rule that always denies.
  */
 export default class AlwaysDenyPrivacyPolicyRule<
-  TFields,
+  TFields extends object,
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,
   TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,

package/src/rules/AlwaysSkipPrivacyPolicyRule.ts

@@ -1,14 +1,14 @@
+import PrivacyPolicyRule, { RuleEvaluationResult } from './PrivacyPolicyRule';
 import { EntityPrivacyPolicyEvaluationContext } from '../EntityPrivacyPolicy';
 import { EntityQueryContext } from '../EntityQueryContext';
 import ReadonlyEntity from '../ReadonlyEntity';
 import ViewerContext from '../ViewerContext';
-import PrivacyPolicyRule, { RuleEvaluationResult } from './PrivacyPolicyRule';
 
 /**
  * A no-op policy rule that always skips.
  */
 export default class AlwaysSkipPrivacyPolicyRule<
-  TFields,
+  TFields extends object,
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,
   TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,

package/src/rules/PrivacyPolicyRule.ts

@@ -37,7 +37,7 @@ export enum RuleEvaluationResult {
  *   would be named something like `DenyIfViewerHasBeenBlockedPrivacyPolicyRule`.
  */
 export default abstract class PrivacyPolicyRule<
-  TFields,
+  TFields extends object,
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,
   TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,

package/src/testfixtures/DateIDTestEntity.ts

@@ -43,19 +43,17 @@ export class DateIDTestEntityPrivacyPolicy extends EntityPrivacyPolicy<
 }
 
 export default class DateIDTestEntity extends Entity<DateIDTestFields, Date, ViewerContext> {
-  static getCompanionDefinition(): EntityCompanionDefinition<
+  static defineCompanionDefinition(): EntityCompanionDefinition<
     DateIDTestFields,
     Date,
     ViewerContext,
     DateIDTestEntity,
     DateIDTestEntityPrivacyPolicy
   > {
-    return dateIDTestEntityCompanion;
+    return {
+      entityClass: DateIDTestEntity,
+      entityConfiguration: dateIDTestEntityConfiguration,
+      privacyPolicyClass: DateIDTestEntityPrivacyPolicy,
+    };
   }
 }
-
-export const dateIDTestEntityCompanion = new EntityCompanionDefinition({
-  entityClass: DateIDTestEntity,
-  entityConfiguration: dateIDTestEntityConfiguration,
-  privacyPolicyClass: DateIDTestEntityPrivacyPolicy,
-});

package/src/testfixtures/SimpleTestEntity.ts

@@ -75,7 +75,7 @@ export default class SimpleTestEntity extends Entity<
   ViewerContext,
   SimpleTestFieldSelection
 > {
-  static getCompanionDefinition(): EntityCompanionDefinition<
+  static defineCompanionDefinition(): EntityCompanionDefinition<
     SimpleTestFields,
     string,
     ViewerContext,
@@ -83,12 +83,10 @@ export default class SimpleTestEntity extends Entity<
     SimpleTestEntityPrivacyPolicy,
     SimpleTestFieldSelection
   > {
-    return testEntityCompanion;
+    return {
+      entityClass: SimpleTestEntity,
+      entityConfiguration: simpleTestEntityConfiguration,
+      privacyPolicyClass: SimpleTestEntityPrivacyPolicy,
+    };
   }
 }
-
-export const testEntityCompanion = new EntityCompanionDefinition({
-  entityClass: SimpleTestEntity,
-  entityConfiguration: simpleTestEntityConfiguration,
-  privacyPolicyClass: SimpleTestEntityPrivacyPolicy,
-});