@expo/entity 0.35.0 → 0.36.0

package/src/internal/__tests__/EntityFieldTransformationUtils-test.ts

@@ -44,10 +44,10 @@ const blahEntityConfiguration = new EntityConfiguration<BlahT>({
 describe(getDatabaseFieldForEntityField, () => {
   it('returns correct mapping', () => {
     expect(getDatabaseFieldForEntityField(blahEntityConfiguration, 'cacheable')).toEqual(
-      'cacheable'
+      'cacheable',
     );
     expect(
-      getDatabaseFieldForEntityField(blahEntityConfiguration, 'uniqueButNotCacheable')
+      getDatabaseFieldForEntityField(blahEntityConfiguration, 'uniqueButNotCacheable'),
     ).toEqual('unique_but_not_cacheable');
   });
 });
@@ -59,7 +59,7 @@ describe(transformDatabaseObjectToFields, () => {
         id: 'blah',
         unique_but_not_cacheable: 'wat',
         who: 'why',
-      })
+      }),
     ).toEqual({
       id: 'blah',
       uniqueButNotCacheable: 'wat',
@@ -79,7 +79,7 @@ describe(transformDatabaseObjectToFields, () => {
     expect(
       transformDatabaseObjectToFields(blahEntityConfiguration, fieldTransformMap, {
         transform_read: 'wat',
-      })
+      }),
     ).toEqual({
       transformRead: 'wat-read-transformed',
     });
@@ -93,7 +93,7 @@ describe(transformFieldsToDatabaseObject, () => {
         id: 'blah',
         cacheable: 'wat',
         uniqueButNotCacheable: 'wat',
-      })
+      }),
     ).toEqual({
       id: 'blah',
       cacheable: 'wat',
@@ -114,7 +114,7 @@ describe(transformFieldsToDatabaseObject, () => {
     expect(
       transformFieldsToDatabaseObject(blahEntityConfiguration, fieldTransformMap, {
         transformWrite: 'wat',
-      })
+      }),
     ).toEqual({
       transform_write: 'wat-write-transformed',
     });
@@ -122,7 +122,7 @@ describe(transformFieldsToDatabaseObject, () => {
 });
 
 describe(transformCacheObjectToFields, () => {
-  it('does field read transformation', () => {
+  it('does field read transformation, keeping unknown fields for cache version inconsistencies', () => {
     const fieldTransformMap = new Map([
       [
         StringField.name,
@@ -136,16 +136,18 @@ describe(transformCacheObjectToFields, () => {
       transformCacheObjectToFields(blahEntityConfiguration, fieldTransformMap, {
         id: 'hello',
         transformRead: 'wat',
-      })
+        unknownField: 'who',
+      }),
     ).toEqual({
       id: 'hello',
       transformRead: 'wat-read-transformed-cache',
+      unknownField: 'who',
     });
   });
 });
 
 describe(transformFieldsToCacheObject, () => {
-  it('does field write transformation', () => {
+  it('does field write transformation, keeping unknown fields at runtime for cache version inconsistencies', () => {
     const fieldTransformMap = new Map([
       [
         StringField.name,
@@ -159,10 +161,12 @@ describe(transformFieldsToCacheObject, () => {
       transformFieldsToCacheObject(blahEntityConfiguration, fieldTransformMap, {
         id: 'hello',
         transformWrite: 'wat',
-      })
+        unknownField: 'who',
+      } as any),
     ).toEqual({
       id: 'hello',
       transformWrite: 'wat-write-transformed-cache',
+      unknownField: 'who',
     });
   });
 });

package/src/internal/__tests__/ReadThroughEntityCache-test.ts

@@ -23,7 +23,7 @@ const makeEntityConfiguration = (cacheIdField: boolean): EntityConfiguration<Bla
 const createIdFetcher =
   (ids: string[]) =>
   async <N extends keyof BlahFields>(
-    fetcherFieldValues: readonly NonNullable<BlahFields[N]>[]
+    fetcherFieldValues: readonly NonNullable<BlahFields[N]>[],
   ): Promise<ReadonlyMap<NonNullable<BlahFields[N]>, readonly Readonly<BlahFields>[]>> => {
     const results = new Map();
     fetcherFieldValues.forEach((v) => {
@@ -36,6 +36,22 @@ const createIdFetcher =
     return results;
   };
 
+const createFetcherNonUnique =
+  (ids: string[]) =>
+  async <N extends keyof BlahFields>(
+    fetcherFieldValues: readonly NonNullable<BlahFields[N]>[],
+  ): Promise<ReadonlyMap<NonNullable<BlahFields[N]>, readonly Readonly<BlahFields>[]>> => {
+    const results = new Map();
+    fetcherFieldValues.forEach((v) => {
+      if (ids.includes(v)) {
+        results.set(v, [{ id: v }, { id: v + '2' }]);
+      } else {
+        results.set(v, []);
+      }
+    });
+    return results;
+  };
+
 describe(ReadThroughEntityCache, () => {
   describe('readManyThroughAsync', () => {
     it('fetches from DB upon cache miss and caches the result', async () => {
@@ -48,7 +64,7 @@ describe(ReadThroughEntityCache, () => {
         new Map([
           ['wat', { status: CacheStatus.MISS }],
           ['who', { status: CacheStatus.MISS }],
-        ])
+        ]),
       );
 
       const result = await entityCache.readManyThroughAsync('id', ['wat', 'who'], fetcher);
@@ -61,16 +77,16 @@ describe(ReadThroughEntityCache, () => {
             new Map([
               ['wat', { id: 'wat' }],
               ['who', { id: 'who' }],
-            ])
-          )
-        )
+            ]),
+          ),
+        ),
       ).once();
       verify(cacheAdapterMock.cacheDBMissesAsync('id', deepEqual([]))).once();
       expect(result).toEqual(
         new Map([
           ['wat', [{ id: 'wat' }]],
           ['who', [{ id: 'who' }]],
-        ])
+        ]),
       );
     });
 
@@ -84,7 +100,7 @@ describe(ReadThroughEntityCache, () => {
         new Map([
           ['wat', { status: CacheStatus.HIT, item: { id: 'wat' } }],
           ['who', { status: CacheStatus.HIT, item: { id: 'who' } }],
-        ])
+        ]),
       );
 
       const result = await entityCache.readManyThroughAsync('id', ['wat', 'who'], fetcher);
@@ -97,16 +113,16 @@ describe(ReadThroughEntityCache, () => {
             new Map([
               ['wat', { id: 'wat' }],
               ['who', { id: 'who' }],
-            ])
-          )
-        )
+            ]),
+          ),
+        ),
       ).never();
       verify(cacheAdapterMock.cacheDBMissesAsync('id', deepEqual([]))).never();
       expect(result).toEqual(
         new Map([
           ['wat', [{ id: 'wat' }]],
           ['who', [{ id: 'who' }]],
-        ])
+        ]),
       );
     });
 
