@expo/entity 0.55.0 → 0.57.0

package/src/{EntityLoaderUtils.ts → EntityInvalidationUtils.ts}

@@ -1,24 +1,19 @@
-import { Result, asyncResult, result } from '@expo/results';
-import nullthrows from 'nullthrows';
-
 import { IEntityClass } from './Entity';
 import { EntityConfiguration } from './EntityConfiguration';
-import { EntityPrivacyPolicy, EntityPrivacyPolicyEvaluationContext } from './EntityPrivacyPolicy';
-import { EntityQueryContext, EntityTransactionalQueryContext } from './EntityQueryContext';
+import { EntityPrivacyPolicy } from './EntityPrivacyPolicy';
+import { EntityTransactionalQueryContext } from './EntityQueryContext';
 import { ReadonlyEntity } from './ReadonlyEntity';
 import { ViewerContext } from './ViewerContext';
-import { pick } from './entityUtils';
 import { EntityDataManager } from './internal/EntityDataManager';
 import { LoadPair } from './internal/EntityLoadInterfaces';
 import { SingleFieldHolder, SingleFieldValueHolder } from './internal/SingleFieldHolder';
 import { IEntityMetricsAdapter } from './metrics/IEntityMetricsAdapter';
-import { mapMapAsync } from './utils/collections/maps';
 
 /**
- * Entity loader utilities for things like invalidation, entity construction, and authorization.
+ * Entity invalidation utilities.
  * Methods are exposed publicly since in rare cases they may need to be called manually.
  */
-export class EntityLoaderUtils<
+export class EntityInvalidationUtils<
   TFields extends Record<string, any>,
   TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
   TViewerContext extends ViewerContext,
@@ -33,17 +28,8 @@ export class EntityLoaderUtils<
   TSelectedFields extends keyof TFields,
 > {
   constructor(
-    private readonly viewerContext: TViewerContext,
-    private readonly queryContext: EntityQueryContext,
-    private readonly privacyPolicyEvaluationContext: EntityPrivacyPolicyEvaluationContext<
-      TFields,
-      TIDField,
-      TViewerContext,
-      TEntity,
-      TSelectedFields
-    >,
     private readonly entityConfiguration: EntityConfiguration<TFields, TIDField>,
-    private readonly entityClass: IEntityClass<
+    _entityClass: IEntityClass<
       TFields,
       TIDField,
       TViewerContext,
@@ -51,8 +37,6 @@ export class EntityLoaderUtils<
       TPrivacyPolicy,
       TSelectedFields
     >,
-    private readonly entitySelectedFields: TSelectedFields[] | undefined,
-    private readonly privacyPolicy: TPrivacyPolicy,
     private readonly dataManager: EntityDataManager<TFields, TIDField>,
     protected readonly metricsAdapter: IEntityMetricsAdapter,
   ) {}
@@ -128,79 +112,4 @@ export class EntityLoaderUtils<
   ): void {
     this.invalidateFieldsForTransaction(queryContext, entity.getAllDatabaseFields());
   }
