@graphql-box/cache-manager 4.1.4 → 5.0.0

package/src/constants.ts

@@ -0,0 +1,6 @@
+export const METADATA = 'metadata' as const;
+export const CACHE_CONTROL = 'cacheControl' as const;
+export const NO_CACHE = 'noCache' as const;
+
+export const HEADER_CACHE_CONTROL = 'cache-control' as const;
+export const HEADER_NO_CACHE = 'no-cache' as const;

package/src/debug/index.ts

@@ -1,3 +1,3 @@
-export { default as logCacheEntry } from "../debug/log-cache-entry";
-export { default as logCacheQuery } from "../debug/log-cache-query";
-export { default as logPartialCompiled } from "../debug/log-partial-compiled";
+export * from './logCacheEntry.ts';
+export * from './logCacheQuery.ts';
+export * from './logPartialCompiled.ts';

package/src/debug/logCacheEntry.ts

@@ -0,0 +1,54 @@
+import { CACHE_ENTRY_ADDED, type CacheTypes, type CachemapOptions, type RequestOptions } from '@graphql-box/core';
+import type { CacheManagerContext, CacheManagerDef } from '../types.ts';
+
+type Descriptor = (
+  cacheType: CacheTypes,
+  hash: string,
+  value: unknown,
+  cachemapOptions: CachemapOptions,
+  options: RequestOptions,
+  context: CacheManagerContext & { requestFieldCacheKey?: string }
+) => Promise<void>;
+
+export const logCacheEntry = () => {
+  return (_target: CacheManagerDef, _propertyName: string, descriptor: TypedPropertyDescriptor<Descriptor>): void => {
+    const method = descriptor.value;
+
+    if (!method) {
+      return;
+    }
+
+    descriptor.value = async function descriptorValue(...args: Parameters<Descriptor>): ReturnType<Descriptor> {
+      return new Promise<void>(resolve => {
+        void (async () => {
+          const { debugManager, requestFieldCacheKey, ...otherContext } = args[5];
+
+          if (!debugManager) {
+            await method.apply(this, args);
+            resolve();
+            return;
+          }
+
+          const startTime = debugManager.now();
+          await method.apply(this, args);
+          const endTime = debugManager.now();
+          const duration = endTime - startTime;
+          resolve();
+
+          const payload = {
+            cacheType: args[0],
+            cachemapOptions: args[3],
+            context: otherContext,
+            options: args[4],
+            requestHash: args[1],
+            stats: { duration, endTime, startTime },
+            value: args[2],
+            ...(requestFieldCacheKey ? { decryptedCacheKey: requestFieldCacheKey } : {}),
+          };
+
+          debugManager.log(CACHE_ENTRY_ADDED, payload);
+        })();
+      });
+    };
+  };
+};

package/src/debug/{log-cache-query/index.ts → logCacheQuery.ts}

