@expo/entity 0.54.0 → 0.57.0

package/src/AuthorizationResultBasedEntityLoader.ts

@@ -8,24 +8,16 @@ import {
   EntityCompositeFieldValue,
   EntityConfiguration,
 } from './EntityConfiguration';
-import {
-  FieldEqualityCondition,
-  isSingleValueFieldEqualityCondition,
-  QuerySelectionModifiers,
-  QuerySelectionModifiersWithOrderByRaw,
-} from './EntityDatabaseAdapter';
-import { EntityLoaderUtils } from './EntityLoaderUtils';
+import { EntityConstructionUtils } from './EntityConstructionUtils';
 import { EntityPrivacyPolicy } from './EntityPrivacyPolicy';
 import { EntityQueryContext } from './EntityQueryContext';
 import { ReadonlyEntity } from './ReadonlyEntity';
 import { ViewerContext } from './ViewerContext';
-import { EntityInvalidFieldValueError } from './errors/EntityInvalidFieldValueError';
 import { EntityNotFoundError } from './errors/EntityNotFoundError';
 import { CompositeFieldHolder, CompositeFieldValueHolder } from './internal/CompositeFieldHolder';
 import { CompositeFieldValueMap } from './internal/CompositeFieldValueMap';
 import { EntityDataManager } from './internal/EntityDataManager';
 import { SingleFieldHolder, SingleFieldValueHolder } from './internal/SingleFieldHolder';
-import { IEntityMetricsAdapter } from './metrics/IEntityMetricsAdapter';
 import { mapKeys, mapMap } from './utils/collections/maps';
 import { areSetsEqual } from './utils/collections/sets';
 
@@ -61,8 +53,7 @@ export class AuthorizationResultBasedEntityLoader<
       TSelectedFields
     >,
     private readonly dataManager: EntityDataManager<TFields, TIDField>,
-    protected readonly metricsAdapter: IEntityMetricsAdapter,
-    public readonly utils: EntityLoaderUtils<
+    private readonly constructionUtils: EntityConstructionUtils<
       TFields,
       TIDField,
       TViewerContext,
@@ -96,7 +87,9 @@ export class AuthorizationResultBasedEntityLoader<
       loadValuesToFieldObjects,
       (loadValue) => loadValue.fieldValue,
     );