-
-  /**
-   * Construct an entity from a fields object (applying field selection if applicable),
-   * checking that the ID field is specified.
-   *
-   * @param fieldsObject - fields object
-   */
-  public constructEntity(fieldsObject: TFields): TEntity {
-    const idField = this.entityConfiguration.idField;
-    const id = nullthrows(fieldsObject[idField], 'must provide ID to create an entity');
-    const entitySelectedFields =
-      this.entitySelectedFields ?? Array.from(this.entityConfiguration.schema.keys());
-    const selectedFields = pick(fieldsObject, entitySelectedFields);
-    return new this.entityClass({
-      viewerContext: this.viewerContext,
-      id: id as TFields[TIDField],
-      databaseFields: fieldsObject,
-      selectedFields,
-    });
-  }
-
-  /**
-   * Construct and authorize entities from fields map, returning error results for entities that fail
-   * to construct or fail to authorize.
-   *
-   * @param map - map from an arbitrary key type to an array of entity field objects
-   */
-  public async constructAndAuthorizeEntitiesAsync<K>(
-    map: ReadonlyMap<K, readonly Readonly<TFields>[]>,
-  ): Promise<ReadonlyMap<K, readonly Result<TEntity>[]>> {
-    return await mapMapAsync(map, async (fieldObjects) => {
-      return await this.constructAndAuthorizeEntitiesArrayAsync(fieldObjects);
-    });
-  }
-
-  /**
-   * Construct and authorize entities from field objects array, returning error results for entities that fail
-   * to construct or fail to authorize.
-   *
-   * @param fieldObjects - array of field objects
-   */
-  public async constructAndAuthorizeEntitiesArrayAsync(
-    fieldObjects: readonly Readonly<TFields>[],
-  ): Promise<readonly Result<TEntity>[]> {
-    const uncheckedEntityResults = this.tryConstructEntities(fieldObjects);
-    return await Promise.all(
-      uncheckedEntityResults.map(async (uncheckedEntityResult) => {
-        if (!uncheckedEntityResult.ok) {
-          return uncheckedEntityResult;
-        }
-        return await asyncResult(
-          this.privacyPolicy.authorizeReadAsync(
-            this.viewerContext,
-            this.queryContext,
-            this.privacyPolicyEvaluationContext,
-            uncheckedEntityResult.value,
-            this.metricsAdapter,
-          ),
-        );
-      }),
-    );
-  }
-
-  private tryConstructEntities(fieldsObjects: readonly TFields[]): readonly Result<TEntity>[] {
-    return fieldsObjects.map((fieldsObject) => {
-      try {
-        return result(this.constructEntity(fieldsObject));
-      } catch (e) {
-        if (!(e instanceof Error)) {
-          throw e;
-        }
-        return result(e);
-      }
-    });
-  }
 }

package/src/EntityLoader.ts

@@ -1,7 +1,6 @@
 import { AuthorizationResultBasedEntityLoader } from './AuthorizationResultBasedEntityLoader';
 import { EnforcingEntityLoader } from './EnforcingEntityLoader';
 import { IEntityClass } from './Entity';
-import { EntityLoaderUtils } from './EntityLoaderUtils';
 import { EntityPrivacyPolicy } from './EntityPrivacyPolicy';
 import { EntityQueryContext } from './EntityQueryContext';
 import { ReadonlyEntity } from './ReadonlyEntity';
@@ -73,19 +72,4 @@ export class EntityLoader<
       .getLoaderFactory()
       .forLoad(this.queryContext, { previousValue: null, cascadingDeleteCause: null });
   }
-
-  /**
-   * Entity loader utilities for things like cache invalidation, entity construction, and authorization.
-   * Calling into these should only be necessary in rare cases.
-   */
-  public utils(): EntityLoaderUtils<
-    TFields,
-    TIDField,
-    TViewerContext,
-    TEntity,
-    TPrivacyPolicy,
-    TSelectedFields
-  > {
-    return this.withAuthorizationResults().utils;
-  }
 }

package/src/EntityLoaderFactory.ts

@@ -1,6 +1,7 @@
 import { AuthorizationResultBasedEntityLoader } from './AuthorizationResultBasedEntityLoader';
 import { EntityCompanion } from './EntityCompanion';
-import { EntityLoaderUtils } from './EntityLoaderUtils';
+import { EntityConstructionUtils } from './EntityConstructionUtils';
+import { EntityInvalidationUtils } from './EntityInvalidationUtils';
 import { EntityPrivacyPolicy, EntityPrivacyPolicyEvaluationContext } from './EntityPrivacyPolicy';
 import { EntityQueryContext } from './EntityQueryContext';
 import { ReadonlyEntity } from './ReadonlyEntity';
@@ -38,6 +39,52 @@ export class EntityLoaderFactory<
     protected readonly metricsAdapter: IEntityMetricsAdapter,
   ) {}
 
