@graphql-box/cache-manager 3.0.0 → 3.1.2

package/src/defs/index.ts

@@ -1,4 +1,5 @@
-import Cachemap, { CacheHeaders, Metadata } from "@cachemap/core";
+import Cachemap, { CacheHeaders } from "@cachemap/core";
+import { Metadata } from "@cachemap/types";
 import {
   CacheMetadata,
   CacheTypes,

package/src/helpers/createFragmentSpreadChecklist.ts

@@ -1,5 +1,5 @@
+import { RequestData } from "@graphql-box/core";
 import { getFragmentDefinitions } from "@graphql-box/helpers";
-import { DocumentNode } from "graphql";
 import { keys } from "lodash";
 
 export type FragmentSpreadCheckist = {
@@ -10,8 +10,8 @@ export type FragmentSpreadCheckist = {
   };
 };
 
-export default (ast: DocumentNode) =>
+export default ({ ast, request }: RequestData) =>
   keys(getFragmentDefinitions(ast) ?? {}).reduce((acc: FragmentSpreadCheckist, name) => {
-    acc[name] = { deleted: 0, paths: [], total: 0 };
+    acc[name] = { deleted: 0, paths: [], total: (request.match(new RegExp(`\\.\\.\\.${name}`, "g")) || []).length };
     return acc;
   }, {});

package/src/helpers/filterField.ts

@@ -1,6 +1,6 @@
 import { TYPE_NAME_KEY } from "@graphql-box/core";
 import { FRAGMENT_SPREAD, deleteChildFields, getChildFields, getName, hasChildFields } from "@graphql-box/helpers";
-import { FieldNode, FragmentDefinitionNode } from "graphql";
+import { FieldNode, FragmentDefinitionNode, OperationDefinitionNode } from "graphql";
 import { CacheManagerContext, FieldPathChecklist, FragmentSpreadFieldCounter } from "../defs";
 import { buildFieldKeysAndPaths } from "./buildKeysAndPaths";
 import checkFieldPathChecklist from "./checkFieldPathChecklist";
@@ -10,7 +10,7 @@ import filterIDsAndTypeNames from "./filterIDsAndTypeNames";
 import filterInlineFragments from "./filterInlineFragments";
 
 const filterField = (
-  field: FieldNode | FragmentDefinitionNode,
+  field: FieldNode | FragmentDefinitionNode | OperationDefinitionNode,
   fieldPathChecklist: FieldPathChecklist,
   fragmentSpreadChecklist: FragmentSpreadCheckist,
   ancestorRequestFieldPath: string,

package/src/helpers/filterFragmentDefinitions.ts

@@ -34,6 +34,10 @@ export default (
     return deleted > 0 && deleted === total ? [...names, key] : names;
   }, []);
 
+  if (!definitionsToDelete.length) {
+    return ast;
+  }
+
   return deleteFragmentDefinitions(ast, {
     include: definitionsToDelete,
   });

package/src/helpers/filterFragmentSpreads.ts

@@ -1,11 +1,11 @@
 import { deleteFragmentSpreads } from "@graphql-box/helpers";
-import { FieldNode, FragmentDefinitionNode } from "graphql";
+import { FieldNode, FragmentDefinitionNode, OperationDefinitionNode } from "graphql";
 import { isEmpty, keys } from "lodash";
 import { FragmentSpreadFieldCounter } from "../defs";
 import { FragmentSpreadCheckist } from "./createFragmentSpreadChecklist";
 
 export default (
-  field: FieldNode | FragmentDefinitionNode,
+  field: FieldNode | FragmentDefinitionNode | OperationDefinitionNode,
   fragmentSpreadFieldCounter: FragmentSpreadFieldCounter,
   fragmentSpreadChecklist: FragmentSpreadCheckist,
   ancestorRequestFieldPath: string,
@@ -15,7 +15,6 @@ export default (
   }
 
   keys(fragmentSpreadFieldCounter).forEach(key => {
-    fragmentSpreadChecklist[key].total += 1;
     fragmentSpreadChecklist[key].paths.push(ancestorRequestFieldPath);
 
     const { hasData, total } = fragmentSpreadFieldCounter[key];

package/src/helpers/filterIDsAndTypeNames.ts

@@ -1,9 +1,12 @@
 import { TYPE_NAME_KEY } from "@graphql-box/core";
 import { deleteChildFields, getChildFields, getName } from "@graphql-box/helpers";
-import { FieldNode, FragmentDefinitionNode } from "graphql";
+import { FieldNode, FragmentDefinitionNode, OperationDefinitionNode } from "graphql";
 import { CacheManagerContext } from "../defs";
 
-export default (field: FieldNode | FragmentDefinitionNode, { fragmentDefinitions, typeIDKey }: CacheManagerContext) => {
+export default (
+  field: FieldNode | FragmentDefinitionNode | OperationDefinitionNode,
+  { fragmentDefinitions, typeIDKey }: CacheManagerContext,
+) => {
   const fieldsAndTypeNames = getChildFields(field, { fragmentDefinitions });
 
   if (!fieldsAndTypeNames || fieldsAndTypeNames.length > 3) {

package/src/helpers/filterInlineFragments.ts

@@ -1,8 +1,11 @@
 import { deleteInlineFragments, getChildFields, getInlineFragments, getName } from "@graphql-box/helpers";
-import { FieldNode, FragmentDefinitionNode } from "graphql";
+import { FieldNode, FragmentDefinitionNode, OperationDefinitionNode } from "graphql";
 import { CacheManagerContext } from "..";
 
-export default (field: FieldNode | FragmentDefinitionNode, { fragmentDefinitions, typeIDKey }: CacheManagerContext) => {
+export default (
+  field: FieldNode | FragmentDefinitionNode | OperationDefinitionNode,
+  { fragmentDefinitions, typeIDKey }: CacheManagerContext,
+) => {
   const inlineFragments = getInlineFragments(field);
   let filtered = false;
 

package/src/helpers/filterOperationAndFragmentDefinitions.ts

@@ -0,0 +1,10 @@
+import { FRAGMENT_DEFINITION, OPERATION_DEFINITION, isKind } from "@graphql-box/helpers";
+import { DocumentNode, FragmentDefinitionNode, OperationDefinitionNode } from "graphql";
+
+export default (ast: DocumentNode) => {
+  return ast.definitions.filter(
+    definition =>
+      isKind<OperationDefinitionNode>(definition, OPERATION_DEFINITION) ||
+      isKind<FragmentDefinitionNode>(definition, FRAGMENT_DEFINITION),
+  ) as (OperationDefinitionNode | FragmentDefinitionNode)[];
+};

package/src/helpers/filterQuery.ts

@@ -6,7 +6,8 @@ import createFragmentSpreadChecklist from "./createFragmentSpreadChecklist";
 import filterField from "./filterField";
 import filterFragmentDefinitions from "./filterFragmentDefinitions";
 
-export default ({ ast }: RequestData, { fieldPathChecklist }: CachedResponseData, context: CacheManagerContext) => {
+export default (requestData: RequestData, { fieldPathChecklist }: CachedResponseData, context: CacheManagerContext) => {
+  const { ast } = requestData;
   const queryNode = getOperationDefinitions(ast, context.operation)[0];
   const { fragmentDefinitions } = context;
   const fieldsAndTypeNames = getChildFields(queryNode, { fragmentDefinitions });
@@ -15,7 +16,7 @@ export default ({ ast }: RequestData, { fieldPathChecklist }: CachedResponseData
     return ast;
   }
 
-  const fragmentSpreadChecklist = createFragmentSpreadChecklist(ast);
+  const fragmentSpreadChecklist = createFragmentSpreadChecklist(requestData);
 
   for (let i = fieldsAndTypeNames.length - 1; i >= 0; i -= 1) {
     const { fieldNode } = fieldsAndTypeNames[i];

package/src/index.test.ts

@@ -1312,6 +1312,58 @@ describe("@graphql-box/cache-manager >>", () => {
         });
       });
 
+      describe("fragment spreads >> within fragment spreads >>", () => {
+        beforeAll(async () => {
+          analyzeQueryResult = undefined;
+          // @ts-ignore
+          jest.spyOn(CacheManager, "_isValid").mockReturnValue(true);
+
+          cacheManager = new CacheManager({
+            cache: new Cachemap({
+              name: "cachemap",
+              store: map(),
+              type: "someType",
+            }),
+            cascadeCacheControl: true,
+            typeIDKey: DEFAULT_TYPE_ID_KEY,
+          });
+
+          const requestData = getRequestData(parsedRequests.getSearchResultsQuery);
+
+          await cacheManager.cacheQuery(
+            requestData,
+            requestData,
+            responses.getSearchResultsQuery,
+            { awaitDataCaching: true },
+            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.getSearchResultsQuery, hasDeferOrStream: true }),
+          );
+
+          analyzeQueryResult = await cacheManager.analyzeQuery(
+            getRequestData(parsedRequests.getMoviePreviewQuery),
+            { awaitDataCaching: true },
+            getRequestContext({ fieldTypeMap: requestFieldTypeMaps.getMoviePreviewQuery, hasDeferOrStream: true }),
+          );
+        });
+
+        it("correct request data", () => {
+          const { ast, ...otherProps } = analyzeQueryResult?.updated as RequestData;
+          expect(otherProps).toMatchSnapshot();
+        });
+
+        it("no response data", () => {
+          expect(analyzeQueryResult?.response).toBeUndefined();
+        });
+
+        it("correct cache data", async () => {
+          expect(await cacheManager.cache.export()).toMatchSnapshot();
+        });
+
+        it("correct partial data", () => {
+          // @ts-ignore
+          expect(cacheManager._partialQueryResponses).toMatchSnapshot();
+        });
+      });
+
       describe("defer >>", () => {
         beforeAll(async () => {
           analyzeQueryResult = undefined;