@expo/entity 0.40.0 → 0.42.0

package/src/__tests__/AuthorizationResultBasedEntityLoader-test.ts

@@ -1,5 +1,5 @@
 import { enforceAsyncResult } from '@expo/results';
-import { mock, instance, verify, spy, deepEqual, anyOfClass, anything, when } from 'ts-mockito';
+import { mock, instance, verify, spy, anyOfClass, anything, when } from 'ts-mockito';
 import { v4 as uuidv4 } from 'uuid';
 
 import AuthorizationResultBasedEntityLoader from '../AuthorizationResultBasedEntityLoader';
@@ -9,17 +9,24 @@ import { EntityPrivacyPolicyEvaluationContext } from '../EntityPrivacyPolicy';
 import ViewerContext from '../ViewerContext';
 import { enforceResultsAsync } from '../entityUtils';
 import EntityNotFoundError from '../errors/EntityNotFoundError';
+import { CompositeFieldHolder, CompositeFieldValueHolder } from '../internal/CompositeFieldHolder';
 import EntityDataManager from '../internal/EntityDataManager';
 import ReadThroughEntityCache from '../internal/ReadThroughEntityCache';
+import {
+  SingleFieldHolder,
+  SingleFieldValueHolder,
+  SingleFieldValueHolderMap,
+} from '../internal/SingleFieldHolder';
 import IEntityMetricsAdapter from '../metrics/IEntityMetricsAdapter';