+  invalidationUtils(): EntityInvalidationUtils<
+    TFields,
+    TIDField,
+    TViewerContext,
+    TEntity,
+    TPrivacyPolicy,
+    TSelectedFields
+  > {
+    return new EntityInvalidationUtils(
+      this.entityCompanion.entityCompanionDefinition.entityConfiguration,
+      this.entityCompanion.entityCompanionDefinition.entityClass,
+      this.dataManager,
+      this.metricsAdapter,
+    );
+  }
+
+  constructionUtils(
+    viewerContext: TViewerContext,
+    queryContext: EntityQueryContext,
+    privacyPolicyEvaluationContext: EntityPrivacyPolicyEvaluationContext<
+      TFields,
+      TIDField,
+      TViewerContext,
+      TEntity,
+      TSelectedFields
+    >,
+  ): EntityConstructionUtils<
+    TFields,
+    TIDField,
+    TViewerContext,
+    TEntity,
+    TPrivacyPolicy,
+    TSelectedFields
+  > {
+    return new EntityConstructionUtils(
+      viewerContext,
+      queryContext,
+      privacyPolicyEvaluationContext,
+      this.entityCompanion.entityCompanionDefinition.entityConfiguration,
+      this.entityCompanion.entityCompanionDefinition.entityClass,
+      this.entityCompanion.entityCompanionDefinition.entitySelectedFields,
+      this.entityCompanion.privacyPolicy,
+      this.metricsAdapter,
+    );
+  }
+
   /**
    * Vend loader for loading an entity in a given query context.
    * @param viewerContext - viewer context of loading user
@@ -61,16 +108,10 @@ export class EntityLoaderFactory<
     TPrivacyPolicy,
     TSelectedFields
   > {
-    const utils = new EntityLoaderUtils(
+    const constructionUtils = this.constructionUtils(
       viewerContext,
       queryContext,
       privacyPolicyEvaluationContext,
-      this.entityCompanion.entityCompanionDefinition.entityConfiguration,
-      this.entityCompanion.entityCompanionDefinition.entityClass,
-      this.entityCompanion.entityCompanionDefinition.entitySelectedFields,
-      this.entityCompanion.privacyPolicy,
-      this.dataManager,
-      this.metricsAdapter,
     );
 
     return new AuthorizationResultBasedEntityLoader(
@@ -78,8 +119,7 @@ export class EntityLoaderFactory<
       this.entityCompanion.entityCompanionDefinition.entityConfiguration,
       this.entityCompanion.entityCompanionDefinition.entityClass,
       this.dataManager,
-      this.metricsAdapter,
-      utils,
+      constructionUtils,
     );
   }
 }

package/src/EntityPrivacyPolicy.ts

@@ -32,6 +32,25 @@ export type EntityPrivacyPolicyEvaluationContext<
   cascadingDeleteCause: EntityCascadingDeletionInfo | null;
 };
 
+export type EntityPrivacyPolicyRuleEvaluationContext<
+  TFields extends Record<string, any>,
+  TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
+  TViewerContext extends ViewerContext,
+  TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>,
+  TSelectedFields extends keyof TFields = keyof TFields,
+> = EntityPrivacyPolicyEvaluationContext<
+  TFields,
+  TIDField,
+  TViewerContext,
+  TEntity,
+  TSelectedFields
+> & {
+  /**
+   * The CRUD action for which the privacy policy rule is being evaluated.
+   */
+  action: EntityAuthorizationAction;
+};
+
 /**
  * Evaluation mode for a EntityPrivacyPolicy. Useful when transitioning to
  * using Entity for privacy.
@@ -123,6 +142,9 @@ export abstract class EntityPrivacyPolicy<
   TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>,
   TSelectedFields extends keyof TFields = keyof TFields,
 > {
+  /**
+   * List of rules to evaluate for create authorization.
+   */
   protected readonly createRules: readonly PrivacyPolicyRule<
     TFields,
     TIDField,
