@graphql-box/cache-manager 4.1.4 → 5.0.0

package/src/index.test.ts

@@ -1,50 +1,49 @@
-import Cachemap from "@cachemap/core";
-import map from "@cachemap/map";
+import { Core } from '@cachemap/core';
+import { init as map } from '@cachemap/map';
 import {
   DEFAULT_TYPE_ID_KEY,
-  DehydratedCacheMetadata,
-  MUTATION,
-  RawResponseDataWithMaybeCacheMetadata,
-  RequestData,
-  ResponseData,
-  SUBSCRIPTION,
-} from "@graphql-box/core";
-import { rehydrateCacheMetadata } from "@graphql-box/helpers";
+  type RawResponseDataWithMaybeCacheMetadata,
+  type RequestData,
+  type ResponseData,
+} from '@graphql-box/core';
+import { rehydrateCacheMetadata } from '@graphql-box/helpers';
 import {
   getRequestContext,
   getRequestData,
   parsedRequests,
   requestFieldTypeMaps,
   responses,
-} from "@graphql-box/test-utils";
-import CacheManager, { AnalyzeQueryResult, CacheManagerDef } from ".";
+} from '@graphql-box/test-utils';
+import { expect, jest } from '@jest/globals';
+import { OperationTypeNode } from 'graphql';
+import { type AnalyzeQueryResult, CacheManager, type CacheManagerDef } from './index.ts';
 