-    return await this.utils.constructAndAuthorizeEntitiesAsync(fieldValuesToFieldObjects);
+    return await this.constructionUtils.constructAndAuthorizeEntitiesAsync(
+      fieldValuesToFieldObjects,
+    );
   }
 
   /**
@@ -141,6 +134,41 @@ export class AuthorizationResultBasedEntityLoader<
     return entityResultsForFieldValue;
   }
 
+  /**
+   * Load one entity where fieldName equals fieldValue, or null if no entity exists matching the condition.
+   * Not cached or coalesced, and not guaranteed to be deterministic if multiple entities match the condition.
+   *
+   * Only used when evaluating EntityEdgeDeletionAuthorizationInferenceBehavior.ONE_IMPLIES_ALL.
+   *
+   * @param fieldName - entity field being queried
+   * @param fieldValue - fieldName field value being queried
+   * @returns entity result matching the query for fieldValue. Returns null if no entity matches the query.
+   * @throws EntityNotAuthorizedError when viewer is not authorized to view the returned entity
+   *
+   * @internal
+   */
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore -- this method is used in EntityPrivacyUtils, but is not intended to be part of the public API of this class, so it is marked as private.
+  private async loadOneByFieldEqualingAsync<N extends keyof Pick<TFields, TSelectedFields>>(
+    fieldName: N,
+    fieldValue: NonNullable<TFields[N]>,
+  ): Promise<Result<TEntity> | null> {
+    const { loadKey, loadValue } = this.validateFieldAndValueAndConvertToHolders(
+      fieldName,
+      fieldValue,
+    );
+    const result = await this.dataManager.loadOneEqualingAsync(
+      this.queryContext,
+      loadKey,
+      loadValue,
+    );
+    if (!result) {
+      return null;
+    }
+
+    return await this.constructionUtils.constructAndAuthorizeEntityAsync(result);
+  }
+
   /**
    * Authorization-result-based version of the EnforcingEntityLoader method by the same name.
    * @returns array of entity results that match the query for compositeFieldValue, where result error can be UnauthorizedError
@@ -265,79 +293,6 @@ export class AuthorizationResultBasedEntityLoader<
     });
   }
 
-  /**
-   * Authorization-result-based version of the EnforcingEntityLoader method by the same name.
-   * @returns the first entity results that matches the query, where result error can be
-   *  UnauthorizedError
-   */
-  async loadFirstByFieldEqualityConjunctionAsync<N extends keyof Pick<TFields, TSelectedFields>>(
-    fieldEqualityOperands: FieldEqualityCondition<TFields, N>[],
-    querySelectionModifiers: Omit<QuerySelectionModifiers<TFields>, 'limit'> &
-      Required<Pick<QuerySelectionModifiers<TFields>, 'orderBy'>>,
-  ): Promise<Result<TEntity> | null> {
-    const results = await this.loadManyByFieldEqualityConjunctionAsync(fieldEqualityOperands, {
-      ...querySelectionModifiers,
-      limit: 1,
-    });
-    return results[0] ?? null;
-  }
-
-  /**
-   * Authorization-result-based version of the EnforcingEntityLoader method by the same name.
-   * @returns array of entity results that match the query, where result error can be UnauthorizedError
-   */
-  async loadManyByFieldEqualityConjunctionAsync<N extends keyof Pick<TFields, TSelectedFields>>(
-    fieldEqualityOperands: FieldEqualityCondition<TFields, N>[],
-    querySelectionModifiers: QuerySelectionModifiers<TFields> = {},
-  ): Promise<readonly Result<TEntity>[]> {
-    for (const fieldEqualityOperand of fieldEqualityOperands) {
-      const fieldValues = isSingleValueFieldEqualityCondition(fieldEqualityOperand)
-        ? [fieldEqualityOperand.fieldValue]
-        : fieldEqualityOperand.fieldValues;
-      this.validateFieldAndValues(fieldEqualityOperand.fieldName, fieldValues);
-    }
-
-    const fieldObjects = await this.dataManager.loadManyByFieldEqualityConjunctionAsync(
-      this.queryContext,
-      fieldEqualityOperands,
-      querySelectionModifiers,
-    );
-    return await this.utils.constructAndAuthorizeEntitiesArrayAsync(fieldObjects);
-  }
-
-  /**
-   * Authorization-result-based version of the EnforcingEntityLoader method by the same name.
-   * @returns array of entity results that match the query, where result error can be UnauthorizedError
-   * @throws Error when rawWhereClause or bindings are invalid
-   */
-  async loadManyByRawWhereClauseAsync(
-    rawWhereClause: string,
-    bindings: any[] | object,
-    querySelectionModifiers: QuerySelectionModifiersWithOrderByRaw<TFields> = {},
-  ): Promise<readonly Result<TEntity>[]> {
-    const fieldObjects = await this.dataManager.loadManyByRawWhereClauseAsync(
-      this.queryContext,
-      rawWhereClause,
-      bindings,
-      querySelectionModifiers,
-    );
-    return await this.utils.constructAndAuthorizeEntitiesArrayAsync(fieldObjects);
-  }
-
-  private validateFieldAndValues<N extends keyof Pick<TFields, TSelectedFields>>(
-    fieldName: N,
-    fieldValues: readonly TFields[N][],
-  ): void {
-    const fieldDefinition = this.entityConfiguration.schema.get(fieldName);
-    invariant(fieldDefinition, `must have field definition for field = ${String(fieldName)}`);
-    for (const fieldValue of fieldValues) {
-      const isInputValid = fieldDefinition.validateInputValue(fieldValue);
-      if (!isInputValid) {
-        throw new EntityInvalidFieldValueError(this.entityClass, fieldName, fieldValue);
-      }
-    }
-  }
-
   private validateFieldAndValuesAndConvertToHolders<N extends keyof Pick<TFields, TSelectedFields>>(
     fieldName: N,
     fieldValues: readonly NonNullable<TFields[N]>[],
@@ -345,7 +300,7 @@ export class AuthorizationResultBasedEntityLoader<
     loadKey: SingleFieldHolder<TFields, TIDField, N>;
     loadValues: readonly SingleFieldValueHolder<TFields, N>[];
   } {
-    this.validateFieldAndValues(fieldName, fieldValues);
+    this.constructionUtils.validateFieldAndValues(fieldName, fieldValues);
 
     return {
       loadKey: new SingleFieldHolder<TFields, TIDField, N>(fieldName),
@@ -355,6 +310,21 @@ export class AuthorizationResultBasedEntityLoader<
     };
   }
 
