@expo/entity 0.41.0 → 0.42.0

package/src/GenericEntityCacheAdapter.ts

@@ -2,64 +2,75 @@ import invariant from 'invariant';
 
 import IEntityCacheAdapter from './IEntityCacheAdapter';
 import IEntityGenericCacher from './IEntityGenericCacher';
+import { IEntityLoadKey, IEntityLoadValue } from './internal/EntityLoadInterfaces';
 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>) {}
+export default class GenericEntityCacheAdapter<
+  TFields extends Record<string, any>,
+  TIDField extends keyof TFields,
+> implements IEntityCacheAdapter<TFields, TIDField>
+{
+  constructor(private readonly genericCacher: IEntityGenericCacher<TFields, TIDField>) {}
 
-  public async loadManyAsync<N extends keyof TFields>(
-    fieldName: N,
-    fieldValues: readonly NonNullable<TFields[N]>[],
-  ): Promise<ReadonlyMap<NonNullable<TFields[N]>, CacheLoadResult<TFields>>> {
+  public async loadManyAsync<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(
+    key: TLoadKey,
+    values: readonly TLoadValue[],
+  ): Promise<ReadonlyMap<TLoadValue, CacheLoadResult<TFields>>> {
     const redisCacheKeyToFieldValueMapping = new Map(
-      fieldValues.map((fieldValue) => [
-        this.genericCacher.makeCacheKey(fieldName, fieldValue),
-        fieldValue,
-      ]),
+      values.map((value) => [this.genericCacher.makeCacheKeyForStorage(key, value), value]),
     );
     const cacheResults = await this.genericCacher.loadManyAsync(
       Array.from(redisCacheKeyToFieldValueMapping.keys()),
     );
 
-    return mapKeys(cacheResults, (redisCacheKey) => {
+    const result = key.vendNewLoadValueMap<CacheLoadResult<TFields>>();
+    for (const [redisCacheKey, cacheResult] of cacheResults) {
       const fieldValue = redisCacheKeyToFieldValueMapping.get(redisCacheKey);
       invariant(
         fieldValue !== undefined,
         'Unspecified cache key %s returned from generic cacher',
         redisCacheKey,
       );
-      return fieldValue;
-    });
+      result.set(fieldValue, cacheResult);
+    }
+    return result;
   }
 
-  public async cacheManyAsync<N extends keyof TFields>(
-    fieldName: N,
-    objectMap: ReadonlyMap<NonNullable<TFields[N]>, Readonly<TFields>>,
-  ): Promise<void> {
+  public async cacheManyAsync<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(key: TLoadKey, objectMap: ReadonlyMap<TLoadValue, Readonly<TFields>>): Promise<void> {
     await this.genericCacher.cacheManyAsync(
-      mapKeys(objectMap, (fieldValue) => this.genericCacher.makeCacheKey(fieldName, fieldValue)),
+      mapKeys(objectMap, (value) => this.genericCacher.makeCacheKeyForStorage(key, value)),
     );
   }
 
-  public async cacheDBMissesAsync<N extends keyof TFields>(
-    fieldName: N,
-    fieldValues: readonly NonNullable<TFields[N]>[],
-  ): Promise<void> {
+  public async cacheDBMissesAsync<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(key: TLoadKey, values: readonly TLoadValue[]): Promise<void> {
     await this.genericCacher.cacheDBMissesAsync(
-      fieldValues.map((fieldValue) => this.genericCacher.makeCacheKey(fieldName, fieldValue)),
+      values.map((value) => this.genericCacher.makeCacheKeyForStorage(key, value)),
     );
   }
 
-  public async invalidateManyAsync<N extends keyof TFields>(
-    fieldName: N,
-    fieldValues: readonly NonNullable<TFields[N]>[],
-  ): Promise<void> {
+  public async invalidateManyAsync<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(key: TLoadKey, values: readonly TLoadValue[]): Promise<void> {
     await this.genericCacher.invalidateManyAsync(
-      fieldValues.map((fieldValue) => this.genericCacher.makeCacheKey(fieldName, fieldValue)),
+      values.flatMap((value) => this.genericCacher.makeCacheKeysForInvalidation(key, value)),
     );
   }
 }

package/src/GenericSecondaryEntityCache.ts

@@ -10,11 +10,14 @@ import { filterMap, zipToMap } from './utils/collections/maps';
  * single entity load. One common way this may be used is to add a second layer of caching in a hot path that makes
  * a call to EntityLoader.loadManyByFieldEqualityConjunctionAsync is guaranteed to return at most one entity.
  */
-export default abstract class GenericSecondaryEntityCache<TFields, TLoadParams>
-  implements ISecondaryEntityCache<TFields, TLoadParams>
+export default abstract class GenericSecondaryEntityCache<
+  TFields extends Record<string, any>,
+  TIDField extends keyof TFields,
+  TLoadParams,
+> implements ISecondaryEntityCache<TFields, TLoadParams>
 {
   constructor(
-    protected readonly cacher: IEntityGenericCacher<TFields>,
+    protected readonly cacher: IEntityGenericCacher<TFields, TIDField>,
     protected readonly constructCacheKey: (params: Readonly<TLoadParams>) => string,
   ) {}
 

package/src/IEntityCacheAdapter.ts

@@ -1,49 +1,69 @@
+import { IEntityLoadKey, IEntityLoadValue } from './internal/EntityLoadInterfaces';
 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 interface IEntityCacheAdapter<TFields> {
+export default interface IEntityCacheAdapter<
+  TFields extends Record<string, any>,
+  TIDField extends keyof 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
+   * @param key - load key to load
+   * @param values - load values to load for the key
+   * @returns map from all load values to a CacheLoadResult for that value
    */
-  loadManyAsync<N extends keyof TFields>(
-    fieldName: N,
-    fieldValues: readonly NonNullable<TFields[N]>[],
-  ): Promise<ReadonlyMap<NonNullable<TFields[N]>, CacheLoadResult<TFields>>>;
+  loadManyAsync<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(
+    key: TLoadKey,
+    values: readonly TLoadValue[],
+  ): Promise<ReadonlyMap<TLoadValue, CacheLoadResult<TFields>>>;
 
   /**
    * Cache many objects fetched from the DB.
-   * @param fieldName - object field being queried
-   * @param objectMap - map from field value to object to cache
+   * @param key - load key to cache
+   * @param objectMap - map from load value to object to cache for the key
    */
-  cacheManyAsync<N extends keyof TFields>(
-    fieldName: N,
-    objectMap: ReadonlyMap<NonNullable<TFields[N]>, Readonly<TFields>>,
+  cacheManyAsync<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(
+    key: TLoadKey,
+    objectMap: ReadonlyMap<TLoadValue, Readonly<TFields>>,
   ): Promise<void>;
 
   /**
    * Negatively cache objects that could not be found in the cache or DB.
-   * @param fieldName - object field being queried
-   * @param fieldValues - fieldValues for objects reported as CacheStatus.NEGATIVE
-   *                    in the cache and not found in the DB.
+   * @param key - load key to cache misses for
+   * @param values - load values for objects reported as CacheStatus.NEGATIVE
+   *                 in the cache and not found in the DB.
    */
-  cacheDBMissesAsync<N extends keyof TFields>(
-    fieldName: N,
-    fieldValues: readonly NonNullable<TFields[N]>[],
+  cacheDBMissesAsync<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(
+    key: TLoadKey,
+    values: readonly TLoadValue[],
   ): Promise<void>;
 
   /**
-   * Invalidate the cache for objects cached by (fieldName, fieldValue).
-   * @param fieldName - object field being queried
-   * @param fieldValues - fieldName field values to be invalidated
+   * Invalidate the cache for objects cached by (key, value).
+   * @param key - load key to invalidate
+   * @param values - load values to be invalidated for the key
    */
-  invalidateManyAsync<N extends keyof TFields>(
-    fieldName: N,
-    fieldValues: readonly NonNullable<TFields[N]>[],
+  invalidateManyAsync<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(
+    key: TLoadKey,
+    values: readonly TLoadValue[],
   ): Promise<void>;
 }

package/src/IEntityCacheAdapterProvider.ts

@@ -9,7 +9,7 @@ export default interface IEntityCacheAdapterProvider {
   /**
    * Vend a cache adapter for an entity configuration.
    */
-  getCacheAdapter<TFields extends Record<string, any>>(
-    entityConfiguration: EntityConfiguration<TFields>,
-  ): IEntityCacheAdapter<TFields>;
+  getCacheAdapter<TFields extends Record<string, any>, TIDField extends keyof TFields>(
+    entityConfiguration: EntityConfiguration<TFields, TIDField>,
+  ): IEntityCacheAdapter<TFields, TIDField>;
 }

package/src/IEntityDatabaseAdapterProvider.ts

@@ -9,7 +9,7 @@ export default interface IEntityDatabaseAdapterProvider {
   /**
    * Vend a database adapter.
    */
-  getDatabaseAdapter<TFields extends Record<string, any>>(
-    entityConfiguration: EntityConfiguration<TFields>,
-  ): EntityDatabaseAdapter<TFields>;
+  getDatabaseAdapter<TFields extends Record<string, any>, TIDField extends keyof TFields>(
+    entityConfiguration: EntityConfiguration<TFields, TIDField>,
+  ): EntityDatabaseAdapter<TFields, TIDField>;
 }

package/src/IEntityGenericCacher.ts

@@ -1,10 +1,14 @@
+import { IEntityLoadKey, IEntityLoadValue } from './internal/EntityLoadInterfaces';
 import { CacheLoadResult } from './internal/ReadThroughEntityCache';
 
 /**
  * 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> {
+export default interface IEntityGenericCacher<
+  TFields extends Record<string, any>,
+  TIDField extends keyof TFields,
+> {
   /**
    * Load many keys from the cache. Return info in a format that is useful for read-through caching and
    * negative caching.
@@ -36,10 +40,34 @@ export default interface IEntityGenericCacher<TFields> {
   invalidateManyAsync(keys: readonly string[]): Promise<void>;
 
   /**
-   * Create a cache key for a field and value of a object being cached or invalidated.
+   * Create a cache key for a load key and load value of an object being cached (or negatively cached).
    *
-   * @param fieldName - name of the object field for this cache key
-   * @param fieldValue - value of the obejct field for this cache key
+   * @param key - load key of the cache key
+   * @param value - load value of the cache key
    */
-  makeCacheKey<N extends keyof TFields>(fieldName: N, fieldValue: NonNullable<TFields[N]>): string;
+  makeCacheKeyForStorage<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(
+    key: TLoadKey,
+    value: TLoadValue,
+  ): string;
+
+  /**
+   * Create a cache key for a load key and load values of an object being invalidated. This is separate
+   * from makeCacheKeyForStorage because invalidation can optionally be configured to invalidate a larger set of keys than
+   * the one for just the current cache version, which can be useful for things like push safety.
+   *
+   * @param key - load key of the cache key
+   * @param values - load values of the cache key
+   */
+  makeCacheKeysForInvalidation<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(
+    key: TLoadKey,
+    value: TLoadValue,
+  ): readonly string[];
 }

package/src/ReadonlyEntity.ts

@@ -21,13 +21,13 @@ import ViewerContext from './ViewerContext';
  * - Entities representing immutable tables.
  */
 export default abstract class ReadonlyEntity<
-  TFields extends object,
-  TID extends NonNullable<TFields[TSelectedFields]>,
+  TFields extends Record<string, any>,
+  TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
   TViewerContext extends ViewerContext,
   TSelectedFields extends keyof TFields = keyof TFields,
 > {
   private readonly viewerContext: TViewerContext;
-  private readonly id: TID;
+  private readonly id: TFields[TIDField];
   private readonly databaseFields: Readonly<TFields>;
   private readonly selectedFields: Readonly<Pick<TFields, TSelectedFields>>;
 
@@ -52,7 +52,7 @@ export default abstract class ReadonlyEntity<
     selectedFields,
   }: {
     viewerContext: TViewerContext;
-    id: TID;
+    id: TFields[TIDField];
     databaseFields: Readonly<TFields>;
     selectedFields: Readonly<Pick<TFields, TSelectedFields>>;
   }) {
@@ -82,7 +82,7 @@ export default abstract class ReadonlyEntity<
   /**
    * @returns the ID of this entity
    */
-  getID(): TID {
+  getID(): TFields[TIDField] {
     return this.id;
   }
 
@@ -91,8 +91,8 @@ export default abstract class ReadonlyEntity<
    */
   associationLoader(
     queryContext?: EntityQueryContext,
-  ): EnforcingEntityAssociationLoader<TFields, TID, TViewerContext, this, TSelectedFields> {
-    return new EntityAssociationLoader<TFields, TID, TViewerContext, this, TSelectedFields>(
+  ): EnforcingEntityAssociationLoader<TFields, TIDField, TViewerContext, this, TSelectedFields> {
+    return new EntityAssociationLoader<TFields, TIDField, TViewerContext, this, TSelectedFields>(
       this,
       queryContext,
     ).enforcing();
@@ -105,12 +105,12 @@ export default abstract class ReadonlyEntity<
     queryContext?: EntityQueryContext,
   ): AuthorizationResultBasedEntityAssociationLoader<
     TFields,
-    TID,
+    TIDField,
     TViewerContext,
     this,
     TSelectedFields
   > {
-    return new EntityAssociationLoader<TFields, TID, TViewerContext, this, TSelectedFields>(
+    return new EntityAssociationLoader<TFields, TIDField, TViewerContext, this, TSelectedFields>(
       this,
       queryContext,
     ).withAuthorizationResults();
@@ -148,13 +148,13 @@ export default abstract class ReadonlyEntity<
    */
   static loader<
     TMFields extends object,
-    TMID extends NonNullable<TMFields[TMSelectedFields]>,
+    TMIDField extends keyof NonNullable<Pick<TMFields, TMSelectedFields>>,
     TMViewerContext extends ViewerContext,
     TMViewerContext2 extends TMViewerContext,
-    TMEntity extends ReadonlyEntity<TMFields, TMID, TMViewerContext, TMSelectedFields>,
+    TMEntity extends ReadonlyEntity<TMFields, TMIDField, TMViewerContext, TMSelectedFields>,
     TMPrivacyPolicy extends EntityPrivacyPolicy<
       TMFields,
-      TMID,
+      TMIDField,
       TMViewerContext,
       TMEntity,
       TMSelectedFields
@@ -163,7 +163,7 @@ export default abstract class ReadonlyEntity<
   >(
     this: IEntityClass<
       TMFields,
-      TMID,
+      TMIDField,
       TMViewerContext,
       TMEntity,
       TMPrivacyPolicy,
@@ -176,7 +176,7 @@ export default abstract class ReadonlyEntity<
       .getQueryContext(),
   ): EnforcingEntityLoader<
     TMFields,
-    TMID,
+    TMIDField,
     TMViewerContext,
     TMEntity,
     TMPrivacyPolicy,
@@ -192,13 +192,13 @@ export default abstract class ReadonlyEntity<
    */
   static loaderWithAuthorizationResults<
     TMFields extends object,
-    TMID extends NonNullable<TMFields[TMSelectedFields]>,
+    TMIDField extends keyof NonNullable<Pick<TMFields, TMSelectedFields>>,
     TMViewerContext extends ViewerContext,
     TMViewerContext2 extends TMViewerContext,
-    TMEntity extends ReadonlyEntity<TMFields, TMID, TMViewerContext, TMSelectedFields>,
+    TMEntity extends ReadonlyEntity<TMFields, TMIDField, TMViewerContext, TMSelectedFields>,
     TMPrivacyPolicy extends EntityPrivacyPolicy<
       TMFields,
-      TMID,
+      TMIDField,
       TMViewerContext,
       TMEntity,
       TMSelectedFields
@@ -207,7 +207,7 @@ export default abstract class ReadonlyEntity<
   >(
     this: IEntityClass<
       TMFields,
-      TMID,
+      TMIDField,
       TMViewerContext,
       TMEntity,
       TMPrivacyPolicy,
@@ -220,7 +220,7 @@ export default abstract class ReadonlyEntity<
       .getQueryContext(),
   ): AuthorizationResultBasedEntityLoader<
     TMFields,
-    TMID,
+    TMIDField,
     TMViewerContext,
     TMEntity,
     TMPrivacyPolicy,
@@ -236,13 +236,13 @@ export default abstract class ReadonlyEntity<
    */
   static loaderUtils<
     TMFields extends object,
-    TMID extends NonNullable<TMFields[TMSelectedFields]>,
+    TMIDField extends keyof NonNullable<Pick<TMFields, TMSelectedFields>>,
     TMViewerContext extends ViewerContext,
     TMViewerContext2 extends TMViewerContext,
-    TMEntity extends ReadonlyEntity<TMFields, TMID, TMViewerContext, TMSelectedFields>,
+    TMEntity extends ReadonlyEntity<TMFields, TMIDField, TMViewerContext, TMSelectedFields>,
     TMPrivacyPolicy extends EntityPrivacyPolicy<
       TMFields,
-      TMID,
+      TMIDField,
       TMViewerContext,
       TMEntity,
       TMSelectedFields
@@ -251,7 +251,7 @@ export default abstract class ReadonlyEntity<
   >(
     this: IEntityClass<
       TMFields,
-      TMID,
+      TMIDField,
       TMViewerContext,
       TMEntity,
       TMPrivacyPolicy,
@@ -264,7 +264,7 @@ export default abstract class ReadonlyEntity<
       .getQueryContext(),
   ): EntityLoaderUtils<
     TMFields,
-    TMID,
+    TMIDField,
     TMViewerContext,
     TMEntity,
     TMPrivacyPolicy,

package/src/ViewerContext.ts

@@ -32,12 +32,12 @@ export default class ViewerContext {
 
   getViewerScopedEntityCompanionForClass<
     TMFields extends object,
-    TMID extends NonNullable<TMFields[TMSelectedFields]>,
+    TMIDField extends keyof NonNullable<Pick<TMFields, TMSelectedFields>>,
     TMViewerContext extends ViewerContext,
-    TMEntity extends ReadonlyEntity<TMFields, TMID, TMViewerContext, TMSelectedFields>,
+    TMEntity extends ReadonlyEntity<TMFields, TMIDField, TMViewerContext, TMSelectedFields>,
     TMPrivacyPolicy extends EntityPrivacyPolicy<
       TMFields,
-      TMID,
+      TMIDField,
       TMViewerContext,
       TMEntity,
       TMSelectedFields
@@ -46,7 +46,7 @@ export default class ViewerContext {
   >(
     entityClass: IEntityClass<
       TMFields,
-      TMID,
+      TMIDField,
       TMViewerContext,
       TMEntity,
       TMPrivacyPolicy,
@@ -54,7 +54,7 @@ export default class ViewerContext {
     >,
   ): ViewerScopedEntityCompanion<
     TMFields,
-    TMID,
+    TMIDField,
     TMViewerContext,
     TMEntity,
     TMPrivacyPolicy,

package/src/ViewerScopedEntityCompanion.ts

@@ -12,13 +12,13 @@ import IEntityMetricsAdapter from './metrics/IEntityMetricsAdapter';
  * from the viewer-scoped entity companion provider.
  */
 export default class ViewerScopedEntityCompanion<
-  TFields extends object,
-  TID extends NonNullable<TFields[TSelectedFields]>,
+  TFields extends Record<string, any>,
+  TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
   TViewerContext extends ViewerContext,
-  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
+  TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>,
   TPrivacyPolicy extends EntityPrivacyPolicy<
     TFields,
-    TID,
+    TIDField,
     TViewerContext,
     TEntity,
     TSelectedFields
@@ -28,7 +28,7 @@ export default class ViewerScopedEntityCompanion<
   constructor(
     public readonly entityCompanion: EntityCompanion<
       TFields,
-      TID,
+      TIDField,
       TViewerContext,
       TEntity,
       TPrivacyPolicy,
@@ -42,7 +42,7 @@ export default class ViewerScopedEntityCompanion<
    */
   getLoaderFactory(): ViewerScopedEntityLoaderFactory<
     TFields,
-    TID,
+    TIDField,
     TViewerContext,
     TEntity,
     TPrivacyPolicy,
@@ -59,7 +59,7 @@ export default class ViewerScopedEntityCompanion<
    */
   getMutatorFactory(): ViewerScopedEntityMutatorFactory<
     TFields,
-    TID,
+    TIDField,
     TViewerContext,
     TEntity,
     TPrivacyPolicy,

package/src/ViewerScopedEntityCompanionProvider.ts

@@ -21,13 +21,13 @@ export default class ViewerScopedEntityCompanionProvider {
    * @param entityClass - entity class to load
    */
   getViewerScopedCompanionForEntity<
-    TFields extends object,
-    TID extends NonNullable<TFields[TSelectedFields]>,
+    TFields extends Record<string, any>,
+    TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
     TViewerContext extends ViewerContext,
-    TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
+    TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>,
     TPrivacyPolicy extends EntityPrivacyPolicy<
       TFields,
-      TID,
+      TIDField,
       TViewerContext,
       TEntity,
       TSelectedFields
@@ -36,7 +36,7 @@ export default class ViewerScopedEntityCompanionProvider {
   >(
     entityClass: IEntityClass<
       TFields,
-      TID,
+      TIDField,
       TViewerContext,
       TEntity,
       TPrivacyPolicy,
@@ -44,7 +44,7 @@ export default class ViewerScopedEntityCompanionProvider {
     >,
   ): ViewerScopedEntityCompanion<
     TFields,
-    TID,
+    TIDField,
     TViewerContext,
     TEntity,
     TPrivacyPolicy,

package/src/ViewerScopedEntityLoaderFactory.ts

@@ -9,13 +9,13 @@ import ViewerContext from './ViewerContext';
  * Provides a cleaner API for loading entities by passing through the ViewerContext.
  */
 export default class ViewerScopedEntityLoaderFactory<
-  TFields extends object,
-  TID extends NonNullable<TFields[TSelectedFields]>,
+  TFields extends Record<string, any>,
+  TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
   TViewerContext extends ViewerContext,
-  TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
+  TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>,
   TPrivacyPolicy extends EntityPrivacyPolicy<
     TFields,
-    TID,
+    TIDField,
     TViewerContext,
     TEntity,
     TSelectedFields
@@ -25,7 +25,7 @@ export default class ViewerScopedEntityLoaderFactory<
   constructor(
     private readonly entityLoaderFactory: EntityLoaderFactory<
       TFields,
-      TID,
+      TIDField,
       TViewerContext,
       TEntity,
       TPrivacyPolicy,
@@ -38,14 +38,14 @@ export default class ViewerScopedEntityLoaderFactory<
     queryContext: EntityQueryContext,
     privacyPolicyEvaluationContext: EntityPrivacyPolicyEvaluationContext<
       TFields,
-      TID,
+      TIDField,
       TViewerContext,
       TEntity,
       TSelectedFields
     >,
   ): AuthorizationResultBasedEntityLoader<
     TFields,
-    TID,
+    TIDField,
     TViewerContext,
     TEntity,
     TPrivacyPolicy,