@expo/entity 0.31.1 → 0.33.0

package/src/EntityMutator.ts

@@ -2,7 +2,7 @@ import { Result, asyncResult, result, enforceAsyncResult } from '@expo/results';
 import invariant from 'invariant';
 
 import Entity, { IEntityClass } from './Entity';
-import { EntityCompanionDefinition } from './EntityCompanionProvider';
+import EntityCompanionProvider from './EntityCompanionProvider';
 import EntityConfiguration from './EntityConfiguration';
 import EntityDatabaseAdapter from './EntityDatabaseAdapter';
 import { EntityEdgeDeletionBehavior } from './EntityFieldDefinition';
@@ -28,7 +28,7 @@ import IEntityMetricsAdapter, { EntityMetricsMutationType } from './metrics/IEnt
 import { mapMapAsync } from './utils/collections/maps';
 
 abstract class BaseMutator<
-  TFields,
+  TFields extends object,
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,
   TEntity extends Entity<TFields, TID, TViewerContext, TSelectedFields>,
@@ -42,6 +42,7 @@ abstract class BaseMutator<
   TSelectedFields extends keyof TFields
 > {
   constructor(
+    protected readonly companionProvider: EntityCompanionProvider,
     protected readonly viewerContext: TViewerContext,
     protected readonly queryContext: EntityQueryContext,
     protected readonly entityConfiguration: EntityConfiguration<TFields>,
@@ -155,7 +156,7 @@ abstract class BaseMutator<
  * Mutator for creating a new entity.
  */
 export class CreateMutator<
-  TFields,
+  TFields extends object,
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,
   TEntity extends Entity<TFields, TID, TViewerContext, TSelectedFields>,
@@ -211,7 +212,11 @@ export class CreateMutator<
   ): Promise<Result<TEntity>> {
     this.validateFields(this.fieldsForEntity);
 
-    const temporaryEntityForPrivacyCheck = new this.entityClass(this.viewerContext, {
+    const entityLoader = this.entityLoaderFactory.forLoad(this.viewerContext, queryContext, {
+      cascadingDeleteCause: null,
+    });
+
+    const temporaryEntityForPrivacyCheck = entityLoader.constructEntity({
       [this.entityConfiguration.idField]: '00000000-0000-0000-0000-000000000000', // zero UUID
       ...this.fieldsForEntity,
     } as unknown as TFields);
@@ -250,14 +255,11 @@ export class CreateMutator<
 
     const insertResult = await this.databaseAdapter.insertAsync(queryContext, this.fieldsForEntity);
 
-    const entityLoader = this.entityLoaderFactory.forLoad(this.viewerContext, queryContext, {
-      cascadingDeleteCause: null,
-    });
     queryContext.appendPostCommitInvalidationCallback(
       entityLoader.invalidateFieldsAsync.bind(entityLoader, insertResult)
     );
 
-    const unauthorizedEntityAfterInsert = new this.entityClass(this.viewerContext, insertResult);
+    const unauthorizedEntityAfterInsert = entityLoader.constructEntity(insertResult);
     const newEntity = await entityLoader
       .enforcing()
       .loadByIDAsync(unauthorizedEntityAfterInsert.getID());
@@ -292,7 +294,7 @@ export class CreateMutator<
  * Mutator for updating an existing entity.
  */
 export class UpdateMutator<
-  TFields,
+  TFields extends object,
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,
   TEntity extends Entity<TFields, TID, TViewerContext, TSelectedFields>,
@@ -310,6 +312,7 @@ export class UpdateMutator<
   private readonly updatedFields: Partial<TFields> = {};
 
   constructor(
+    companionProvider: EntityCompanionProvider,
     viewerContext: TViewerContext,
     queryContext: EntityQueryContext,
     entityConfiguration: EntityConfiguration<TFields>,
@@ -349,6 +352,7 @@ export class UpdateMutator<
     originalEntity: TEntity
   ) {
     super(
+      companionProvider,
       viewerContext,
       queryContext,
       entityConfiguration,
@@ -419,7 +423,11 @@ export class UpdateMutator<
   ): Promise<Result<TEntity>> {
     this.validateFields(this.updatedFields);
 
-    const entityAboutToBeUpdated = new this.entityClass(this.viewerContext, this.fieldsForEntity);
+    const entityLoader = this.entityLoaderFactory.forLoad(this.viewerContext, queryContext, {
+      cascadingDeleteCause,
+    });
+
+    const entityAboutToBeUpdated = entityLoader.constructEntity(this.fieldsForEntity);
     const authorizeUpdateResult = await asyncResult(
       this.privacyPolicy.authorizeUpdateAsync(
         this.viewerContext,
@@ -462,10 +470,6 @@ export class UpdateMutator<
           this.updatedFields
         );
 
-    const entityLoader = this.entityLoaderFactory.forLoad(this.viewerContext, queryContext, {
-      cascadingDeleteCause,
-    });
-
     queryContext.appendPostCommitInvalidationCallback(
       entityLoader.invalidateFieldsAsync.bind(
         entityLoader,
@@ -481,7 +485,7 @@ export class UpdateMutator<
     const updatedEntity = updateResult
       ? await entityLoader
           .enforcing()
-          .loadByIDAsync(new this.entityClass(this.viewerContext, updateResult).getID())
+          .loadByIDAsync(entityLoader.constructEntity(updateResult).getID())
       : entityAboutToBeUpdated;
 
     await this.executeMutationTriggersAsync(
@@ -518,7 +522,7 @@ export class UpdateMutator<
  * Mutator for deleting an existing entity.
  */
 export class DeleteMutator<
-  TFields,
+  TFields extends object,
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,
   TEntity extends Entity<TFields, TID, TViewerContext, TSelectedFields>,
@@ -532,6 +536,7 @@ export class DeleteMutator<
   TSelectedFields extends keyof TFields
 > extends BaseMutator<TFields, TID, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields> {
   constructor(
+    companionProvider: EntityCompanionProvider,
     viewerContext: TViewerContext,
     queryContext: EntityQueryContext,
     entityConfiguration: EntityConfiguration<TFields>,
@@ -571,6 +576,7 @@ export class DeleteMutator<
     private readonly entity: TEntity
   ) {
     super(
+      companionProvider,
       viewerContext,
       queryContext,
       entityConfiguration,
@@ -723,31 +729,32 @@ export class DeleteMutator<
     }
     processedEntityIdentifiers.add(entity.getUniqueIdentifier());
 
-    const companionDefinition = (
-      entity.constructor as any
-    ).getCompanionDefinition() as EntityCompanionDefinition<
-      TFields,
-      TID,
-      TViewerContext,
-      TEntity,
-      TPrivacyPolicy,
-      TSelectedFields
-    >;
+    const companionDefinition = this.companionProvider.getCompanionForEntity(
+      entity.constructor as IEntityClass<
+        TFields,
+        TID,
+        TViewerContext,
+        TEntity,
+        TPrivacyPolicy,
+        TSelectedFields
+      >
+    ).entityCompanionDefinition;
     const entityConfiguration = companionDefinition.entityConfiguration;
-    const inboundEdges = entityConfiguration.getInboundEdges();
+    const inboundEdges = entityConfiguration.inboundEdges;
     await Promise.all(
       inboundEdges.map(async (entityClass) => {
         return await mapMapAsync(
-          entityClass.getCompanionDefinition().entityConfiguration.schema,
+          this.companionProvider.getCompanionForEntity(entityClass).entityCompanionDefinition
+            .entityConfiguration.schema,
           async (fieldDefinition, fieldName) => {
             const association = fieldDefinition.association;
             if (!association) {
               return;
             }
 
-            const associatedConfiguration = association
-              .getAssociatedEntityClass()
-              .getCompanionDefinition().entityConfiguration;
+            const associatedConfiguration = this.companionProvider.getCompanionForEntity(
+              association.associatedEntityClass
+            ).entityCompanionDefinition.entityConfiguration;
             if (associatedConfiguration !== entityConfiguration) {
               return;
             }

package/src/EntityMutatorFactory.ts

@@ -1,4 +1,5 @@
 import Entity, { IEntityClass } from './Entity';
+import EntityCompanionProvider from './EntityCompanionProvider';
 import EntityConfiguration from './EntityConfiguration';
 import EntityDatabaseAdapter from './EntityDatabaseAdapter';
 import EntityLoaderFactory from './EntityLoaderFactory';
@@ -14,7 +15,7 @@ import IEntityMetricsAdapter from './metrics/IEntityMetricsAdapter';
  * The primary interface for creating, mutating, and deleting entities.
  */
 export default class EntityMutatorFactory<
-  TFields,
+  TFields extends object,
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,
   TEntity extends Entity<TFields, TID, TViewerContext, TSelectedFields>,
@@ -28,6 +29,7 @@ export default class EntityMutatorFactory<
   TSelectedFields extends keyof TFields = keyof TFields
 > {
   constructor(
+    private readonly entityCompanionProvider: EntityCompanionProvider,
     private readonly entityConfiguration: EntityConfiguration<TFields>,
     private readonly entityClass: IEntityClass<
       TFields,
@@ -75,6 +77,7 @@ export default class EntityMutatorFactory<
     queryContext: EntityQueryContext
   ): CreateMutator<TFields, TID, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields> {
     return new CreateMutator(
+      this.entityCompanionProvider,
       viewerContext,
       queryContext,
       this.entityConfiguration,
@@ -99,6 +102,7 @@ export default class EntityMutatorFactory<
     queryContext: EntityQueryContext
   ): UpdateMutator<TFields, TID, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields> {
     return new UpdateMutator(
+      this.entityCompanionProvider,
       existingEntity.getViewerContext(),
       queryContext,
       this.entityConfiguration,
@@ -123,6 +127,7 @@ export default class EntityMutatorFactory<
     queryContext: EntityQueryContext
   ): DeleteMutator<TFields, TID, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields> {
     return new DeleteMutator(
+      this.entityCompanionProvider,
       existingEntity.getViewerContext(),
       queryContext,
       this.entityConfiguration,

package/src/EntityPrivacyPolicy.ts

@@ -41,7 +41,7 @@ export enum EntityPrivacyPolicyEvaluationMode {
 }
 
 export type EntityPrivacyPolicyEvaluator<
-  TFields,
+  TFields extends object,
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,
   TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
@@ -92,7 +92,7 @@ export enum EntityAuthorizationAction {
  * ```
  */
 export default abstract class EntityPrivacyPolicy<
-  TFields,
+  TFields extends object,
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,
   TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,

package/src/EntityQueryContext.ts

@@ -8,6 +8,16 @@ export type PreCommitCallback = (
   ...args: any
 ) => Promise<any>;
 
+export enum TransactionIsolationLevel {
+  READ_COMMITTED = 'READ_COMMITTED',
+  REPEATABLE_READ = 'REPEATABLE_READ',
+  SERIALIZABLE = 'SERIALIZABLE',
+}
+
+export type TransactionConfig = {
+  isolationLevel?: TransactionIsolationLevel;
+};
+
 /**
  * Entity framework representation of transactional and non-transactional database
  * query execution units.
@@ -25,7 +35,8 @@ export abstract class EntityQueryContext {
   }
 
   abstract runInTransactionIfNotInTransactionAsync<T>(
-    transactionScope: (queryContext: EntityTransactionalQueryContext) => Promise<T>
+    transactionScope: (queryContext: EntityTransactionalQueryContext) => Promise<T>,
+    transactionConfig?: TransactionConfig
   ): Promise<T>;
 }
 
@@ -48,9 +59,13 @@ export class EntityNonTransactionalQueryContext extends EntityQueryContext {
   }
 
   async runInTransactionIfNotInTransactionAsync<T>(
-    transactionScope: (queryContext: EntityTransactionalQueryContext) => Promise<T>
+    transactionScope: (queryContext: EntityTransactionalQueryContext) => Promise<T>,
+    transactionConfig?: TransactionConfig
   ): Promise<T> {
-    return await this.entityQueryContextProvider.runInTransactionAsync(transactionScope);
+    return await this.entityQueryContextProvider.runInTransactionAsync(
+      transactionScope,
+      transactionConfig
+    );
   }
 }
 
@@ -132,8 +147,13 @@ export class EntityTransactionalQueryContext extends EntityQueryContext {
   }
 
   async runInTransactionIfNotInTransactionAsync<T>(
-    transactionScope: (queryContext: EntityTransactionalQueryContext) => Promise<T>
+    transactionScope: (queryContext: EntityTransactionalQueryContext) => Promise<T>,
+    transactionConfig?: TransactionConfig
   ): Promise<T> {
+    assert(
+      transactionConfig === undefined,
+      'Should not pass transactionConfig to a nested transaction'
+    );
     return await transactionScope(this);
   }
 

package/src/EntityQueryContextProvider.ts

@@ -2,6 +2,7 @@ import {
   EntityTransactionalQueryContext,
   EntityNonTransactionalQueryContext,
   EntityNestedTransactionalQueryContext,
+  TransactionConfig,
 } from './EntityQueryContext';
 
 /**
@@ -23,9 +24,9 @@ export default abstract class EntityQueryContextProvider {
   /**
    * Vend a transaction runner for use in runInTransactionAsync.
    */
-  protected abstract createTransactionRunner<T>(): (
-    transactionScope: (queryInterface: any) => Promise<T>
-  ) => Promise<T>;
+  protected abstract createTransactionRunner<T>(
+    transactionConfig?: TransactionConfig
+  ): (transactionScope: (queryInterface: any) => Promise<T>) => Promise<T>;
 
   protected abstract createNestedTransactionRunner<T>(
     outerQueryInterface: any
@@ -36,11 +37,12 @@ export default abstract class EntityQueryContextProvider {
    * @param transactionScope - async callback to execute within the transaction
    */
   async runInTransactionAsync<T>(
-    transactionScope: (queryContext: EntityTransactionalQueryContext) => Promise<T>
+    transactionScope: (queryContext: EntityTransactionalQueryContext) => Promise<T>,
+    transactionConfig?: TransactionConfig
   ): Promise<T> {
     const [returnedValue, queryContext] = await this.createTransactionRunner<
       [T, EntityTransactionalQueryContext]
-    >()(async (queryInterface) => {
+    >(transactionConfig)(async (queryInterface) => {
       const queryContext = new EntityTransactionalQueryContext(queryInterface, this);
       const result = await transactionScope(queryContext);
       await queryContext.runPreCommitCallbacksAsync();

package/src/EntitySecondaryCacheLoader.ts

@@ -45,7 +45,7 @@ export interface ISecondaryEntityCache<TFields, TLoadParams> {
  */
 export default abstract class EntitySecondaryCacheLoader<
   TLoadParams,
-  TFields,
+  TFields extends object,
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,
   TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,

package/src/GenericEntityCacheAdapter.ts

@@ -0,0 +1,65 @@
+import invariant from 'invariant';
+
+import IEntityCacheAdapter from './IEntityCacheAdapter';
+import IEntityGenericCacher from './IEntityGenericCacher';
+import { CacheLoadResult } from './internal/ReadThroughEntityCache';
+import { mapKeys } from './utils/collections/maps';
+
+/**
+ * A standard IEntityCacheAdapter that coordinates caching through an IEntityGenericCacher.
+ */
+export default class GenericEntityCacheAdapter<TFields> implements IEntityCacheAdapter<TFields> {
+  constructor(private readonly genericCacher: IEntityGenericCacher<TFields>) {}
+
+  public async loadManyAsync<N extends keyof TFields>(
+    fieldName: N,
+    fieldValues: readonly NonNullable<TFields[N]>[]
+  ): Promise<ReadonlyMap<NonNullable<TFields[N]>, CacheLoadResult<TFields>>> {
+    const redisCacheKeyToFieldValueMapping = new Map(
+      fieldValues.map((fieldValue) => [
+        this.genericCacher.makeCacheKey(fieldName, fieldValue),
+        fieldValue,
+      ])
+    );
+    const cacheResults = await this.genericCacher.loadManyAsync(
+      Array.from(redisCacheKeyToFieldValueMapping.keys())
+    );
+
+    return mapKeys(cacheResults, (redisCacheKey) => {
+      const fieldValue = redisCacheKeyToFieldValueMapping.get(redisCacheKey);
+      invariant(
+        fieldValue !== undefined,
+        'Unspecified cache key %s returned from generic cacher',
+        redisCacheKey
+      );
+      return fieldValue;
+    });
+  }
+
+  public async cacheManyAsync<N extends keyof TFields>(
+    fieldName: N,
+    objectMap: ReadonlyMap<NonNullable<TFields[N]>, Readonly<TFields>>
+  ): Promise<void> {
+    await this.genericCacher.cacheManyAsync(
+      mapKeys(objectMap, (fieldValue) => this.genericCacher.makeCacheKey(fieldName, fieldValue))
+    );
+  }
+
+  public async cacheDBMissesAsync<N extends keyof TFields>(
+    fieldName: N,
+    fieldValues: readonly NonNullable<TFields[N]>[]
+  ): Promise<void> {
+    await this.genericCacher.cacheDBMissesAsync(
+      fieldValues.map((fieldValue) => this.genericCacher.makeCacheKey(fieldName, fieldValue))
+    );
+  }
+
+  public async invalidateManyAsync<N extends keyof TFields>(
+    fieldName: N,
+    fieldValues: readonly NonNullable<TFields[N]>[]
+  ): Promise<void> {
+    await this.genericCacher.invalidateManyAsync(
+      fieldValues.map((fieldValue) => this.genericCacher.makeCacheKey(fieldName, fieldValue))
+    );
+  }
+}

package/src/{EntityCacheAdapter.ts → IEntityCacheAdapter.ts}

@@ -1,20 +1,17 @@
-import EntityConfiguration from './EntityConfiguration';
 import { CacheLoadResult } from './internal/ReadThroughEntityCache';
 
 /**
  * A cache adapter is an interface by which objects can be
  * cached, fetched from cache, and removed from cache (invalidated).
  */
-export default abstract class EntityCacheAdapter<TFields> {
-  constructor(protected readonly entityConfiguration: EntityConfiguration<TFields>) {}
-
+export default interface IEntityCacheAdapter<TFields> {
   /**
    * Load many objects from cache.
    * @param fieldName - object field being queried
    * @param fieldValues - fieldName field values being queried
    * @returns map from all field values to a CacheLoadResult for each input value
    */
-  public abstract loadManyAsync<N extends keyof TFields>(
+  loadManyAsync<N extends keyof TFields>(
     fieldName: N,
     fieldValues: readonly NonNullable<TFields[N]>[]
   ): Promise<ReadonlyMap<NonNullable<TFields[N]>, CacheLoadResult<TFields>>>;
@@ -24,7 +21,7 @@ export default abstract class EntityCacheAdapter<TFields> {
    * @param fieldName - object field being queried
    * @param objectMap - map from field value to object to cache
    */
-  public abstract cacheManyAsync<N extends keyof TFields>(
+  cacheManyAsync<N extends keyof TFields>(
     fieldName: N,
     objectMap: ReadonlyMap<NonNullable<TFields[N]>, Readonly<TFields>>
   ): Promise<void>;
@@ -35,7 +32,7 @@ export default abstract class EntityCacheAdapter<TFields> {
    * @param fieldValues - fieldValues for objects reported as CacheStatus.NEGATIVE
    *                    in the cache and not found in the DB.
    */
-  public abstract cacheDBMissesAsync<N extends keyof TFields>(
+  cacheDBMissesAsync<N extends keyof TFields>(
     fieldName: N,
     fieldValues: readonly NonNullable<TFields[N]>[]
   ): Promise<void>;
@@ -45,7 +42,7 @@ export default abstract class EntityCacheAdapter<TFields> {
    * @param fieldName - object field being queried
    * @param fieldValues - fieldName field values to be invalidated
    */
-  public abstract invalidateManyAsync<N extends keyof TFields>(
+  invalidateManyAsync<N extends keyof TFields>(
     fieldName: N,
     fieldValues: readonly NonNullable<TFields[N]>[]
   ): Promise<void>;

package/src/IEntityCacheAdapterProvider.ts

@@ -1,5 +1,5 @@
-import EntityCacheAdapter from './EntityCacheAdapter';
 import EntityConfiguration from './EntityConfiguration';
+import IEntityCacheAdapter from './IEntityCacheAdapter';
 
 /**
  * A cache adapter provider vends cache adapters for a particular cache adapter type.
@@ -11,5 +11,5 @@ export default interface IEntityCacheAdapterProvider {
    */
   getCacheAdapter<TFields>(
     entityConfiguration: EntityConfiguration<TFields>
-  ): EntityCacheAdapter<TFields>;
+  ): IEntityCacheAdapter<TFields>;
 }

package/src/IEntityGenericCacher.ts

@@ -1,15 +1,45 @@
 import { CacheLoadResult } from './internal/ReadThroughEntityCache';
 
 /**
- * A cacher stores and loads key-value pairs. It also supports negative caching - it stores the absence
- * of keys that don't exist in the backing datastore.
+ * A generic cacher stores and loads key-value pairs. It also supports negative caching - it stores the absence
+ * of keys that don't exist in the backing datastore. It is also responsible for cache key creation.
  */
 export default interface IEntityGenericCacher<TFields> {
+  /**
+   * Load many keys from the cache. Return info in a format that is useful for read-through caching and
+   * negative caching.
+   *
+   * @param keys - cache keys to load
+   */
   loadManyAsync(keys: readonly string[]): Promise<ReadonlyMap<string, CacheLoadResult<TFields>>>;
 
+  /**
+   * Cache many objects for specified keys.
+   *
+   * @param objectMap - map from cache key to object to cache for key
+   */
   cacheManyAsync(objectMap: ReadonlyMap<string, Readonly<TFields>>): Promise<void>;
 
+  /**
+   * Negatively-cache specified keys. Subsequent loads for these keys (without calling invalidate) may
+   * return a negative CacheLoadResult
+   *
+   * @param keys - keys to cache negatively
+   */
   cacheDBMissesAsync(keys: readonly string[]): Promise<void>;
 
+  /**
+   * Invalidate specified keys in cache. Subsequent loads for these keys may return a cache miss.
+   *
+   * @param keys - keys to invalidate
+   */
   invalidateManyAsync(keys: readonly string[]): Promise<void>;
+
+  /**
+   * Create a cache key for a field and value of a object being cached or invalidated.
+   *
+   * @param fieldName - name of the object field for this cache key
+   * @param fieldValue - value of the obejct field for this cache key
+   */
+  makeCacheKey<N extends keyof TFields>(fieldName: N, fieldValue: NonNullable<TFields[N]>): string;
 }

package/src/ReadonlyEntity.ts

@@ -2,12 +2,10 @@ import invariant from 'invariant';
 
 import { IEntityClass } from './Entity';
 import EntityAssociationLoader from './EntityAssociationLoader';
-import { EntityCompanionDefinition } from './EntityCompanionProvider';
 import EntityLoader from './EntityLoader';
 import EntityPrivacyPolicy from './EntityPrivacyPolicy';
 import { EntityQueryContext } from './EntityQueryContext';
 import ViewerContext from './ViewerContext';
-import { pick } from './entityUtils';
 
 /**
  * A readonly entity exposes only the read functionality of an Entity. Used as the base
@@ -18,45 +16,47 @@ import { pick } from './entityUtils';
  * - Entities representing immutable tables.
  */
 export default abstract class ReadonlyEntity<
-  TFields,
+  TFields extends object,
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,
   TSelectedFields extends keyof TFields = keyof TFields
 > {
+  private readonly viewerContext: TViewerContext;
   private readonly id: TID;
-  private readonly rawFields: Readonly<Pick<TFields, TSelectedFields>>;
+  private readonly databaseFields: Readonly<TFields>;
+  private readonly selectedFields: Readonly<Pick<TFields, TSelectedFields>>;
 
   /**
    * Constructs an instance of an Entity.
-   * @param viewerContext - the ViewerContext reading this entity
-   * @param rawFields - all underlying fields for this entity's data
+   *
+   * @param constructorParam - data needed to construct an instance of an entity
+   * viewerContext - the ViewerContext reading this entity
+   * id - the ID of this entity
+   * databaseFields - all underlying fields for this entity's data
+   * selectedFields - selected fields for this entity from TSelectedFields type
+   *
+   * This should only be overridden in cases where additional data validation is needed.
+   * The params should not be modified when calling super during constructions.
    *
    * @internal
    */
-  constructor(
-    private readonly viewerContext: TViewerContext,
-    private readonly databaseFields: Readonly<TFields>
-  ) {
-    const companionDefinition = (
-      this.constructor as any
-    ).getCompanionDefinition() as EntityCompanionDefinition<
-      TFields,
-      TID,
-      TViewerContext,
-      this,
-      EntityPrivacyPolicy<TFields, TID, TViewerContext, this, TSelectedFields>,
-      TSelectedFields
-    >;
-    const idField = companionDefinition.entityConfiguration.idField as keyof Pick<
-      TFields,
-      TSelectedFields
-    >;
-    const id = databaseFields[idField];
-    invariant(id, 'must provide ID to create an entity');
-    this.id = id as any;
+  constructor({
+    viewerContext,
+    id,
+    databaseFields,
+    selectedFields,
+  }: {
+    viewerContext: TViewerContext;
+    id: TID;
+    databaseFields: Readonly<TFields>;
+    selectedFields: Readonly<Pick<TFields, TSelectedFields>>;
+  }) {
+    invariant(id !== null && id !== undefined, 'id must be non-null');
 
-    const entitySelectedFields = companionDefinition.entitySelectedFields as (keyof TFields)[];
-    this.rawFields = pick(databaseFields, entitySelectedFields);
+    this.viewerContext = viewerContext;
+    this.id = id;
+    this.databaseFields = databaseFields;
+    this.selectedFields = selectedFields;
   }
 
   toString(): string {
@@ -102,14 +102,14 @@ export default abstract class ReadonlyEntity<
   getField<K extends keyof Pick<TFields, TSelectedFields>>(
     fieldName: K
   ): Pick<TFields, TSelectedFields>[K] {
-    return this.rawFields[fieldName];
+    return this.selectedFields[fieldName];
   }
 
   /**
    * @returns all underlying fields from this entity's data
    */
   getAllFields(): Readonly<Pick<TFields, TSelectedFields>> {
-    return { ...this.rawFields };
+    return { ...this.selectedFields };
   }
 
   /**
@@ -125,7 +125,7 @@ export default abstract class ReadonlyEntity<
    * @param queryContext - query context in which to perform the load
    */
   static loader<
-    TMFields,
+    TMFields extends object,
     TMID extends NonNullable<TMFields[TMSelectedFields]>,
     TMViewerContext extends ViewerContext,
     TMViewerContext2 extends TMViewerContext,