+import { NoCacheStubCacheAdapterProvider } from '../utils/__testfixtures__/StubCacheAdapter';
+import StubDatabaseAdapter from '../utils/__testfixtures__/StubDatabaseAdapter';
+import StubQueryContextProvider from '../utils/__testfixtures__/StubQueryContextProvider';
+import { deepEqualEntityAware } from '../utils/__testfixtures__/TSMockitoExtensions';
 import TestEntity, {
   TestFields,
   TestEntityPrivacyPolicy,
   testEntityConfiguration,
-} from '../testfixtures/TestEntity';
-import { NoCacheStubCacheAdapterProvider } from '../utils/testing/StubCacheAdapter';
-import StubDatabaseAdapter from '../utils/testing/StubDatabaseAdapter';
-import StubQueryContextProvider from '../utils/testing/StubQueryContextProvider';
+} from '../utils/__testfixtures__/TestEntity';
 
 describe(AuthorizationResultBasedEntityLoader, () => {
   it('loads entities', async () => {
@@ -27,14 +34,21 @@ describe(AuthorizationResultBasedEntityLoader, () => {
     const viewerContext = instance(mock(ViewerContext));
     const privacyPolicyEvaluationContext =
       instance(
-        mock<EntityPrivacyPolicyEvaluationContext<TestFields, string, ViewerContext, TestEntity>>(),
+        mock<
+          EntityPrivacyPolicyEvaluationContext<
+            TestFields,
+            'customIdField',
+            ViewerContext,
+            TestEntity
+          >
+        >(),
       );
     const metricsAdapter = instance(mock<IEntityMetricsAdapter>());
     const queryContext = new StubQueryContextProvider().getQueryContext();
 
     const id1 = uuidv4();
     const id2 = uuidv4();
-    const databaseAdapter = new StubDatabaseAdapter<TestFields>(
+    const databaseAdapter = new StubDatabaseAdapter<TestFields, 'customIdField'>(
       testEntityConfiguration,
       StubDatabaseAdapter.convertFieldObjectsToDataStore(
         testEntityConfiguration,
@@ -141,13 +155,185 @@ describe(AuthorizationResultBasedEntityLoader, () => {
     );
   });
 
+  it('loads entities by composite fields', async () => {
+    const dateToInsert = new Date();
+    const viewerContext = instance(mock(ViewerContext));
+    const privacyPolicyEvaluationContext =
+      instance(
+        mock<
+          EntityPrivacyPolicyEvaluationContext<
+            TestFields,
+            'customIdField',
+            ViewerContext,
+            TestEntity
+          >
+        >(),
+      );
+    const metricsAdapter = instance(mock<IEntityMetricsAdapter>());
+    const queryContext = new StubQueryContextProvider().getQueryContext();
+
+    const id1 = uuidv4();
+    const id2 = uuidv4();
+    const id3 = uuidv4();
+    const id4 = uuidv4();
+    const databaseAdapter = new StubDatabaseAdapter<TestFields, 'customIdField'>(
+      testEntityConfiguration,
+      StubDatabaseAdapter.convertFieldObjectsToDataStore(
+        testEntityConfiguration,
+        new Map([
+          [
+            testEntityConfiguration.tableName,
+            [
+              {
+                customIdField: id1,
+                testIndexedField: 'h1',
+                intField: 5,
+                stringField: 'huh',
+                dateField: dateToInsert,
+                nullableField: null,
+              },
+              {
+                customIdField: id2,
+                testIndexedField: 'h2',
+                intField: 5,
+                stringField: 'huh',
+                dateField: dateToInsert,
+                nullableField: null,
+              },
+              {
+                customIdField: id3,
+                testIndexedField: 'h2',
+                intField: 3,
+                stringField: 'huh',
+                dateField: dateToInsert,
+                nullableField: null,
+              },
+              {
+                customIdField: id4,
+                stringField: 'huh3',
+                intField: 4,
+                testIndexedField: '7',
+                dateField: new Date(),
+                nullableField: 'non-null-nullable-field',
+              },
+            ],
+          ],
+        ]),
+      ),
+    );
+    const privacyPolicy = new TestEntityPrivacyPolicy();
+    const cacheAdapterProvider = new NoCacheStubCacheAdapterProvider();
+    const cacheAdapter = cacheAdapterProvider.getCacheAdapter(testEntityConfiguration);
+    const entityCache = new ReadThroughEntityCache(testEntityConfiguration, cacheAdapter);
+    const dataManager = new EntityDataManager(
+      databaseAdapter,
+      entityCache,
+      new StubQueryContextProvider(),
+      instance(mock<IEntityMetricsAdapter>()),
+      TestEntity.name,
+    );
+    const utils = new EntityLoaderUtils(
+      viewerContext,
+      queryContext,
+      privacyPolicyEvaluationContext,
+      testEntityConfiguration,
+      TestEntity,
+      /* entitySelectedFields */ undefined,
+      privacyPolicy,
+      dataManager,
+      metricsAdapter,
+    );
+    const entityLoader = new AuthorizationResultBasedEntityLoader(
+      queryContext,
+      testEntityConfiguration,
+      TestEntity,
+      dataManager,
+      metricsAdapter,
+      utils,
+    );
+
+    const entities = await enforceResultsAsync(
+      entityLoader.loadManyByCompositeFieldEqualingAsync(['stringField', 'intField'], {
+        stringField: 'huh',
+        intField: 5,
+      }),
+    );
+    expect(entities.map((m) => m.getID())).toEqual([id1, id2]);
+
+    const entityNullableCompositeValueResult = await entityLoader.loadByCompositeFieldEqualingAsync(
+      ['nullableField', 'testIndexedField'],
+      {
+        nullableField: 'non-null-nullable-field',
+        testIndexedField: '7',
+      },
+    );
+    expect(entityNullableCompositeValueResult?.enforceValue().getID()).toBe(id4);
+
+    const entityResultDuplicateValues =
+      await entityLoader.loadManyByCompositeFieldEqualingManyAsync(
+        ['stringField', 'intField'],
+        [
+          { stringField: 'huh', intField: 5 },
+          { stringField: 'huh', intField: 5 },
+        ],
+      );
+    expect(entityResultDuplicateValues.size).toBe(1);
+    expect(
+      entityResultDuplicateValues
+        .get({ stringField: 'huh', intField: 5 })
+        ?.map((m) => m.enforceValue().getID()),
+    ).toEqual([id1, id2]);
+
+    const entityResultNoValues = await entityLoader.loadManyByCompositeFieldEqualingAsync(
+      ['stringField', 'intField'],
+      { stringField: 'huh', intField: 999 },
+    );
+    expect(entityResultNoValues).toHaveLength(0);
+
+    await expect(
+      entityLoader.loadByCompositeFieldEqualingAsync(['stringField', 'intField'], {
+        stringField: 'huh',
+        intField: 5,
+      }),
+    ).rejects.toThrowError(
+      'loadByCompositeFieldEqualing: Multiple entities of type TestEntity found for composite field (stringField,intField)={"stringField":"huh","intField":5}',
+    );
+
+    // test the result map
+    const entityResultMap = await entityLoader.loadManyByCompositeFieldEqualingManyAsync(
+      ['stringField', 'intField'],
+      [
+        { stringField: 'huh', intField: 5 },
+        { stringField: 'huh', intField: 3 },
+      ],
+    );
+    expect(entityResultMap.size).toBe(2);
+    expect(
+      entityResultMap
+        .get({ stringField: 'huh', intField: 5 })
+        ?.map((m) => m.enforceValue().getID()),
+    ).toEqual([id1, id2]);
+    expect(
+      entityResultMap
+        .get({ stringField: 'huh', intField: 3 })
+        ?.map((m) => m.enforceValue().getID()),
+    ).toEqual([id3]);
+  });
+
   it('loads entities with loadManyByFieldEqualityConjunction', async () => {
     const privacyPolicy = new TestEntityPrivacyPolicy();
     const spiedPrivacyPolicy = spy(privacyPolicy);
     const viewerContext = instance(mock(ViewerContext));
     const privacyPolicyEvaluationContext =
       instance(
-        mock<EntityPrivacyPolicyEvaluationContext<TestFields, string, ViewerContext, TestEntity>>(),
+        mock<
+          EntityPrivacyPolicyEvaluationContext<
+            TestFields,
+            'customIdField',
+            ViewerContext,
+            TestEntity
+          >
+        >(),
       );
     const metricsAdapter = instance(mock<IEntityMetricsAdapter>());
     const queryContext = new StubQueryContextProvider().getQueryContext();
@@ -155,7 +341,7 @@ describe(AuthorizationResultBasedEntityLoader, () => {
     const id1 = uuidv4();
     const id2 = uuidv4();
     const id3 = uuidv4();
-    const databaseAdapter = new StubDatabaseAdapter<TestFields>(
+    const databaseAdapter = new StubDatabaseAdapter<TestFields, 'customIdField'>(
       testEntityConfiguration,
       StubDatabaseAdapter.convertFieldObjectsToDataStore(
         testEntityConfiguration,
@@ -257,7 +443,14 @@ describe(AuthorizationResultBasedEntityLoader, () => {
     const viewerContext = instance(mock(ViewerContext));
     const privacyPolicyEvaluationContext =
       instance(
-        mock<EntityPrivacyPolicyEvaluationContext<TestFields, string, ViewerContext, TestEntity>>(),
+        mock<
+          EntityPrivacyPolicyEvaluationContext<
+            TestFields,
+            'customIdField',
+            ViewerContext,
+            TestEntity
+          >
+        >(),
       );
     const metricsAdapter = instance(mock<IEntityMetricsAdapter>());
     const queryContext = new StubQueryContextProvider().getQueryContext();
@@ -265,7 +458,7 @@ describe(AuthorizationResultBasedEntityLoader, () => {
     const id1 = uuidv4();
     const id2 = uuidv4();
     const id3 = uuidv4();
-    const databaseAdapter = new StubDatabaseAdapter<TestFields>(
+    const databaseAdapter = new StubDatabaseAdapter<TestFields, 'customIdField'>(
       testEntityConfiguration,
       StubDatabaseAdapter.convertFieldObjectsToDataStore(
         testEntityConfiguration,
@@ -364,12 +557,19 @@ describe(AuthorizationResultBasedEntityLoader, () => {
     const viewerContext = instance(mock(ViewerContext));
     const privacyPolicyEvaluationContext =
       instance(
-        mock<EntityPrivacyPolicyEvaluationContext<TestFields, string, ViewerContext, TestEntity>>(),
+        mock<
+          EntityPrivacyPolicyEvaluationContext<
+            TestFields,
+            'customIdField',
+            ViewerContext,
+            TestEntity
+          >
+        >(),
       );
     const metricsAdapter = instance(mock<IEntityMetricsAdapter>());
     const queryContext = new StubQueryContextProvider().getQueryContext();
 
-    const dataManagerMock = mock<EntityDataManager<TestFields>>(EntityDataManager);
+    const dataManagerMock = mock<EntityDataManager<TestFields, 'customIdField'>>(EntityDataManager);
     when(
       dataManagerMock.loadManyByRawWhereClauseAsync(
         queryContext,
@@ -432,13 +632,20 @@ describe(AuthorizationResultBasedEntityLoader, () => {
     const viewerContext = instance(mock(ViewerContext));
     const privacyPolicyEvaluationContext =
       instance(
-        mock<EntityPrivacyPolicyEvaluationContext<TestFields, string, ViewerContext, TestEntity>>(),
+        mock<
+          EntityPrivacyPolicyEvaluationContext<
+            TestFields,
+            'customIdField',
+            ViewerContext,
+            TestEntity
+          >
+        >(),
       );
     const metricsAdapter = instance(mock<IEntityMetricsAdapter>());
     const queryContext = new StubQueryContextProvider().getQueryContext();
 
     const id1 = uuidv4();
-    const databaseAdapter = new StubDatabaseAdapter<TestFields>(
+    const databaseAdapter = new StubDatabaseAdapter<TestFields, 'customIdField'>(
       testEntityConfiguration,
       StubDatabaseAdapter.convertFieldObjectsToDataStore(
         testEntityConfiguration,
@@ -504,12 +711,19 @@ describe(AuthorizationResultBasedEntityLoader, () => {
     const viewerContext = instance(mock(ViewerContext));
     const privacyPolicyEvaluationContext =
       instance(
-        mock<EntityPrivacyPolicyEvaluationContext<TestFields, string, ViewerContext, TestEntity>>(),
+        mock<
+          EntityPrivacyPolicyEvaluationContext<
+            TestFields,
+            'customIdField',
+            ViewerContext,
+            TestEntity
+          >
+        >(),
       );
     const metricsAdapter = instance(mock<IEntityMetricsAdapter>());
     const queryContext = new StubQueryContextProvider().getQueryContext();
     const privacyPolicy = instance(mock(TestEntityPrivacyPolicy));
-    const dataManagerMock = mock<EntityDataManager<TestFields>>();
+    const dataManagerMock = mock<EntityDataManager<TestFields, 'customIdField'>>();
     const dataManagerInstance = instance(dataManagerMock);
 
     const id1 = uuidv4();
@@ -532,48 +746,54 @@ describe(AuthorizationResultBasedEntityLoader, () => {
       metricsAdapter,
       utils,
     );
-    await entityLoader.utils.invalidateFieldsAsync({ customIdField: id1 } as any);
 
-    verify(
-      dataManagerMock.invalidateObjectFieldsAsync(deepEqual({ customIdField: id1 } as any)),
-    ).once();
-  });
+    const date = new Date();
 
-  it('invalidates upon invalidate by field', async () => {
-    const viewerContext = instance(mock(ViewerContext));
-    const privacyPolicyEvaluationContext =
-      instance(
-        mock<EntityPrivacyPolicyEvaluationContext<TestFields, string, ViewerContext, TestEntity>>(),
-      );
-    const metricsAdapter = instance(mock<IEntityMetricsAdapter>());
-    const queryContext = new StubQueryContextProvider().getQueryContext();
-    const privacyPolicy = instance(mock(TestEntityPrivacyPolicy));
-    const dataManagerMock = mock<EntityDataManager<TestFields>>();
-    const dataManagerInstance = instance(dataManagerMock);
+    await entityLoader.utils.invalidateFieldsAsync({
+      customIdField: id1,
+      testIndexedField: 'h1',
+      intField: 5,
+      stringField: 'huh',
+      dateField: date,
+      nullableField: null,
+    });
 
-    const id1 = uuidv4();
-    const utils = new EntityLoaderUtils(
-      viewerContext,
-      queryContext,
-      privacyPolicyEvaluationContext,
-      testEntityConfiguration,
-      TestEntity,
-      /* entitySelectedFields */ undefined,
-      privacyPolicy,
-      dataManagerInstance,
-      metricsAdapter,
-    );
-    const entityLoader = new AuthorizationResultBasedEntityLoader(
-      queryContext,
-      testEntityConfiguration,
-      TestEntity,
-      dataManagerInstance,
-      metricsAdapter,
-      utils,
-    );
-    await entityLoader.utils.invalidateFieldsAsync({ customIdField: id1 } as any);
+    verify(dataManagerMock.invalidateKeyValuePairsAsync(anything())).once();
     verify(
-      dataManagerMock.invalidateObjectFieldsAsync(deepEqual({ customIdField: id1 } as any)),
+      dataManagerMock.invalidateKeyValuePairsAsync(
+        deepEqualEntityAware([
+          [
+            new SingleFieldHolder<TestFields, 'customIdField', 'customIdField'>('customIdField'),
+            new SingleFieldValueHolder<TestFields, 'customIdField'>(id1),
+          ],
+          [
+            new SingleFieldHolder<TestFields, 'customIdField', 'testIndexedField'>(
+              'testIndexedField',
+            ),
+            new SingleFieldValueHolder<TestFields, 'testIndexedField'>('h1'),
+          ],
+          [
+            new SingleFieldHolder<TestFields, 'customIdField', 'intField'>('intField'),
+            new SingleFieldValueHolder<TestFields, 'intField'>(5),
+          ],
+          [
+            new SingleFieldHolder<TestFields, 'customIdField', 'stringField'>('stringField'),
+            new SingleFieldValueHolder<TestFields, 'stringField'>('huh'),
+          ],
+          [
+            new SingleFieldHolder<TestFields, 'customIdField', 'dateField'>('dateField'),
+            new SingleFieldValueHolder<TestFields, 'dateField'>(date),
+          ],
+          [
+            new CompositeFieldHolder(['stringField', 'intField']),
+            new CompositeFieldValueHolder({ stringField: 'huh', intField: 5 }),
+          ],
+          [
+            new CompositeFieldHolder(['stringField', 'testIndexedField']),
+            new CompositeFieldValueHolder({ stringField: 'huh', testIndexedField: 'h1' }),
+          ],
+        ]),
+      ),
     ).once();
   });
 
@@ -581,17 +801,33 @@ describe(AuthorizationResultBasedEntityLoader, () => {
     const viewerContext = instance(mock(ViewerContext));
     const privacyPolicyEvaluationContext =
       instance(
-        mock<EntityPrivacyPolicyEvaluationContext<TestFields, string, ViewerContext, TestEntity>>(),
+        mock<
+          EntityPrivacyPolicyEvaluationContext<
+            TestFields,
+            'customIdField',
+            ViewerContext,
+            TestEntity
+          >
+        >(),
       );
     const metricsAdapter = instance(mock<IEntityMetricsAdapter>());
     const queryContext = new StubQueryContextProvider().getQueryContext();
     const privacyPolicy = instance(mock(TestEntityPrivacyPolicy));
-    const dataManagerMock = mock<EntityDataManager<TestFields>>();
+    const dataManagerMock = mock<EntityDataManager<TestFields, 'customIdField'>>();
     const dataManagerInstance = instance(dataManagerMock);
 
     const id1 = uuidv4();
     const entityMock = mock(TestEntity);
-    when(entityMock.getAllDatabaseFields()).thenReturn({ customIdField: id1 } as any);
+    const date = new Date();
+
+    when(entityMock.getAllDatabaseFields()).thenReturn({
+      customIdField: id1,
+      testIndexedField: 'h1',
+      intField: 5,
+      stringField: 'huh',
+      dateField: date,
+      nullableField: null,
+    });
     const entityInstance = instance(entityMock);
 
     const utils = new EntityLoaderUtils(
@@ -614,8 +850,43 @@ describe(AuthorizationResultBasedEntityLoader, () => {
       utils,
     );
     await entityLoader.utils.invalidateEntityAsync(entityInstance);
+
+    verify(dataManagerMock.invalidateKeyValuePairsAsync(anything())).once();
     verify(
-      dataManagerMock.invalidateObjectFieldsAsync(deepEqual({ customIdField: id1 } as any)),
+      dataManagerMock.invalidateKeyValuePairsAsync(
+        deepEqualEntityAware([
+          [
+            new SingleFieldHolder<TestFields, 'customIdField', 'customIdField'>('customIdField'),
+            new SingleFieldValueHolder<TestFields, 'customIdField'>(id1),
+          ],
+          [
+            new SingleFieldHolder<TestFields, 'customIdField', 'testIndexedField'>(
+              'testIndexedField',
+            ),
+            new SingleFieldValueHolder<TestFields, 'testIndexedField'>('h1'),
+          ],
+          [
+            new SingleFieldHolder<TestFields, 'customIdField', 'intField'>('intField'),
+            new SingleFieldValueHolder<TestFields, 'intField'>(5),
+          ],
+          [
+            new SingleFieldHolder<TestFields, 'customIdField', 'stringField'>('stringField'),
+            new SingleFieldValueHolder<TestFields, 'stringField'>('huh'),
+          ],
+          [
+            new SingleFieldHolder<TestFields, 'customIdField', 'dateField'>('dateField'),
+            new SingleFieldValueHolder<TestFields, 'dateField'>(date),
+          ],
+          [
+            new CompositeFieldHolder(['stringField', 'intField']),
+            new CompositeFieldValueHolder({ stringField: 'huh', intField: 5 }),
+          ],
+          [
+            new CompositeFieldHolder(['stringField', 'testIndexedField']),
+            new CompositeFieldValueHolder({ stringField: 'huh', testIndexedField: 'h1' }),
+          ],
+        ]),
+      ),
     ).once();
   });
 
@@ -623,17 +894,37 @@ describe(AuthorizationResultBasedEntityLoader, () => {
     const viewerContext = instance(mock(ViewerContext));
     const privacyPolicyEvaluationContext =
       instance(
-        mock<EntityPrivacyPolicyEvaluationContext<TestFields, string, ViewerContext, TestEntity>>(),
+        mock<
+          EntityPrivacyPolicyEvaluationContext<
+            TestFields,
+            'customIdField',
+            ViewerContext,
+            TestEntity
+          >
+        >(),
       );
     const metricsAdapter = instance(mock<IEntityMetricsAdapter>());
     const queryContext = new StubQueryContextProvider().getQueryContext();
     const privacyPolicyMock = mock(TestEntityPrivacyPolicy);
-    const dataManagerMock = mock<EntityDataManager<TestFields>>();
+    const dataManagerMock = mock<EntityDataManager<TestFields, 'customIdField'>>();
 
     const id1 = uuidv4();
-    when(
-      dataManagerMock.loadManyByFieldEqualingAsync(anything(), anything(), anything()),
-    ).thenResolve(new Map().set(id1, [{ customIdField: id1 }]));
+    when(dataManagerMock.loadManyEqualingAsync(anything(), anything(), anything())).thenResolve(
+      new SingleFieldValueHolderMap<
+        TestFields,
+        'customIdField',
+        readonly Readonly<TestFields>[]
+      >().set(new SingleFieldValueHolder(id1), [
+        {
+          customIdField: id1,
+          testIndexedField: '',
+          stringField: '',
+          intField: 0,
+          dateField: new Date(),
+          nullableField: null,
+        },
+      ]),
+    );
 
     const rejectionError = new Error();
 
@@ -680,18 +971,25 @@ describe(AuthorizationResultBasedEntityLoader, () => {
     const viewerContext = instance(mock(ViewerContext));
     const privacyPolicyEvaluationContext =
       instance(
-        mock<EntityPrivacyPolicyEvaluationContext<TestFields, string, ViewerContext, TestEntity>>(),
+        mock<
+          EntityPrivacyPolicyEvaluationContext<
+            TestFields,
+            'customIdField',
+            ViewerContext,
+            TestEntity
+          >
+        >(),
       );
     const metricsAdapter = instance(mock<IEntityMetricsAdapter>());
     const queryContext = new StubQueryContextProvider().getQueryContext();
     const privacyPolicy = instance(mock(TestEntityPrivacyPolicy));
-    const dataManagerMock = mock<EntityDataManager<TestFields>>();
+    const dataManagerMock = mock<EntityDataManager<TestFields, 'customIdField'>>();
 
     const error = new Error();
 
-    when(
-      dataManagerMock.loadManyByFieldEqualingAsync(anything(), anything(), anything()),
-    ).thenReject(error);
+    when(dataManagerMock.loadManyEqualingAsync(anything(), anything(), anything())).thenReject(
+      error,
+    );
 
     const dataManagerInstance = instance(dataManagerMock);