@@ -130,6 +152,10 @@ export abstract class EntityPrivacyPolicy<
     TEntity,
     TSelectedFields
   >[] = [];
+
+  /**
+   * List of rules to evaluate for read authorization.
+   */
   protected readonly readRules: readonly PrivacyPolicyRule<
     TFields,
     TIDField,
@@ -137,6 +163,10 @@ export abstract class EntityPrivacyPolicy<
     TEntity,
     TSelectedFields
   >[] = [];
+
+  /**
+   * List of rules to evaluate for update authorization.
+   */
   protected readonly updateRules: readonly PrivacyPolicyRule<
     TFields,
     TIDField,
@@ -144,6 +174,10 @@ export abstract class EntityPrivacyPolicy<
     TEntity,
     TSelectedFields
   >[] = [];
+
+  /**
+   * List of rules to evaluate for delete authorization.
+   */
   protected readonly deleteRules: readonly PrivacyPolicyRule<
     TFields,
     TIDField,
@@ -156,6 +190,9 @@ export abstract class EntityPrivacyPolicy<
    * Get the privacy policy evaluation mode and deny handler for this policy.
    * Defaults to normal enforcing policy.
    *
+   * DRY_RUN mode is useful for testing and logging the effects of a policy without actually enforcing it, such as when
+   * first rolling out a new policy. Entities that fail the policy will be allowed so caution should be take when using.
+   *
    * @remarks
    *
    * Override to enable dry run evaluation of the policy.
@@ -204,7 +241,9 @@ export abstract class EntityPrivacyPolicy<
    * Authorize an entity against read policy.
    * @param viewerContext - viewer context of user reading the entity
    * @param queryContext - query context in which to perform the read authorization
+   * @param evaluationContext - context about the reason for this privacy policy evaluation
    * @param entity - entity to authorize
+   * @param metricsAdapter - adapter for logging metrics about this authorization
    * @returns entity if authorized
    * @throws EntityNotAuthorizedError when not authorized
    */
@@ -236,7 +275,9 @@ export abstract class EntityPrivacyPolicy<
    * Authorize an entity against update policy.
    * @param viewerContext - viewer context of user updating the entity
    * @param queryContext - query context in which to perform the update authorization
+   * @param evaluationContext - context about the reason for this privacy policy evaluation
    * @param entity - entity to authorize
+   * @param metricsAdapter - adapter for logging metrics about this authorization
    * @returns entity if authorized
    * @throws EntityNotAuthorizedError when not authorized
    */
@@ -268,7 +309,9 @@ export abstract class EntityPrivacyPolicy<
    * Authorize an entity against deletion policy.
    * @param viewerContext - viewer context of user deleting the entity
    * @param queryContext - query context in which to perform the delete authorization
+   * @param evaluationContext - context about the reason for this privacy policy evaluation
    * @param entity - entity to authorize
+   * @param metricsAdapter - adapter for logging metrics about this authorization
    * @returns entity if authorized
    * @throws EntityNotAuthorizedError when not authorized
    */