+  private validateFieldAndValueAndConvertToHolders<N extends keyof Pick<TFields, TSelectedFields>>(
+    fieldName: N,
+    fieldValue: NonNullable<TFields[N]>,
+  ): {
+    loadKey: SingleFieldHolder<TFields, TIDField, N>;
+    loadValue: SingleFieldValueHolder<TFields, N>;
+  } {
+    this.constructionUtils.validateFieldAndValues(fieldName, [fieldValue]);
+
+    return {
+      loadKey: new SingleFieldHolder<TFields, TIDField, N>(fieldName),
+      loadValue: new SingleFieldValueHolder<TFields, N>(fieldValue),
+    };
+  }
+
   private validateCompositeFieldAndValuesAndConvertToHolders<
     N extends EntityCompositeField<Pick<TFields, TSelectedFields>>,
   >(
@@ -388,7 +358,7 @@ export class AuthorizationResultBasedEntityLoader<
       );
       for (const field of compositeField) {
         const fieldValue = compositeFieldValueHolder.compositeFieldValue[field];
-        this.validateFieldAndValues(field, [fieldValue]);
+        this.constructionUtils.validateFieldAndValues(field, [fieldValue]);
       }
     }
 
@@ -408,7 +378,7 @@ export class AuthorizationResultBasedEntityLoader<
         Array.from(map.entries()).map(async ([compositeFieldValueHolder, fieldObjects]) => {
           return [
             compositeFieldValueHolder,
-            await this.utils.constructAndAuthorizeEntitiesArrayAsync(fieldObjects),
+            await this.constructionUtils.constructAndAuthorizeEntitiesArrayAsync(fieldObjects),
           ];
         }),
       ),

package/src/AuthorizationResultBasedEntityMutator.ts

@@ -333,8 +333,17 @@ export class AuthorizationResultBasedCreateMutator<
       previousValue: null,
       cascadingDeleteCause: null,
     });
+    const invalidationUtils = this.entityLoaderFactory.invalidationUtils();
+    const constructionUtils = this.entityLoaderFactory.constructionUtils(
+      this.viewerContext,
+      queryContext,
+      {
+        previousValue: null,
+        cascadingDeleteCause: null,
+      },
+    );
 
-    const temporaryEntityForPrivacyCheck = entityLoader.utils.constructEntity({
+    const temporaryEntityForPrivacyCheck = constructionUtils.constructEntity({
       [this.entityConfiguration.idField]: '00000000-0000-0000-0000-000000000000', // zero UUID
       ...this.fieldsForEntity,
     } as unknown as TFields);
@@ -376,13 +385,13 @@ export class AuthorizationResultBasedCreateMutator<
     // Invalidate all caches for the new entity so that any previously-negatively-cached loads
     // are removed from the caches.
     queryContext.appendPostCommitInvalidationCallback(async () => {
-      entityLoader.utils.invalidateFieldsForTransaction(queryContext, insertResult);
-      await entityLoader.utils.invalidateFieldsAsync(insertResult);
+      invalidationUtils.invalidateFieldsForTransaction(queryContext, insertResult);
+      await invalidationUtils.invalidateFieldsAsync(insertResult);
     });
 
-    entityLoader.utils.invalidateFieldsForTransaction(queryContext, insertResult);
+    invalidationUtils.invalidateFieldsForTransaction(queryContext, insertResult);
 
-    const unauthorizedEntityAfterInsert = entityLoader.utils.constructEntity(insertResult);
+    const unauthorizedEntityAfterInsert = constructionUtils.constructEntity(insertResult);
     const newEntity = await enforceAsyncResult(
       entityLoader.loadByIDAsync(unauthorizedEntityAfterInsert.getID()),
     );
@@ -541,8 +550,17 @@ export class AuthorizationResultBasedUpdateMutator<
       previousValue: this.originalEntity,
       cascadingDeleteCause: this.cascadingDeleteCause,
     });
