@expo/entity 0.41.0 → 0.43.0

package/src/AuthorizationResultBasedEntityMutator.ts

@@ -28,13 +28,13 @@ import IEntityMetricsAdapter, { EntityMetricsMutationType } from './metrics/IEnt
 import { mapMapAsync } from './utils/collections/maps';
 
 abstract class AuthorizationResultBasedBaseMutator<
-  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 Entity<TFields, TID, TViewerContext, TSelectedFields>,
+  TEntity extends Entity<TFields, TIDField, TViewerContext, TSelectedFields>,
   TPrivacyPolicy extends EntityPrivacyPolicy<
     TFields,
-    TID,
+    TIDField,
     TViewerContext,
     TEntity,
     TSelectedFields
@@ -45,10 +45,10 @@ abstract class AuthorizationResultBasedBaseMutator<
     protected readonly companionProvider: EntityCompanionProvider,
     protected readonly viewerContext: TViewerContext,
     protected readonly queryContext: EntityQueryContext,
-    protected readonly entityConfiguration: EntityConfiguration<TFields>,
+    protected readonly entityConfiguration: EntityConfiguration<TFields, TIDField>,
     protected readonly entityClass: IEntityClass<
       TFields,
-      TID,
+      TIDField,
       TViewerContext,
       TEntity,
       TPrivacyPolicy,
@@ -57,27 +57,27 @@ abstract class AuthorizationResultBasedBaseMutator<
     protected readonly privacyPolicy: TPrivacyPolicy,
     protected readonly mutationValidators: EntityMutationValidator<
       TFields,
-      TID,
+      TIDField,
       TViewerContext,
       TEntity,
       TSelectedFields
     >[],
     protected readonly mutationTriggers: EntityMutationTriggerConfiguration<
       TFields,
-      TID,
+      TIDField,
       TViewerContext,
       TEntity,
       TSelectedFields
     >,
     protected readonly entityLoaderFactory: EntityLoaderFactory<
       TFields,
-      TID,
+      TIDField,
       TViewerContext,
       TEntity,
       TPrivacyPolicy,
       TSelectedFields
     >,
-    protected readonly databaseAdapter: EntityDatabaseAdapter<TFields>,
+    protected readonly databaseAdapter: EntityDatabaseAdapter<TFields, TIDField>,
     protected readonly metricsAdapter: IEntityMetricsAdapter,
   ) {}
 