@@ -436,7 +479,7 @@ export abstract class EntityPrivacyPolicy<
       const ruleEvaluationResult = await rule.evaluateAsync(
         viewerContext,
         queryContext,
-        evaluationContext,
+        { ...evaluationContext, action },
         entity,
       );
       switch (ruleEvaluationResult) {

package/src/EntitySecondaryCacheLoader.ts

@@ -1,7 +1,9 @@
 import { Result } from '@expo/results';
 
-import { AuthorizationResultBasedEntityLoader } from './AuthorizationResultBasedEntityLoader';
+import { IEntityClass } from './Entity';
+import { EntityConstructionUtils } from './EntityConstructionUtils';
 import { EntityPrivacyPolicy } from './EntityPrivacyPolicy';
+import { EntityQueryContext } from './EntityQueryContext';
 import { ReadonlyEntity } from './ReadonlyEntity';
 import { ViewerContext } from './ViewerContext';
 import { mapMap } from './utils/collections/maps';
@@ -60,7 +62,7 @@ export abstract class EntitySecondaryCacheLoader<
 > {
   constructor(
     private readonly secondaryEntityCache: ISecondaryEntityCache<TFields, TLoadParams>,
-    protected readonly entityLoader: AuthorizationResultBasedEntityLoader<
+    private readonly constructionUtils: EntityConstructionUtils<
       TFields,
       TIDField,
       TViewerContext,
@@ -84,7 +86,7 @@ export abstract class EntitySecondaryCacheLoader<
     );
 
     // convert value to and from array to reuse complex code
-    const entitiesMap = await this.entityLoader.utils.constructAndAuthorizeEntitiesAsync(
+    const entitiesMap = await this.constructionUtils.constructAndAuthorizeEntitiesAsync(
       mapMap(loadParamsToFieldObjects, (fieldObject) => (fieldObject ? [fieldObject] : [])),
     );
     return mapMap(entitiesMap, (fieldObjects) => fieldObjects[0] ?? null);
@@ -109,4 +111,53 @@ export abstract class EntitySecondaryCacheLoader<
   protected abstract fetchObjectsFromDatabaseAsync(
     loadParamsArray: readonly Readonly<TLoadParams>[],
   ): Promise<ReadonlyMap<Readonly<Readonly<TLoadParams>>, Readonly<TFields> | null>>;
+
+  /**
+   * Helper to get construction utils for instantiating a EntitySecondaryCacheLoader.
+   *
+   * @param entityClass - the entity class for which to get construction utils for
+   * @param viewerContext - the viewer context to use for construction utils
+   * @param queryContext - query context to use for construction utils
+   * @returns construction utils for the given entity class and viewer context
+   */
+  public static getConstructionUtilsForEntityClass<
+    TFields extends Record<string, any>,
+    TIDField extends keyof NonNullable<Pick<TFields, TSelectedFields>>,
+    TViewerContext extends ViewerContext,
+    TEntity extends ReadonlyEntity<TFields, TIDField, TViewerContext, TSelectedFields>,
+    TPrivacyPolicy extends EntityPrivacyPolicy<
+      TFields,
+      TIDField,
+      TViewerContext,
+      TEntity,
+      TSelectedFields
+    >,
+    TSelectedFields extends keyof TFields = keyof TFields,
+  >(
+    entityClass: IEntityClass<
+      TFields,
+      TIDField,
+      TViewerContext,
+      TEntity,
+      TPrivacyPolicy,
+      TSelectedFields
+    >,
+    viewerContext: TViewerContext,
+    queryContext: EntityQueryContext = viewerContext
+      .getViewerScopedEntityCompanionForClass(entityClass)
+      .getQueryContextProvider()
+      .getQueryContext(),
+  ): EntityConstructionUtils<
+    TFields,
+    TIDField,
+    TViewerContext,
+    TEntity,
+    TPrivacyPolicy,
+    TSelectedFields
+  > {
+    return viewerContext
+      .getViewerScopedEntityCompanionForClass(entityClass)
+      .getLoaderFactory()
+      .constructionUtils(queryContext, { previousValue: null, cascadingDeleteCause: null });
+  }
 }

package/src/ReadonlyEntity.ts

@@ -6,8 +6,8 @@ import { EnforcingEntityAssociationLoader } from './EnforcingEntityAssociationLo
 import { EnforcingEntityLoader } from './EnforcingEntityLoader';
 import { IEntityClass } from './Entity';
 import { EntityAssociationLoader } from './EntityAssociationLoader';
+import { EntityInvalidationUtils } from './EntityInvalidationUtils';
 import { EntityLoader } from './EntityLoader';
-import { EntityLoaderUtils } from './EntityLoaderUtils';
 import { EntityPrivacyPolicy } from './EntityPrivacyPolicy';
 import { EntityQueryContext } from './EntityQueryContext';
 import { ViewerContext } from './ViewerContext';
@@ -230,11 +230,10 @@ export abstract class ReadonlyEntity<
   }
 
   /**
-   * Vend loader for loading an entity in a given query context.
-   * @param viewerContext - viewer context of loading user
-   * @param queryContext - query context in which to perform the load
+   * Utilities for entity invalidation.
+   * Call these manually to keep entity cache consistent when performing operations outside of the entity framework.
    */
-  static loaderUtils<
+  static invalidationUtils<
     TMFields extends object,
     TMIDField extends keyof NonNullable<Pick<TMFields, TMSelectedFields>>,
     TMViewerContext extends ViewerContext,
@@ -258,11 +257,7 @@ export abstract class ReadonlyEntity<
       TMSelectedFields
     >,
     viewerContext: TMViewerContext2,
-    queryContext: EntityQueryContext = viewerContext
-      .getViewerScopedEntityCompanionForClass(this)
-      .getQueryContextProvider()
-      .getQueryContext(),
-  ): EntityLoaderUtils<
+  ): EntityInvalidationUtils<
     TMFields,
     TMIDField,
     TMViewerContext,