+    const invalidationUtils = this.entityLoaderFactory.invalidationUtils();
+    const constructionUtils = this.entityLoaderFactory.constructionUtils(
+      this.viewerContext,
+      queryContext,
+      {
+        previousValue: this.originalEntity,
+        cascadingDeleteCause: this.cascadingDeleteCause,
+      },
+    );
 
-    const entityAboutToBeUpdated = entityLoader.utils.constructEntity(this.fieldsForEntity);
+    const entityAboutToBeUpdated = constructionUtils.constructEntity(this.fieldsForEntity);
     const authorizeUpdateResult = await asyncResult(
       this.privacyPolicy.authorizeUpdateAsync(
         this.viewerContext,
@@ -606,22 +624,22 @@ export class AuthorizationResultBasedUpdateMutator<
     // version of the entity.
 
     queryContext.appendPostCommitInvalidationCallback(async () => {
-      entityLoader.utils.invalidateFieldsForTransaction(
+      invalidationUtils.invalidateFieldsForTransaction(
         queryContext,
         this.originalEntity.getAllDatabaseFields(),
       );
-      entityLoader.utils.invalidateFieldsForTransaction(queryContext, this.fieldsForEntity);
+      invalidationUtils.invalidateFieldsForTransaction(queryContext, this.fieldsForEntity);
       await Promise.all([
-        entityLoader.utils.invalidateFieldsAsync(this.originalEntity.getAllDatabaseFields()),
-        entityLoader.utils.invalidateFieldsAsync(this.fieldsForEntity),
+        invalidationUtils.invalidateFieldsAsync(this.originalEntity.getAllDatabaseFields()),
+        invalidationUtils.invalidateFieldsAsync(this.fieldsForEntity),
       ]);
     });
 
-    entityLoader.utils.invalidateFieldsForTransaction(
+    invalidationUtils.invalidateFieldsForTransaction(
       queryContext,
       this.originalEntity.getAllDatabaseFields(),
     );
-    entityLoader.utils.invalidateFieldsForTransaction(queryContext, this.fieldsForEntity);
+    invalidationUtils.invalidateFieldsForTransaction(queryContext, this.fieldsForEntity);
 
     const updatedEntity = await enforceAsyncResult(
       entityLoader.loadByIDAsync(entityAboutToBeUpdated.getID()),
@@ -839,21 +857,18 @@ export class AuthorizationResultBasedDeleteMutator<
       );
     }
 
-    const entityLoader = this.entityLoaderFactory.forLoad(this.viewerContext, queryContext, {
-      previousValue: null,
-      cascadingDeleteCause: this.cascadingDeleteCause,
-    });
+    const invalidationUtils = this.entityLoaderFactory.invalidationUtils();
 
     // Invalidate all caches for the entity so that any previously-cached loads
     // are removed from the caches.
     queryContext.appendPostCommitInvalidationCallback(async () => {
-      entityLoader.utils.invalidateFieldsForTransaction(
+      invalidationUtils.invalidateFieldsForTransaction(
         queryContext,
         this.entity.getAllDatabaseFields(),
       );
-      await entityLoader.utils.invalidateFieldsAsync(this.entity.getAllDatabaseFields());
+      await invalidationUtils.invalidateFieldsAsync(this.entity.getAllDatabaseFields());
     });
-    entityLoader.utils.invalidateFieldsForTransaction(
+    invalidationUtils.invalidateFieldsForTransaction(
       queryContext,
       this.entity.getAllDatabaseFields(),
     );
@@ -971,7 +986,7 @@ export class AuthorizationResultBasedDeleteMutator<
                 .loadManyByFieldEqualingAsync(
                   fieldName,
                   association.associatedEntityLookupByField
-                    ? entity.getField(association.associatedEntityLookupByField as any)
+                    ? entity.getField(association.associatedEntityLookupByField)
                     : entity.getID(),
                 ),
             );

package/src/EnforcingEntityCreator.ts

@@ -6,7 +6,7 @@ import { ReadonlyEntity } from './ReadonlyEntity';
 import { ViewerContext } from './ViewerContext';
 
 /**
- * Enforcing entity creator. All updates
+ * Enforcing entity creator. All creates
  * through this creator will throw if authorization is not successful.
  */
 export class EnforcingEntityCreator<

package/src/EnforcingEntityLoader.ts

@@ -1,10 +1,5 @@
 import { AuthorizationResultBasedEntityLoader } from './AuthorizationResultBasedEntityLoader';
 import { EntityCompositeField, EntityCompositeFieldValue } from './EntityConfiguration';
-import {
-  FieldEqualityCondition,
-  QuerySelectionModifiers,
-  QuerySelectionModifiersWithOrderByRaw,
-} from './EntityDatabaseAdapter';
 import { EntityPrivacyPolicy } from './EntityPrivacyPolicy';
 import { ReadonlyEntity } from './ReadonlyEntity';
 import { ViewerContext } from './ViewerContext';
@@ -29,7 +24,7 @@ export class EnforcingEntityLoader<
     TEntity,
     TSelectedFields
   >,
-  TSelectedFields extends keyof TFields,
+  TSelectedFields extends keyof TFields = keyof TFields,
 > {
   constructor(
     private readonly entityLoader: AuthorizationResultBasedEntityLoader<
@@ -219,93 +214,4 @@ export class EnforcingEntityLoader<
     const entityResults = await this.entityLoader.loadManyByIDsNullableAsync(ids);
     return mapMap(entityResults, (result) => result?.enforceValue() ?? null);
   }
-
-  /**
-   * Loads the first entity matching the selection constructed from the conjunction of specified
-   * operands, or null if no matching entity exists. Entities loaded using this method are not
-   * batched or cached.
-   *
-   * This is a convenience method for {@link loadManyByFieldEqualityConjunctionAsync}. However, the
-   * `orderBy` option must be specified to define what "first" means. If ordering doesn't matter,
-   * explicitly pass in an empty array.
-   *
-   * @param fieldEqualityOperands - list of field equality selection operand specifications
-   * @param querySelectionModifiers - orderBy and optional offset for the query
-   * @returns the first entity that matches the query or null if no entity matches the query
-   * @throws EntityNotAuthorizedError when viewer is not authorized to view the returned entity
-   */
-  async loadFirstByFieldEqualityConjunctionAsync<N extends keyof Pick<TFields, TSelectedFields>>(
-    fieldEqualityOperands: FieldEqualityCondition<TFields, N>[],
-    querySelectionModifiers: Omit<QuerySelectionModifiers<TFields>, 'limit'> &
-      Required<Pick<QuerySelectionModifiers<TFields>, 'orderBy'>>,
-  ): Promise<TEntity | null> {
-    const entityResult = await this.entityLoader.loadFirstByFieldEqualityConjunctionAsync(
-      fieldEqualityOperands,
-      querySelectionModifiers,
-    );
-    return entityResult ? entityResult.enforceValue() : null;
-  }
-
-  /**
-   * Loads many entities matching the selection constructed from the conjunction of specified operands.
-   * Entities loaded using this method are not batched or cached.
-   *
-   * @example
-   * fieldEqualityOperands:
-   * `[{fieldName: 'hello', fieldValue: 1}, {fieldName: 'world', fieldValues: [2, 3]}]`
-   * Entities returned with a SQL EntityDatabaseAdapter:
-   * `WHERE hello = 1 AND world = ANY({2, 3})`
-   *
-   * @param fieldEqualityOperands - list of field equality selection operand specifications
-   * @param querySelectionModifiers - limit, offset, and orderBy for the query
-   * @returns array of entities that match the query
-   * @throws EntityNotAuthorizedError when viewer is not authorized to view one or more of the returned entities
-   */
-  async loadManyByFieldEqualityConjunctionAsync<N extends keyof Pick<TFields, TSelectedFields>>(
-    fieldEqualityOperands: FieldEqualityCondition<TFields, N>[],
-    querySelectionModifiers: QuerySelectionModifiers<TFields> = {},
-  ): Promise<readonly TEntity[]> {
-    const entityResults = await this.entityLoader.loadManyByFieldEqualityConjunctionAsync(
-      fieldEqualityOperands,
-      querySelectionModifiers,
-    );
-    return entityResults.map((result) => result.enforceValue());
-  }
-
-  /**
-   * Loads many entities matching the raw WHERE clause. Corresponds to the knex `whereRaw` argument format.
-   *
-   * @remarks
-   * Important notes:
-   * - Fields in clause are database column names instead of transformed entity field names.
-   * - Entities loaded using this method are not batched or cached.
-   * - Not all database adapters implement the ability to execute this method of fetching entities.
-   *
-   * @example
-   * rawWhereClause: `id = ?`
-   * bindings: `[1]`
-   * Entites returned `WHERE id = 1`
-   *
-   * http://knexjs.org/#Builder-whereRaw
-   * http://knexjs.org/#Raw-Bindings
-   *
-   * @param rawWhereClause - parameterized SQL WHERE clause with positional binding placeholders or named binding placeholders
-   * @param bindings - array of positional bindings or object of named bindings
-   * @param querySelectionModifiers - limit, offset, orderBy, and orderByRaw for the query
-   * @returns array of entities that match the query
-   * @throws EntityNotAuthorizedError when viewer is not authorized to view one or more of the returned entities
-   * @throws Error when rawWhereClause or bindings are invalid
-   */
-  async loadManyByRawWhereClauseAsync(
-    rawWhereClause: string,
-    bindings: any[] | object,
-    querySelectionModifiers: QuerySelectionModifiersWithOrderByRaw<TFields> = {},
-  ): Promise<readonly TEntity[]> {
-    const entityResults = await this.entityLoader.loadManyByRawWhereClauseAsync(
-      rawWhereClause,
-      bindings,
-      querySelectionModifiers,
-    );
-    return entityResults.map((result) => result.enforceValue());
-  }
 }

package/src/Entity.ts

@@ -32,6 +32,12 @@ import { ViewerContext } from './ViewerContext';
  *
  * All concrete entity implementations should extend this class and provide their
  * own EntityCompanionDefinition.
+ *
+ * Generic type parameters:
+ * TFields - the shape of the underlying data for this entity, typically corresponding to a database table schema. The mapping from TFields to the actual database schema is defined in the EntityCompanionDefinition for this entity.
+ * TIDField - the key of the ID field in TFields, which must be non-nullable and is used to uniquely identify individual entities
+ * TViewerContext - the type of ViewerContext that can be used with this entity
+ * TSelectedFields - the keys of fields in TFields that belong to this entity; used when there are multiple entities backed by the same underlying table with different field subsets
  */
 export abstract class Entity<
   TFields extends Record<string, any>,

package/src/EntityCompanion.ts

@@ -59,8 +59,8 @@ export class EntityCompanion<
       TPrivacyPolicy,
       TSelectedFields
     >,
-    private readonly tableDataCoordinator: EntityTableDataCoordinator<TFields, TIDField>,
-    private readonly metricsAdapter: IEntityMetricsAdapter,
+    public readonly tableDataCoordinator: EntityTableDataCoordinator<TFields, TIDField>,
+    public readonly metricsAdapter: IEntityMetricsAdapter,
   ) {
     this.privacyPolicy = new entityCompanionDefinition.privacyPolicyClass();
     this.entityLoaderFactory = new EntityLoaderFactory<

package/src/EntityCompanionProvider.ts

@@ -208,13 +208,13 @@ export class EntityCompanionProvider {
     });
   }
 
-  getQueryContextProviderForDatabaseAdaptorFlavor(
+  getQueryContextProviderForDatabaseAdapterFlavor(
     databaseAdapterFlavor: DatabaseAdapterFlavor,
   ): EntityQueryContextProvider {
     const entityDatabaseAdapterFlavor = this.databaseAdapterFlavors.get(databaseAdapterFlavor);
     invariant(
       entityDatabaseAdapterFlavor,
-      `No database adaptor configuration found for flavor: ${databaseAdapterFlavor}`,
+      `No database adapter configuration found for flavor: ${databaseAdapterFlavor}`,
     );
 
     return entityDatabaseAdapterFlavor.queryContextProvider;
@@ -233,7 +233,7 @@ export class EntityCompanionProvider {
       );
       invariant(
         entityDatabaseAdapterFlavor,
-        `No database adaptor configuration found for flavor: ${entityConfiguration.databaseAdapterFlavor}`,
+        `No database adapter configuration found for flavor: ${entityConfiguration.databaseAdapterFlavor}`,
       );
 
       const entityCacheAdapterFlavor = this.cacheAdapterFlavors.get(
@@ -241,7 +241,7 @@ export class EntityCompanionProvider {
       );
       invariant(
         entityCacheAdapterFlavor,
-        `No cache adaptor configuration found for flavor: ${entityConfiguration.cacheAdapterFlavor}`,
+        `No cache adapter configuration found for flavor: ${entityConfiguration.cacheAdapterFlavor}`,
       );
 
       return new EntityTableDataCoordinator(

package/src/EntityConfiguration.ts

@@ -67,7 +67,9 @@ export class CompositeFieldInfo<
           keyDefinition.compositeField.length === new Set(keyDefinition.compositeField).size,
           'Composite field must have unique sub-fields',
         );
-        const compositeFieldHolder = new CompositeFieldHolder(keyDefinition.compositeField);
+        const compositeFieldHolder = new CompositeFieldHolder<TFields, TIDField>(
+          keyDefinition.compositeField,
+        );
         return [
           compositeFieldHolder.serialize(),
           { compositeFieldHolder, cache: keyDefinition.cache ?? false },
@@ -79,8 +81,9 @@ export class CompositeFieldInfo<
   public getCompositeFieldHolderForCompositeField(
     compositeField: EntityCompositeField<TFields>,
   ): CompositeFieldHolder<TFields, TIDField> | undefined {
-    return this.compositeFieldInfoMap.get(new CompositeFieldHolder(compositeField).serialize())
-      ?.compositeFieldHolder;
+    return this.compositeFieldInfoMap.get(
+      new CompositeFieldHolder<TFields, TIDField>(compositeField).serialize(),
+    )?.compositeFieldHolder;
   }
 
   public getAllCompositeFieldHolders(): readonly CompositeFieldHolder<TFields, TIDField>[] {
@@ -89,7 +92,7 @@ export class CompositeFieldInfo<
 
   public canCacheCompositeField(compositeField: EntityCompositeField<TFields>): boolean {
     const compositeFieldInfo = this.compositeFieldInfoMap.get(
-      new CompositeFieldHolder(compositeField).serialize(),
+      new CompositeFieldHolder<TFields, TIDField>(compositeField).serialize(),
     );
     invariant(
       compositeFieldInfo,
@@ -107,7 +110,7 @@ export class EntityConfiguration<
   TFields extends Record<string, any>,
   TIDField extends keyof TFields,
 > {
-  readonly idField: keyof TFields;
+  readonly idField: TIDField;
   readonly tableName: string;
   readonly cacheableKeys: ReadonlySet<keyof TFields>;
   readonly compositeFieldInfo: CompositeFieldInfo<TFields, TIDField>;