@expo/entity 0.43.0 → 0.45.0

package/src/internal/CompositeFieldHolder.ts

@@ -14,6 +14,10 @@ import {
 } from '../internal/EntityLoadInterfaces';
 
 declare const CompositeFieldHolderSerializedBrand: unique symbol;
+
+/**
+ * @internal
+ */
 export type SerializedCompositeFieldHolder = string & {
   readonly [CompositeFieldHolderSerializedBrand]: true;
 };
@@ -21,6 +25,8 @@ export type SerializedCompositeFieldHolder = string & {
 /**
  * A load key that represents a composite field (set of fieldName) on an entity.
  * Must be defined in the entity configuration composite field definition.
+ *
+ * @internal
  */
 export class CompositeFieldHolder<
   TFields extends Record<string, any>,
@@ -151,12 +157,18 @@ export class CompositeFieldHolder<
 }
 
 declare const CompositeFieldValueHolderSerializedBrand: unique symbol;
+
+/**
+ * @internal
+ */
 export type SerializedCompositeFieldValueHolder = string & {
   readonly [CompositeFieldValueHolderSerializedBrand]: true;
 };
 
 /**
  * A load value for a CompositeFieldHolder.
+ *
+ * @internal
  */
 export class CompositeFieldValueHolder<
   TFields extends Record<string, any>,
@@ -201,6 +213,9 @@ export class CompositeFieldValueHolder<
   }
 }
 
+/**
+ * @internal
+ */
 export class CompositeFieldValueHolderMap<
   TFields extends Record<string, any>,
   N extends EntityCompositeField<TFields>,

package/src/internal/CompositeFieldValueMap.ts

@@ -4,6 +4,9 @@ import {
   CompositeFieldValueHolder,
 } from './CompositeFieldHolder';
 
+/**
+ * @internal
+ */
 export class CompositeFieldValueMap<
   TFields extends Record<string, any>,
   N extends EntityCompositeField<TFields>,

package/src/internal/EntityDataManager.ts

@@ -7,7 +7,11 @@ import EntityDatabaseAdapter, {
   QuerySelectionModifiers,
   QuerySelectionModifiersWithOrderByRaw,
 } from '../EntityDatabaseAdapter';
-import { EntityQueryContext } from '../EntityQueryContext';
+import {
+  EntityQueryContext,
+  EntityTransactionalQueryContext,
+  TransactionalDataLoaderMode,
+} from '../EntityQueryContext';
 import EntityQueryContextProvider from '../EntityQueryContextProvider';
 import { partitionErrors } from '../entityUtils';
 import { IEntityLoadKey, IEntityLoadValue, LoadPair } from './EntityLoadInterfaces';
@@ -21,18 +25,28 @@ import IEntityMetricsAdapter, {
 } from '../metrics/IEntityMetricsAdapter';
 import { computeIfAbsent } from '../utils/collections/maps';
 
