@expo/entity 0.35.0 → 0.37.0

package/src/internal/EntityDataManager.ts

@@ -25,7 +25,7 @@ import { computeIfAbsent, zipToMap } from '../utils/collections/maps';
  *
  * It is also responsible for invalidating all sources of data when mutated using EntityMutator.
  */
-export default class EntityDataManager<TFields> {
+export default class EntityDataManager<TFields extends Record<string, any>> {
   private readonly fieldDataLoaders: Map<
     keyof TFields,
     DataLoader<NonNullable<TFields[keyof TFields]>, readonly Readonly<TFields>[]>
@@ -36,30 +36,30 @@ export default class EntityDataManager<TFields> {
     private readonly entityCache: ReadThroughEntityCache<TFields>,
     private readonly queryContextProvider: EntityQueryContextProvider,
     private readonly metricsAdapter: IEntityMetricsAdapter,
-    private readonly entityClassName: string
+    private readonly entityClassName: string,
   ) {}
 
   private getFieldDataLoaderForFieldName<N extends keyof TFields>(
-    fieldName: N
+    fieldName: N,
   ): DataLoader<NonNullable<TFields[N]>, readonly Readonly<TFields>[]> {
     return computeIfAbsent(this.fieldDataLoaders, fieldName, () => {
       return new DataLoader(
         async (
-          fieldValues: readonly NonNullable<TFields[N]>[]
+          fieldValues: readonly NonNullable<TFields[N]>[],
         ): Promise<readonly (readonly TFields[])[]> => {
           const objectMap = await this.loadManyForDataLoaderByFieldEqualingAsync(
             fieldName,
-            fieldValues
+            fieldValues,
           );
           return fieldValues.map((fv) => objectMap.get(fv) ?? []);
-        }
+        },
       );
     });
   }
 
   private async loadManyForDataLoaderByFieldEqualingAsync<N extends keyof TFields>(
     fieldName: N,
-    fieldValues: readonly NonNullable<TFields[N]>[]
+    fieldValues: readonly NonNullable<TFields[N]>[],
   ): Promise<ReadonlyMap<NonNullable<TFields[N]>, readonly Readonly<TFields>[]>> {
     this.metricsAdapter.incrementDataManagerLoadCount({
       type: IncrementLoadCountEventType.CACHE,
@@ -78,9 +78,9 @@ export default class EntityDataManager<TFields> {
         return await this.databaseAdapter.fetchManyWhereAsync(
           this.queryContextProvider.getQueryContext(),
           fieldName,
-          fetcherValues
+          fetcherValues,
         );
-      }
+      },
     );
   }
 
@@ -95,28 +95,28 @@ export default class EntityDataManager<TFields> {
   async loadManyByFieldEqualingAsync<N extends keyof TFields>(
     queryContext: EntityQueryContext,
     fieldName: N,
-    fieldValues: readonly NonNullable<TFields[N]>[]
+    fieldValues: readonly NonNullable<TFields[N]>[],
   ): Promise<ReadonlyMap<NonNullable<TFields[N]>, readonly Readonly<TFields>[]>> {
     return await timeAndLogLoadMapEventAsync(
       this.metricsAdapter,
       EntityMetricsLoadType.LOAD_MANY,
-      this.entityClassName
+      this.entityClassName,
     )(this.loadManyByFieldEqualingInternalAsync(queryContext, fieldName, fieldValues));
   }
 
   private async loadManyByFieldEqualingInternalAsync<N extends keyof TFields>(
     queryContext: EntityQueryContext,
     fieldName: N,
-    fieldValues: readonly NonNullable<TFields[N]>[]
+    fieldValues: readonly NonNullable<TFields[N]>[],
   ): Promise<ReadonlyMap<NonNullable<TFields[N]>, readonly Readonly<TFields>[]>> {
     const nullOrUndefinedValueIndex = fieldValues.findIndex(
-      (value) => value === null || value === undefined
+      (value) => value === null || value === undefined,
     );
     if (nullOrUndefinedValueIndex >= 0) {
       throw new Error(
         `Invalid load: ${this.entityClassName} (${String(fieldName)} = ${
           fieldValues[nullOrUndefinedValueIndex]
-        })`
+        })`,
       );
     }
 
@@ -153,18 +153,18 @@ export default class EntityDataManager<TFields> {
   async loadManyByFieldEqualityConjunctionAsync<N extends keyof TFields>(
     queryContext: EntityQueryContext,
     fieldEqualityOperands: FieldEqualityCondition<TFields, N>[],
-    querySelectionModifiers: QuerySelectionModifiers<TFields>
+    querySelectionModifiers: QuerySelectionModifiers<TFields>,
   ): Promise<readonly Readonly<TFields>[]> {
     return await timeAndLogLoadEventAsync(
       this.metricsAdapter,
       EntityMetricsLoadType.LOAD_MANY_EQUALITY_CONJUNCTION,
-      this.entityClassName
+      this.entityClassName,
     )(
       this.databaseAdapter.fetchManyByFieldEqualityConjunctionAsync(
         queryContext,
         fieldEqualityOperands,
-        querySelectionModifiers
-      )
+        querySelectionModifiers,
+      ),
     );
   }
 
@@ -181,25 +181,25 @@ export default class EntityDataManager<TFields> {
     queryContext: EntityQueryContext,
     rawWhereClause: string,
     bindings: any[] | object,
-    querySelectionModifiers: QuerySelectionModifiersWithOrderByRaw<TFields>
+    querySelectionModifiers: QuerySelectionModifiersWithOrderByRaw<TFields>,
   ): Promise<readonly Readonly<TFields>[]> {
     return await timeAndLogLoadEventAsync(
       this.metricsAdapter,
       EntityMetricsLoadType.LOAD_MANY_RAW,
-      this.entityClassName
+      this.entityClassName,
     )(
       this.databaseAdapter.fetchManyByRawWhereClauseAsync(
         queryContext,
         rawWhereClause,
         bindings,
-        querySelectionModifiers
-      )
+        querySelectionModifiers,
+      ),
     );
   }
 
   private async invalidateManyByFieldEqualingAsync<N extends keyof TFields>(
     fieldName: N,
-    fieldValues: readonly NonNullable<TFields[N]>[]
+    fieldValues: readonly NonNullable<TFields[N]>[],
   ): Promise<void> {
     await this.entityCache.invalidateManyAsync(fieldName, fieldValues);
     const dataLoader = this.getFieldDataLoaderForFieldName(fieldName);
@@ -222,7 +222,7 @@ export default class EntityDataManager<TFields> {
             value as NonNullable<TFields[keyof TFields]>,
           ]);
         }
-      })
+      }),
     );
   }
 }

package/src/internal/EntityFieldTransformationUtils.ts

@@ -1,4 +1,5 @@
 import invariant from 'invariant';
+import nullthrows from 'nullthrows';
 
 import EntityConfiguration from '../EntityConfiguration';
 
@@ -19,19 +20,19 @@ export interface FieldTransformer<T> {
  */
 export type FieldTransformerMap = Map<string, FieldTransformer<any>>;
 
-export const getDatabaseFieldForEntityField = <TFields>(
+export const getDatabaseFieldForEntityField = <TFields extends Record<string, any>>(
   entityConfiguration: EntityConfiguration<TFields>,
-  entityField: keyof TFields
+  entityField: keyof TFields,
 ): string => {
   const databaseField = entityConfiguration.entityToDBFieldsKeyMapping.get(entityField);
   invariant(databaseField, `database field mapping missing for ${String(entityField)}`);
   return databaseField!;
 };
 
-export const transformDatabaseObjectToFields = <TFields>(
+export const transformDatabaseObjectToFields = <TFields extends Record<string, any>>(
   entityConfiguration: EntityConfiguration<TFields>,
   fieldTransformerMap: FieldTransformerMap,
-  databaseObject: { [key: string]: any }
+  databaseObject: { [key: string]: any },
 ): Readonly<TFields> => {
   const fields: TFields = {} as any;
   for (const k in databaseObject) {
@@ -42,17 +43,17 @@ export const transformDatabaseObjectToFields = <TFields>(
         entityConfiguration,
         fieldTransformerMap,
         fieldsKey,
-        val
+        val,
       );
     }
   }
   return fields;
 };
 
-export const transformFieldsToDatabaseObject = <TFields>(
+export const transformFieldsToDatabaseObject = <TFields extends Record<string, any>>(
   entityConfiguration: EntityConfiguration<TFields>,
   fieldTransformerMap: FieldTransformerMap,
-  fields: Readonly<Partial<TFields>>
+  fields: Readonly<Partial<TFields>>,
 ): object => {
   const databaseObject: { [key: string]: any } = {};
   for (const k in fields) {
@@ -63,16 +64,16 @@ export const transformFieldsToDatabaseObject = <TFields>(
       entityConfiguration,
       fieldTransformerMap,
       k,
-      val
+      val,
     );
   }
   return databaseObject;
 };
 
-export const transformCacheObjectToFields = <TFields>(
+export const transformCacheObjectToFields = <TFields extends Record<string, any>>(
   entityConfiguration: EntityConfiguration<TFields>,
   fieldTransformerMap: FieldTransformerMap,
-  cacheObject: { [key: string]: any }
+  cacheObject: { [key: string]: any },
 ): Readonly<TFields> => {
   const fields: TFields = {} as any;
   for (const fieldsKey in cacheObject) {
@@ -81,16 +82,16 @@ export const transformCacheObjectToFields = <TFields>(
       entityConfiguration,
       fieldTransformerMap,
       fieldsKey as keyof TFields,
-      val
+      val,
     );
   }
   return fields;
 };
 
-export const transformFieldsToCacheObject = <TFields>(
+export const transformFieldsToCacheObject = <TFields extends Record<string, any>>(
   entityConfiguration: EntityConfiguration<TFields>,
   fieldTransformerMap: FieldTransformerMap,
-  fields: Readonly<Partial<TFields>>
+  fields: Readonly<Partial<TFields>>,
 ): object => {
   const cacheObject: { [key: string]: any } = {};
   for (const fieldsKey in fields) {
@@ -99,49 +100,52 @@ export const transformFieldsToCacheObject = <TFields>(
       entityConfiguration,
       fieldTransformerMap,
       fieldsKey,
-      val
+      val,
     );
   }
   return cacheObject;
 };
 
-const maybeTransformDatabaseValueToFieldValue = <TFields, N extends keyof TFields>(
+const maybeTransformDatabaseValueToFieldValue = <
+  TFields extends Record<string, any>,
+  N extends keyof TFields,
+>(
   entityConfiguration: EntityConfiguration<TFields>,
   fieldTransformerMap: FieldTransformerMap,
   fieldName: N,
-  value: any
+  value: any,
 ): TFields[N] => {
-  const fieldDefinition = entityConfiguration.schema.get(fieldName);
-  if (!fieldDefinition) {
-    return value;
-  }
-
+  // this will always be non-null due to the way the dbToEntityFieldsKeyMapping is computed and this
+  // function is called conditionally
+  const fieldDefinition = nullthrows(entityConfiguration.schema.get(fieldName));
   const transformer = fieldTransformerMap.get(fieldDefinition.constructor.name);
   const readTransformer = transformer?.read;
   return readTransformer ? readTransformer(value) : value;
 };
 
-const maybeTransformFieldValueToDatabaseValue = <TFields, N extends keyof TFields>(
+const maybeTransformFieldValueToDatabaseValue = <
+  TFields extends Record<string, any>,
+  N extends keyof TFields,
+>(
   entityConfiguration: EntityConfiguration<TFields>,
   fieldTransformerMap: FieldTransformerMap,
   fieldName: N,
-  value: TFields[N]
+  value: TFields[N],
 ): any => {
-  const fieldDefinition = entityConfiguration.schema.get(fieldName);
-  if (!fieldDefinition) {
-    return value;
-  }
-
+  const fieldDefinition = nullthrows(entityConfiguration.schema.get(fieldName));
   const transformer = fieldTransformerMap.get(fieldDefinition.constructor.name);
   const writeTransformer = transformer?.write;
   return writeTransformer ? writeTransformer(value) : value;
 };
 
-const maybeTransformCacheValueToFieldValue = <TFields, N extends keyof TFields>(
+const maybeTransformCacheValueToFieldValue = <
+  TFields extends Record<string, any>,
+  N extends keyof TFields,
+>(
   entityConfiguration: EntityConfiguration<TFields>,
   fieldTransformerMap: FieldTransformerMap,
   fieldName: N,
-  value: any
+  value: any,
 ): TFields[N] => {
   const fieldDefinition = entityConfiguration.schema.get(fieldName);
   if (!fieldDefinition) {
@@ -153,11 +157,14 @@ const maybeTransformCacheValueToFieldValue = <TFields, N extends keyof TFields>(
   return readTransformer ? readTransformer(value) : value;
 };
 
-const maybeTransformFieldValueToCacheValue = <TFields, N extends keyof TFields>(
+const maybeTransformFieldValueToCacheValue = <
+  TFields extends Record<string, any>,
+  N extends keyof TFields,
+>(
   entityConfiguration: EntityConfiguration<TFields>,
   fieldTransformerMap: FieldTransformerMap,
   fieldName: N,
-  value: TFields[N]
+  value: TFields[N],
 ): any => {
   const fieldDefinition = entityConfiguration.schema.get(fieldName);
   if (!fieldDefinition) {

package/src/internal/EntityTableDataCoordinator.ts

@@ -13,7 +13,7 @@ import IEntityMetricsAdapter from '../metrics/IEntityMetricsAdapter';
  * table. Note that one instance is shared amongst all entities that read from
  * the table to ensure cross-entity data consistency.
  */
-export default class EntityTableDataCoordinator<TFields> {
+export default class EntityTableDataCoordinator<TFields extends Record<string, any>> {
   readonly databaseAdapter: EntityDatabaseAdapter<TFields>;
   readonly cacheAdapter: IEntityCacheAdapter<TFields>;
   readonly dataManager: EntityDataManager<TFields>;
@@ -24,7 +24,7 @@ export default class EntityTableDataCoordinator<TFields> {
     cacheAdapterProvider: IEntityCacheAdapterProvider,
     private readonly queryContextProvider: EntityQueryContextProvider,
     metricsAdapter: IEntityMetricsAdapter,
-    entityClassName: string
+    entityClassName: string,
   ) {
     this.databaseAdapter = databaseAdapterProvider.getDatabaseAdapter(entityConfiguration);
     this.cacheAdapter = cacheAdapterProvider.getCacheAdapter(entityConfiguration);
@@ -33,7 +33,7 @@ export default class EntityTableDataCoordinator<TFields> {
       new ReadThroughEntityCache(entityConfiguration, this.cacheAdapter),
       queryContextProvider,
       metricsAdapter,
-      entityClassName
+      entityClassName,
     );
   }
 

package/src/internal/ReadThroughEntityCache.ts

@@ -26,10 +26,10 @@ export type CacheLoadResult<TFields> =
  * A read-through entity cache is responsible for coordinating EntityDatabaseAdapter and
  * EntityCacheAdapter within the EntityDataManager.
  */
-export default class ReadThroughEntityCache<TFields> {
+export default class ReadThroughEntityCache<TFields extends Record<string, any>> {
   constructor(
     private readonly entityConfiguration: EntityConfiguration<TFields>,
-    private readonly entityCacheAdapter: IEntityCacheAdapter<TFields>
+    private readonly entityCacheAdapter: IEntityCacheAdapter<TFields>,
   ) {}
 
   private isFieldCacheable<N extends keyof TFields>(fieldName: N): boolean {
@@ -56,8 +56,8 @@ export default class ReadThroughEntityCache<TFields> {
     fieldName: N,
     fieldValues: readonly NonNullable<TFields[N]>[],
     fetcher: (
-      fetcherFieldValues: readonly NonNullable<TFields[N]>[]
-    ) => Promise<ReadonlyMap<NonNullable<TFields[N]>, readonly Readonly<TFields>[]>>
+      fetcherFieldValues: readonly NonNullable<TFields[N]>[],
+    ) => Promise<ReadonlyMap<NonNullable<TFields[N]>, readonly Readonly<TFields>[]>>,
   ): Promise<ReadonlyMap<NonNullable<TFields[N]>, readonly Readonly<TFields>[]>> {
     // return normal fetch when cache by fieldName not supported
     if (!this.isFieldCacheable(fieldName)) {
@@ -68,14 +68,14 @@ export default class ReadThroughEntityCache<TFields> {
 
     invariant(
       cacheLoadResults.size === fieldValues.length,
-      `${this.constructor.name} loadMany should return a result for each fieldValue`
+      `${this.constructor.name} loadMany should return a result for each fieldValue`,
     );
 
     const fieldValuesToFetchFromDB = Array.from(
       filterMap(
         cacheLoadResults,
-        (cacheLoadResult) => cacheLoadResult.status === CacheStatus.MISS
-      ).keys()
+        (cacheLoadResult) => cacheLoadResult.status === CacheStatus.MISS,
+      ).keys(),
     );
 
     // put transformed cache hits in result map
@@ -104,7 +104,7 @@ export default class ReadThroughEntityCache<TFields> {
           console.warn(
             `unique key ${String(fieldName)} in ${
               this.entityConfiguration.tableName
-            } returned multiple rows for ${fieldValue}`
+            } returned multiple rows for ${fieldValue}`,
           );
           continue;
         }
@@ -132,7 +132,7 @@ export default class ReadThroughEntityCache<TFields> {
    */
   public async invalidateManyAsync<N extends keyof TFields>(
     fieldName: N,
-    fieldValues: readonly NonNullable<TFields[N]>[]
+    fieldValues: readonly NonNullable<TFields[N]>[],
   ): Promise<void> {
     // no-op when cache by fieldName not supported
     if (!this.isFieldCacheable(fieldName)) {