-describe("@graphql-box/cache-manager >>", () => {
+describe('@graphql-box/cache-manager >>', () => {
   const realDateNow = Date.now.bind(global.Date);
   let cacheManager: CacheManagerDef;
 
   beforeAll(() => {
-    global.Date.now = jest.fn().mockReturnValue(Date.parse("June 6, 1979 GMT"));
+    globalThis.Date.now = jest.fn<() => number>().mockReturnValue(Date.parse('June 6, 1979 GMT'));
   });
 
   afterAll(() => {
     global.Date.now = realDateNow;
   });
 
-  describe("resolveRequest >>", () => {
+  describe('cacheResponse >>', () => {
     let responseData: ResponseData | undefined;
     let requestData: RequestData;
 
-    describe("mutation >> nested interface >>", () => {
-      describe("cascading cache control >>", () => {
+    describe('mutation >> nested interface >>', () => {
+      describe('cascading cache control >>', () => {
         beforeAll(async () => {
           responseData = undefined;
 
           cacheManager = new CacheManager({
-            cache: new Cachemap({
-              name: "cachemap",
+            cache: new Core({
+              name: 'cachemap',
               store: map(),
-              type: "someType",
+              type: 'someType',
             }),
             cascadeCacheControl: true,
             typeIDKey: DEFAULT_TYPE_ID_KEY,
@@ -56,35 +55,38 @@ describe("@graphql-box/cache-manager >>", () => {
             requestData,
             responses.nestedInterfaceMutation,
             { awaitDataCaching: true },
-            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedInterfaceMutation, operation: MUTATION }),
+            getRequestContext({
+              fieldTypeMap: requestFieldTypeMaps.nestedInterfaceMutation,
+              operation: OperationTypeNode.MUTATION,
+            })
           );
         });
 
-        it("correct response data", () => {
+        it('correct response data', () => {
           expect(responseData).toMatchSnapshot();
         });
 
-        it("correct cache data", async () => {
-          expect(await cacheManager.cache.export()).toMatchSnapshot();
+        it('correct cache data', async () => {
+          await expect(cacheManager.cache.export()).resolves.toMatchSnapshot();
         });
       });
 
-      describe("type cache directives >>", () => {
+      describe('type cache directives >>', () => {
         beforeAll(async () => {
           responseData = undefined;
 
           cacheManager = new CacheManager({
-            cache: new Cachemap({
-              name: "cachemap",
+            cache: new Core({
+              name: 'cachemap',
               store: map(),
-              type: "someType",
+              type: 'someType',
             }),
             typeCacheDirectives: {
-              AddStarPayload: "no-cache, no-store",
-              StargazerConnection: "public, max-age=1",
-              StargazerEdge: "public, max-age=1",
-              Starrable: "public, max-age=10",
-              User: "public, max-age=5",
+              AddStarPayload: 'no-cache, no-store',
+              StargazerConnection: 'public, max-age=1',
+              StargazerEdge: 'public, max-age=1',
+              Starrable: 'public, max-age=10',
+              User: 'public, max-age=5',
             },
             typeIDKey: DEFAULT_TYPE_ID_KEY,
           });
@@ -95,30 +97,33 @@ describe("@graphql-box/cache-manager >>", () => {
             requestData,
             responses.nestedInterfaceMutation,
             { awaitDataCaching: true },
-            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedInterfaceMutation, operation: MUTATION }),
+            getRequestContext({
+              fieldTypeMap: requestFieldTypeMaps.nestedInterfaceMutation,
+              operation: OperationTypeNode.MUTATION,
+            })
           );
         });
 
-        it("correct response data", () => {
+        it('correct response data', () => {
           expect(responseData).toMatchSnapshot();
         });
 
-        it("correct cache data", async () => {
-          expect(await cacheManager.cache.export()).toMatchSnapshot();
+        it('correct cache data', async () => {
+          await expect(cacheManager.cache.export()).resolves.toMatchSnapshot();
         });
       });
     });
 
-    describe("subscription >> nested type >>", () => {
-      describe("cascading cache control >>", () => {
+    describe('subscription >> nested type >>', () => {
+      describe('cascading cache control >>', () => {
         beforeAll(async () => {
           responseData = undefined;
 
           cacheManager = new CacheManager({
-            cache: new Cachemap({
-              name: "cachemap",
+            cache: new Core({
+              name: 'cachemap',
               store: map(),
-              type: "someType",
+              type: 'someType',
             }),
             cascadeCacheControl: true,
             typeIDKey: DEFAULT_TYPE_ID_KEY,
@@ -130,32 +135,35 @@ describe("@graphql-box/cache-manager >>", () => {
             requestData,
             responses.nestedTypeSubscription,
             { awaitDataCaching: true },
-            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedTypeSubscription, operation: SUBSCRIPTION }),
+            getRequestContext({
+              fieldTypeMap: requestFieldTypeMaps.nestedTypeSubscription,
+              operation: OperationTypeNode.SUBSCRIPTION,
+            })
           );
         });
 
-        it("correct response data", () => {
+        it('correct response data', () => {
           expect(responseData).toMatchSnapshot();
         });
 
-        it("correct cache data", async () => {
-          expect(await cacheManager.cache.export()).toMatchSnapshot();
+        it('correct cache data', async () => {
+          await expect(cacheManager.cache.export()).resolves.toMatchSnapshot();
         });
       });
 
-      describe("type cache directives >>", () => {
+      describe('type cache directives >>', () => {
         beforeAll(async () => {
           responseData = undefined;
 
           cacheManager = new CacheManager({
-            cache: new Cachemap({
-              name: "cachemap",
+            cache: new Core({
+              name: 'cachemap',
               store: map(),
-              type: "someType",
+              type: 'someType',
             }),
             typeCacheDirectives: {
-              Email: "public, max-age=5",
-              Inbox: "public, max-age=1",
+              Email: 'public, max-age=5',
+              Inbox: 'public, max-age=1',
             },
             typeIDKey: DEFAULT_TYPE_ID_KEY,
           });
@@ -166,36 +174,39 @@ describe("@graphql-box/cache-manager >>", () => {
             requestData,
             responses.nestedTypeSubscription,
             { awaitDataCaching: true },
-            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedTypeSubscription, operation: SUBSCRIPTION }),
+            getRequestContext({
+              fieldTypeMap: requestFieldTypeMaps.nestedTypeSubscription,
+              operation: OperationTypeNode.SUBSCRIPTION,
+            })
           );
         });
 
-        it("correct response data", () => {
+        it('correct response data', () => {
           expect(responseData).toMatchSnapshot();
         });
 
-        it("correct cache data", async () => {
-          expect(await cacheManager.cache.export()).toMatchSnapshot();
+        it('correct cache data', async () => {
+          await expect(cacheManager.cache.export()).resolves.toMatchSnapshot();
         });
       });
     });
   });
 
-  describe("resolveQuery >>", () => {
+  describe('cacheQuery >>', () => {
     let responseData: ResponseData | undefined;
     let requestData: RequestData;
 
-    describe("not filtered >>", () => {
-      describe("single type >>", () => {
-        describe("cascading cache control >>", () => {
+    describe('not filtered >>', () => {
+      describe('single type >>', () => {
+        describe('cascading cache control >>', () => {
           beforeAll(async () => {
             responseData = undefined;
 
             cacheManager = new CacheManager({
-              cache: new Cachemap({
-                name: "cachemap",
+              cache: new Core({
+                name: 'cachemap',
                 store: map(),
-                type: "someType",
+                type: 'someType',
               }),
               cascadeCacheControl: true,
               typeIDKey: DEFAULT_TYPE_ID_KEY,
@@ -208,31 +219,31 @@ describe("@graphql-box/cache-manager >>", () => {
               requestData,
               responses.singleTypeQuery,
               { awaitDataCaching: true },
-              getRequestContext({ fieldTypeMap: requestFieldTypeMaps.singleTypeQuery }),
+              getRequestContext({ fieldTypeMap: requestFieldTypeMaps.singleTypeQuery })
             );
           });
 
-          it("correct response data", () => {
+          it('correct response data', () => {
             expect(responseData).toMatchSnapshot();
           });
 
-          it("correct cache data", async () => {
-            expect(await cacheManager.cache.export()).toMatchSnapshot();
+          it('correct cache data', async () => {
+            await expect(cacheManager.cache.export()).resolves.toMatchSnapshot();
           });
         });
 
-        describe("type cache directives >>", () => {
+        describe('type cache directives >>', () => {
           beforeAll(async () => {
             responseData = undefined;
 
             cacheManager = new CacheManager({
-              cache: new Cachemap({
-                name: "cachemap",
+              cache: new Core({
+                name: 'cachemap',
                 store: map(),
-                type: "someType",
+                type: 'someType',
               }),
               typeCacheDirectives: {
-                Organization: "public, max-age=1",
+                Organization: 'public, max-age=1',
               },
               typeIDKey: DEFAULT_TYPE_ID_KEY,
             });
@@ -244,30 +255,30 @@ describe("@graphql-box/cache-manager >>", () => {
               requestData,
               responses.singleTypeQuery,
               { awaitDataCaching: true },
-              getRequestContext({ fieldTypeMap: requestFieldTypeMaps.singleTypeQuery }),
+              getRequestContext({ fieldTypeMap: requestFieldTypeMaps.singleTypeQuery })
             );
           });
 
-          it("correct response data", () => {
+          it('correct response data', () => {
             expect(responseData).toMatchSnapshot();
           });
 
-          it("correct cache data", async () => {
-            expect(await cacheManager.cache.export()).toMatchSnapshot();
+          it('correct cache data', async () => {
+            await expect(cacheManager.cache.export()).resolves.toMatchSnapshot();
           });
         });
       });
 
-      describe("nested type with edges >>", () => {
-        describe("cascading cache control >>", () => {
+      describe('nested type with edges >>', () => {
+        describe('cascading cache control >>', () => {
           beforeAll(async () => {
             responseData = undefined;
 
             cacheManager = new CacheManager({
-              cache: new Cachemap({
-                name: "cachemap",
+              cache: new Core({
+                name: 'cachemap',
                 store: map(),
-                type: "someType",
+                type: 'someType',
               }),
               cascadeCacheControl: true,
               typeIDKey: DEFAULT_TYPE_ID_KEY,
@@ -280,34 +291,34 @@ describe("@graphql-box/cache-manager >>", () => {
               requestData,
               responses.nestedTypeQuery,
               { awaitDataCaching: true },
-              getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedTypeQuery }),
+              getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedTypeQuery })
             );
           });
 
-          it("correct response data", () => {
+          it('correct response data', () => {
             expect(responseData).toMatchSnapshot();
           });
 
-          it("correct cache data", async () => {
-            expect(await cacheManager.cache.export()).toMatchSnapshot();
+          it('correct cache data', async () => {
+            await expect(cacheManager.cache.export()).resolves.toMatchSnapshot();
           });
         });
 
-        describe("type cache directives >>", () => {
+        describe('type cache directives >>', () => {
           beforeAll(async () => {
             responseData = undefined;
 
             cacheManager = new CacheManager({
-              cache: new Cachemap({
-                name: "cachemap",
+              cache: new Core({
+                name: 'cachemap',
                 store: map(),
-                type: "someType",
+                type: 'someType',
               }),
               typeCacheDirectives: {
-                Organization: "public, max-age=3",
-                Repository: "public, max-age=2",
-                RepositoryConnection: "public, max-age=1",
-                RepositoryOwner: "public, max-age=10",
+                Organization: 'public, max-age=3',
+                Repository: 'public, max-age=2',
+                RepositoryConnection: 'public, max-age=1',
+                RepositoryOwner: 'public, max-age=10',
               },
               typeIDKey: DEFAULT_TYPE_ID_KEY,
             });
@@ -319,30 +330,30 @@ describe("@graphql-box/cache-manager >>", () => {
               requestData,
               responses.nestedTypeQuery,
               { awaitDataCaching: true },
-              getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedTypeQuery }),
+              getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedTypeQuery })
             );
           });
 
-          it("correct response data", () => {
+          it('correct response data', () => {
             expect(responseData).toMatchSnapshot();
           });
 
-          it("correct cache data", async () => {
-            expect(await cacheManager.cache.export()).toMatchSnapshot();
+          it('correct cache data', async () => {
+            await expect(cacheManager.cache.export()).resolves.toMatchSnapshot();
           });
         });
       });
 
-      describe("nested union with edges >>", () => {
-        describe("cascading cache control >>", () => {
+      describe('nested union with edges >>', () => {
+        describe('cascading cache control >>', () => {
           beforeAll(async () => {
             responseData = undefined;
 
             cacheManager = new CacheManager({
-              cache: new Cachemap({
-                name: "cachemap",
+              cache: new Core({
+                name: 'cachemap',
                 store: map(),
-                type: "someType",
+                type: 'someType',
               }),
               cascadeCacheControl: true,
               typeIDKey: DEFAULT_TYPE_ID_KEY,
@@ -355,32 +366,32 @@ describe("@graphql-box/cache-manager >>", () => {
               requestData,
               responses.nestedUnionQuery,
               { awaitDataCaching: true },
-              getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedUnionQuery }),
+              getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedUnionQuery })
             );
           });
 
-          it("correct response data", () => {
+          it('correct response data', () => {
             expect(responseData).toMatchSnapshot();
           });
 
-          it("correct cache data", async () => {
-            expect(await cacheManager.cache.export()).toMatchSnapshot();
+          it('correct cache data', async () => {
+            await expect(cacheManager.cache.export()).resolves.toMatchSnapshot();
           });
         });
 
-        describe("type cache directives >>", () => {
+        describe('type cache directives >>', () => {
           beforeAll(async () => {
             responseData = undefined;
 
             cacheManager = new CacheManager({
-              cache: new Cachemap({
-                name: "cachemap",
+              cache: new Core({
+                name: 'cachemap',
                 store: map(),
-                type: "someType",
+                type: 'someType',
               }),
               typeCacheDirectives: {
-                SearchResultItem: "public, max-age=1",
-                SearchResultItemConnection: "public, max-age=3",
+                SearchResultItem: 'public, max-age=1',
+                SearchResultItemConnection: 'public, max-age=3',
               },
               typeIDKey: DEFAULT_TYPE_ID_KEY,
             });
@@ -392,34 +403,34 @@ describe("@graphql-box/cache-manager >>", () => {
               requestData,
               responses.nestedUnionQuery,
               { awaitDataCaching: true },
-              getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedUnionQuery }),
+              getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedUnionQuery })
             );
           });
 
-          it("correct response data", () => {
+          it('correct response data', () => {
             expect(responseData).toMatchSnapshot();
           });
 
-          it("correct cache data", async () => {
-            expect(await cacheManager.cache.export()).toMatchSnapshot();
+          it('correct cache data', async () => {
+            await expect(cacheManager.cache.export()).resolves.toMatchSnapshot();
           });
         });
       });
     });
 
-    describe("filtered >>", () => {
-      describe("single type >>", () => {
-        describe("cascading cache control >>", () => {
+    describe('filtered >>', () => {
+      describe('single type >>', () => {
+        describe('cascading cache control >>', () => {
           beforeAll(async () => {
             responseData = undefined;
-            // @ts-ignore
-            jest.spyOn(CacheManager, "_isValid").mockReturnValue(true);
+            // @ts-expect-error property is private
+            jest.spyOn(CacheManager, '_isValid').mockReturnValue(true);
 
             cacheManager = new CacheManager({
-              cache: new Cachemap({
-                name: "cachemap",
+              cache: new Core({
+                name: 'cachemap',
                 store: map(),
-                type: "someType",
+                type: 'someType',
               }),
               cascadeCacheControl: true,
               typeIDKey: DEFAULT_TYPE_ID_KEY,
@@ -432,14 +443,16 @@ describe("@graphql-box/cache-manager >>", () => {
               requestData,
               responses.singleTypeQuerySet.initial,
               { awaitDataCaching: true },
-              getRequestContext({ fieldTypeMap: requestFieldTypeMaps.singleTypeQuery }),
+              getRequestContext({ fieldTypeMap: requestFieldTypeMaps.singleTypeQuery })
             );
 
             const { cacheMetadata, data } = responses.singleTypeQuerySet.partial;
 
-            // @ts-ignore
-            jest.spyOn(cacheManager._partialQueryResponses, "get").mockReturnValue({
-              cacheMetadata: rehydrateCacheMetadata(cacheMetadata as DehydratedCacheMetadata),
+            // @ts-expect-error property is private
+            // eslint-disable-next-line max-len
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+            jest.spyOn(cacheManager._partialQueryResponses, 'get').mockReturnValue({
+              cacheMetadata: rehydrateCacheMetadata(cacheMetadata),
               data,
             });
 
@@ -448,33 +461,33 @@ describe("@graphql-box/cache-manager >>", () => {
               getRequestData(parsedRequests.singleTypeQuerySet.updated),
               responses.singleTypeQuerySet.updated as RawResponseDataWithMaybeCacheMetadata,
               { awaitDataCaching: true },
-              getRequestContext({ fieldTypeMap: requestFieldTypeMaps.singleTypeQuery, queryFiltered: true }),
+              getRequestContext({ fieldTypeMap: requestFieldTypeMaps.singleTypeQuery, queryFiltered: true })
             );
           });
 
-          it("correct response data", () => {
+          it('correct response data', () => {
             expect(responseData).toMatchSnapshot();
           });
 
-          it("correct cache data", async () => {
-            expect(await cacheManager.cache.export()).toMatchSnapshot();
+          it('correct cache data', async () => {
+            await expect(cacheManager.cache.export()).resolves.toMatchSnapshot();
           });
         });
 
-        describe("type cache directives >>", () => {
+        describe('type cache directives >>', () => {
           beforeAll(async () => {
             responseData = undefined;
-            // @ts-ignore
-            jest.spyOn(CacheManager, "_isValid").mockReturnValue(true);
+            // @ts-expect-error property is private
+            jest.spyOn(CacheManager, '_isValid').mockReturnValue(true);
 
             cacheManager = new CacheManager({
-              cache: new Cachemap({
-                name: "cachemap",
+              cache: new Core({
+                name: 'cachemap',
                 store: map(),
-                type: "someType",
+                type: 'someType',
               }),
               typeCacheDirectives: {
-                Organization: "public, max-age=1",
+                Organization: 'public, max-age=1',
               },
               typeIDKey: DEFAULT_TYPE_ID_KEY,
             });
@@ -486,14 +499,16 @@ describe("@graphql-box/cache-manager >>", () => {
               requestData,
               responses.singleTypeQuerySet.initial,
               { awaitDataCaching: true },
-              getRequestContext({ fieldTypeMap: requestFieldTypeMaps.singleTypeQuery }),
+              getRequestContext({ fieldTypeMap: requestFieldTypeMaps.singleTypeQuery })
             );
 
             const { cacheMetadata, data } = responses.singleTypeQuerySet.partial;
 
-            // @ts-ignore
-            jest.spyOn(cacheManager._partialQueryResponses, "get").mockReturnValue({
-              cacheMetadata: rehydrateCacheMetadata(cacheMetadata as DehydratedCacheMetadata),
+            // @ts-expect-error property is private
+            // eslint-disable-next-line max-len
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+            jest.spyOn(cacheManager._partialQueryResponses, 'get').mockReturnValue({
+              cacheMetadata: rehydrateCacheMetadata(cacheMetadata),
               data,
             });
 
@@ -502,32 +517,32 @@ describe("@graphql-box/cache-manager >>", () => {
               getRequestData(parsedRequests.singleTypeQuerySet.updated),
               responses.singleTypeQuerySet.updated as RawResponseDataWithMaybeCacheMetadata,
               { awaitDataCaching: true },
-              getRequestContext({ fieldTypeMap: requestFieldTypeMaps.singleTypeQuery, queryFiltered: true }),
+              getRequestContext({ fieldTypeMap: requestFieldTypeMaps.singleTypeQuery, queryFiltered: true })
             );
           });
 
-          it("correct response data", () => {
+          it('correct response data', () => {
             expect(responseData).toMatchSnapshot();
           });
 
-          it("correct cache data", async () => {
-            expect(await cacheManager.cache.export()).toMatchSnapshot();
+          it('correct cache data', async () => {
+            await expect(cacheManager.cache.export()).resolves.toMatchSnapshot();
           });
         });
       });
 
-      describe("nested type with edges >>", () => {
-        describe("cascading cache control >>", () => {
+      describe('nested type with edges >>', () => {
+        describe('cascading cache control >>', () => {
           beforeAll(async () => {
             responseData = undefined;
-            // @ts-ignore
-            jest.spyOn(CacheManager, "_isValid").mockReturnValue(true);
+            // @ts-expect-error property is private
+            jest.spyOn(CacheManager, '_isValid').mockReturnValue(true);
 
             cacheManager = new CacheManager({
-              cache: new Cachemap({
-                name: "cachemap",
+              cache: new Core({
+                name: 'cachemap',
                 store: map(),
-                type: "someType",
+                type: 'someType',
               }),
               cascadeCacheControl: true,
               typeIDKey: DEFAULT_TYPE_ID_KEY,
@@ -540,14 +555,16 @@ describe("@graphql-box/cache-manager >>", () => {
               requestData,
               responses.nestedTypeQuerySet.initial,
               { awaitDataCaching: true },
-              getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedTypeQuery }),
+              getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedTypeQuery })
             );
 
             const { cacheMetadata, data } = responses.nestedTypeQuerySet.partial;
 
-            // @ts-ignore
-            jest.spyOn(cacheManager._partialQueryResponses, "get").mockReturnValue({
-              cacheMetadata: rehydrateCacheMetadata(cacheMetadata as DehydratedCacheMetadata),
+            // @ts-expect-error property is private
+            // eslint-disable-next-line max-len
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+            jest.spyOn(cacheManager._partialQueryResponses, 'get').mockReturnValue({
+              cacheMetadata: rehydrateCacheMetadata(cacheMetadata),
               data,
             });
 
@@ -556,36 +573,36 @@ describe("@graphql-box/cache-manager >>", () => {
               getRequestData(parsedRequests.nestedTypeQuerySet.updated),
               responses.nestedTypeQuerySet.updated as RawResponseDataWithMaybeCacheMetadata,
               { awaitDataCaching: true },
-              getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedTypeQuery, queryFiltered: true }),
+              getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedTypeQuery, queryFiltered: true })
             );
           });
 
-          it("correct response data", () => {
+          it('correct response data', () => {
             expect(responseData).toMatchSnapshot();
           });
 
-          it("correct cache data", async () => {
-            expect(await cacheManager.cache.export()).toMatchSnapshot();
+          it('correct cache data', async () => {
+            await expect(cacheManager.cache.export()).resolves.toMatchSnapshot();
           });
         });
 
-        describe("type cache directives >>", () => {
+        describe('type cache directives >>', () => {
           beforeAll(async () => {
             responseData = undefined;
-            // @ts-ignore
-            jest.spyOn(CacheManager, "_isValid").mockReturnValue(true);
+            // @ts-expect-error property is private
+            jest.spyOn(CacheManager, '_isValid').mockReturnValue(true);
 
             cacheManager = new CacheManager({
-              cache: new Cachemap({
-                name: "cachemap",
+              cache: new Core({
+                name: 'cachemap',
                 store: map(),
-                type: "someType",
+                type: 'someType',
               }),
               typeCacheDirectives: {
-                Organization: "public, max-age=3",
-                Repository: "public, max-age=2",
-                RepositoryConnection: "public, max-age=1",
-                RepositoryOwner: "public, max-age=10",
+                Organization: 'public, max-age=3',
+                Repository: 'public, max-age=2',
+                RepositoryConnection: 'public, max-age=1',
+                RepositoryOwner: 'public, max-age=10',
               },
               typeIDKey: DEFAULT_TYPE_ID_KEY,
             });
@@ -597,14 +614,16 @@ describe("@graphql-box/cache-manager >>", () => {
               requestData,
               responses.nestedTypeQuerySet.initial,
               { awaitDataCaching: true },
-              getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedTypeQuery }),
+              getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedTypeQuery })
             );
 
             const { cacheMetadata, data } = responses.nestedTypeQuerySet.partial;
 
-            // @ts-ignore
-            jest.spyOn(cacheManager._partialQueryResponses, "get").mockReturnValue({
-              cacheMetadata: rehydrateCacheMetadata(cacheMetadata as DehydratedCacheMetadata),
+            // @ts-expect-error property is private
+            // eslint-disable-next-line max-len
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+            jest.spyOn(cacheManager._partialQueryResponses, 'get').mockReturnValue({
+              cacheMetadata: rehydrateCacheMetadata(cacheMetadata),
               data,
             });
 
@@ -613,32 +632,32 @@ describe("@graphql-box/cache-manager >>", () => {
               getRequestData(parsedRequests.nestedTypeQuerySet.updated),
               responses.nestedTypeQuerySet.updated as RawResponseDataWithMaybeCacheMetadata,
               { awaitDataCaching: true },
-              getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedTypeQuery, queryFiltered: true }),
+              getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedTypeQuery, queryFiltered: true })
             );
           });
 
-          it("correct response data", () => {
+          it('correct response data', () => {
             expect(responseData).toMatchSnapshot();
           });
 
-          it("correct cache data", async () => {
-            expect(await cacheManager.cache.export()).toMatchSnapshot();
+          it('correct cache data', async () => {
+            await expect(cacheManager.cache.export()).resolves.toMatchSnapshot();
           });
         });
       });
 
-      describe("nested union with edges >>", () => {
-        describe("cascading cache control >>", () => {
+      describe('nested union with edges >>', () => {
+        describe('cascading cache control >>', () => {
           beforeAll(async () => {
             responseData = undefined;
-            // @ts-ignore
-            jest.spyOn(CacheManager, "_isValid").mockReturnValue(true);
+            // @ts-expect-error property is private
+            jest.spyOn(CacheManager, '_isValid').mockReturnValue(true);
 
             cacheManager = new CacheManager({
-              cache: new Cachemap({
-                name: "cachemap",
+              cache: new Core({
+                name: 'cachemap',
                 store: map(),
-                type: "someType",
+                type: 'someType',
               }),
               cascadeCacheControl: true,
               typeIDKey: DEFAULT_TYPE_ID_KEY,
@@ -651,14 +670,16 @@ describe("@graphql-box/cache-manager >>", () => {
               requestData,
               responses.nestedUnionQuerySet.initial,
               { awaitDataCaching: true },
-              getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedUnionQuery }),
+              getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedUnionQuery })
             );
 
             const { cacheMetadata, data } = responses.nestedUnionQuerySet.partial;
 
-            // @ts-ignore
-            jest.spyOn(cacheManager._partialQueryResponses, "get").mockReturnValue({
-              cacheMetadata: rehydrateCacheMetadata(cacheMetadata as DehydratedCacheMetadata),
+            // @ts-expect-error property is private
+            // eslint-disable-next-line max-len
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+            jest.spyOn(cacheManager._partialQueryResponses, 'get').mockReturnValue({
+              cacheMetadata: rehydrateCacheMetadata(cacheMetadata),
               data,
             });
 
@@ -667,34 +688,34 @@ describe("@graphql-box/cache-manager >>", () => {
               getRequestData(parsedRequests.nestedUnionQuerySet.updated),
               responses.nestedUnionQuerySet.updated as RawResponseDataWithMaybeCacheMetadata,
               { awaitDataCaching: true },
-              getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedUnionQuery, queryFiltered: true }),
+              getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedUnionQuery, queryFiltered: true })
             );
           });
 
-          it("correct response data", () => {
+          it('correct response data', () => {
             expect(responseData).toMatchSnapshot();
           });
 
-          it("correct cache data", async () => {
-            expect(await cacheManager.cache.export()).toMatchSnapshot();
+          it('correct cache data', async () => {
+            await expect(cacheManager.cache.export()).resolves.toMatchSnapshot();
           });
         });
 
-        describe("type cache directives >>", () => {
+        describe('type cache directives >>', () => {
           beforeAll(async () => {
             responseData = undefined;
-            // @ts-ignore
-            jest.spyOn(CacheManager, "_isValid").mockReturnValue(true);
+            // @ts-expect-error property is private
+            jest.spyOn(CacheManager, '_isValid').mockReturnValue(true);
 
             cacheManager = new CacheManager({
-              cache: new Cachemap({
-                name: "cachemap",
+              cache: new Core({
+                name: 'cachemap',
                 store: map(),
-                type: "someType",
+                type: 'someType',
               }),
               typeCacheDirectives: {
-                SearchResultItem: "public, max-age=1",
-                SearchResultItemConnection: "public, max-age=3",
+                SearchResultItem: 'public, max-age=1',
+                SearchResultItemConnection: 'public, max-age=3',
               },
               typeIDKey: DEFAULT_TYPE_ID_KEY,
             });
@@ -706,14 +727,16 @@ describe("@graphql-box/cache-manager >>", () => {
               requestData,
               responses.nestedUnionQuerySet.initial,
               { awaitDataCaching: true },
-              getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedUnionQuery }),
+              getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedUnionQuery })
             );
 
             const { cacheMetadata, data } = responses.nestedUnionQuerySet.partial;
 
-            // @ts-ignore
-            jest.spyOn(cacheManager._partialQueryResponses, "get").mockReturnValue({
-              cacheMetadata: rehydrateCacheMetadata(cacheMetadata as DehydratedCacheMetadata),
+            // @ts-expect-error property is private
+            // eslint-disable-next-line max-len
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+            jest.spyOn(cacheManager._partialQueryResponses, 'get').mockReturnValue({
+              cacheMetadata: rehydrateCacheMetadata(cacheMetadata),
               data,
             });
 
@@ -722,33 +745,33 @@ describe("@graphql-box/cache-manager >>", () => {
               getRequestData(parsedRequests.nestedUnionQuerySet.updated),
               responses.nestedUnionQuerySet.updated as RawResponseDataWithMaybeCacheMetadata,
               { awaitDataCaching: true },
-              getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedUnionQuery, queryFiltered: true }),
+              getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedUnionQuery, queryFiltered: true })
             );
           });
 
-          it("correct response data", () => {
+          it('correct response data', () => {
             expect(responseData).toMatchSnapshot();
           });
 
-          it("correct cache data", async () => {
-            expect(await cacheManager.cache.export()).toMatchSnapshot();
+          it('correct cache data', async () => {
+            await expect(cacheManager.cache.export()).resolves.toMatchSnapshot();
           });
         });
       });
 
-      describe("defer >>", () => {
-        describe("cascading cache control >>", () => {
+      describe('defer >>', () => {
+        describe('cascading cache control >>', () => {
           const responseDataSet: ResponseData[] = [];
 
           beforeAll(async () => {
-            // @ts-ignore
-            jest.spyOn(CacheManager, "_isValid").mockReturnValue(true);
+            // @ts-expect-error property is private
+            jest.spyOn(CacheManager, '_isValid').mockReturnValue(true);
 
             cacheManager = new CacheManager({
-              cache: new Cachemap({
-                name: "cachemap",
+              cache: new Core({
+                name: 'cachemap',
                 store: map(),
-                type: "someType",
+                type: 'someType',
               }),
               cascadeCacheControl: true,
               typeIDKey: DEFAULT_TYPE_ID_KEY,
@@ -761,68 +784,72 @@ describe("@graphql-box/cache-manager >>", () => {
               requestData,
               responses.deferQuerySet.initial,
               { awaitDataCaching: true },
-              getRequestContext({ fieldTypeMap: requestFieldTypeMaps.deferQuery, hasDeferOrStream: true }),
+              getRequestContext({ fieldTypeMap: requestFieldTypeMaps.deferQuery, hasDeferOrStream: true })
             );
 
             const { cacheMetadata, data } = responses.deferQuerySet.partial;
 
-            // @ts-ignore
-            jest.spyOn(cacheManager._partialQueryResponses, "get").mockReturnValue({
-              cacheMetadata: rehydrateCacheMetadata(cacheMetadata as DehydratedCacheMetadata),
+            // @ts-expect-error property is private
+            // eslint-disable-next-line max-len
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+            jest.spyOn(cacheManager._partialQueryResponses, 'get').mockReturnValue({
+              cacheMetadata: rehydrateCacheMetadata(cacheMetadata),
               data,
             });
 
-            await new Promise((resolve: (value: void) => void) => {
+            await new Promise<void>(resolve => {
               const updateResponses = [...(responses.deferQuerySet.updated as RawResponseDataWithMaybeCacheMetadata[])];
 
-              const interval = setInterval(async () => {
-                const result = await cacheManager.cacheQuery(
-                  getRequestData(parsedRequests.deferQuerySet.full),
-                  getRequestData(parsedRequests.deferQuerySet.updated),
-                  updateResponses.shift() as RawResponseDataWithMaybeCacheMetadata,
-                  { awaitDataCaching: true },
-                  getRequestContext({
-                    fieldTypeMap: requestFieldTypeMaps.deferQuery,
-                    hasDeferOrStream: true,
-                    queryFiltered: true,
-                  }),
-                );
-
-                responseDataSet.push(result);
-
-                if (!updateResponses.length) {
-                  clearInterval(interval);
-                  resolve();
-                }
+              const interval = setInterval(() => {
+                void (async () => {
+                  const result = await cacheManager.cacheQuery(
+                    getRequestData(parsedRequests.deferQuerySet.full),
+                    getRequestData(parsedRequests.deferQuerySet.updated),
+                    updateResponses.shift()!,
+                    { awaitDataCaching: true },
+                    getRequestContext({
+                      fieldTypeMap: requestFieldTypeMaps.deferQuery,
+                      hasDeferOrStream: true,
+                      queryFiltered: true,
+                    })
+                  );
+
+                  responseDataSet.push(result);
+
+                  if (updateResponses.length === 0) {
+                    clearInterval(interval);
+                    resolve();
+                  }
+                })();
               }, 50);
             });
           });
 
-          it("correct response data", () => {
+          it('correct response data', () => {
             expect(responseDataSet).toMatchSnapshot();
           });
 
-          it("correct cache data", async () => {
-            expect(await cacheManager.cache.export()).toMatchSnapshot();
+          it('correct cache data', async () => {
+            await expect(cacheManager.cache.export()).resolves.toMatchSnapshot();
           });
         });
       });
     });
   });
 
-  describe("analyzeQuery >>", () => {
+  describe('analyzeQuery >>', () => {
     let analyzeQueryResult: AnalyzeQueryResult | undefined;
 
-    describe("no matching data >>", () => {
-      describe("single type >>", () => {
+    describe('no matching data >>', () => {
+      describe('single type >>', () => {
         beforeAll(async () => {
           analyzeQueryResult = undefined;
 
           cacheManager = new CacheManager({
-            cache: new Cachemap({
-              name: "cachemap",
+            cache: new Core({
+              name: 'cachemap',
               store: map(),
-              type: "someType",
+              type: 'someType',
             }),
             typeIDKey: DEFAULT_TYPE_ID_KEY,
           });
@@ -830,29 +857,29 @@ describe("@graphql-box/cache-manager >>", () => {
           analyzeQueryResult = await cacheManager.analyzeQuery(
             getRequestData(parsedRequests.singleTypeQuery),
             { awaitDataCaching: true },
-            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.singleTypeQuery }),
+            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.singleTypeQuery })
           );
         });
 
-        it("correct request data", () => {
-          const { ast, ...otherProps } = analyzeQueryResult?.updated as RequestData;
+        it('correct request data', () => {
+          const { ast, ...otherProps } = analyzeQueryResult!.updated!;
           expect(otherProps).toMatchSnapshot();
         });
 
-        it("no response data", () => {
+        it('no response data', () => {
           expect(analyzeQueryResult?.response).toBeUndefined();
         });
       });
 
-      describe("nested type with edges >>", () => {
+      describe('nested type with edges >>', () => {
         beforeAll(async () => {
           analyzeQueryResult = undefined;
 
           cacheManager = new CacheManager({
-            cache: new Cachemap({
-              name: "cachemap",
+            cache: new Core({
+              name: 'cachemap',
               store: map(),
-              type: "someType",
+              type: 'someType',
             }),
             typeIDKey: DEFAULT_TYPE_ID_KEY,
           });
@@ -860,29 +887,29 @@ describe("@graphql-box/cache-manager >>", () => {
           analyzeQueryResult = await cacheManager.analyzeQuery(
             getRequestData(parsedRequests.nestedTypeQuery),
             { awaitDataCaching: true },
-            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedTypeQuery }),
+            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedTypeQuery })
           );
         });
 
-        it("correct request data", () => {
-          const { ast, ...otherProps } = analyzeQueryResult?.updated as RequestData;
+        it('correct request data', () => {
+          const { ast, ...otherProps } = analyzeQueryResult!.updated!;
           expect(otherProps).toMatchSnapshot();
         });
 
-        it("no response data", () => {
+        it('no response data', () => {
           expect(analyzeQueryResult?.response).toBeUndefined();
         });
       });
 
-      describe("nested union with edges >>", () => {
+      describe('nested union with edges >>', () => {
         beforeAll(async () => {
           analyzeQueryResult = undefined;
 
           cacheManager = new CacheManager({
-            cache: new Cachemap({
-              name: "cachemap",
+            cache: new Core({
+              name: 'cachemap',
               store: map(),
-              type: "someType",
+              type: 'someType',
             }),
             typeIDKey: DEFAULT_TYPE_ID_KEY,
           });
@@ -890,29 +917,29 @@ describe("@graphql-box/cache-manager >>", () => {
           analyzeQueryResult = await cacheManager.analyzeQuery(
             getRequestData(parsedRequests.nestedUnionQuery),
             { awaitDataCaching: true },
-            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedUnionQuery }),
+            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedUnionQuery })
           );
         });
 
-        it("correct request data", () => {
-          const { ast, ...otherProps } = analyzeQueryResult?.updated as RequestData;
+        it('correct request data', () => {
+          const { ast, ...otherProps } = analyzeQueryResult!.updated!;
           expect(otherProps).toMatchSnapshot();
         });
 
-        it("no response data", () => {
+        it('no response data', () => {
           expect(analyzeQueryResult?.response).toBeUndefined();
         });
       });
 
-      describe("defer >>", () => {
+      describe('defer >>', () => {
         beforeAll(async () => {
           analyzeQueryResult = undefined;
 
           cacheManager = new CacheManager({
-            cache: new Cachemap({
-              name: "cachemap",
+            cache: new Core({
+              name: 'cachemap',
               store: map(),
-              type: "someType",
+              type: 'someType',
             }),
             typeIDKey: DEFAULT_TYPE_ID_KEY,
           });
@@ -920,36 +947,36 @@ describe("@graphql-box/cache-manager >>", () => {
           analyzeQueryResult = await cacheManager.analyzeQuery(
             getRequestData(parsedRequests.deferQuery),
             { awaitDataCaching: true },
-            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.deferQuery, hasDeferOrStream: true }),
+            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.deferQuery, hasDeferOrStream: true })
           );
         });
 
-        it("correct request data", () => {
-          const { ast, ...otherProps } = analyzeQueryResult?.updated as RequestData;
+        it('correct request data', () => {
+          const { ast, ...otherProps } = analyzeQueryResult!.updated!;
           expect(otherProps).toMatchSnapshot();
         });
 
-        it("no response data", () => {
+        it('no response data', () => {
           expect(analyzeQueryResult?.response).toBeUndefined();
         });
       });
     });
 
-    describe("entire matching data >>", () => {
-      describe("single type >>", () => {
+    describe('entire matching data >>', () => {
+      describe('single type >>', () => {
         beforeAll(async () => {
           analyzeQueryResult = undefined;
-          // @ts-ignore
-          jest.spyOn(CacheManager, "_isValid").mockReturnValue(true);
+          // @ts-expect-error property is private
+          jest.spyOn(CacheManager, '_isValid').mockReturnValue(true);
 
           cacheManager = new CacheManager({
-            cache: new Cachemap({
-              name: "cachemap",
+            cache: new Core({
+              name: 'cachemap',
               store: map(),
-              type: "someType",
+              type: 'someType',
             }),
             typeCacheDirectives: {
-              Organization: "public, max-age=1",
+              Organization: 'public, max-age=1',
             },
             typeIDKey: DEFAULT_TYPE_ID_KEY,
           });
@@ -961,46 +988,46 @@ describe("@graphql-box/cache-manager >>", () => {
             requestData,
             responses.singleTypeQuery,
             { awaitDataCaching: true },
-            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.singleTypeQuery }),
+            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.singleTypeQuery })
           );
 
           analyzeQueryResult = await cacheManager.analyzeQuery(
             getRequestData(parsedRequests.singleTypeQuery),
             { awaitDataCaching: true },
-            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.singleTypeQuery }),
+            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.singleTypeQuery })
           );
         });
 
-        it("no request data", () => {
+        it('no request data', () => {
           expect(analyzeQueryResult?.updated).toBeUndefined();
         });
 
-        it("correct response data", () => {
+        it('correct response data', () => {
           expect(analyzeQueryResult?.response).toMatchSnapshot();
         });
 
-        it("correct cache data", async () => {
-          expect(await cacheManager.cache.export()).toMatchSnapshot();
+        it('correct cache data', async () => {
+          await expect(cacheManager.cache.export()).resolves.toMatchSnapshot();
         });
       });
 
-      describe("nested type with edges >>", () => {
+      describe('nested type with edges >>', () => {
         beforeAll(async () => {
           analyzeQueryResult = undefined;
-          // @ts-ignore
-          jest.spyOn(CacheManager, "_isValid").mockReturnValue(true);
+          // @ts-expect-error property is private
+          jest.spyOn(CacheManager, '_isValid').mockReturnValue(true);
 
           cacheManager = new CacheManager({
-            cache: new Cachemap({
-              name: "cachemap",
+            cache: new Core({
+              name: 'cachemap',
               store: map(),
-              type: "someType",
+              type: 'someType',
             }),
             typeCacheDirectives: {
-              Organization: "public, max-age=3",
-              Repository: "public, max-age=2",
-              RepositoryConnection: "public, max-age=1",
-              RepositoryOwner: "public, max-age=10",
+              Organization: 'public, max-age=3',
+              Repository: 'public, max-age=2',
+              RepositoryConnection: 'public, max-age=1',
+              RepositoryOwner: 'public, max-age=10',
             },
             typeIDKey: DEFAULT_TYPE_ID_KEY,
           });
@@ -1012,44 +1039,44 @@ describe("@graphql-box/cache-manager >>", () => {
             requestData,
             responses.nestedTypeQuery,
             { awaitDataCaching: true },
-            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedTypeQuery }),
+            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedTypeQuery })
           );
 
           analyzeQueryResult = await cacheManager.analyzeQuery(
             getRequestData(parsedRequests.nestedTypeQuery),
             { awaitDataCaching: true },
-            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedTypeQuery }),
+            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedTypeQuery })
           );
         });
 
-        it("no request data", () => {
+        it('no request data', () => {
           expect(analyzeQueryResult?.updated).toBeUndefined();
         });
 
-        it("correct response data", () => {
+        it('correct response data', () => {
           expect(analyzeQueryResult?.response).toMatchSnapshot();
         });
 
-        it("correct cache data", async () => {
-          expect(await cacheManager.cache.export()).toMatchSnapshot();
+        it('correct cache data', async () => {
+          await expect(cacheManager.cache.export()).resolves.toMatchSnapshot();
         });
       });
 
-      describe("nested union with edges >>", () => {
+      describe('nested union with edges >>', () => {
         beforeAll(async () => {
           analyzeQueryResult = undefined;
-          // @ts-ignore
-          jest.spyOn(CacheManager, "_isValid").mockReturnValue(true);
+          // @ts-expect-error property is private
+          jest.spyOn(CacheManager, '_isValid').mockReturnValue(true);
 
           cacheManager = new CacheManager({
-            cache: new Cachemap({
-              name: "cachemap",
+            cache: new Core({
+              name: 'cachemap',
               store: map(),
-              type: "someType",
+              type: 'someType',
             }),
             typeCacheDirectives: {
-              SearchResultItem: "public, max-age=1",
-              SearchResultItemConnection: "public, max-age=3",
+              SearchResultItem: 'public, max-age=1',
+              SearchResultItemConnection: 'public, max-age=3',
             },
             typeIDKey: DEFAULT_TYPE_ID_KEY,
           });
@@ -1061,40 +1088,40 @@ describe("@graphql-box/cache-manager >>", () => {
             requestData,
             responses.nestedUnionQuery,
             { awaitDataCaching: true },
-            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedUnionQuery }),
+            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedUnionQuery })
           );
 
           analyzeQueryResult = await cacheManager.analyzeQuery(
             getRequestData(parsedRequests.nestedUnionQuery),
             { awaitDataCaching: true },
-            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedUnionQuery }),
+            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedUnionQuery })
           );
         });
 
-        it("no request data", () => {
+        it('no request data', () => {
           expect(analyzeQueryResult?.updated).toBeUndefined();
         });
 
-        it("correct response data", () => {
+        it('correct response data', () => {
           expect(analyzeQueryResult?.response).toMatchSnapshot();
         });
 
-        it("correct cache data", async () => {
-          expect(await cacheManager.cache.export()).toMatchSnapshot();
+        it('correct cache data', async () => {
+          await expect(cacheManager.cache.export()).resolves.toMatchSnapshot();
         });
       });
 
-      describe("defer >>", () => {
+      describe('defer >>', () => {
         beforeAll(async () => {
           analyzeQueryResult = undefined;
-          // @ts-ignore
-          jest.spyOn(CacheManager, "_isValid").mockReturnValue(true);
+          // @ts-expect-error property is private
+          jest.spyOn(CacheManager, '_isValid').mockReturnValue(true);
 
           cacheManager = new CacheManager({
-            cache: new Cachemap({
-              name: "cachemap",
+            cache: new Core({
+              name: 'cachemap',
               store: map(),
-              type: "someType",
+              type: 'someType',
             }),
             cascadeCacheControl: true,
             typeIDKey: DEFAULT_TYPE_ID_KEY,
@@ -1102,64 +1129,66 @@ describe("@graphql-box/cache-manager >>", () => {
 
           const requestData = getRequestData(parsedRequests.deferQuerySet.updated);
 
-          await new Promise((resolve: (value: void) => void) => {
+          await new Promise<void>(resolve => {
             const updateResponses = [...(responses.deferQuerySet.updated as RawResponseDataWithMaybeCacheMetadata[])];
 
-            const interval = setInterval(async () => {
-              await cacheManager.cacheQuery(
-                requestData,
-                requestData,
-                updateResponses.shift() as RawResponseDataWithMaybeCacheMetadata,
-                { awaitDataCaching: true },
-                getRequestContext({
-                  fieldTypeMap: requestFieldTypeMaps.deferQuery,
-                  hasDeferOrStream: true,
-                }),
-              );
-
-              if (!updateResponses.length) {
-                clearInterval(interval);
-                resolve();
-              }
+            const interval = setInterval(() => {
+              void (async () => {
+                await cacheManager.cacheQuery(
+                  requestData,
+                  requestData,
+                  updateResponses.shift()!,
+                  { awaitDataCaching: true },
+                  getRequestContext({
+                    fieldTypeMap: requestFieldTypeMaps.deferQuery,
+                    hasDeferOrStream: true,
+                  })
+                );
+
+                if (updateResponses.length === 0) {
+                  clearInterval(interval);
+                  resolve();
+                }
+              })();
             }, 50);
           });
 
           analyzeQueryResult = await cacheManager.analyzeQuery(
             requestData,
             { awaitDataCaching: true },
-            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.deferQuery, hasDeferOrStream: true }),
+            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.deferQuery, hasDeferOrStream: true })
           );
         });
 
-        it("no request data", () => {
+        it('no request data', () => {
           expect(analyzeQueryResult?.updated).toBeUndefined();
         });
 
-        it("correct response data", () => {
+        it('correct response data', () => {
           expect(analyzeQueryResult?.response).toMatchSnapshot();
         });
 
-        it("correct cache data", async () => {
-          expect(await cacheManager.cache.export()).toMatchSnapshot();
+        it('correct cache data', async () => {
+          await expect(cacheManager.cache.export()).resolves.toMatchSnapshot();
         });
       });
     });
 
-    describe("some matching data >>", () => {
-      describe("single type >>", () => {
+    describe('some matching data >>', () => {
+      describe('single type >>', () => {
         beforeAll(async () => {
           analyzeQueryResult = undefined;
-          // @ts-ignore
-          jest.spyOn(CacheManager, "_isValid").mockReturnValue(true);
+          // @ts-expect-error property is private
+          jest.spyOn(CacheManager, '_isValid').mockReturnValue(true);
 
           cacheManager = new CacheManager({
-            cache: new Cachemap({
-              name: "cachemap",
+            cache: new Core({
+              name: 'cachemap',
               store: map(),
-              type: "someType",
+              type: 'someType',
             }),
             typeCacheDirectives: {
-              Organization: "public, max-age=1",
+              Organization: 'public, max-age=1',
             },
             typeIDKey: DEFAULT_TYPE_ID_KEY,
           });
@@ -1171,49 +1200,49 @@ describe("@graphql-box/cache-manager >>", () => {
             requestData,
             responses.singleTypeQuerySet.initial,
             { awaitDataCaching: true },
-            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.singleTypeQuery }),
+            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.singleTypeQuery })
           );
 
           analyzeQueryResult = await cacheManager.analyzeQuery(
             getRequestData(parsedRequests.singleTypeQuery),
             { awaitDataCaching: true },
-            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.singleTypeQuery }),
+            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.singleTypeQuery })
           );
         });
 
-        it("correct request data", () => {
-          const { ast, ...otherProps } = analyzeQueryResult?.updated as RequestData;
+        it('correct request data', () => {
+          const { ast, ...otherProps } = analyzeQueryResult!.updated!;
           expect(otherProps).toMatchSnapshot();
         });
 
-        it("no response data", () => {
+        it('no response data', () => {
           expect(analyzeQueryResult?.response).toBeUndefined();
         });
 
-        it("correct cache data", async () => {
-          expect(await cacheManager.cache.export()).toMatchSnapshot();
+        it('correct cache data', async () => {
+          await expect(cacheManager.cache.export()).resolves.toMatchSnapshot();
         });
 
-        it("correct partial data", () => {
-          // @ts-ignore
+        it('correct partial data', () => {
+          // @ts-expect-error property is private
           expect(cacheManager._partialQueryResponses).toMatchSnapshot();
         });
       });
 
-      describe("single type with just ID match >>", () => {
+      describe('single type with just ID match >>', () => {
         beforeAll(async () => {
           analyzeQueryResult = undefined;
-          // @ts-ignore
-          jest.spyOn(CacheManager, "_isValid").mockReturnValue(true);
+          // @ts-expect-error property is private
+          jest.spyOn(CacheManager, '_isValid').mockReturnValue(true);
 
           cacheManager = new CacheManager({
-            cache: new Cachemap({
-              name: "cachemap",
+            cache: new Core({
+              name: 'cachemap',
               store: map(),
-              type: "someType",
+              type: 'someType',
             }),
             typeCacheDirectives: {
-              Organization: "public, max-age=1",
+              Organization: 'public, max-age=1',
             },
             typeIDKey: DEFAULT_TYPE_ID_KEY,
           });
@@ -1225,52 +1254,52 @@ describe("@graphql-box/cache-manager >>", () => {
             requestData,
             responses.singleTypeQuerySmallA,
             { awaitDataCaching: true },
-            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.singleTypeQuery }),
+            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.singleTypeQuery })
           );
 
           analyzeQueryResult = await cacheManager.analyzeQuery(
             getRequestData(parsedRequests.singleTypeQuerySmallB),
             { awaitDataCaching: true },
-            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.singleTypeQuery }),
+            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.singleTypeQuery })
           );
         });
 
-        it("correct request data", () => {
-          const { ast, ...otherProps } = analyzeQueryResult?.updated as RequestData;
+        it('correct request data', () => {
+          const { ast, ...otherProps } = analyzeQueryResult!.updated!;
           expect(otherProps).toMatchSnapshot();
         });
 
-        it("no response data", () => {
+        it('no response data', () => {
           expect(analyzeQueryResult?.response).toBeUndefined();
         });
 
-        it("correct cache data", async () => {
-          expect(await cacheManager.cache.export()).toMatchSnapshot();
+        it('correct cache data', async () => {
+          await expect(cacheManager.cache.export()).resolves.toMatchSnapshot();
         });
 
-        it("correct partial data", () => {
-          // @ts-ignore
+        it('correct partial data', () => {
+          // @ts-expect-error property is private
           expect(cacheManager._partialQueryResponses).toMatchSnapshot();
         });
       });
 
-      describe("nested type with edges >", () => {
+      describe('nested type with edges >', () => {
         beforeAll(async () => {
           analyzeQueryResult = undefined;
-          // @ts-ignore
-          jest.spyOn(CacheManager, "_isValid").mockReturnValue(true);
+          // @ts-expect-error property is private
+          jest.spyOn(CacheManager, '_isValid').mockReturnValue(true);
 
           cacheManager = new CacheManager({
-            cache: new Cachemap({
-              name: "cachemap",
+            cache: new Core({
+              name: 'cachemap',
               store: map(),
-              type: "someType",
+              type: 'someType',
             }),
             typeCacheDirectives: {
-              Organization: "public, max-age=3",
-              Repository: "public, max-age=2",
-              RepositoryConnection: "public, max-age=1",
-              RepositoryOwner: "public, max-age=10",
+              Organization: 'public, max-age=3',
+              Repository: 'public, max-age=2',
+              RepositoryConnection: 'public, max-age=1',
+              RepositoryOwner: 'public, max-age=10',
             },
             typeIDKey: DEFAULT_TYPE_ID_KEY,
           });
@@ -1282,50 +1311,50 @@ describe("@graphql-box/cache-manager >>", () => {
             requestData,
             responses.nestedTypeQuerySet.initial,
             { awaitDataCaching: true },
-            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedTypeQuery }),
+            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedTypeQuery })
           );
 
           analyzeQueryResult = await cacheManager.analyzeQuery(
             getRequestData(parsedRequests.nestedTypeQuery),
             { awaitDataCaching: true },
-            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedTypeQuery }),
+            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedTypeQuery })
           );
         });
 
-        it("correct request data", () => {
-          const { ast, ...otherProps } = analyzeQueryResult?.updated as RequestData;
+        it('correct request data', () => {
+          const { ast, ...otherProps } = analyzeQueryResult!.updated!;
           expect(otherProps).toMatchSnapshot();
         });
 
-        it("no response data", () => {
+        it('no response data', () => {
           expect(analyzeQueryResult?.response).toBeUndefined();
         });
 
-        it("correct cache data", async () => {
-          expect(await cacheManager.cache.export()).toMatchSnapshot();
+        it('correct cache data', async () => {
+          await expect(cacheManager.cache.export()).resolves.toMatchSnapshot();
         });
 
-        it("correct partial data", () => {
-          // @ts-ignore
+        it('correct partial data', () => {
+          // @ts-expect-error property is private
           expect(cacheManager._partialQueryResponses).toMatchSnapshot();
         });
       });
 
-      describe("nested union with edges >>", () => {
+      describe('nested union with edges >>', () => {
         beforeAll(async () => {
           analyzeQueryResult = undefined;
-          // @ts-ignore
-          jest.spyOn(CacheManager, "_isValid").mockReturnValue(true);
+          // @ts-expect-error property is private
+          jest.spyOn(CacheManager, '_isValid').mockReturnValue(true);
 
           cacheManager = new CacheManager({
-            cache: new Cachemap({
-              name: "cachemap",
+            cache: new Core({
+              name: 'cachemap',
               store: map(),
-              type: "someType",
+              type: 'someType',
             }),
             typeCacheDirectives: {
-              SearchResultItem: "public, max-age=1",
-              SearchResultItemConnection: "public, max-age=3",
+              SearchResultItem: 'public, max-age=1',
+              SearchResultItemConnection: 'public, max-age=3',
             },
             typeIDKey: DEFAULT_TYPE_ID_KEY,
           });
@@ -1337,46 +1366,46 @@ describe("@graphql-box/cache-manager >>", () => {
             requestData,
             responses.nestedUnionQuerySet.initial,
             { awaitDataCaching: true },
-            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedUnionQuery }),
+            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedUnionQuery })
           );
 
           analyzeQueryResult = await cacheManager.analyzeQuery(
             getRequestData(parsedRequests.nestedUnionQuery),
             { awaitDataCaching: true },
-            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedUnionQuery }),
+            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.nestedUnionQuery })
           );
         });
 
-        it("correct request data", () => {
-          const { ast, ...otherProps } = analyzeQueryResult?.updated as RequestData;
+        it('correct request data', () => {
+          const { ast, ...otherProps } = analyzeQueryResult!.updated!;
           expect(otherProps).toMatchSnapshot();
         });
 
-        it("no response data", () => {
+        it('no response data', () => {
           expect(analyzeQueryResult?.response).toBeUndefined();
         });
 
-        it("correct cache data", async () => {
-          expect(await cacheManager.cache.export()).toMatchSnapshot();
+        it('correct cache data', async () => {
+          await expect(cacheManager.cache.export()).resolves.toMatchSnapshot();
         });
 
-        it("correct partial data", () => {
-          // @ts-ignore
+        it('correct partial data', () => {
+          // @ts-expect-error property is private
           expect(cacheManager._partialQueryResponses).toMatchSnapshot();
         });
       });
 
-      describe("fragment spreads >> within fragment spreads >>", () => {
+      describe('fragment spreads >> within fragment spreads >>', () => {
         beforeAll(async () => {
           analyzeQueryResult = undefined;
-          // @ts-ignore
-          jest.spyOn(CacheManager, "_isValid").mockReturnValue(true);
+          // @ts-expect-error property is private
+          jest.spyOn(CacheManager, '_isValid').mockReturnValue(true);
 
           cacheManager = new CacheManager({
-            cache: new Cachemap({
-              name: "cachemap",
+            cache: new Core({
+              name: 'cachemap',
               store: map(),
-              type: "someType",
+              type: 'someType',
             }),
             cascadeCacheControl: true,
             typeIDKey: DEFAULT_TYPE_ID_KEY,
@@ -1389,46 +1418,46 @@ describe("@graphql-box/cache-manager >>", () => {
             requestData,
             responses.getSearchResultsQuery,
             { awaitDataCaching: true },
-            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.getSearchResultsQuery, hasDeferOrStream: true }),
+            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.getSearchResultsQuery, hasDeferOrStream: true })
           );
 
           analyzeQueryResult = await cacheManager.analyzeQuery(
             getRequestData(parsedRequests.getMoviePreviewQuery),
             { awaitDataCaching: true },
-            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.getMoviePreviewQuery, hasDeferOrStream: true }),
+            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.getMoviePreviewQuery, hasDeferOrStream: true })
           );
         });
 
-        it("correct request data", () => {
-          const { ast, ...otherProps } = analyzeQueryResult?.updated as RequestData;
+        it('correct request data', () => {
+          const { ast, ...otherProps } = analyzeQueryResult!.updated!;
           expect(otherProps).toMatchSnapshot();
         });
 
-        it("no response data", () => {
+        it('no response data', () => {
           expect(analyzeQueryResult?.response).toBeUndefined();
         });
 
-        it("correct cache data", async () => {
-          expect(await cacheManager.cache.export()).toMatchSnapshot();
+        it('correct cache data', async () => {
+          await expect(cacheManager.cache.export()).resolves.toMatchSnapshot();
         });
 
-        it("correct partial data", () => {
-          // @ts-ignore
+        it('correct partial data', () => {
+          // @ts-expect-error property is private
           expect(cacheManager._partialQueryResponses).toMatchSnapshot();
         });
       });
 
-      describe("defer >>", () => {
+      describe('defer >>', () => {
         beforeAll(async () => {
           analyzeQueryResult = undefined;
-          // @ts-ignore
-          jest.spyOn(CacheManager, "_isValid").mockReturnValue(true);
+          // @ts-expect-error property is private
+          jest.spyOn(CacheManager, '_isValid').mockReturnValue(true);
 
           cacheManager = new CacheManager({
-            cache: new Cachemap({
-              name: "cachemap",
+            cache: new Core({
+              name: 'cachemap',
               store: map(),
-              type: "someType",
+              type: 'someType',
             }),
             cascadeCacheControl: true,
             typeIDKey: DEFAULT_TYPE_ID_KEY,
@@ -1441,31 +1470,31 @@ describe("@graphql-box/cache-manager >>", () => {
             requestData,
             responses.deferQuerySet.initial,
             { awaitDataCaching: true },
-            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.deferQuery, hasDeferOrStream: true }),
+            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.deferQuery, hasDeferOrStream: true })
           );
 
           analyzeQueryResult = await cacheManager.analyzeQuery(
             getRequestData(parsedRequests.deferQuery),
             { awaitDataCaching: true },
-            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.deferQuery, hasDeferOrStream: true }),
+            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.deferQuery, hasDeferOrStream: true })
           );
         });
 
-        it("correct request data", () => {
-          const { ast, ...otherProps } = analyzeQueryResult?.updated as RequestData;
+        it('correct request data', () => {
+          const { ast, ...otherProps } = analyzeQueryResult!.updated!;
           expect(otherProps).toMatchSnapshot();
         });
 
-        it("no response data", () => {
+        it('no response data', () => {
           expect(analyzeQueryResult?.response).toBeUndefined();
         });
 
-        it("correct cache data", async () => {
-          expect(await cacheManager.cache.export()).toMatchSnapshot();
+        it('correct cache data', async () => {
+          await expect(cacheManager.cache.export()).resolves.toMatchSnapshot();
         });
 
-        it("correct partial data", () => {
-          // @ts-ignore
+        it('correct partial data', () => {
+          // @ts-expect-error property is private
           expect(cacheManager._partialQueryResponses).toMatchSnapshot();
         });
       });