@expo/entity 0.55.0 → 0.57.0

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

@@ -1,13 +1,11 @@
 import { describe, expect, it, jest } from '@jest/globals';
 import {
   anyNumber,
-  anyString,
   anything,
   deepEqual,
   instance,
   mock,
   resetCalls,
-  spy,
   verify,
   when,
 } from 'ts-mockito';
@@ -98,7 +96,7 @@ describe(EntityDataManager, () => {
 
     const entityDatas = await entityDataManager.loadManyEqualingAsync(
       queryContext,
-      new SingleFieldHolder('customIdField'),
+      new SingleFieldHolder<TestFields, 'customIdField', 'customIdField'>('customIdField'),
       [new SingleFieldValueHolder('2')],
     );
     expect(entityDatas.get(new SingleFieldValueHolder('2'))).toHaveLength(1);
@@ -110,7 +108,7 @@ describe(EntityDataManager, () => {
 
     const entityDatas2 = await entityDataManager.loadManyEqualingAsync(
       queryContext,
-      new SingleFieldHolder('testIndexedField'),
+      new SingleFieldHolder<TestFields, 'customIdField', 'testIndexedField'>('testIndexedField'),
       [new SingleFieldValueHolder('unique2'), new SingleFieldValueHolder('unique3')],
     );
     expect(entityDatas2.get(new SingleFieldValueHolder('unique2'))).toHaveLength(1);
@@ -122,7 +120,7 @@ describe(EntityDataManager, () => {
     cacheSpy.mockClear();
   });
 
-  it('loads from a caching adaptor', async () => {
+  it('loads from a caching adapter', async () => {
     const objects = getObjects();
     const dataStore = StubDatabaseAdapter.convertFieldObjectsToDataStore(
       testEntityConfiguration,
@@ -149,7 +147,7 @@ describe(EntityDataManager, () => {
 
     const entityDatas = await entityDataManager.loadManyEqualingAsync(
       queryContext,
-      new SingleFieldHolder('customIdField'),
+      new SingleFieldHolder<TestFields, 'customIdField', 'customIdField'>('customIdField'),
       [new SingleFieldValueHolder('1')],
     );
     expect(entityDatas.get(new SingleFieldValueHolder('1'))).toHaveLength(1);
@@ -161,7 +159,7 @@ describe(EntityDataManager, () => {
 
     const entityDatas2 = await entityDataManager.loadManyEqualingAsync(
       queryContext,
-      new SingleFieldHolder('testIndexedField'),
+      new SingleFieldHolder<TestFields, 'customIdField', 'testIndexedField'>('testIndexedField'),
       [new SingleFieldValueHolder('unique2'), new SingleFieldValueHolder('unique3')],
     );
     expect(entityDatas2.get(new SingleFieldValueHolder('unique2'))).toHaveLength(1);
@@ -208,12 +206,12 @@ describe(EntityDataManager, () => {
 
     await entityDataManager.loadManyEqualingAsync(
       queryContext,
-      new SingleFieldHolder('testIndexedField'),
+      new SingleFieldHolder<TestFields, 'customIdField', 'testIndexedField'>('testIndexedField'),
       [new SingleFieldValueHolder('unique2')],
     );
     await entityDataManager2.loadManyEqualingAsync(
       queryContext,
-      new SingleFieldHolder('testIndexedField'),
+      new SingleFieldHolder<TestFields, 'customIdField', 'testIndexedField'>('testIndexedField'),
       [new SingleFieldValueHolder('unique2')],
     );
 
@@ -251,12 +249,12 @@ describe(EntityDataManager, () => {
 
     await entityDataManager.loadManyEqualingAsync(
       queryContext,
-      new SingleFieldHolder('testIndexedField'),
+      new SingleFieldHolder<TestFields, 'customIdField', 'testIndexedField'>('testIndexedField'),
       [new SingleFieldValueHolder('unique2')],
     );
     await entityDataManager.loadManyEqualingAsync(
       queryContext,
-      new SingleFieldHolder('testIndexedField'),
+      new SingleFieldHolder<TestFields, 'customIdField', 'testIndexedField'>('testIndexedField'),
       [new SingleFieldValueHolder('unique2')],
     );
 
@@ -294,12 +292,12 @@ describe(EntityDataManager, () => {
 
     const entityData = await entityDataManager.loadManyEqualingAsync(
       queryContext,
-      new SingleFieldHolder('stringField'),
+      new SingleFieldHolder<TestFields, 'customIdField', 'stringField'>('stringField'),
       [new SingleFieldValueHolder('hello'), new SingleFieldValueHolder('world')],
     );
     const entityData2 = await entityDataManager.loadManyEqualingAsync(
       queryContext,
-      new SingleFieldHolder('stringField'),
+      new SingleFieldHolder<TestFields, 'customIdField', 'stringField'>('stringField'),
       [new SingleFieldValueHolder('hello'), new SingleFieldValueHolder('world')],
     );
 
@@ -343,12 +341,12 @@ describe(EntityDataManager, () => {
         const [entityData, entityData2] = await Promise.all([
           entityDataManager.loadManyEqualingAsync(
             queryContext,
-            new SingleFieldHolder('stringField'),
+            new SingleFieldHolder<TestFields, 'customIdField', 'stringField'>('stringField'),
             [new SingleFieldValueHolder('hello'), new SingleFieldValueHolder('world')],
           ),
           entityDataManager.loadManyEqualingAsync(
             queryContext,
-            new SingleFieldHolder('stringField'),
+            new SingleFieldHolder<TestFields, 'customIdField', 'stringField'>('stringField'),
             [new SingleFieldValueHolder('hello'), new SingleFieldValueHolder('world')],
           ),
         ]);
@@ -356,7 +354,7 @@ describe(EntityDataManager, () => {
           async (innerQueryContext) => {
             const entityData3 = await entityDataManager.loadManyEqualingAsync(
               innerQueryContext,
-              new SingleFieldHolder('stringField'),
+              new SingleFieldHolder<TestFields, 'customIdField', 'stringField'>('stringField'),
               [new SingleFieldValueHolder('hello'), new SingleFieldValueHolder('world')],
             );
 
@@ -364,7 +362,7 @@ describe(EntityDataManager, () => {
               async (innerInnerQueryContext) => {
                 return await entityDataManager.loadManyEqualingAsync(
                   innerInnerQueryContext,
-                  new SingleFieldHolder('stringField'),
+                  new SingleFieldHolder<TestFields, 'customIdField', 'stringField'>('stringField'),
                   [new SingleFieldValueHolder('hello'), new SingleFieldValueHolder('world')],
                 );
               },
@@ -419,19 +417,19 @@ describe(EntityDataManager, () => {
       await new StubQueryContextProvider().runInTransactionAsync(async (queryContext) => {
         const entityData = await entityDataManager.loadManyEqualingAsync(
           queryContext,
-          new SingleFieldHolder('stringField'),
+          new SingleFieldHolder<TestFields, 'customIdField', 'stringField'>('stringField'),
           [new SingleFieldValueHolder('hello'), new SingleFieldValueHolder('world')],
         );
         const entityData2 = await entityDataManager.loadManyEqualingAsync(
           queryContext,
-          new SingleFieldHolder('stringField'),
+          new SingleFieldHolder<TestFields, 'customIdField', 'stringField'>('stringField'),
           [new SingleFieldValueHolder('hello'), new SingleFieldValueHolder('world')],
         );
         const [entityData3, entityData4] = await queryContext.runInNestedTransactionAsync(
           async (innerQueryContext) => {
             const entityData3 = await entityDataManager.loadManyEqualingAsync(
               innerQueryContext,
-              new SingleFieldHolder('stringField'),
+              new SingleFieldHolder<TestFields, 'customIdField', 'stringField'>('stringField'),
               [new SingleFieldValueHolder('hello'), new SingleFieldValueHolder('world')],
             );
 
@@ -439,7 +437,7 @@ describe(EntityDataManager, () => {
               async (innerInnerQueryContext) => {
                 return await entityDataManager.loadManyEqualingAsync(
                   innerInnerQueryContext,
-                  new SingleFieldHolder('stringField'),
+                  new SingleFieldHolder<TestFields, 'customIdField', 'stringField'>('stringField'),
                   [new SingleFieldValueHolder('hello'), new SingleFieldValueHolder('world')],
                 );
               },
@@ -495,19 +493,19 @@ describe(EntityDataManager, () => {
         async (queryContext) => {
           const entityData = await entityDataManager.loadManyEqualingAsync(
             queryContext,
-            new SingleFieldHolder('stringField'),
+            new SingleFieldHolder<TestFields, 'customIdField', 'stringField'>('stringField'),
             [new SingleFieldValueHolder('hello'), new SingleFieldValueHolder('world')],
           );
           const entityData2 = await entityDataManager.loadManyEqualingAsync(
             queryContext,
-            new SingleFieldHolder('stringField'),
+            new SingleFieldHolder<TestFields, 'customIdField', 'stringField'>('stringField'),
             [new SingleFieldValueHolder('hello'), new SingleFieldValueHolder('world')],
           );
           const [entityData3, entityData4] = await queryContext.runInNestedTransactionAsync(
             async (innerQueryContext) => {
               const entityData3 = await entityDataManager.loadManyEqualingAsync(
                 innerQueryContext,
-                new SingleFieldHolder('stringField'),
+                new SingleFieldHolder<TestFields, 'customIdField', 'stringField'>('stringField'),
                 [new SingleFieldValueHolder('hello'), new SingleFieldValueHolder('world')],
               );
 
@@ -515,7 +513,9 @@ describe(EntityDataManager, () => {
                 async (innerInnerQueryContext) => {
                   return await entityDataManager.loadManyEqualingAsync(
                     innerInnerQueryContext,
-                    new SingleFieldHolder('stringField'),
+                    new SingleFieldHolder<TestFields, 'customIdField', 'stringField'>(
+                      'stringField',
+                    ),
                     [new SingleFieldValueHolder('hello'), new SingleFieldValueHolder('world')],
                   );
                 },
@@ -574,18 +574,18 @@ describe(EntityDataManager, () => {
 
     await entityDataManager.loadManyEqualingAsync(
       queryContext,
-      new SingleFieldHolder('testIndexedField'),
+      new SingleFieldHolder<TestFields, 'customIdField', 'testIndexedField'>('testIndexedField'),
       [new SingleFieldValueHolder(objectInQuestion['testIndexedField'])],
     );
     await entityDataManager.invalidateKeyValuePairsAsync([
       [
-        new SingleFieldHolder('testIndexedField'),
+        new SingleFieldHolder<TestFields, 'customIdField', 'testIndexedField'>('testIndexedField'),
         new SingleFieldValueHolder(objectInQuestion['testIndexedField']),
       ],
     ]);
     await entityDataManager.loadManyEqualingAsync(
       queryContext,
-      new SingleFieldHolder('testIndexedField'),
+      new SingleFieldHolder<TestFields, 'customIdField', 'testIndexedField'>('testIndexedField'),
       [new SingleFieldValueHolder(objectInQuestion['testIndexedField'])],
     );
 
@@ -625,18 +625,18 @@ describe(EntityDataManager, () => {
 
     await entityDataManager.loadManyEqualingAsync(
       queryContext,
-      new SingleFieldHolder('testIndexedField'),
+      new SingleFieldHolder<TestFields, 'customIdField', 'testIndexedField'>('testIndexedField'),
       [new SingleFieldValueHolder(objectInQuestion['testIndexedField'])],
     );
     await entityDataManager.invalidateKeyValuePairsAsync([
       [
-        new SingleFieldHolder('testIndexedField'),
+        new SingleFieldHolder<TestFields, 'customIdField', 'testIndexedField'>('testIndexedField'),
         new SingleFieldValueHolder(objectInQuestion['testIndexedField']),
       ],
     ]);
     await entityDataManager.loadManyEqualingAsync(
       queryContext,
-      new SingleFieldHolder('customIdField'),
+      new SingleFieldHolder<TestFields, 'customIdField', 'customIdField'>('customIdField'),
       [new SingleFieldValueHolder(objectInQuestion['customIdField'])],
     );
 
@@ -676,18 +676,20 @@ describe(EntityDataManager, () => {
 
       await entityDataManager.loadManyEqualingAsync(
         queryContext,
-        new SingleFieldHolder('testIndexedField'),
+        new SingleFieldHolder<TestFields, 'customIdField', 'testIndexedField'>('testIndexedField'),
         [new SingleFieldValueHolder(objectInQuestion['testIndexedField'])],
       );
       entityDataManager.invalidateKeyValuePairsForTransaction(queryContext, [
         [
-          new SingleFieldHolder('testIndexedField'),
+          new SingleFieldHolder<TestFields, 'customIdField', 'testIndexedField'>(
+            'testIndexedField',
+          ),
           new SingleFieldValueHolder(objectInQuestion['testIndexedField']),
         ],
       ]);
       await entityDataManager.loadManyEqualingAsync(
         queryContext,
-        new SingleFieldHolder('testIndexedField'),
+        new SingleFieldHolder<TestFields, 'customIdField', 'testIndexedField'>('testIndexedField'),
         [new SingleFieldValueHolder(objectInQuestion['testIndexedField'])],
       );
 
@@ -700,18 +702,24 @@ describe(EntityDataManager, () => {
       await queryContext.runInNestedTransactionAsync(async (innerQueryContext) => {
         await entityDataManager.loadManyEqualingAsync(
           innerQueryContext,
-          new SingleFieldHolder('testIndexedField'),
+          new SingleFieldHolder<TestFields, 'customIdField', 'testIndexedField'>(
+            'testIndexedField',
+          ),
           [new SingleFieldValueHolder(objectInQuestion['testIndexedField'])],
         );
         entityDataManager.invalidateKeyValuePairsForTransaction(innerQueryContext, [
           [
-            new SingleFieldHolder('testIndexedField'),
+            new SingleFieldHolder<TestFields, 'customIdField', 'testIndexedField'>(
+              'testIndexedField',
+            ),
             new SingleFieldValueHolder(objectInQuestion['testIndexedField']),
           ],
         ]);
         await entityDataManager.loadManyEqualingAsync(
           innerQueryContext,
-          new SingleFieldHolder('testIndexedField'),
+          new SingleFieldHolder<TestFields, 'customIdField', 'testIndexedField'>(
+            'testIndexedField',
+          ),
           [new SingleFieldValueHolder(objectInQuestion['testIndexedField'])],
         );
 
@@ -754,18 +762,24 @@ describe(EntityDataManager, () => {
 
         await entityDataManager.loadManyEqualingAsync(
           queryContext,
-          new SingleFieldHolder('testIndexedField'),
+          new SingleFieldHolder<TestFields, 'customIdField', 'testIndexedField'>(
+            'testIndexedField',
+          ),
           [new SingleFieldValueHolder(objectInQuestion['testIndexedField'])],
         );
         entityDataManager.invalidateKeyValuePairsForTransaction(queryContext, [
           [
-            new SingleFieldHolder('testIndexedField'),
+            new SingleFieldHolder<TestFields, 'customIdField', 'testIndexedField'>(
+              'testIndexedField',
+            ),
             new SingleFieldValueHolder(objectInQuestion['testIndexedField']),
           ],
         ]);
         await entityDataManager.loadManyEqualingAsync(
           queryContext,
-          new SingleFieldHolder('testIndexedField'),
+          new SingleFieldHolder<TestFields, 'customIdField', 'testIndexedField'>(
+            'testIndexedField',
+          ),
           [new SingleFieldValueHolder(objectInQuestion['testIndexedField'])],
         );
 
@@ -809,7 +823,7 @@ describe(EntityDataManager, () => {
       async (queryContext) => {
         return await entityDataManager.loadManyEqualingAsync(
           queryContext,
-          new SingleFieldHolder('customIdField'),
+          new SingleFieldHolder<TestFields, 'customIdField', 'customIdField'>('customIdField'),
           [new SingleFieldValueHolder('1')],
         );
       },
@@ -825,55 +839,6 @@ describe(EntityDataManager, () => {
     cacheSpy.mockReset();
   });
 
-  it('loads by field equality conjunction and does not cache', async () => {
-    const objects = getObjects();
-    const dataStore = StubDatabaseAdapter.convertFieldObjectsToDataStore(
-      testEntityConfiguration,
-      objects,
-    );
-    const databaseAdapter = new StubDatabaseAdapter<TestFields, 'customIdField'>(
-      testEntityConfiguration,
-      dataStore,
-    );
-    const cacheAdapterProvider = new InMemoryFullCacheStubCacheAdapterProvider();
-    const cacheAdapter = cacheAdapterProvider.getCacheAdapter(testEntityConfiguration);
-    const entityCache = new ReadThroughEntityCache(testEntityConfiguration, cacheAdapter);
-    const entityDataManager = new EntityDataManager(
-      databaseAdapter,
-      entityCache,
-      new StubQueryContextProvider(),
-      new NoOpEntityMetricsAdapter(),
-      TestEntity.name,
-    );
-    const queryContext = new StubQueryContextProvider().getQueryContext();
-
-    const dbSpy = jest.spyOn(databaseAdapter, 'fetchManyByFieldEqualityConjunctionAsync');
-    const cacheSpy = jest.spyOn(entityCache, 'readManyThroughAsync');
-
-    const entityDatas = await entityDataManager.loadManyByFieldEqualityConjunctionAsync(
-      queryContext,
-      [
-        {
-          fieldName: 'stringField',
-          fieldValue: 'hello',
-        },
-        {
-          fieldName: 'intField',
-          fieldValue: 1,
-        },
-      ],
-      {},
-    );
-
-    expect(entityDatas).toHaveLength(2);
-
-    expect(dbSpy).toHaveBeenCalled();
-    expect(cacheSpy).not.toHaveBeenCalled();
-
-    dbSpy.mockReset();
-    cacheSpy.mockReset();
-  });
-
   it('handles DB errors as expected', async () => {
     const databaseAdapterMock = mock<EntityDatabaseAdapter<TestFields, 'customIdField'>>();
     when(databaseAdapterMock.fetchManyWhereAsync(anything(), anything(), anything())).thenReject(
@@ -896,7 +861,7 @@ describe(EntityDataManager, () => {
     await expect(
       entityDataManager.loadManyEqualingAsync(
         queryContext,
-        new SingleFieldHolder('customIdField'),
+        new SingleFieldHolder<TestFields, 'customIdField', 'customIdField'>('customIdField'),
         [new SingleFieldValueHolder('2')],
       ),
     ).rejects.toThrow();
@@ -932,7 +897,7 @@ describe(EntityDataManager, () => {
       // for dataloader, cache, and database
       await entityDataManager.loadManyEqualingAsync(
         queryContext,
-        new SingleFieldHolder('testIndexedField'),
+        new SingleFieldHolder<TestFields, 'customIdField', 'testIndexedField'>('testIndexedField'),
         [new SingleFieldValueHolder('unique1')],
       );
       verify(
@@ -987,7 +952,7 @@ describe(EntityDataManager, () => {
       // entity is in local dataloader
       await entityDataManager.loadManyEqualingAsync(
         queryContext,
-        new SingleFieldHolder('testIndexedField'),
+        new SingleFieldHolder<TestFields, 'customIdField', 'testIndexedField'>('testIndexedField'),
         [new SingleFieldValueHolder('unique1')],
       );
       verify(metricsAdapterMock.incrementDataManagerLoadCount(anything())).once();
@@ -1017,7 +982,7 @@ describe(EntityDataManager, () => {
       );
       await entityDataManager2.loadManyEqualingAsync(
         queryContext,
-        new SingleFieldHolder('testIndexedField'),
+        new SingleFieldHolder<TestFields, 'customIdField', 'testIndexedField'>('testIndexedField'),
         [new SingleFieldValueHolder('unique1'), new SingleFieldValueHolder('unique2')],
       );
       verify(metricsAdapterMock.incrementDataManagerLoadCount(anything())).thrice();
@@ -1054,56 +1019,6 @@ describe(EntityDataManager, () => {
           }),
         ),
       ).once();
-
-      resetCalls(metricsAdapterMock);
-
-      await entityDataManager.loadManyByFieldEqualityConjunctionAsync(
-        queryContext,
-        [
-          {
-            fieldName: 'testIndexedField',
-            fieldValue: 'unique1',
-          },
-        ],
-        {},
-      );
-      verify(
-        metricsAdapterMock.logDataManagerLoadEvent(
-          deepEqual({
-            type: EntityMetricsLoadType.LOAD_MANY_EQUALITY_CONJUNCTION,
-            isInTransaction: false,
-            entityClassName: TestEntity.name,
-            duration: anyNumber(),
-            count: 1,
-          }),
-        ),
-      ).once();
-
-      resetCalls(metricsAdapterMock);
-
-      const databaseAdapterSpy = spy(databaseAdapter);
-      when(
-        databaseAdapterSpy.fetchManyByRawWhereClauseAsync(
-          anything(),
-          anyString(),
-          anything(),
-          anything(),
-        ),
-      ).thenResolve([]);
-      await entityDataManager.loadManyByRawWhereClauseAsync(queryContext, '', [], {});
-      verify(
-        metricsAdapterMock.logDataManagerLoadEvent(
-          deepEqual({
-            type: EntityMetricsLoadType.LOAD_MANY_RAW,
-            isInTransaction: false,
-            entityClassName: TestEntity.name,
-            duration: anyNumber(),
-            count: 0,
-          }),
-        ),
-      ).once();
-
-      verify(metricsAdapterMock.incrementDataManagerLoadCount(anything())).never();
     });
 
     it('records metrics appropriately inside of transactions', async () => {
@@ -1135,7 +1050,9 @@ describe(EntityDataManager, () => {
         // for dataloader, cache, and database
         await entityDataManager.loadManyEqualingAsync(
           queryContext,
-          new SingleFieldHolder('testIndexedField'),
+          new SingleFieldHolder<TestFields, 'customIdField', 'testIndexedField'>(
+            'testIndexedField',
+          ),
           [new SingleFieldValueHolder('unique1')],
         );
         verify(
@@ -1179,7 +1096,9 @@ describe(EntityDataManager, () => {
         // entity is in local dataloader
         await entityDataManager.loadManyEqualingAsync(
           queryContext,
-          new SingleFieldHolder('testIndexedField'),
+          new SingleFieldHolder<TestFields, 'customIdField', 'testIndexedField'>(
+            'testIndexedField',
+          ),
           [new SingleFieldValueHolder('unique1')],
         );
         verify(metricsAdapterMock.incrementDataManagerLoadCount(anything())).once();
@@ -1194,56 +1113,6 @@ describe(EntityDataManager, () => {
             }),
           ),
         ).once();
-
-        resetCalls(metricsAdapterMock);
-
-        await entityDataManager.loadManyByFieldEqualityConjunctionAsync(
-          queryContext,
-          [
-            {
-              fieldName: 'testIndexedField',
-              fieldValue: 'unique1',
-            },
-          ],
-          {},
-        );
-        verify(
-          metricsAdapterMock.logDataManagerLoadEvent(
-            deepEqual({
-              type: EntityMetricsLoadType.LOAD_MANY_EQUALITY_CONJUNCTION,
-              isInTransaction: true,
-              entityClassName: TestEntity.name,
-              duration: anyNumber(),
-              count: 1,
-            }),
-          ),
-        ).once();
-
-        resetCalls(metricsAdapterMock);
-
-        const databaseAdapterSpy = spy(databaseAdapter);
-        when(
-          databaseAdapterSpy.fetchManyByRawWhereClauseAsync(
-            anything(),
-            anyString(),
-            anything(),
-            anything(),
-          ),
-        ).thenResolve([]);
-        await entityDataManager.loadManyByRawWhereClauseAsync(queryContext, '', [], {});
-        verify(
-          metricsAdapterMock.logDataManagerLoadEvent(
-            deepEqual({
-              type: EntityMetricsLoadType.LOAD_MANY_RAW,
-              isInTransaction: true,
-              entityClassName: TestEntity.name,
-              duration: anyNumber(),
-              count: 0,
-            }),
-          ),
-        ).once();
-
-        verify(metricsAdapterMock.incrementDataManagerLoadCount(anything())).never();
       });
     });
   });
@@ -1273,16 +1142,16 @@ describe(EntityDataManager, () => {
     await expect(
       entityDataManager.loadManyEqualingAsync(
         queryContext,
-        new SingleFieldHolder('nullableField'),
-        [new SingleFieldValueHolder(null as any)],
+        new SingleFieldHolder<TestFields, 'customIdField', 'nullableField'>('nullableField'),
+        [new SingleFieldValueHolder(null)],
       ),
     ).rejects.toThrow('Invalid load: TestEntity (nullableField = null)');
 
     await expect(
       entityDataManager.loadManyEqualingAsync(
         queryContext,
-        new SingleFieldHolder('nullableField'),
-        [new SingleFieldValueHolder(undefined as any)],
+        new SingleFieldHolder<TestFields, 'customIdField', 'nullableField'>('nullableField'),
+        [new SingleFieldValueHolder(undefined)],
       ),
     ).rejects.toThrow('Invalid load: TestEntity (nullableField = undefined)');
   });
@@ -1318,7 +1187,7 @@ describe(EntityDataManager, () => {
         ]),
         [
           new CompositeFieldValueHolder({
-            nullableField: null as any,
+            nullableField: null,
             testIndexedField: 'unique1',
           }),
         ],
@@ -1336,7 +1205,7 @@ describe(EntityDataManager, () => {
         ]),
         [
           new CompositeFieldValueHolder({
-            nullableField: undefined as any,
+            nullableField: undefined,
             testIndexedField: 'unique1',
           }),
         ],