@@ -119,7 +135,7 @@ describe(ReadThroughEntityCache, () => {
       const fetcher = createIdFetcher(['wat', 'who']);
 
       when(cacheAdapterMock.loadManyAsync('id', deepEqual(['why']))).thenResolve(
-        new Map([['why', { status: CacheStatus.MISS }]])
+        new Map([['why', { status: CacheStatus.MISS }]]),
       );
 
       const result = await entityCache.readManyThroughAsync('id', ['why'], fetcher);
@@ -137,7 +153,7 @@ describe(ReadThroughEntityCache, () => {
       const fetcher = createIdFetcher([]);
 
       when(cacheAdapterMock.loadManyAsync('id', deepEqual(['why']))).thenResolve(
-        new Map([['why', { status: CacheStatus.NEGATIVE }]])
+        new Map([['why', { status: CacheStatus.NEGATIVE }]]),
       );
 
       const result = await entityCache.readManyThroughAsync('id', ['why'], fetcher);
@@ -154,31 +170,31 @@ describe(ReadThroughEntityCache, () => {
       const fetcher = createIdFetcher(['wat', 'who', 'why']);
 
       when(
-        cacheAdapterMock.loadManyAsync('id', deepEqual(['wat', 'who', 'why', 'how']))
+        cacheAdapterMock.loadManyAsync('id', deepEqual(['wat', 'who', 'why', 'how'])),
       ).thenResolve(
         new Map([
           ['wat', { status: CacheStatus.MISS }],
           ['who', { status: CacheStatus.NEGATIVE }],
           ['why', { status: CacheStatus.HIT, item: { id: 'why' } }],
           ['how', { status: CacheStatus.MISS }],
-        ])
+        ]),
       );
 
       const result = await entityCache.readManyThroughAsync(
         'id',
         ['wat', 'who', 'why', 'how'],
-        fetcher
+        fetcher,
       );
       verify(cacheAdapterMock.loadManyAsync('id', deepEqual(['wat', 'who', 'why', 'how']))).once();
       verify(
-        cacheAdapterMock.cacheManyAsync('id', deepEqual(new Map([['wat', { id: 'wat' }]])))
+        cacheAdapterMock.cacheManyAsync('id', deepEqual(new Map([['wat', { id: 'wat' }]]))),
       ).once();
       verify(cacheAdapterMock.cacheDBMissesAsync('id', deepEqual(['how']))).once();
       expect(result).toEqual(
         new Map([
           ['wat', [{ id: 'wat' }]],
           ['why', [{ id: 'why' }]],
-        ])
+        ]),
       );
     });
 