@@ -270,6 +265,9 @@ export abstract class ReadonlyEntity<
     TMPrivacyPolicy,
     TMSelectedFields
   > {
-    return new EntityLoader(viewerContext, queryContext, this).utils();
+    return viewerContext
+      .getViewerScopedEntityCompanionForClass(this)
+      .getLoaderFactory()
+      .invalidationUtils();
   }
 }

package/src/ViewerContext.ts

@@ -64,30 +64,30 @@ export class ViewerContext {
   }
 
   /**
-   * Get the regular (non-transactional) query context for a database adaptor flavor.
-   * @param databaseAdaptorFlavor - database adaptor flavor
+   * Get the regular (non-transactional) query context for a database adapter flavor.
+   * @param databaseAdapterFlavor - database adapter flavor
    */
-  getQueryContextForDatabaseAdaptorFlavor(
-    databaseAdaptorFlavor: DatabaseAdapterFlavor,
+  getQueryContextForDatabaseAdapterFlavor(
+    databaseAdapterFlavor: DatabaseAdapterFlavor,
   ): EntityQueryContext {
     return this.entityCompanionProvider
-      .getQueryContextProviderForDatabaseAdaptorFlavor(databaseAdaptorFlavor)
+      .getQueryContextProviderForDatabaseAdapterFlavor(databaseAdapterFlavor)
       .getQueryContext();
   }
 
   /**
-   * Run a transaction of specified database adaptor flavor and execute the provided
+   * Run a transaction of specified database adapter flavor and execute the provided
    * transaction-scoped closure within the transaction.
-   * @param databaseAdaptorFlavor - databaseAdaptorFlavor
+   * @param databaseAdapterFlavor - databaseAdapterFlavor
    * @param transactionScope - async callback to execute within the transaction
    */
-  async runInTransactionForDatabaseAdaptorFlavorAsync<TResult>(
-    databaseAdaptorFlavor: DatabaseAdapterFlavor,
+  async runInTransactionForDatabaseAdapterFlavorAsync<TResult>(
+    databaseAdapterFlavor: DatabaseAdapterFlavor,
     transactionScope: (queryContext: EntityTransactionalQueryContext) => Promise<TResult>,
     transactionConfig?: TransactionConfig,
   ): Promise<TResult> {
     return await this.entityCompanionProvider
-      .getQueryContextProviderForDatabaseAdaptorFlavor(databaseAdaptorFlavor)
+      .getQueryContextProviderForDatabaseAdapterFlavor(databaseAdapterFlavor)
       .getQueryContext()
       .runInTransactionIfNotInTransactionAsync(transactionScope, transactionConfig);
   }

package/src/ViewerScopedEntityCompanion.ts

@@ -34,7 +34,7 @@ export class ViewerScopedEntityCompanion<
       TPrivacyPolicy,
       TSelectedFields
     >,
-    private readonly viewerContext: TViewerContext,
+    public readonly viewerContext: TViewerContext,
   ) {}
 
   /**

package/src/ViewerScopedEntityLoaderFactory.ts

@@ -1,4 +1,6 @@
 import { AuthorizationResultBasedEntityLoader } from './AuthorizationResultBasedEntityLoader';
+import { EntityConstructionUtils } from './EntityConstructionUtils';
+import { EntityInvalidationUtils } from './EntityInvalidationUtils';
 import { EntityLoaderFactory } from './EntityLoaderFactory';
 import { EntityPrivacyPolicy, EntityPrivacyPolicyEvaluationContext } from './EntityPrivacyPolicy';
 import { EntityQueryContext } from './EntityQueryContext';
@@ -34,6 +36,41 @@ export class ViewerScopedEntityLoaderFactory<
     private readonly viewerContext: TViewerContext,
   ) {}
 
+  invalidationUtils(): EntityInvalidationUtils<
+    TFields,
+    TIDField,
+    TViewerContext,
+    TEntity,
+    TPrivacyPolicy,
+    TSelectedFields
+  > {
+    return this.entityLoaderFactory.invalidationUtils();
+  }
+
+  constructionUtils(
+    queryContext: EntityQueryContext,
+    privacyPolicyEvaluationContext: EntityPrivacyPolicyEvaluationContext<
+      TFields,
+      TIDField,
+      TViewerContext,
+      TEntity,
+      TSelectedFields
+    >,
+  ): EntityConstructionUtils<
+    TFields,
+    TIDField,
+    TViewerContext,
+    TEntity,
+    TPrivacyPolicy,
+    TSelectedFields
+  > {
+    return this.entityLoaderFactory.constructionUtils(
+      this.viewerContext,
+      queryContext,
+      privacyPolicyEvaluationContext,
+    );
+  }
+
   forLoad(
     queryContext: EntityQueryContext,
     privacyPolicyEvaluationContext: EntityPrivacyPolicyEvaluationContext<

package/src/__tests__/AuthorizationResultBasedEntityLoader-constructor-test.ts

@@ -5,8 +5,8 @@ import { AuthorizationResultBasedEntityLoader } from '../AuthorizationResultBase
 import { Entity } from '../Entity';
 import { EntityCompanionDefinition } from '../EntityCompanionProvider';
 import { EntityConfiguration } from '../EntityConfiguration';
+import { EntityConstructionUtils } from '../EntityConstructionUtils';
 import { StringField } from '../EntityFields';
-import { EntityLoaderUtils } from '../EntityLoaderUtils';
 import { EntityPrivacyPolicy, EntityPrivacyPolicyEvaluationContext } from '../EntityPrivacyPolicy';
 import { ViewerContext } from '../ViewerContext';
 import { EntityDataManager } from '../internal/EntityDataManager';
@@ -164,7 +164,7 @@ describe(AuthorizationResultBasedEntityLoader, () => {
       metricsAdapter,
       TestEntity.name,
     );
-    const utils = new EntityLoaderUtils(
+    const constructionUtils = new EntityConstructionUtils(
       viewerContext,
       queryContext,
       privacyPolicyEvaluationContext,
@@ -172,7 +172,6 @@ describe(AuthorizationResultBasedEntityLoader, () => {
       TestEntity,
       /* entitySelectedFields */ undefined,
       privacyPolicy,
-      dataManager,
       metricsAdapter,
     );
     const entityLoader = new AuthorizationResultBasedEntityLoader(
@@ -180,8 +179,7 @@ describe(AuthorizationResultBasedEntityLoader, () => {
       testEntityConfiguration,
       TestEntity,
       dataManager,
-      metricsAdapter,
-      utils,
+      constructionUtils,
     );
 
     let capturedThrownThing1: any;