@@ -88,18 +88,32 @@ abstract class AuthorizationResultBasedBaseMutator<
       invariant(fieldDefinition, `must have field definition for field = ${fieldName}`);
       const isInputValid = fieldDefinition.validateInputValue(fieldValue);
       if (!isInputValid) {
-        throw new EntityInvalidFieldValueError(this.entityClass, fieldName, fieldValue);
+        throw new EntityInvalidFieldValueError<
+          TFields,
+          TIDField,
+          TViewerContext,
+          TEntity,
+          TPrivacyPolicy,
+          keyof TFields,
+          TSelectedFields
+        >(this.entityClass, fieldName, fieldValue);
       }
     }
   }
 
   protected async executeMutationValidatorsAsync(
-    validators: EntityMutationValidator<TFields, TID, TViewerContext, TEntity, TSelectedFields>[],
+    validators: EntityMutationValidator<
+      TFields,
+      TIDField,
+      TViewerContext,
+      TEntity,
+      TSelectedFields
+    >[],
     queryContext: EntityTransactionalQueryContext,
     entity: TEntity,
     mutationInfo: EntityValidatorMutationInfo<
       TFields,
-      TID,
+      TIDField,
       TViewerContext,
       TEntity,
       TSelectedFields
@@ -114,11 +128,17 @@ abstract class AuthorizationResultBasedBaseMutator<
 
   protected async executeMutationTriggersAsync(
     triggers:
-      | EntityMutationTrigger<TFields, TID, TViewerContext, TEntity, TSelectedFields>[]
+      | EntityMutationTrigger<TFields, TIDField, TViewerContext, TEntity, TSelectedFields>[]
       | undefined,
     queryContext: EntityTransactionalQueryContext,
     entity: TEntity,
-    mutationInfo: EntityTriggerMutationInfo<TFields, TID, TViewerContext, TEntity, TSelectedFields>,
+    mutationInfo: EntityTriggerMutationInfo<
+      TFields,
+      TIDField,
+      TViewerContext,
+      TEntity,
+      TSelectedFields
+    >,
   ): Promise<void> {
     if (!triggers) {
       return;
@@ -134,14 +154,20 @@ abstract class AuthorizationResultBasedBaseMutator<
     triggers:
       | EntityNonTransactionalMutationTrigger<
           TFields,
-          TID,
+          TIDField,
           TViewerContext,
           TEntity,
           TSelectedFields
         >[]
       | undefined,
     entity: TEntity,
-    mutationInfo: EntityTriggerMutationInfo<TFields, TID, TViewerContext, TEntity, TSelectedFields>,
+    mutationInfo: EntityTriggerMutationInfo<
+      TFields,
+      TIDField,
+      TViewerContext,
+      TEntity,
+      TSelectedFields
+    >,
   ): Promise<void> {
     if (!triggers) {
       return;
@@ -156,13 +182,13 @@ abstract class AuthorizationResultBasedBaseMutator<
  * Mutator for creating a new entity.
  */
 export class AuthorizationResultBasedCreateMutator<
-  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 Entity<TFields, TID, TViewerContext, TSelectedFields>,
+  TEntity extends Entity<TFields, TIDField, TViewerContext, TSelectedFields>,
   TPrivacyPolicy extends EntityPrivacyPolicy<
     TFields,
-    TID,
+    TIDField,
     TViewerContext,
     TEntity,
     TSelectedFields
@@ -170,7 +196,7 @@ export class AuthorizationResultBasedCreateMutator<
   TSelectedFields extends keyof TFields,
 > extends AuthorizationResultBasedBaseMutator<
   TFields,
-  TID,
+  TIDField,
   TViewerContext,
   TEntity,
   TPrivacyPolicy,
@@ -295,13 +321,13 @@ export class AuthorizationResultBasedCreateMutator<
  * Mutator for updating an existing entity.
  */
 export class AuthorizationResultBasedUpdateMutator<
-  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 Entity<TFields, TID, TViewerContext, TSelectedFields>,
+  TEntity extends Entity<TFields, TIDField, TViewerContext, TSelectedFields>,
   TPrivacyPolicy extends EntityPrivacyPolicy<
     TFields,
-    TID,
+    TIDField,
     TViewerContext,
     TEntity,
     TSelectedFields
@@ -309,7 +335,7 @@ export class AuthorizationResultBasedUpdateMutator<
   TSelectedFields extends keyof TFields,
 > extends AuthorizationResultBasedBaseMutator<
   TFields,
-  TID,
+  TIDField,
   TViewerContext,
   TEntity,
   TPrivacyPolicy,
@@ -323,10 +349,10 @@ export class AuthorizationResultBasedUpdateMutator<
     companionProvider: EntityCompanionProvider,
     viewerContext: TViewerContext,
     queryContext: EntityQueryContext,
-    entityConfiguration: EntityConfiguration<TFields>,
+    entityConfiguration: EntityConfiguration<TFields, TIDField>,
     entityClass: IEntityClass<
       TFields,
-      TID,
+      TIDField,
       TViewerContext,
       TEntity,
       TPrivacyPolicy,
@@ -335,27 +361,27 @@ export class AuthorizationResultBasedUpdateMutator<
     privacyPolicy: TPrivacyPolicy,
     mutationValidators: EntityMutationValidator<
       TFields,
-      TID,
+      TIDField,
       TViewerContext,
       TEntity,
       TSelectedFields
     >[],
     mutationTriggers: EntityMutationTriggerConfiguration<
       TFields,
-      TID,
+      TIDField,
       TViewerContext,
       TEntity,
       TSelectedFields
     >,
     entityLoaderFactory: EntityLoaderFactory<
       TFields,
-      TID,
+      TIDField,
       TViewerContext,
       TEntity,
       TPrivacyPolicy,
       TSelectedFields
     >,
-    databaseAdapter: EntityDatabaseAdapter<TFields>,
+    databaseAdapter: EntityDatabaseAdapter<TFields, TIDField>,
     metricsAdapter: IEntityMetricsAdapter,
     originalEntity: TEntity,
   ) {
@@ -529,13 +555,13 @@ export class AuthorizationResultBasedUpdateMutator<
  * Mutator for deleting an existing entity.
  */
 export class AuthorizationResultBasedDeleteMutator<
-  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 Entity<TFields, TID, TViewerContext, TSelectedFields>,
+  TEntity extends Entity<TFields, TIDField, TViewerContext, TSelectedFields>,
   TPrivacyPolicy extends EntityPrivacyPolicy<
     TFields,
-    TID,
+    TIDField,
     TViewerContext,
     TEntity,
     TSelectedFields
@@ -543,7 +569,7 @@ export class AuthorizationResultBasedDeleteMutator<
   TSelectedFields extends keyof TFields,
 > extends AuthorizationResultBasedBaseMutator<
   TFields,
-  TID,
+  TIDField,
   TViewerContext,
   TEntity,
   TPrivacyPolicy,
@@ -553,10 +579,10 @@ export class AuthorizationResultBasedDeleteMutator<
     companionProvider: EntityCompanionProvider,
     viewerContext: TViewerContext,
     queryContext: EntityQueryContext,
-    entityConfiguration: EntityConfiguration<TFields>,
+    entityConfiguration: EntityConfiguration<TFields, TIDField>,
     entityClass: IEntityClass<
       TFields,
-      TID,
+      TIDField,
       TViewerContext,
       TEntity,
       TPrivacyPolicy,
@@ -565,27 +591,27 @@ export class AuthorizationResultBasedDeleteMutator<
     privacyPolicy: TPrivacyPolicy,
     mutationValidators: EntityMutationValidator<
       TFields,
-      TID,
+      TIDField,
       TViewerContext,
       TEntity,
       TSelectedFields
     >[],
     mutationTriggers: EntityMutationTriggerConfiguration<
       TFields,
-      TID,
+      TIDField,
       TViewerContext,
       TEntity,
       TSelectedFields
     >,
     entityLoaderFactory: EntityLoaderFactory<
       TFields,
-      TID,
+      TIDField,
       TViewerContext,
       TEntity,
       TPrivacyPolicy,
       TSelectedFields
     >,
-    databaseAdapter: EntityDatabaseAdapter<TFields>,
+    databaseAdapter: EntityDatabaseAdapter<TFields, TIDField>,
     metricsAdapter: IEntityMetricsAdapter,
     private readonly entity: TEntity,
   ) {
@@ -743,7 +769,7 @@ export class AuthorizationResultBasedDeleteMutator<
     const companionDefinition = this.companionProvider.getCompanionForEntity(
       entity.constructor as IEntityClass<
         TFields,
-        TID,
+        TIDField,
         TViewerContext,
         TEntity,
         TPrivacyPolicy,

package/src/ComposedEntityCacheAdapter.ts

@@ -1,49 +1,55 @@
 import nullthrows from 'nullthrows';
 
 import IEntityCacheAdapter from './IEntityCacheAdapter';
+import { IEntityLoadKey, IEntityLoadValue } from './internal/EntityLoadInterfaces';
 import { CacheStatus, CacheLoadResult } from './internal/ReadThroughEntityCache';
 
 /**
  * A IEntityCacheAdapter that composes other IEntityCacheAdapter instances.
  */
-export default class ComposedEntityCacheAdapter<TFields> implements IEntityCacheAdapter<TFields> {
+export default class ComposedEntityCacheAdapter<
+  TFields extends Record<string, any>,
+  TIDField extends keyof TFields,
+> implements IEntityCacheAdapter<TFields, TIDField>
+{
   /**
    * @param cacheAdapters - list of cache adapters to compose in order of precedence.
    *                        Earlier cache adapters are read from first and written to (including invalidations) last.
    *                        Typically, caches closer to the application should be ordered before caches closer to the database.
    *                        A lower layer cache is closer to the database, while a higher layer cache is closer to the application.
    */
-  constructor(private readonly cacheAdapters: IEntityCacheAdapter<TFields>[]) {}
+  constructor(private readonly cacheAdapters: IEntityCacheAdapter<TFields, TIDField>[]) {}
 
-  public async loadManyAsync<N extends keyof TFields>(
-    fieldName: N,
-    fieldValues: readonly NonNullable<TFields[N]>[],
-  ): Promise<ReadonlyMap<NonNullable<TFields[N]>, CacheLoadResult<TFields>>> {
-    const retMap = new Map<NonNullable<TFields[N]>, CacheLoadResult<TFields>>();
-    const fulfilledFieldValuesByCacheIndex: NonNullable<TFields[N]>[][] = Array.from(
+  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 retMap = key.vendNewLoadValueMap<CacheLoadResult<TFields>>();
+    const fulfilledValuesByCacheIndex: TLoadValue[][] = Array.from(
       { length: this.cacheAdapters.length },
       () => [],
     );
 
-    let unfulfilledFieldValues = fieldValues;
+    let unfulfilledValues = values;
     for (let i = 0; i < this.cacheAdapters.length; i++) {
       const cacheAdapter = nullthrows(this.cacheAdapters[i]);
-      const cacheResultsFromAdapter = await cacheAdapter.loadManyAsync(
-        fieldName,
-        unfulfilledFieldValues,
-      );
+      const cacheResultsFromAdapter = await cacheAdapter.loadManyAsync(key, unfulfilledValues);
 
-      const newUnfulfilledFieldValues = [];
-      for (const [fieldValue, cacheResult] of cacheResultsFromAdapter) {
+      const newUnfulfilledValues = [];
+      for (const [value, cacheResult] of cacheResultsFromAdapter) {
         if (cacheResult.status === CacheStatus.MISS) {
-          newUnfulfilledFieldValues.push(fieldValue);
+          newUnfulfilledValues.push(value);
         } else {
-          retMap.set(fieldValue, cacheResult);
-          nullthrows(fulfilledFieldValuesByCacheIndex[i]).push(fieldValue);
+          retMap.set(value, cacheResult);
+          nullthrows(fulfilledValuesByCacheIndex[i]).push(value);
         }
       }
-      unfulfilledFieldValues = newUnfulfilledFieldValues;
-      if (unfulfilledFieldValues.length === 0) {
+      unfulfilledValues = newUnfulfilledValues;
+      if (unfulfilledValues.length === 0) {
         break;
       }
     }
@@ -52,69 +58,72 @@ export default class ComposedEntityCacheAdapter<TFields> implements IEntityCache
     // Write to lower layers first
     for (let i = this.cacheAdapters.length - 1; i >= 0; i--) {
       const cacheAdapter = nullthrows(this.cacheAdapters[i]);
-      const hitsToCache = new Map<NonNullable<TFields[N]>, Readonly<TFields>>();
-      const negativesToCache: NonNullable<TFields[N]>[] = [];
+      const hitsToCache = key.vendNewLoadValueMap<Readonly<TFields>>();
+      const negativesToCache: TLoadValue[] = [];
 
       // Loop over all lower layer caches to collect hits and misses
       for (let j = i + 1; j < this.cacheAdapters.length; j++) {
-        const fulfilledFieldValues = nullthrows(fulfilledFieldValuesByCacheIndex[j]);
-        fulfilledFieldValues.forEach((fieldValue) => {
-          const cacheResult = nullthrows(retMap.get(fieldValue));
+        const fulfilledValues = nullthrows(fulfilledValuesByCacheIndex[j]);
+        fulfilledValues.forEach((value) => {
+          const cacheResult = nullthrows(retMap.get(value));
           if (cacheResult.status === CacheStatus.HIT) {
-            hitsToCache.set(fieldValue, cacheResult.item);
+            hitsToCache.set(value, cacheResult.item);
           } else if (cacheResult.status === CacheStatus.NEGATIVE) {
-            negativesToCache.push(fieldValue);
+            negativesToCache.push(value);
           }
         });
       }
 
       const promises = [];
       if (hitsToCache.size > 0) {
-        promises.push(cacheAdapter.cacheManyAsync(fieldName, hitsToCache));
+        promises.push(cacheAdapter.cacheManyAsync(key, hitsToCache));
       }
       if (negativesToCache.length > 0) {
-        promises.push(cacheAdapter.cacheDBMissesAsync(fieldName, negativesToCache));
+        promises.push(cacheAdapter.cacheDBMissesAsync(key, negativesToCache));
       }
       await Promise.all(promises);
     }
 
-    for (const fieldValue of unfulfilledFieldValues) {
-      retMap.set(fieldValue, { status: CacheStatus.MISS });
+    for (const value of unfulfilledValues) {
+      retMap.set(value, { status: CacheStatus.MISS });
     }
 
     return retMap;
   }
 
-  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> {
     // write to lower layers first
     for (let i = this.cacheAdapters.length - 1; i >= 0; i--) {
       const cacheAdapter = nullthrows(this.cacheAdapters[i]);
-      await cacheAdapter.cacheManyAsync(fieldName, objectMap);
+      await cacheAdapter.cacheManyAsync(key, objectMap);
     }
   }
 
-  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> {
     // write to lower layers first
     for (let i = this.cacheAdapters.length - 1; i >= 0; i--) {
       const cacheAdapter = nullthrows(this.cacheAdapters[i]);
-      await cacheAdapter.cacheDBMissesAsync(fieldName, fieldValues);
+      await cacheAdapter.cacheDBMissesAsync(key, values);
     }
   }
 
-  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> {
     // delete from lower layers first
     for (let i = this.cacheAdapters.length - 1; i >= 0; i--) {
       const cacheAdapter = nullthrows(this.cacheAdapters[i]);
-      await cacheAdapter.invalidateManyAsync(fieldName, fieldValues);
+      await cacheAdapter.invalidateManyAsync(key, values);
     }
   }
 }

package/src/ComposedSecondaryEntityCache.ts

@@ -5,7 +5,7 @@ import { ISecondaryEntityCache } from './EntitySecondaryCacheLoader';
 /**
  * A ISecondaryEntityCache that composes other ISecondaryEntityCache instances.
  */
-export default class ComposedSecondaryEntityCache<TLoadParams, TFields>
+export default class ComposedSecondaryEntityCache<TLoadParams, TFields extends Record<string, any>>
   implements ISecondaryEntityCache<TFields, TLoadParams>
 {
   /**
@@ -30,7 +30,10 @@ export default class ComposedSecondaryEntityCache<TLoadParams, TFields>
     );
   }
 
-  private static async loadManyThroughRecursivelyAsync<TLoadParams, TFields>(
+  private static async loadManyThroughRecursivelyAsync<
+    TLoadParams,
+    TFields extends Record<string, any>,
+  >(
     secondaryEntityCaches: ISecondaryEntityCache<TFields, TLoadParams>[],
     loadParamsArray: readonly Readonly<TLoadParams>[],
     fetcher: (