@@ -191,6 +207,46 @@ describe(ReadThroughEntityCache, () => {
       verify(cacheAdapterMock.loadManyAsync('id', anything())).never();
       expect(result).toEqual(new Map([['wat', [{ id: 'wat' }]]]));
     });
+
+    it('does not cache when DB returns multiple objects for what is supposed to be unique and returns empty', async () => {
+      const consoleSpy = jest.spyOn(console, 'warn');
+
+      const cacheAdapterMock = mock<IEntityCacheAdapter<BlahFields>>();
+      const cacheAdapter = instance(cacheAdapterMock);
+      const entityCache = new ReadThroughEntityCache(makeEntityConfiguration(true), cacheAdapter);
+      const fetcher = createFetcherNonUnique(['wat', 'who']);
+
+      when(cacheAdapterMock.loadManyAsync('id', deepEqual(['wat', 'who']))).thenResolve(
+        new Map([
+          ['wat', { status: CacheStatus.MISS }],
+          ['who', { status: CacheStatus.MISS }],
+        ]),
+      );
+
+      const result = await entityCache.readManyThroughAsync('id', ['wat', 'who'], fetcher);
+
+      verify(cacheAdapterMock.loadManyAsync('id', deepEqual(['wat', 'who']))).once();
+      verify(
+        cacheAdapterMock.cacheManyAsync(
+          'id',
+          deepEqual(
+            new Map([
+              ['wat', { id: 'wat' }],
+              ['who', { id: 'who' }],
+            ]),
+          ),
+        ),
+      ).never();
+      verify(cacheAdapterMock.cacheDBMissesAsync('id', deepEqual([]))).once();
+      expect(result).toEqual(new Map());
+
+      expect(consoleSpy).toHaveBeenCalledWith(
+        'unique key id in blah returned multiple rows for wat',
+      );
+      expect(consoleSpy).toHaveBeenCalledWith(
+        'unique key id in blah returned multiple rows for who',
+      );
+    });
   });
 
   describe('invalidateManyAsync', () => {

package/src/metrics/EntityMetricsUtils.ts

@@ -8,7 +8,7 @@ export const timeAndLogLoadEventAsync =
   (
     metricsAdapter: IEntityMetricsAdapter,
     loadType: EntityMetricsLoadType,
-    entityClassName: string
+    entityClassName: string,
   ) =>
   async <TFields>(promise: Promise<readonly Readonly<TFields>[]>) => {
     const startTime = Date.now();
@@ -29,10 +29,10 @@ export const timeAndLogLoadMapEventAsync =
   (
     metricsAdapter: IEntityMetricsAdapter,
     loadType: EntityMetricsLoadType,
-    entityClassName: string
+    entityClassName: string,
   ) =>
   async <TFields, N extends keyof TFields>(
-    promise: Promise<ReadonlyMap<NonNullable<TFields[N]>, readonly Readonly<TFields>[]>>
+    promise: Promise<ReadonlyMap<NonNullable<TFields[N]>, readonly Readonly<TFields>[]>>,
   ) => {
     const startTime = Date.now();
     const result = await promise;
@@ -54,7 +54,7 @@ export const timeAndLogMutationEventAsync =
   (
     metricsAdapter: IEntityMetricsAdapter,
     mutationType: EntityMetricsMutationType,
-    entityClassName: string
+    entityClassName: string,
   ) =>
   async <T>(promise: Promise<T>) => {
     const startTime = Date.now();

package/src/metrics/IEntityMetricsAdapter.ts

@@ -140,7 +140,7 @@ export default interface IEntityMetricsAdapter {
    * Called when a dataloader, cache, or database load is initiated via the standard
    * load methods (not equality conjunction or raw). Most commonly used for logging
    * a waterfall to determine dataloader and cache hit rates and ratios.
-   * @param fieldValueCount - count of field values being loaded for a field
+   * @param incrementLoadCountEvent - count of field values being loaded for a field
    */
   incrementDataManagerLoadCount(incrementLoadCountEvent: IncrementLoadCountEvent): void;
 }

package/src/rules/AlwaysAllowPrivacyPolicyRule.ts

@@ -12,13 +12,19 @@ export default class AlwaysAllowPrivacyPolicyRule<
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,
   TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
-  TSelectedFields extends keyof TFields = keyof TFields
+  TSelectedFields extends keyof TFields = keyof TFields,
 > extends PrivacyPolicyRule<TFields, TID, TViewerContext, TEntity, TSelectedFields> {
   async evaluateAsync(
     _viewerContext: TViewerContext,
     _queryContext: EntityQueryContext,
-    _evaluationContext: EntityPrivacyPolicyEvaluationContext,
-    _entity: TEntity
+    _evaluationContext: EntityPrivacyPolicyEvaluationContext<
+      TFields,
+      TID,
+      TViewerContext,
+      TEntity,
+      TSelectedFields
+    >,
+    _entity: TEntity,
   ): Promise<RuleEvaluationResult> {
     return RuleEvaluationResult.ALLOW;
   }

package/src/rules/AlwaysDenyPrivacyPolicyRule.ts

@@ -12,13 +12,19 @@ export default class AlwaysDenyPrivacyPolicyRule<
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,
   TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
-  TSelectedFields extends keyof TFields = keyof TFields
+  TSelectedFields extends keyof TFields = keyof TFields,
 > extends PrivacyPolicyRule<TFields, TID, TViewerContext, TEntity, TSelectedFields> {
   async evaluateAsync(
     _viewerContext: TViewerContext,
     _queryContext: EntityQueryContext,
-    _evaluationContext: EntityPrivacyPolicyEvaluationContext,
-    _entity: TEntity
+    _evaluationContext: EntityPrivacyPolicyEvaluationContext<
+      TFields,
+      TID,
+      TViewerContext,
+      TEntity,
+      TSelectedFields
+    >,
+    _entity: TEntity,
   ): Promise<RuleEvaluationResult> {
     return RuleEvaluationResult.DENY;
   }

package/src/rules/AlwaysSkipPrivacyPolicyRule.ts

@@ -12,13 +12,19 @@ export default class AlwaysSkipPrivacyPolicyRule<
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,
   TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
-  TSelectedFields extends keyof TFields = keyof TFields
+  TSelectedFields extends keyof TFields = keyof TFields,
 > extends PrivacyPolicyRule<TFields, TID, TViewerContext, TEntity, TSelectedFields> {
   async evaluateAsync(
     _viewerContext: TViewerContext,
     _queryContext: EntityQueryContext,
-    _evaluationContext: EntityPrivacyPolicyEvaluationContext,
-    _entity: TEntity
+    _evaluationContext: EntityPrivacyPolicyEvaluationContext<
+      TFields,
+      TID,
+      TViewerContext,
+      TEntity,
+      TSelectedFields
+    >,
+    _entity: TEntity,
   ): Promise<RuleEvaluationResult> {
     return RuleEvaluationResult.SKIP;
   }

package/src/rules/PrivacyPolicyRule.ts

@@ -41,12 +41,18 @@ export default abstract class PrivacyPolicyRule<
   TID extends NonNullable<TFields[TSelectedFields]>,
   TViewerContext extends ViewerContext,
   TEntity extends ReadonlyEntity<TFields, TID, TViewerContext, TSelectedFields>,
-  TSelectedFields extends keyof TFields = keyof TFields
+  TSelectedFields extends keyof TFields = keyof TFields,
 > {
   abstract evaluateAsync(
     viewerContext: TViewerContext,
     queryContext: EntityQueryContext,
-    evaluationContext: EntityPrivacyPolicyEvaluationContext,
-    entity: TEntity
+    evaluationContext: EntityPrivacyPolicyEvaluationContext<
+      TFields,
+      TID,
+      TViewerContext,
+      TEntity,
+      TSelectedFields
+    >,
+    entity: TEntity,
   ): Promise<RuleEvaluationResult>;
 }

package/src/rules/__tests__/AlwaysAllowPrivacyPolicyRule-test.ts

@@ -11,7 +11,8 @@ describePrivacyPolicyRule(new AlwaysAllowPrivacyPolicyRule(), {
     {
       viewerContext: instance(mock(ViewerContext)),
       queryContext: instance(mock(EntityQueryContext)),
-      evaluationContext: instance(mock<EntityPrivacyPolicyEvaluationContext>()),
+      evaluationContext:
+        instance(mock<EntityPrivacyPolicyEvaluationContext<any, any, any, any, any>>()),
       entity: anything(),
     },
   ],

package/src/rules/__tests__/AlwaysDenyPrivacyPolicyRule-test.ts

@@ -11,7 +11,8 @@ describePrivacyPolicyRule(new AlwaysDenyPrivacyPolicyRule(), {
     {
       viewerContext: instance(mock(ViewerContext)),
       queryContext: instance(mock(EntityQueryContext)),
-      evaluationContext: instance(mock<EntityPrivacyPolicyEvaluationContext>()),
+      evaluationContext:
+        instance(mock<EntityPrivacyPolicyEvaluationContext<any, any, any, any, any>>()),
       entity: anything(),
     },
   ],

package/src/rules/__tests__/AlwaysSkipPrivacyPolicyRule-test.ts

@@ -11,7 +11,8 @@ describePrivacyPolicyRule(new AlwaysSkipPrivacyPolicyRule(), {
     {
       viewerContext: instance(mock(ViewerContext)),
       queryContext: instance(mock(EntityQueryContext)),
-      evaluationContext: instance(mock<EntityPrivacyPolicyEvaluationContext>()),
+      evaluationContext:
+        instance(mock<EntityPrivacyPolicyEvaluationContext<any, any, any, any, any>>()),
       entity: anything(),
     },
   ],

package/src/testfixtures/TestEntity.ts

@@ -99,7 +99,7 @@ export default class TestEntity extends Entity<TestFields, string, ViewerContext
         id: testValue,
         databaseFields: fields,
         selectedFields: fields,
-      })
+      }),
     );
   }
 

package/src/testfixtures/TestEntityWithMutationTriggers.ts

@@ -0,0 +1,156 @@
+import Entity from '../Entity';
+import { EntityCompanionDefinition } from '../EntityCompanionProvider';
+import EntityConfiguration from '../EntityConfiguration';
+import { StringField, UUIDField } from '../EntityFields';
+import { EntityTriggerMutationInfo } from '../EntityMutationInfo';
+import {
+  EntityMutationTrigger,
+  EntityNonTransactionalMutationTrigger,
+} from '../EntityMutationTriggerConfiguration';
+import EntityPrivacyPolicy from '../EntityPrivacyPolicy';
+import { EntityQueryContext } from '../EntityQueryContext';
+import ViewerContext from '../ViewerContext';
+import AlwaysAllowPrivacyPolicyRule from '../rules/AlwaysAllowPrivacyPolicyRule';
+
+export type TestMTFields = {
+  id: string;
+  stringField: string;
+};
+
+export const testEntityMTConfiguration = new EntityConfiguration<TestMTFields>({
+  idField: 'id',
+  tableName: 'test_entity_should_not_write_to_db_3',
+  schema: {
+    id: new UUIDField({
+      columnName: 'id',
+    }),
+    stringField: new StringField({
+      columnName: 'string_field',
+    }),
+  },
+  databaseAdapterFlavor: 'postgres',
+  cacheAdapterFlavor: 'redis',
+});
+
+export class TestEntityMTPrivacyPolicy extends EntityPrivacyPolicy<
+  TestMTFields,
+  string,
+  ViewerContext,
+  TestEntityWithMutationTriggers
+> {
+  protected override readonly readRules = [
+    new AlwaysAllowPrivacyPolicyRule<
+      TestMTFields,
+      string,
+      ViewerContext,
+      TestEntityWithMutationTriggers
+    >(),
+  ];
+  protected override readonly createRules = [
+    new AlwaysAllowPrivacyPolicyRule<
+      TestMTFields,
+      string,
+      ViewerContext,
+      TestEntityWithMutationTriggers
+    >(),
+  ];
+  protected override readonly updateRules = [
+    new AlwaysAllowPrivacyPolicyRule<
+      TestMTFields,
+      string,
+      ViewerContext,
+      TestEntityWithMutationTriggers
+    >(),
+  ];
+  protected override readonly deleteRules = [
+    new AlwaysAllowPrivacyPolicyRule<
+      TestMTFields,
+      string,
+      ViewerContext,
+      TestEntityWithMutationTriggers
+    >(),
+  ];
+}
+
+export class TestMutationTrigger extends EntityMutationTrigger<
+  TestMTFields,
+  string,
+  ViewerContext,
+  TestEntityWithMutationTriggers,
+  keyof TestMTFields
+> {
+  constructor(
+    // @ts-expect-error key is never used but is helpful for debugging
+    private readonly key: string,
+  ) {
+    super();
+  }
+
+  async executeAsync(
+    _viewerContext: ViewerContext,
+    _queryContext: EntityQueryContext,
+    _entity: TestEntityWithMutationTriggers,
+    _mutationInfo: EntityTriggerMutationInfo<
+      TestMTFields,
+      string,
+      ViewerContext,
+      TestEntityWithMutationTriggers,
+      keyof TestMTFields
+    >,
+  ): Promise<void> {}
+}
+
+export class NonTransactionalTestMutationTrigger extends EntityNonTransactionalMutationTrigger<
+  TestMTFields,
+  string,
+  ViewerContext,
+  TestEntityWithMutationTriggers,
+  keyof TestMTFields
+> {
+  constructor(
+    // @ts-expect-error key is never used but is helpful for debugging
+    private readonly key: string,
+  ) {
+    super();
+  }
+
+  async executeAsync(
+    _viewerContext: ViewerContext,
+    _entity: TestEntityWithMutationTriggers,
+    _mutationInfo: EntityTriggerMutationInfo<
+      TestMTFields,
+      string,
+      ViewerContext,
+      TestEntityWithMutationTriggers,
+      keyof TestMTFields
+    >,
+  ): Promise<void> {}
+}
+
+/**
+ * A test Entity that has one afterCreate and one afterAll trigger
+ */
+export default class TestEntityWithMutationTriggers extends Entity<
+  TestMTFields,
+  string,
+  ViewerContext
+> {
+  static defineCompanionDefinition(): EntityCompanionDefinition<
+    TestMTFields,
+    string,
+    ViewerContext,
+    TestEntityWithMutationTriggers,
+    TestEntityMTPrivacyPolicy
+  > {
+    return {
+      entityClass: TestEntityWithMutationTriggers,
+      entityConfiguration: testEntityMTConfiguration,
+      privacyPolicyClass: TestEntityMTPrivacyPolicy,
+      mutationTriggers: {
+        afterCreate: [new TestMutationTrigger('localAfterCreate')],
+        afterAll: [new TestMutationTrigger('localAfterAll')],
+        afterCommit: [new NonTransactionalTestMutationTrigger('localAfterCommit')],
+      },
+    };
+  }
+}