@@ -1,20 +1,25 @@
-import { CACHE_ENTRY_QUERIED, RequestContext } from "@graphql-box/core";
-
-export default function logCacheQuery() {
-  return (
-    _target: any,
-    _propertyName: string,
-    descriptor: TypedPropertyDescriptor<(...args: any[]) => Promise<any>>,
-  ): void => {
+import { CACHE_ENTRY_QUERIED, type CacheTypes, type RequestOptions } from '@graphql-box/core';
+import type { CacheManagerContext, CacheManagerDef } from '../types.ts';
+
+type Descriptor = (
+  cacheType: CacheTypes,
+  hash: string,
+  options: RequestOptions,
+  context: CacheManagerContext & { requestFieldCacheKey?: string }
+) => Promise<never | undefined>;
+
+export const logCacheQuery = () => {
+  return (_target: CacheManagerDef, _propertyName: string, descriptor: TypedPropertyDescriptor<Descriptor>): void => {
     const method = descriptor.value;
-    if (!method) return;
 
-    descriptor.value = async function descriptorValue(...args: any[]): Promise<any> {
-      try {
-        return new Promise(async resolve => {
-          const { debugManager, requestFieldCacheKey, ...otherContext } = args[3] as RequestContext & {
-            requestFieldCacheKey?: string;
-          };
+    if (!method) {
+      return;
+    }
+
+    descriptor.value = async function descriptorValue(...args: Parameters<Descriptor>): ReturnType<Descriptor> {
+      return new Promise(resolve => {
+        void (async () => {
+          const { debugManager, requestFieldCacheKey, ...otherContext } = args[3];
 
           if (!debugManager) {
             resolve(await method.apply(this, args));
@@ -38,10 +43,8 @@ export default function logCacheQuery() {
           };
 
           debugManager.log(CACHE_ENTRY_QUERIED, payload);
-        });
-      } catch (error) {
-        return Promise.reject(error);
-      }
+        })();
+      });
     };
   };
-}
+};

package/src/debug/logPartialCompiled.ts

@@ -0,0 +1,41 @@
+import { PARTIAL_QUERY_COMPILED, type RequestOptions } from '@graphql-box/core';
+import type { CacheManagerContext, CacheManagerDef, PartialQueryResponse } from '../types.ts';
+
+type Descriptor = (
+  hash: string,
+  partialQueryResponse: PartialQueryResponse,
+  options: RequestOptions,
+  context: CacheManagerContext
+) => void;
+
+export const logPartialCompiled = () => {
+  return (_target: CacheManagerDef, _propertyName: string, descriptor: TypedPropertyDescriptor<Descriptor>): void => {
+    const method = descriptor.value;
+
+    if (!method) {
+      return;
+    }
+
+    descriptor.value = function descriptorValue(...args: Parameters<Descriptor>): ReturnType<Descriptor> {
+      const { debugManager, ...otherContext } = args[3];
+
+      if (!debugManager) {
+        method.apply(this, args);
+        return;
+      }
+
+      const startTime = debugManager.now();
+      method.apply(this, args);
+      const endTime = debugManager.now();
+      const duration = endTime - startTime;
+
+      debugManager.log(PARTIAL_QUERY_COMPILED, {
+        context: otherContext,
+        options: args[2],
+        requestHash: args[0],
+        result: args[1],
+        stats: { duration, endTime, startTime },
+      });
+    };
+  };
+};

package/src/helpers/areOnlyPopulatedFieldsTypeIdKeys.ts

@@ -1,10 +1,11 @@
-import { PlainObjectMap } from "@graphql-box/core";
-import { isArray, isPlainObject } from "lodash";
+import type { PlainData } from '@graphql-box/core';
+import { isArray, isPlainObject } from '@graphql-box/helpers';
+import { isNumber, isString } from 'lodash-es';
 
-const checkValue = (value: any, typeIDKey: string): boolean => {
+const checkValue = (value: unknown, typeIDKey: string): boolean => {
   if (isArray(value)) {
-    return value.reduce((accB: boolean, entry) => {
-      if (!accB) {
+    return value.reduce<boolean>((acc, entry) => {
+      if (!acc) {
         return false;
       }
 
@@ -19,22 +20,28 @@ const checkValue = (value: any, typeIDKey: string): boolean => {
   return false;
 };
 
-const recursivelyCheckProps = (data: PlainObjectMap, typeIDKey: string): boolean => {
-  const keys = Object.keys(data);
+const recursivelyCheckProps = (data: PlainData, typeIDKey: string): boolean => {
+  const keys = isPlainObject(data) ? Object.keys(data) : [...data.keys()];
 
-  if (keys.length === 1 && !!data[typeIDKey]) {
+  if (keys.length === 1 && isPlainObject(data) && !!data[typeIDKey]) {
     return true;
   }
 
-  return keys.reduce((accA: boolean, key) => {
-    if (!accA) {
+  return keys.reduce<boolean>((acc, key) => {
+    if (!acc) {
       return false;
     }
 
-    return checkValue(data[key], typeIDKey);
+    if (isNumber(key) && isArray(data)) {
+      return checkValue(data[key], typeIDKey);
+    } else if (isString(key) && isPlainObject(data)) {
+      return checkValue(data[key], typeIDKey);
+    }
+
+    return acc;
   }, true);
 };
 
-export default (data: PlainObjectMap, typeIDKey: string) => {
+export const areOnlyPopulatedFieldsTypeIdKeys = (data: PlainData, typeIDKey: string) => {
   return recursivelyCheckProps(data, typeIDKey);
 };

package/src/helpers/checkFieldPathChecklist.ts

@@ -1,16 +1,18 @@
-import { CheckFieldPathChecklistResult, FieldPathChecklistValue } from "../defs";
+import { type CheckFieldPathChecklistResult, type FieldPathChecklistValue } from '../types.ts';
 
-export default (
+export const checkFieldPathChecklist = (
   fieldPathChecklistValues: FieldPathChecklistValue[] | undefined,
-  fieldTypeName: string | undefined,
+  fieldTypeName: string | undefined
 ): CheckFieldPathChecklistResult => {
-  if (!fieldPathChecklistValues || !fieldPathChecklistValues.length) {
+  if (!fieldPathChecklistValues || fieldPathChecklistValues.length === 0) {
     return { hasData: false, typeUnused: !!fieldTypeName };
   }
 
-  if (fieldPathChecklistValues.length === 1) {
-    const { hasData, typeName } = fieldPathChecklistValues[0];
-    const typeUnused = !typeName ? undefined : typeName !== fieldTypeName;
+  const [fieldPathChecklistValue] = fieldPathChecklistValues;
+
+  if (fieldPathChecklistValue) {
+    const { hasData, typeName } = fieldPathChecklistValue;
+    const typeUnused = typeName ? typeName !== fieldTypeName : undefined;
     return { hasData, typeUnused };
   }
 

package/src/helpers/combineData.ts

@@ -0,0 +1,14 @@
+import { isObjectLike } from '@graphql-box/helpers';
+import { mergeDataSets } from './mergeObjects.ts';
+
+export const combineDataSets = (dataSetA: unknown, dataSetB: unknown, typeIDKey: string) => {
+  if (!dataSetA && dataSetB) {
+    return dataSetB;
+  }
+
+  if (isObjectLike(dataSetA) && isObjectLike(dataSetB)) {
+    return mergeDataSets(dataSetA, dataSetB, typeIDKey);
+  }
+
+  return dataSetA;
+};

package/src/helpers/createFragmentSpreadChecklist.ts

@@ -1,17 +1,18 @@
-import { RequestData } from "@graphql-box/core";
-import { keys } from "lodash";
-import { CacheManagerContext } from "../defs";
+import { type RequestData } from '@graphql-box/core';
+import { keys } from 'lodash-es';
+import { type CacheManagerContext } from '../types.ts';
 
-export type FragmentSpreadCheckist = {
-  [key: string]: {
+export type FragmentSpreadCheckist = Record<
+  string,
+  {
     deleted: number;
     paths: string[];
     total: number;
-  };
-};
+  }
+>;
 
-export default ({ request }: RequestData, { fragmentDefinitions }: CacheManagerContext) =>
-  keys(fragmentDefinitions ?? {}).reduce((acc: FragmentSpreadCheckist, name) => {
-    acc[name] = { deleted: 0, paths: [], total: (request.match(new RegExp(`\\.\\.\\.${name}`, "g")) || []).length };
+export const createFragmentSpreadChecklist = ({ request }: RequestData, { fragmentDefinitions }: CacheManagerContext) =>
+  keys(fragmentDefinitions ?? {}).reduce<FragmentSpreadCheckist>((acc, name) => {
+    acc[name] = { deleted: 0, paths: [], total: (request.match(new RegExp(`\\.\\.\\.${name}`, 'g')) ?? []).length };
     return acc;
   }, {});

package/src/helpers/deriveOpCacheability.ts

@@ -1,7 +1,7 @@
-import { DehydratedCacheMetadata } from "@graphql-box/core";
-import Cacheability from "cacheability";
-import { isEmpty } from "lodash";
-import { HEADER_CACHE_CONTROL } from "../consts";
+import { type DehydratedCacheMetadata } from '@graphql-box/core';
+import { Cacheability } from 'cacheability';
+import { isEmpty } from 'lodash-es';
+import { HEADER_CACHE_CONTROL } from '../constants.ts';
 
 export type Params = {
   _cacheMetadata?: DehydratedCacheMetadata;
@@ -9,12 +9,16 @@ export type Params = {
   headers?: Headers;
 };
 
-export default ({ _cacheMetadata, fallback, headers }: Params): Cacheability => {
+export const deriveOpCacheability = ({ _cacheMetadata, fallback, headers }: Params): Cacheability => {
   if (_cacheMetadata && !isEmpty(_cacheMetadata)) {
     const [first, ...rest] = Object.values(_cacheMetadata);
 
     return new Cacheability({
       metadata: rest.reduce((acc, metadata) => {
+        if (!acc) {
+          return metadata;
+        }
+
         if (metadata.ttl < acc.ttl) {
           return metadata;
         }
@@ -24,7 +28,7 @@ export default ({ _cacheMetadata, fallback, headers }: Params): Cacheability =>
     });
   }
 
-  if (headers && headers.has(HEADER_CACHE_CONTROL)) {
+  if (headers?.has(HEADER_CACHE_CONTROL)) {
     return new Cacheability({ headers });
   }
 

package/src/helpers/filterField.ts

@@ -1,26 +1,25 @@
-import { TYPE_NAME_KEY } from "@graphql-box/core";
+import { TYPE_NAME_KEY } from '@graphql-box/core';
 import {
-  FRAGMENT_SPREAD,
   buildFieldKeysAndPaths,
   deleteChildFields,
   getChildFields,
   getName,
   hasChildFields,
-} from "@graphql-box/helpers";
-import { FieldNode, FragmentDefinitionNode, OperationDefinitionNode } from "graphql";
-import { CacheManagerContext, FieldPathChecklist, FragmentSpreadFieldCounter } from "../defs";
-import checkFieldPathChecklist from "./checkFieldPathChecklist";
-import { FragmentSpreadCheckist } from "./createFragmentSpreadChecklist";
-import filterFragmentSpreads from "./filterFragmentSpreads";
-import filterIDsAndTypeNames from "./filterIDsAndTypeNames";
-import filterInlineFragments from "./filterInlineFragments";
+} from '@graphql-box/helpers';
+import { type FieldNode, type FragmentDefinitionNode, Kind, type OperationDefinitionNode } from 'graphql';
+import { type CacheManagerContext, type FieldPathChecklist, type FragmentSpreadFieldCounter } from '../types.ts';
+import { checkFieldPathChecklist } from './checkFieldPathChecklist.ts';
+import { type FragmentSpreadCheckist } from './createFragmentSpreadChecklist.ts';
+import { filterFragmentSpreads } from './filterFragmentSpreads.ts';
+import { filterIDsAndTypeNames } from './filterIDsAndTypeNames.ts';
+import { filterInlineFragments } from './filterInlineFragments.ts';
 
-const filterField = (
+export const filterField = (
   field: FieldNode | FragmentDefinitionNode | OperationDefinitionNode,
   fieldPathChecklist: FieldPathChecklist,
   fragmentSpreadChecklist: FragmentSpreadCheckist,
   ancestorRequestFieldPath: string,
-  context: CacheManagerContext,
+  context: CacheManagerContext
 ): boolean => {
   const { fragmentDefinitions, typeIDKey } = context;
   const fieldsAndTypeNames = getChildFields(field, { fragmentDefinitions });
@@ -31,14 +30,20 @@ const filterField = (
 
   const fragmentSpreadFieldCounter: FragmentSpreadFieldCounter = {};
 
-  for (let i = fieldsAndTypeNames.length - 1; i >= 0; i -= 1) {
-    const { fieldNode: childField, fragmentKind, fragmentName, typeName: childTypeName } = fieldsAndTypeNames[i];
+  for (let index = fieldsAndTypeNames.length - 1; index >= 0; index -= 1) {
+    const fieldAndTypeName = fieldsAndTypeNames[index];
 
-    if (fragmentKind === FRAGMENT_SPREAD && fragmentName && !fragmentSpreadFieldCounter[fragmentName]) {
+    if (!fieldAndTypeName) {
+      continue;
+    }
+
+    const { fieldNode: childField, fragmentKind, fragmentName, typeName: childTypeName } = fieldAndTypeName;
+
+    if (fragmentKind === Kind.FRAGMENT_SPREAD && fragmentName && !fragmentSpreadFieldCounter[fragmentName]) {
       fragmentSpreadFieldCounter[fragmentName] = {
         hasData: 0,
         total: fragmentDefinitions?.[fragmentName]
-          ? getChildFields(fragmentDefinitions?.[fragmentName], { fragmentDefinitions })?.length ?? 0
+          ? getChildFields(fragmentDefinitions[fragmentName]!, { fragmentDefinitions })?.length ?? 0
           : 0,
       };
     }
@@ -54,14 +59,18 @@ const filterField = (
       {
         requestFieldPath: ancestorRequestFieldPath,
       },
-      context,
+      context
     );
 
     const { hasData, typeUnused } = checkFieldPathChecklist(fieldPathChecklist.get(requestFieldPath), childTypeName);
 
     if (hasData || typeUnused) {
-      if (fragmentKind === FRAGMENT_SPREAD) {
-        fragmentSpreadFieldCounter[fragmentName as string].hasData += 1;
+      if (fragmentKind === Kind.FRAGMENT_SPREAD && fragmentName) {
+        const counter = fragmentSpreadFieldCounter[fragmentName];
+
+        if (counter) {
+          counter.hasData += 1;
+        }
       } else if (!hasChildFields(childField, { fragmentDefinitions })) {
         deleteChildFields(field, childField);
       } else if (filterField(childField, fieldPathChecklist, fragmentSpreadChecklist, requestFieldPath, context)) {
@@ -75,5 +84,3 @@ const filterField = (
   filterIDsAndTypeNames(field, context);
   return !hasChildFields(field, { fragmentDefinitions });
 };
-
-export default filterField;

package/src/helpers/filterFragmentDefinitions.ts

@@ -1,40 +1,54 @@
-import { deleteFragmentDefinitions } from "@graphql-box/helpers";
-import { DocumentNode } from "graphql";
-import { keys } from "lodash";
-import { CacheManagerContext, FieldPathChecklist } from "../defs";
-import { FragmentSpreadCheckist } from "./createFragmentSpreadChecklist";
-import filterField from "./filterField";
-
-export default (
+import { deleteFragmentDefinitions } from '@graphql-box/helpers';
+import { type DocumentNode } from 'graphql';
+import { keys } from 'lodash-es';
+import { type CacheManagerContext, type FieldPathChecklist } from '../types.ts';
+import { type FragmentSpreadCheckist } from './createFragmentSpreadChecklist.ts';
+import { filterField } from './filterField.ts';
+
+export const filterFragmentDefinitions = (
   ast: DocumentNode,
   fieldPathChecklist: FieldPathChecklist,
   fragmentSpreadChecklist: FragmentSpreadCheckist,
-  context: CacheManagerContext,
+  context: CacheManagerContext
 ) => {
-  const definitionsToFilter = keys(fragmentSpreadChecklist).reduce(
-    (namesAndPaths: { name: string; path: string }[], key) => {
-      const { deleted, total } = fragmentSpreadChecklist[key];
+  const definitionsToFilter = keys(fragmentSpreadChecklist).reduce<{ name: string; path: string }[]>(
+    (namesAndPaths, key) => {
+      const checklist = fragmentSpreadChecklist[key];
+
+      if (!checklist) {
+        return namesAndPaths;
+      }
 
-      return deleted === 0 && total === 1
-        ? [...namesAndPaths, { name: key, path: fragmentSpreadChecklist[key].paths[0] as string }]
-        : namesAndPaths;
+      const { deleted, paths, total } = checklist;
+      return deleted === 0 && total === 1 ? [...namesAndPaths, { name: key, path: paths[0]! }] : namesAndPaths;
     },
-    [],
+    []
   );
 
   const { fragmentDefinitions = {} } = context;
 
-  definitionsToFilter.forEach(({ name, path }) => {
+  for (const { name, path } of definitionsToFilter) {
     const fragmentDefinition = fragmentDefinitions[name];
+
+    if (!fragmentDefinition) {
+      continue;
+    }
+
     filterField(fragmentDefinition, fieldPathChecklist, fragmentSpreadChecklist, path, context);
-  });
+  }
+
+  const definitionsToDelete = keys(fragmentSpreadChecklist).reduce<string[]>((names, key) => {
+    const checklist = fragmentSpreadChecklist[key];
+
+    if (!checklist) {
+      return names;
+    }
 
-  const definitionsToDelete = keys(fragmentSpreadChecklist).reduce((names: string[], key) => {
-    const { deleted, total } = fragmentSpreadChecklist[key];
+    const { deleted, total } = checklist;
     return deleted > 0 && deleted === total ? [...names, key] : names;
   }, []);
 
-  if (!definitionsToDelete.length) {
+  if (definitionsToDelete.length === 0) {
     return ast;
   }
 

package/src/helpers/filterFragmentSpreads.ts

@@ -1,27 +1,32 @@
-import { deleteFragmentSpreads } from "@graphql-box/helpers";
-import { FieldNode, FragmentDefinitionNode, OperationDefinitionNode } from "graphql";
-import { isEmpty, keys } from "lodash";
-import { FragmentSpreadFieldCounter } from "../defs";
-import { FragmentSpreadCheckist } from "./createFragmentSpreadChecklist";
+import { deleteFragmentSpreads } from '@graphql-box/helpers';
+import { type FieldNode, type FragmentDefinitionNode, type OperationDefinitionNode } from 'graphql';
+import { isEmpty } from 'lodash-es';
+import { type FragmentSpreadFieldCounter } from '../types.ts';
+import { type FragmentSpreadCheckist } from './createFragmentSpreadChecklist.ts';
 
-export default (
+export const filterFragmentSpreads = (
   field: FieldNode | FragmentDefinitionNode | OperationDefinitionNode,
   fragmentSpreadFieldCounter: FragmentSpreadFieldCounter,
   fragmentSpreadChecklist: FragmentSpreadCheckist,
-  ancestorRequestFieldPath: string,
+  ancestorRequestFieldPath: string
 ) => {
   if (isEmpty(fragmentSpreadFieldCounter)) {
     return;
   }
 
-  keys(fragmentSpreadFieldCounter).forEach(key => {
-    fragmentSpreadChecklist[key].paths.push(ancestorRequestFieldPath);
+  for (const key of Object.keys(fragmentSpreadFieldCounter)) {
+    const checklist = fragmentSpreadChecklist[key];
 
-    const { hasData, total } = fragmentSpreadFieldCounter[key];
+    if (!checklist) {
+      continue;
+    }
+
+    checklist.paths.push(ancestorRequestFieldPath);
+    const { hasData, total } = fragmentSpreadFieldCounter[key]!;
 
     if (hasData === total) {
       deleteFragmentSpreads(field, key);
-      fragmentSpreadChecklist[key].deleted += 1;
+      checklist.deleted += 1;
     }
-  });
+  }
 };

package/src/helpers/filterIDsAndTypeNames.ts

@@ -1,11 +1,11 @@
-import { TYPE_NAME_KEY } from "@graphql-box/core";
-import { deleteChildFields, getChildFields, getName } from "@graphql-box/helpers";
-import { FieldNode, FragmentDefinitionNode, OperationDefinitionNode } from "graphql";
-import { CacheManagerContext } from "../defs";
+import { TYPE_NAME_KEY } from '@graphql-box/core';
+import { deleteChildFields, getChildFields, getName } from '@graphql-box/helpers';
+import { type FieldNode, type FragmentDefinitionNode, type OperationDefinitionNode } from 'graphql';
+import { type CacheManagerContext } from '../types.ts';
 
-export default (
+export const filterIDsAndTypeNames = (
   field: FieldNode | FragmentDefinitionNode | OperationDefinitionNode,
-  { fragmentDefinitions, typeIDKey }: CacheManagerContext,
+  { fragmentDefinitions, typeIDKey }: CacheManagerContext
 ) => {
   const fieldsAndTypeNames = getChildFields(field, { fragmentDefinitions });
 
@@ -13,21 +13,25 @@ export default (
     return false;
   }
 
-  const fieldNames = fieldsAndTypeNames.map(({ fieldNode }) => getName(fieldNode) as FieldNode["name"]["value"]);
+  const fieldNames = fieldsAndTypeNames.map(({ fieldNode }) => getName(fieldNode)!);
 
   if (fieldNames.length === 2 && fieldNames.every(name => name === typeIDKey || name === TYPE_NAME_KEY)) {
     deleteChildFields(
       field,
-      fieldsAndTypeNames.map(({ fieldNode }) => fieldNode),
+      fieldsAndTypeNames.map(({ fieldNode }) => fieldNode)
     );
 
     return true;
   }
 
   if ((fieldNames.length === 1 && fieldNames[0] === typeIDKey) || fieldNames[0] === TYPE_NAME_KEY) {
-    const { fieldNode } = fieldsAndTypeNames[0];
-    deleteChildFields(field, fieldNode);
-    return true;
+    const [fieldAndTypeName] = fieldsAndTypeNames;
+
+    if (fieldAndTypeName) {
+      const { fieldNode } = fieldAndTypeName;
+      deleteChildFields(field, fieldNode);
+      return true;
+    }
   }
 
   return false;

package/src/helpers/filterInlineFragments.ts

@@ -1,32 +1,34 @@
-import { deleteInlineFragments, getChildFields, getInlineFragments, getName } from "@graphql-box/helpers";
-import { FieldNode, FragmentDefinitionNode, OperationDefinitionNode } from "graphql";
-import { CacheManagerContext } from "..";
+import { deleteInlineFragments, getChildFields, getInlineFragments, getName } from '@graphql-box/helpers';
+import { type FieldNode, type FragmentDefinitionNode, type OperationDefinitionNode } from 'graphql';
+import { type CacheManagerContext } from '../types.ts';
 
-export default (
+export const filterInlineFragments = (
   field: FieldNode | FragmentDefinitionNode | OperationDefinitionNode,
-  { fragmentDefinitions, typeIDKey }: CacheManagerContext,
+  { fragmentDefinitions, typeIDKey }: CacheManagerContext
 ) => {
   const inlineFragments = getInlineFragments(field);
   let filtered = false;
 
-  inlineFragments.forEach(fragment => {
+  for (const fragment of inlineFragments) {
     const fieldsAndTypeNames = getChildFields(fragment, { fragmentDefinitions });
 
-    if (!fieldsAndTypeNames || !fieldsAndTypeNames.length) {
+    if (!fieldsAndTypeNames || fieldsAndTypeNames.length === 0) {
       deleteInlineFragments(field, fragment);
       filtered = true;
-      return;
+      continue;
     }
 
-    if (fieldsAndTypeNames.length === 1) {
-      const { fieldNode } = fieldsAndTypeNames[0];
+    const [fieldAndTypeName] = fieldsAndTypeNames;
+
+    if (fieldAndTypeName) {
+      const { fieldNode } = fieldAndTypeName;
 
       if (getName(fieldNode) === typeIDKey) {
         deleteInlineFragments(field, fragment);
         filtered = true;
       }
     }
-  });
+  }
 
   return filtered;
 };