+type DataLoaderMap<TFields extends Record<string, any>> = Map<
+  string,
+  DataLoader<unknown, readonly Readonly<TFields>[]>
+>;
+
 /**
  * A data manager is responsible for orchestrating multiple sources of entity
  * data including local caches, EntityCacheAdapter, and EntityDatabaseAdapter.
  *
  * It is also responsible for invalidating all sources of data when mutated using EntityMutator.
+ *
+ * @internal
  */
 export default class EntityDataManager<
   TFields extends Record<string, any>,
   TIDField extends keyof TFields,
 > {
-  private readonly dataloaders: Map<string, DataLoader<unknown, readonly Readonly<TFields>[]>> =
-    new Map();
+  // map from (load method type + data manager data loader key) to dataloader
+  private readonly dataLoaders: DataLoaderMap<TFields> = new Map();
+
+  // map from transaction id to dataloader map
+  private readonly transactionalDataLoaders: Map<string, DataLoaderMap<TFields>> = new Map();
 
   constructor(
     private readonly databaseAdapter: EntityDatabaseAdapter<TFields, TIDField>,
@@ -48,7 +62,7 @@ export default class EntityDataManager<
     TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
   >(key: TLoadKey): DataLoader<TSerializedLoadValue, readonly Readonly<TFields>[]> {
     return computeIfAbsent(
-      this.dataloaders,
+      this.dataLoaders,
       key.getLoadMethodType() + key.getDataManagerDataLoaderKey(),
       () => {
         return new DataLoader(
@@ -58,7 +72,7 @@ export default class EntityDataManager<
             const values = serializedLoadValues.map((serializedLoadValue) =>
               key.deserializeLoadValue(serializedLoadValue),
             );
-            const objectMap = await this.loadManyForDataLoaderAsync(key, values);
+            const objectMap = await this.loadManyForNonTransactionalDataLoaderAsync(key, values);
             return values.map((value) => objectMap.get(value) ?? []);
           },
         );
@@ -66,7 +80,7 @@ export default class EntityDataManager<
     );
   }
 
-  private async loadManyForDataLoaderAsync<
+  private async loadManyForNonTransactionalDataLoaderAsync<
     TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
     TSerializedLoadValue,
     TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
@@ -76,6 +90,7 @@ export default class EntityDataManager<
   ): Promise<ReadonlyMap<TLoadValue, readonly Readonly<TFields>[]>> {
     this.metricsAdapter.incrementDataManagerLoadCount({
       type: IncrementLoadCountEventType.CACHE,
+      isInTransaction: false,
       fieldValueCount: values.length,
       entityClassName: this.entityClassName,
       loadType: key.getLoadMethodType(),
@@ -84,6 +99,7 @@ export default class EntityDataManager<
     return await this.entityCache.readManyThroughAsync(key, values, async (fetcherValues) => {
       this.metricsAdapter.incrementDataManagerLoadCount({
         type: IncrementLoadCountEventType.DATABASE,
+        isInTransaction: false,
         fieldValueCount: fetcherValues.length,
         entityClassName: this.entityClassName,
         loadType: key.getLoadMethodType(),
@@ -96,6 +112,65 @@ export default class EntityDataManager<
     });
   }
 
+  private getTransactionalDataLoaderForLoadKey<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(
+    queryContext: EntityTransactionalQueryContext,
+    key: TLoadKey,
+  ): DataLoader<TSerializedLoadValue, readonly Readonly<TFields>[]> {
+    const dataLoaderMapForTransaction = computeIfAbsent(
+      this.transactionalDataLoaders,
+      queryContext.transactionId,
+      () => new Map(),
+    );
+    return computeIfAbsent(
+      dataLoaderMapForTransaction,
+      key.getLoadMethodType() + key.getDataManagerDataLoaderKey(),
+      () => {
+        return new DataLoader(
+          async (
+            serializedLoadValues: readonly TSerializedLoadValue[],
+          ): Promise<readonly (readonly TFields[])[]> => {
+            const values = serializedLoadValues.map((serializedLoadValue) =>
+              key.deserializeLoadValue(serializedLoadValue),
+            );
+            const objectMap = await this.loadManyForTransactionalDataLoaderAsync(
+              queryContext,
+              key,
+              values,
+            );
+            return values.map((value) => objectMap.get(value) ?? []);
+          },
+          {
+            // only cache if transactional dataloader caching is enabled for the transactional query context
+            cache: queryContext.transactionalDataLoaderMode === TransactionalDataLoaderMode.ENABLED,
+          },
+        );
+      },
+    );
+  }
+
+  private async loadManyForTransactionalDataLoaderAsync<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(
+    queryContext: EntityTransactionalQueryContext,
+    key: TLoadKey,
+    values: readonly TLoadValue[],
+  ): Promise<ReadonlyMap<TLoadValue, readonly Readonly<TFields>[]>> {
+    this.metricsAdapter.incrementDataManagerLoadCount({
+      type: IncrementLoadCountEventType.DATABASE,
+      isInTransaction: true,
+      fieldValueCount: values.length,
+      entityClassName: this.entityClassName,
+      loadType: key.getLoadMethodType(),
+    });
+    return await this.databaseAdapter.fetchManyWhereAsync(queryContext, key, values);
+  }
+
   /**
    * Load many objects through read-through dataloader (batcher) and cache (optional).
    *
@@ -117,6 +192,7 @@ export default class EntityDataManager<
       this.metricsAdapter,
       EntityMetricsLoadType.LOAD_MANY,
       this.entityClassName,
+      queryContext,
     )(this.loadManyEqualingInternalAsync(queryContext, key, values));
   }
 
@@ -131,18 +207,30 @@ export default class EntityDataManager<
   ): Promise<ReadonlyMap<TLoadValue, readonly Readonly<TFields>[]>> {
     key.validateRuntimeLoadValuesForDataManagerDataLoader(values, this.entityClassName);
 
-    // don't cache when in transaction, as rollbacks complicate things significantly
-    if (queryContext.isInTransaction()) {
+    if (
+      queryContext.isInTransaction() &&
+      queryContext.transactionalDataLoaderMode === TransactionalDataLoaderMode.DISABLED
+    ) {
+      this.metricsAdapter.incrementDataManagerLoadCount({
+        type: IncrementLoadCountEventType.DATABASE,
+        isInTransaction: true,
+        fieldValueCount: values.length,
+        entityClassName: this.entityClassName,
+        loadType: key.getLoadMethodType(),
+      });
       return await this.databaseAdapter.fetchManyWhereAsync(queryContext, key, values);
     }
 
     this.metricsAdapter.incrementDataManagerLoadCount({
       type: IncrementLoadCountEventType.DATALOADER,
+      isInTransaction: queryContext.isInTransaction(),
       fieldValueCount: values.length,
       entityClassName: this.entityClassName,
       loadType: key.getLoadMethodType(),
     });
-    const dataLoader = this.getDataLoaderForLoadKey(key);
+    const dataLoader = queryContext.isInTransaction()
+      ? this.getTransactionalDataLoaderForLoadKey(queryContext, key)
+      : this.getDataLoaderForLoadKey(key);
     const results = await dataLoader.loadMany(values.map((v) => key.serializeLoadValue(v)));
     const [successfulValues, errors] = partitionErrors(results);
     if (errors.length > 0) {
@@ -179,6 +267,7 @@ export default class EntityDataManager<
       this.metricsAdapter,
       EntityMetricsLoadType.LOAD_MANY_EQUALITY_CONJUNCTION,
       this.entityClassName,
+      queryContext,
     )(
       this.databaseAdapter.fetchManyByFieldEqualityConjunctionAsync(
         queryContext,
@@ -207,6 +296,7 @@ export default class EntityDataManager<
       this.metricsAdapter,
       EntityMetricsLoadType.LOAD_MANY_RAW,
       this.entityClassName,
+      queryContext,
     )(
       this.databaseAdapter.fetchManyByRawWhereClauseAsync(
         queryContext,
@@ -226,6 +316,16 @@ export default class EntityDataManager<
     this.getDataLoaderForLoadKey(key).clear(key.serializeLoadValue(value));
   }
 
+  private invalidateOneForTransaction<
+    TLoadKey extends IEntityLoadKey<TFields, TIDField, TSerializedLoadValue, TLoadValue>,
+    TSerializedLoadValue,
+    TLoadValue extends IEntityLoadValue<TSerializedLoadValue>,
+  >(queryContext: EntityTransactionalQueryContext, key: TLoadKey, value: TLoadValue): void {
+    this.getTransactionalDataLoaderForLoadKey(queryContext, key).clear(
+      key.serializeLoadValue(value),
+    );
+  }
+
   /**
    * Invalidate all caches, in-memory or otherwise, for sets of key-value pairs.
    * @param pairs - key-value pairs to invalidate
@@ -233,7 +333,67 @@ export default class EntityDataManager<
   public async invalidateKeyValuePairsAsync(
     pairs: readonly LoadPair<TFields, TIDField, any, any, any>[],
   ): Promise<void> {
-    // TODO(wschurman): check for races with load
     await Promise.all(pairs.map(([key, value]) => this.invalidateOneAsync(key, value)));
   }
+
+  /**
+   * Invalidate all in-memory caches for sets of key-value pairs for all transactions and parent transactions.
+   * @param pairs - key-value pairs to invalidate
+   */
+  public invalidateKeyValuePairsForTransaction(
+    queryContext: EntityTransactionalQueryContext,
+    pairs: readonly LoadPair<TFields, TIDField, any, any, any>[],
+  ): void {
+    if (queryContext.transactionalDataLoaderMode === TransactionalDataLoaderMode.DISABLED) {
+      return;
+    }
+
+    // invalidate all query contexts in transaction tree
+    const outermostTransactionalQueryContext =
+      EntityDataManager.getOutermostTransactionalQueryContextIfInNestedTransaction(queryContext);
+    const allQueryContextsToInvalidate = [
+      outermostTransactionalQueryContext,
+      ...EntityDataManager.getAllDescendantTransactionalQueryContexts(
+        outermostTransactionalQueryContext,
+      ),
+    ];
+    for (const currentQueryContext of allQueryContextsToInvalidate) {
+      for (const [key, value] of pairs) {
+        this.invalidateOneForTransaction(currentQueryContext, key, value);
+      }
+    }
+  }
+
+  /**
+   * Traverse to root of transactional query context tree.
+   */
+  private static getOutermostTransactionalQueryContextIfInNestedTransaction(
+    queryContext: EntityTransactionalQueryContext,
+  ): EntityTransactionalQueryContext {
+    if (queryContext.isInNestedTransaction()) {
+      return EntityDataManager.getOutermostTransactionalQueryContextIfInNestedTransaction(
+        queryContext.parentQueryContext,
+      );
+    } else {
+      return queryContext;
+    }
+  }
+
+  /**
+   * Get a list of all child query contexts recursively for a given query context.
+   */
+  private static getAllDescendantTransactionalQueryContexts(
+    queryContext: EntityTransactionalQueryContext,
+  ): readonly EntityTransactionalQueryContext[] {
+    if (queryContext.childQueryContexts.length === 0) {
+      return [];
+    }
+
+    return queryContext.childQueryContexts.flatMap((childQueryContext) => {
+      return [
+        childQueryContext,
+        ...EntityDataManager.getAllDescendantTransactionalQueryContexts(childQueryContext),
+      ];
+    });
+  }
 }

package/src/internal/EntityFieldTransformationUtils.ts

@@ -3,6 +3,9 @@ import nullthrows from 'nullthrows';
 
 import EntityConfiguration from '../EntityConfiguration';
 
+/**
+ * @internal
+ */
 export interface FieldTransformer<T> {
   /**
    * Transformation to apply when a value is read from an adapter.
@@ -17,9 +20,14 @@ export interface FieldTransformer<T> {
 
 /**
  * Map from concrete EntityFieldDefinition implementation class name to field transformer.
+ *
+ * @internal
  */
 export type FieldTransformerMap = Map<string, FieldTransformer<any>>;
 
+/**
+ * @internal
+ */
 export const getDatabaseFieldForEntityField = <
   TFields extends Record<string, any>,
   TIDField extends keyof TFields,
@@ -32,6 +40,9 @@ export const getDatabaseFieldForEntityField = <
   return databaseField;
 };
 
+/**
+ * @internal
+ */
 export const transformDatabaseObjectToFields = <
   TFields extends Record<string, any>,
   TIDField extends keyof TFields,
@@ -56,6 +67,9 @@ export const transformDatabaseObjectToFields = <
   return fields;
 };
 
+/**
+ * @internal
+ */
 export const transformFieldsToDatabaseObject = <
   TFields extends Record<string, any>,
   TIDField extends keyof TFields,
@@ -79,6 +93,9 @@ export const transformFieldsToDatabaseObject = <
   return databaseObject;
 };
 
+/**
+ * @internal
+ */
 export const transformCacheObjectToFields = <
   TFields extends Record<string, any>,
   TIDField extends keyof TFields,
@@ -100,6 +117,9 @@ export const transformCacheObjectToFields = <
   return fields;
 };
 
+/**
+ * @internal
+ */
 export const transformFieldsToCacheObject = <
   TFields extends Record<string, any>,
   TIDField extends keyof TFields,

package/src/internal/EntityLoadInterfaces.ts

@@ -19,6 +19,8 @@ export enum EntityLoadMethodType {
 /**
  * Interface responsible for defining how the key and corresponding load values behave in the data manager, cache adapter,
  * and database adapter during entity field loading.
+ *
+ * @internal
  */
 export interface IEntityLoadKey<
   TFields extends Record<string, any>,
@@ -117,6 +119,8 @@ export interface IEntityLoadKey<
 
 /**
  * Interface for a load value corresponding to a load key.
+ *
+ * @internal
  */
 export interface IEntityLoadValue<TSerialized> extends ISerializable<TSerialized> {
   toString(): string;
@@ -124,6 +128,8 @@ export interface IEntityLoadValue<TSerialized> extends ISerializable<TSerialized
 
 /**
  * Map from load value interface to value.
+ *
+ * @internal
  */
 export abstract class LoadValueMap<
   TSerialized,
@@ -133,6 +139,8 @@ export abstract class LoadValueMap<
 
 /**
  * Load pair type for a load key and load value.
+ *
+ * @internal
  */
 export type LoadPair<
   TFields extends Record<string, any>,

package/src/internal/EntityTableDataCoordinator.ts

@@ -12,6 +12,8 @@ import IEntityMetricsAdapter from '../metrics/IEntityMetricsAdapter';
  * Responsible for orchestrating fetching and caching of entity data from a
  * table. Note that one instance is shared amongst all entities that read from
  * the table to ensure cross-entity data consistency.
+ *
+ * @internal
  */
 export default class EntityTableDataCoordinator<
   TFields extends Record<string, any>,

package/src/internal/ReadThroughEntityCache.ts

@@ -5,12 +5,18 @@ import IEntityCacheAdapter from '../IEntityCacheAdapter';
 import { IEntityLoadKey, IEntityLoadValue } from './EntityLoadInterfaces';
 import { filterMap } from '../utils/collections/maps';
 
+/**
+ * @internal
+ */
 export enum CacheStatus {
   HIT,
   MISS,
   NEGATIVE,
 }
 
+/**
+ * @internal
+ */
 export type CacheLoadResult<TFields extends Record<string, any>> =
   | {
       status: CacheStatus.HIT;
@@ -26,6 +32,8 @@ export type CacheLoadResult<TFields extends Record<string, any>> =
 /**
  * A read-through entity cache is responsible for coordinating EntityDatabaseAdapter and
  * EntityCacheAdapter within the EntityDataManager.
+ *
+ * @internal
  */
 export default class ReadThroughEntityCache<
   TFields extends Record<string, any>,

package/src/internal/SingleFieldHolder.ts

@@ -11,6 +11,8 @@ import {
 
 /**
  * A load key that represents a single field (fieldName) on an entity.
+ *
+ * @internal
  */
 export class SingleFieldHolder<
   TFields extends Record<string, any>,
@@ -97,6 +99,8 @@ export class SingleFieldHolder<
 
 /**
  * A load value for a SingleFieldHolder.
+ *
+ * @internal
  */
 export class SingleFieldValueHolder<TFields extends Record<string, any>, N extends keyof TFields>
   implements IEntityLoadValue<NonNullable<TFields[N]>>
@@ -118,6 +122,9 @@ export class SingleFieldValueHolder<TFields extends Record<string, any>, N exten
   }
 }
 
+/**
+ * @internal
+ */
 export class SingleFieldValueHolderMap<
   TFields extends Record<string, any>,
   N extends keyof TFields,