@expo/entity 0.43.0 → 0.44.0

package/src/__tests__/EntityQueryContext-test.ts

@@ -1,7 +1,18 @@
+import assert from 'assert';
 import invariant from 'invariant';
 
-import { EntityQueryContext, TransactionIsolationLevel } from '../EntityQueryContext';
+import EntityCompanionProvider from '../EntityCompanionProvider';
+import {
+  EntityQueryContext,
+  TransactionalDataLoaderMode,
+  TransactionConfig,
+  TransactionIsolationLevel,
+} from '../EntityQueryContext';
+import EntityQueryContextProvider from '../EntityQueryContextProvider';
 import ViewerContext from '../ViewerContext';
+import NoOpEntityMetricsAdapter from '../metrics/NoOpEntityMetricsAdapter';
+import { InMemoryFullCacheStubCacheAdapterProvider } from '../utils/__testfixtures__/StubCacheAdapter';
+import StubDatabaseAdapterProvider from '../utils/__testfixtures__/StubDatabaseAdapterProvider';
 import { createUnitTestEntityCompanionProvider } from '../utils/__testfixtures__/createUnitTestEntityCompanionProvider';
 
 describe(EntityQueryContext, () => {
@@ -89,7 +100,9 @@ describe(EntityQueryContext, () => {
         throw new Error('wat');
       });
       const postCommitInvalidationCallback = jest.fn(async (): Promise<void> => {});
+      const postCommitNestedInvalidationCallback = jest.fn(async (): Promise<void> => {});
       const postCommitCallback = jest.fn(async (): Promise<void> => {});
+      const postCommitNestedCallback = jest.fn(async (): Promise<void> => {});
 
       await viewerContext.runInTransactionForDatabaseAdaptorFlavorAsync(
         'postgres',
@@ -100,19 +113,19 @@ describe(EntityQueryContext, () => {
 
           await Promise.all([
             queryContext.runInNestedTransactionAsync(async (innerQueryContext) => {
-              innerQueryContext.appendPostCommitCallback(postCommitCallback);
+              innerQueryContext.appendPostCommitCallback(postCommitNestedCallback);
               innerQueryContext.appendPostCommitInvalidationCallback(
-                postCommitInvalidationCallback,
+                postCommitNestedInvalidationCallback,
               );
               innerQueryContext.appendPreCommitCallback(preCommitNestedCallback, 0);
             }),
             (async () => {
               try {
                 await queryContext.runInNestedTransactionAsync(async (innerQueryContext) => {
-                  // these two shouldn't be called
-                  innerQueryContext.appendPostCommitCallback(postCommitCallback);
+                  // these two shouldn't be called due to throwing pre-commit callback
+                  innerQueryContext.appendPostCommitCallback(postCommitNestedCallback);
                   innerQueryContext.appendPostCommitInvalidationCallback(
-                    postCommitInvalidationCallback,
+                    postCommitNestedInvalidationCallback,
                   );
                   innerQueryContext.appendPreCommitCallback(preCommitNestedCallbackThrow, 0);
                 });
@@ -125,26 +138,10 @@ describe(EntityQueryContext, () => {
       expect(preCommitCallback).toHaveBeenCalledTimes(1);
       expect(preCommitNestedCallback).toHaveBeenCalledTimes(1);
       expect(preCommitNestedCallbackThrow).toHaveBeenCalledTimes(1);
-      expect(postCommitCallback).toHaveBeenCalledTimes(2);
-      expect(postCommitInvalidationCallback).toHaveBeenCalledTimes(2);
-    });
-
-    it('does not support calling runPostCommitCallbacksAsync on nested transaction', async () => {
-      const companionProvider = createUnitTestEntityCompanionProvider();
-      const viewerContext = new ViewerContext(companionProvider);
-
-      await expect(
-        viewerContext.runInTransactionForDatabaseAdaptorFlavorAsync(
-          'postgres',
-          async (queryContext) => {
-            await queryContext.runInNestedTransactionAsync(async (innerQueryContext) => {
-              await innerQueryContext.runPostCommitCallbacksAsync();
-            });
-          },
-        ),
-      ).rejects.toThrowError(
-        'Must not call runPostCommitCallbacksAsync on EntityNestedTransactionalQueryContext',
-      );
+      expect(postCommitCallback).toHaveBeenCalledTimes(1);
+      expect(postCommitInvalidationCallback).toHaveBeenCalledTimes(1);
+      expect(postCommitNestedInvalidationCallback).toHaveBeenCalledTimes(2);
+      expect(postCommitNestedCallback).toHaveBeenCalledTimes(1);
     });
   });
 
@@ -168,5 +165,123 @@ describe(EntityQueryContext, () => {
 
       expect(queryContextProviderSpy).toHaveBeenCalledWith(transactionScopeFn, transactionConfig);
     });
+
+    it('makes the result query context enable/disable transactional dataloaders', async () => {
+      const companionProvider = createUnitTestEntityCompanionProvider();
+      const viewerContext = new ViewerContext(companionProvider);
+
+      await viewerContext.runInTransactionForDatabaseAdaptorFlavorAsync(
+        'postgres',
+        async (queryContext) => {
+          assert(queryContext.isInTransaction());
+          expect(queryContext.transactionalDataLoaderMode).toBe(
+            TransactionalDataLoaderMode.DISABLED,
+          );
+        },
+        { transactionalDataLoaderMode: TransactionalDataLoaderMode.DISABLED },
+      );
+
+      await viewerContext.runInTransactionForDatabaseAdaptorFlavorAsync(
+        'postgres',
+        async (queryContext) => {
+          assert(queryContext.isInTransaction());
+          expect(queryContext.transactionalDataLoaderMode).toBe(
+            TransactionalDataLoaderMode.ENABLED_BATCH_ONLY,
+          );
+        },
+        { transactionalDataLoaderMode: TransactionalDataLoaderMode.ENABLED_BATCH_ONLY },
+      );
+
+      await viewerContext.runInTransactionForDatabaseAdaptorFlavorAsync(
+        'postgres',
+        async (queryContext) => {
+          assert(queryContext.isInTransaction());
+          expect(queryContext.transactionalDataLoaderMode).toBe(
+            TransactionalDataLoaderMode.ENABLED,
+          );
+        },
+      );
+    });
+  });
+
+  describe('global defaultTransactionalDataLoaderMode', () => {
+    class StubQueryContextProviderWithDisabledTransactionalDataLoaders extends EntityQueryContextProvider {
+      protected getQueryInterface(): any {
+        return {};
+      }
+
+      protected override defaultTransactionalDataLoaderMode(): TransactionalDataLoaderMode {
+        return TransactionalDataLoaderMode.DISABLED;
+      }
+
+      protected createTransactionRunner<T>(
+        _transactionConfig?: TransactionConfig,
+      ): (transactionScope: (queryInterface: any) => Promise<T>) => Promise<T> {
+        return (transactionScope) => Promise.resolve(transactionScope({}));
+      }
+
+      protected createNestedTransactionRunner<T>(
+        _outerQueryInterface: any,
+      ): (transactionScope: (queryInterface: any) => Promise<T>) => Promise<T> {
+        return (transactionScope) => Promise.resolve(transactionScope({}));
+      }
+    }
+
+    it('respects the global setting but allows overriding by transaction config', async () => {
+      const companionProvider = new EntityCompanionProvider(
+        new NoOpEntityMetricsAdapter(),
+        new Map([
+          [
+            'postgres',
+            {
+              adapterProvider: new StubDatabaseAdapterProvider(),
+              queryContextProvider:
+                new StubQueryContextProviderWithDisabledTransactionalDataLoaders(),
+            },
+          ],
+        ]),
+        new Map([
+          [
+            'redis',
+            {
+              cacheAdapterProvider: new InMemoryFullCacheStubCacheAdapterProvider(),
+            },
+          ],
+        ]),
+      );
+      const viewerContext = new ViewerContext(companionProvider);
+
+      await viewerContext.runInTransactionForDatabaseAdaptorFlavorAsync(
+        'postgres',
+        async (queryContext) => {
+          assert(queryContext.isInTransaction());
+          expect(queryContext.transactionalDataLoaderMode).toBe(
+            TransactionalDataLoaderMode.DISABLED,
+          );
+        },
+        { transactionalDataLoaderMode: TransactionalDataLoaderMode.DISABLED },
+      );
+
+      await viewerContext.runInTransactionForDatabaseAdaptorFlavorAsync(
+        'postgres',
+        async (queryContext) => {
+          assert(queryContext.isInTransaction());
+          expect(queryContext.transactionalDataLoaderMode).toBe(
+            TransactionalDataLoaderMode.ENABLED_BATCH_ONLY,
+          );
+        },
+        { transactionalDataLoaderMode: TransactionalDataLoaderMode.ENABLED_BATCH_ONLY },
+      );
+
+      await viewerContext.runInTransactionForDatabaseAdaptorFlavorAsync(
+        'postgres',
+        async (queryContext) => {
+          assert(queryContext.isInTransaction());
+          expect(queryContext.transactionalDataLoaderMode).toBe(
+            TransactionalDataLoaderMode.DISABLED,
+          );
+        },
+      );
+    });
   });
 });

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>,