@expo/entity 0.35.0 → 0.37.0

package/src/IEntityCacheAdapterProvider.ts

@@ -9,7 +9,7 @@ export default interface IEntityCacheAdapterProvider {
   /**
    * Vend a cache adapter for an entity configuration.
    */
-  getCacheAdapter<TFields>(
-    entityConfiguration: EntityConfiguration<TFields>
+  getCacheAdapter<TFields extends Record<string, any>>(
+    entityConfiguration: EntityConfiguration<TFields>,
   ): IEntityCacheAdapter<TFields>;
 }

package/src/IEntityDatabaseAdapterProvider.ts

@@ -9,7 +9,7 @@ export default interface IEntityDatabaseAdapterProvider {
   /**
    * Vend a database adapter.
    */
-  getDatabaseAdapter<TFields>(
-    entityConfiguration: EntityConfiguration<TFields>
+  getDatabaseAdapter<TFields extends Record<string, any>>(
+    entityConfiguration: EntityConfiguration<TFields>,
   ): EntityDatabaseAdapter<TFields>;
 }

package/src/ReadonlyEntity.ts

@@ -19,7 +19,7 @@ export default abstract class ReadonlyEntity<
   TFields extends object,
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,
-  TSelectedFields extends keyof TFields = keyof TFields
+  TSelectedFields extends keyof TFields = keyof TFields,
 > {
   private readonly viewerContext: TViewerContext;
   private readonly id: TID;
@@ -100,7 +100,7 @@ export default abstract class ReadonlyEntity<
    * @returns the value of the field or undefined if not loaded with that field
    */
   getField<K extends keyof Pick<TFields, TSelectedFields>>(
-    fieldName: K
+    fieldName: K,
   ): Pick<TFields, TSelectedFields>[K] {
     return this.selectedFields[fieldName];
   }
@@ -137,7 +137,7 @@ export default abstract class ReadonlyEntity<
       TMEntity,
       TMSelectedFields
     >,
-    TMSelectedFields extends keyof TMFields = keyof TMFields
+    TMSelectedFields extends keyof TMFields = keyof TMFields,
   >(
     this: IEntityClass<
       TMFields,
@@ -151,11 +151,11 @@ export default abstract class ReadonlyEntity<
     queryContext: EntityQueryContext = viewerContext
       .getViewerScopedEntityCompanionForClass(this)
       .getQueryContextProvider()
-      .getQueryContext()
+      .getQueryContext(),
   ): EntityLoader<TMFields, TMID, TMViewerContext, TMEntity, TMPrivacyPolicy, TMSelectedFields> {
     return viewerContext
       .getViewerScopedEntityCompanionForClass(this)
       .getLoaderFactory()
-      .forLoad(queryContext, { cascadingDeleteCause: null });
+      .forLoad(queryContext, { previousValue: null, cascadingDeleteCause: null });
   }
 }

package/src/ViewerContext.ts

@@ -22,7 +22,7 @@ export default class ViewerContext {
   constructor(public readonly entityCompanionProvider: EntityCompanionProvider) {
     this.viewerScopedEntityCompanionProvider = new ViewerScopedEntityCompanionProvider(
       entityCompanionProvider,
-      this
+      this,
     );
   }
 
@@ -42,7 +42,7 @@ export default class ViewerContext {
       TMEntity,
       TMSelectedFields
     >,
-    TMSelectedFields extends keyof TMFields
+    TMSelectedFields extends keyof TMFields,
   >(
     entityClass: IEntityClass<
       TMFields,
@@ -51,7 +51,7 @@ export default class ViewerContext {
       TMEntity,
       TMPrivacyPolicy,
       TMSelectedFields
-    >
+    >,
   ): ViewerScopedEntityCompanion<
     TMFields,
     TMID,
@@ -68,7 +68,7 @@ export default class ViewerContext {
    * @param databaseAdaptorFlavor - database adaptor flavor
    */
   getQueryContextForDatabaseAdaptorFlavor(
-    databaseAdaptorFlavor: DatabaseAdapterFlavor
+    databaseAdaptorFlavor: DatabaseAdapterFlavor,
   ): EntityQueryContext {
     return this.entityCompanionProvider
       .getQueryContextProviderForDatabaseAdaptorFlavor(databaseAdaptorFlavor)
@@ -84,7 +84,7 @@ export default class ViewerContext {
   async runInTransactionForDatabaseAdaptorFlavorAsync<TResult>(
     databaseAdaptorFlavor: DatabaseAdapterFlavor,
     transactionScope: (queryContext: EntityTransactionalQueryContext) => Promise<TResult>,
-    transactionConfig?: TransactionConfig
+    transactionConfig?: TransactionConfig,
   ): Promise<TResult> {
     return await this.entityCompanionProvider
       .getQueryContextProviderForDatabaseAdaptorFlavor(databaseAdaptorFlavor)

package/src/ViewerScopedEntityCompanion.ts

@@ -23,7 +23,7 @@ export default class ViewerScopedEntityCompanion<
     TEntity,
     TSelectedFields
   >,
-  TSelectedFields extends keyof TFields
+  TSelectedFields extends keyof TFields,
 > {
   constructor(
     public readonly entityCompanion: EntityCompanion<
@@ -34,7 +34,7 @@ export default class ViewerScopedEntityCompanion<
       TPrivacyPolicy,
       TSelectedFields
     >,
-    private readonly viewerContext: TViewerContext
+    private readonly viewerContext: TViewerContext,
   ) {}
 
   /**
@@ -50,7 +50,7 @@ export default class ViewerScopedEntityCompanion<
   > {
     return new ViewerScopedEntityLoaderFactory(
       this.entityCompanion.getLoaderFactory(),
-      this.viewerContext
+      this.viewerContext,
     );
   }
 
@@ -67,7 +67,7 @@ export default class ViewerScopedEntityCompanion<
   > {
     return new ViewerScopedEntityMutatorFactory(
       this.entityCompanion.getMutatorFactory(),
-      this.viewerContext
+      this.viewerContext,
     );
   }
 

package/src/ViewerScopedEntityCompanionProvider.ts

@@ -11,7 +11,7 @@ import ViewerScopedEntityCompanion from './ViewerScopedEntityCompanion';
 export default class ViewerScopedEntityCompanionProvider {
   constructor(
     private readonly entityCompanionProvider: EntityCompanionProvider,
-    private readonly viewerContext: ViewerContext
+    private readonly viewerContext: ViewerContext,
   ) {}
 
   /**
@@ -19,7 +19,6 @@ export default class ViewerScopedEntityCompanionProvider {
    * companion is constructed using the configuration provided by the factory.
    *
    * @param entityClass - entity class to load
-   * @param entityCompanionDefinitionFn - function defining entity companion definition
    */
   getViewerScopedCompanionForEntity<
     TFields extends object,
@@ -33,7 +32,7 @@ export default class ViewerScopedEntityCompanionProvider {
       TEntity,
       TSelectedFields
     >,
-    TSelectedFields extends keyof TFields
+    TSelectedFields extends keyof TFields,
   >(
     entityClass: IEntityClass<
       TFields,
@@ -42,7 +41,7 @@ export default class ViewerScopedEntityCompanionProvider {
       TEntity,
       TPrivacyPolicy,
       TSelectedFields
-    >
+    >,
   ): ViewerScopedEntityCompanion<
     TFields,
     TID,
@@ -53,7 +52,7 @@ export default class ViewerScopedEntityCompanionProvider {
   > {
     return new ViewerScopedEntityCompanion(
       this.entityCompanionProvider.getCompanionForEntity(entityClass),
-      this.viewerContext as TViewerContext
+      this.viewerContext as TViewerContext,
     );
   }
 }

package/src/ViewerScopedEntityLoaderFactory.ts

@@ -20,7 +20,7 @@ export default class ViewerScopedEntityLoaderFactory<
     TEntity,
     TSelectedFields
   >,
-  TSelectedFields extends keyof TFields
+  TSelectedFields extends keyof TFields,
 > {
   constructor(
     private readonly entityLoaderFactory: EntityLoaderFactory<
@@ -31,17 +31,23 @@ export default class ViewerScopedEntityLoaderFactory<
       TPrivacyPolicy,
       TSelectedFields
     >,
-    private readonly viewerContext: TViewerContext
+    private readonly viewerContext: TViewerContext,
   ) {}
 
   forLoad(
     queryContext: EntityQueryContext,
-    privacyPolicyEvaluationContext: EntityPrivacyPolicyEvaluationContext
+    privacyPolicyEvaluationContext: EntityPrivacyPolicyEvaluationContext<
+      TFields,
+      TID,
+      TViewerContext,
+      TEntity,
+      TSelectedFields
+    >,
   ): EntityLoader<TFields, TID, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields> {
     return this.entityLoaderFactory.forLoad(
       this.viewerContext,
       queryContext,
-      privacyPolicyEvaluationContext
+      privacyPolicyEvaluationContext,
     );
   }
 }

package/src/ViewerScopedEntityMutatorFactory.ts

@@ -20,7 +20,7 @@ export default class ViewerScopedEntityMutatorFactory<
     TEntity,
     TSelectedFields
   >,
-  TSelectedFields extends keyof TFields
+  TSelectedFields extends keyof TFields,
 > {
   constructor(
     private readonly entityMutatorFactory: EntityMutatorFactory<
@@ -31,25 +31,25 @@ export default class ViewerScopedEntityMutatorFactory<
       TPrivacyPolicy,
       TSelectedFields
     >,
-    private readonly viewerContext: TViewerContext
+    private readonly viewerContext: TViewerContext,
   ) {}
 
   forCreate(
-    queryContext: EntityQueryContext
+    queryContext: EntityQueryContext,
   ): CreateMutator<TFields, TID, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields> {
     return this.entityMutatorFactory.forCreate(this.viewerContext, queryContext);
   }
 
   forUpdate(
     existingEntity: TEntity,
-    queryContext: EntityQueryContext
+    queryContext: EntityQueryContext,
   ): UpdateMutator<TFields, TID, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields> {
     return this.entityMutatorFactory.forUpdate(existingEntity, queryContext);
   }
 
   forDelete(
     existingEntity: TEntity,
-    queryContext: EntityQueryContext
+    queryContext: EntityQueryContext,
   ): DeleteMutator<TFields, TID, TViewerContext, TEntity, TPrivacyPolicy, TSelectedFields> {
     return this.entityMutatorFactory.forDelete(existingEntity, queryContext);
   }

package/src/__tests__/ComposedCacheAdapter-test.ts

@@ -23,18 +23,20 @@ const entityConfiguration = new EntityConfiguration<BlahFields>({
 export const DOES_NOT_EXIST_LOCAL_MEMORY_CACHE = Symbol('doesNotExist');
 type LocalMemoryCacheValue<TFields> = Readonly<TFields> | typeof DOES_NOT_EXIST_LOCAL_MEMORY_CACHE;
 
-class TestLocalCacheAdapter<TFields> implements IEntityCacheAdapter<TFields> {
+class TestLocalCacheAdapter<TFields extends Record<string, any>>
+  implements IEntityCacheAdapter<TFields>
+{
   constructor(
     private readonly entityConfiguration: EntityConfiguration<TFields>,
-    private readonly cache: Map<string, LocalMemoryCacheValue<TFields>>
+    private readonly cache: Map<string, LocalMemoryCacheValue<TFields>>,
   ) {}
 
   public async loadManyAsync<N extends keyof TFields>(
     fieldName: N,
-    fieldValues: readonly NonNullable<TFields[N]>[]
+    fieldValues: readonly NonNullable<TFields[N]>[],
   ): Promise<ReadonlyMap<NonNullable<TFields[N]>, CacheLoadResult<TFields>>> {
     const localMemoryCacheKeyToFieldValueMapping = new Map(
-      fieldValues.map((fieldValue) => [this.makeCacheKey(fieldName, fieldValue), fieldValue])
+      fieldValues.map((fieldValue) => [this.makeCacheKey(fieldName, fieldValue), fieldValue]),
     );
     const cacheResults = new Map<NonNullable<TFields[N]>, CacheLoadResult<TFields>>();
     for (const [cacheKey, fieldValue] of localMemoryCacheKeyToFieldValueMapping) {
@@ -60,7 +62,7 @@ class TestLocalCacheAdapter<TFields> implements IEntityCacheAdapter<TFields> {
 
   public async cacheManyAsync<N extends keyof TFields>(
     fieldName: N,
-    objectMap: ReadonlyMap<NonNullable<TFields[N]>, Readonly<TFields>>
+    objectMap: ReadonlyMap<NonNullable<TFields[N]>, Readonly<TFields>>,
   ): Promise<void> {
     for (const [fieldValue, item] of objectMap) {
       const cacheKey = this.makeCacheKey(fieldName, fieldValue);
@@ -70,7 +72,7 @@ class TestLocalCacheAdapter<TFields> implements IEntityCacheAdapter<TFields> {
 
   public async cacheDBMissesAsync<N extends keyof TFields>(
     fieldName: N,
-    fieldValues: readonly NonNullable<TFields[N]>[]
+    fieldValues: readonly NonNullable<TFields[N]>[],
   ): Promise<void> {
     for (const fieldValue of fieldValues) {
       const cacheKey = this.makeCacheKey(fieldName, fieldValue);
@@ -80,7 +82,7 @@ class TestLocalCacheAdapter<TFields> implements IEntityCacheAdapter<TFields> {
 
   public async invalidateManyAsync<N extends keyof TFields>(
     fieldName: N,
-    fieldValues: readonly NonNullable<TFields[N]>[]
+    fieldValues: readonly NonNullable<TFields[N]>[],
   ): Promise<void> {
     for (const fieldValue of fieldValues) {
       const cacheKey = this.makeCacheKey(fieldName, fieldValue);
@@ -90,7 +92,7 @@ class TestLocalCacheAdapter<TFields> implements IEntityCacheAdapter<TFields> {
 
   private makeCacheKey<N extends keyof TFields>(
     fieldName: N,
-    fieldValue: NonNullable<TFields[N]>
+    fieldValue: NonNullable<TFields[N]>,
   ): string {
     const columnName = this.entityConfiguration.entityToDBFieldsKeyMapping.get(fieldName);
     invariant(columnName, `database field mapping missing for ${String(fieldName)}`);
@@ -102,7 +104,7 @@ class TestLocalCacheAdapter<TFields> implements IEntityCacheAdapter<TFields> {
     ];
     const delimiter = ':';
     const escapedParts = parts.map((part) =>
-      part.replace('\\', '\\\\').replace(delimiter, `\\${delimiter}`)
+      part.replace('\\', '\\\\').replace(delimiter, `\\${delimiter}`),
     );
     return escapedParts.join(delimiter);
   }
@@ -271,7 +273,7 @@ describe(ComposedEntityCacheAdapter, () => {
 
       const fallbackLocalMemoryCacheKey = fallbackCacheAdapter['makeCacheKey']('id', 'test-id-1');
       expect(fallbackCache.get(fallbackLocalMemoryCacheKey)).toBe(
-        DOES_NOT_EXIST_LOCAL_MEMORY_CACHE
+        DOES_NOT_EXIST_LOCAL_MEMORY_CACHE,
       );
     });
   });

package/src/__tests__/ComposedSecondaryEntityCache-test.ts

@@ -9,14 +9,14 @@ type TestLoadParams = { lp: string };
 
 class TestEntitySecondaryCache implements ISecondaryEntityCache<TestFields, TestLoadParams> {
   constructor(
-    private readonly prefilledResults: Map<Readonly<TestLoadParams>, Readonly<TestFields>>
+    private readonly prefilledResults: Map<Readonly<TestLoadParams>, Readonly<TestFields>>,
   ) {}
 
   async loadManyThroughAsync(
     loadParamsArray: readonly Readonly<TestLoadParams>[],
     fetcher: (
-      fetcherLoadParamsArray: readonly Readonly<TestLoadParams>[]
-    ) => Promise<ReadonlyMap<Readonly<TestLoadParams>, Readonly<TestFields> | null>>
+      fetcherLoadParamsArray: readonly Readonly<TestLoadParams>[],
+    ) => Promise<ReadonlyMap<Readonly<TestLoadParams>, Readonly<TestFields> | null>>,
   ): Promise<ReadonlyMap<Readonly<TestLoadParams>, Readonly<TestFields> | null>> {
     // this does an unusual method of calling fetcher, but there's no constraint that says fetcher can only be called once
     // so this tests that
@@ -50,10 +50,10 @@ describe(ComposedSecondaryEntityCache, () => {
     const lp3 = { lp: '3' };
 
     const primarySecondaryEntityCache = new TestEntitySecondaryCache(
-      new Map([[lp1, { id: 'primary-1' }]])
+      new Map([[lp1, { id: 'primary-1' }]]),
     );
     const fallbackSecondaryEntityCache = new TestEntitySecondaryCache(
-      new Map([[lp2, { id: 'fallback-2' }]])
+      new Map([[lp2, { id: 'fallback-2' }]]),
     );
 
     const composedSecondaryEntityCache = new ComposedSecondaryEntityCache([
@@ -64,7 +64,7 @@ describe(ComposedSecondaryEntityCache, () => {
     const results = await composedSecondaryEntityCache.loadManyThroughAsync(
       [lp1, lp2, lp3],
       async (fetcherLoadParamsArray) =>
-        new Map(fetcherLoadParamsArray.map((flp) => [flp, { id: `db-fetched-${flp.lp}` }]))
+        new Map(fetcherLoadParamsArray.map((flp) => [flp, { id: `db-fetched-${flp.lp}` }])),
     );
 
     expect(results.get(lp1)).toEqual({ id: 'primary-1' });
@@ -76,7 +76,7 @@ describe(ComposedSecondaryEntityCache, () => {
     const resultsAfterInvalidate = await composedSecondaryEntityCache.loadManyThroughAsync(
       [lp1, lp2, lp3],
       async (fetcherLoadParamsArray) =>
-        new Map(fetcherLoadParamsArray.map((flp) => [flp, { id: `db-fetched-${flp.lp}` }]))
+        new Map(fetcherLoadParamsArray.map((flp) => [flp, { id: `db-fetched-${flp.lp}` }])),
     );
 
     expect(resultsAfterInvalidate.get(lp1)).toEqual({ id: 'db-fetched-1' });
@@ -93,7 +93,7 @@ describe(ComposedSecondaryEntityCache, () => {
     const results = await composedSecondaryEntityCache.loadManyThroughAsync(
       [lp1],
       async (fetcherLoadParamsArray) =>
-        new Map(fetcherLoadParamsArray.map((flp) => [flp, { id: `db-fetched-${flp.lp}` }]))
+        new Map(fetcherLoadParamsArray.map((flp) => [flp, { id: `db-fetched-${flp.lp}` }])),
     );
 
     expect(results.get(lp1)).toEqual({ id: 'db-fetched-1' });