@graphql-box/cache-manager 2.1.2 → 2.3.0

package/src/debug/log-cache-entry/index.ts

@@ -11,7 +11,7 @@ export default function logCacheEntry() {
     if (!method) return;
 
     descriptor.value = async function descriptorValue(...args: any[]): Promise<any> {
-      return new Promise(async resolve => {
+      return new Promise<void>(async resolve => {
         const { debugManager, ...otherContext } = args[5] as RequestContext;
 
         if (!debugManager) {

package/src/debug/log-partial-compiled/index.ts

@@ -11,7 +11,7 @@ export default function logPartialCompiled() {
     if (!method) return;
 
     descriptor.value = async function descriptorValue(...args: any[]): Promise<any> {
-      return new Promise(async resolve => {
+      return new Promise<void>(async resolve => {
         const { debugManager, ...otherContext } = args[3] as RequestContext;
 
         if (!debugManager) {

package/src/defs/index.ts

@@ -12,6 +12,7 @@ import {
   RequestOptions,
   ResponseData,
 } from "@graphql-box/core";
+import { FragmentDefinitionNodeMap } from "@graphql-box/helpers";
 import Cacheability from "cacheability";
 
 export interface UserOptions {
@@ -62,6 +63,11 @@ export interface ConstructorOptions {
   typeIDKey: string;
 }
 
+export interface CacheManagerContext extends RequestContext {
+  fragmentDefinitions?: FragmentDefinitionNodeMap;
+  typeIDKey?: string;
+}
+
 export interface PartialQueryResponse {
   cacheMetadata: CacheMetadata;
   data: PlainObjectMap;
@@ -75,6 +81,8 @@ export interface FieldCount {
 }
 
 export interface FieldPathChecklistValue {
+  fragmentKind: string | undefined;
+  fragmentName: string | undefined;
   hasData: boolean;
   typeName?: string | undefined;
 }
@@ -100,12 +108,6 @@ export interface AncestorKeysAndPaths {
   responseDataPath?: string;
 }
 
-export interface CachedFieldData {
-  cacheability?: Cacheability;
-  dataEntityData?: any;
-  requestFieldPathData?: any;
-}
-
 export interface MergedCachedFieldData {
   cacheability?: Cacheability;
   data: any;
@@ -113,7 +115,9 @@ export interface MergedCachedFieldData {
 
 export interface CachedAncestorFieldData {
   cacheability?: Cacheability;
-  dataEntityData?: any;
+  entityData?: any;
+  fragmentKind?: string;
+  fragmentName?: string;
   index?: number;
   requestFieldCacheKey?: string;
   requestFieldPath?: string;
@@ -136,14 +140,18 @@ export interface KeysAndPaths {
   responseDataPath: string;
 }
 
-export interface TypeNames {
+export interface TypeNamesAndKind {
   dataTypeName: string | undefined;
   fieldTypeName: string | undefined;
+  fragmentKind: string | undefined;
+  fragmentName: string | undefined;
 }
 
+export type FragmentSpreadFieldCounter = Record<string, { hasData: number; total: number }>;
+
 export interface ResponseDataForCaching {
   cacheMetadata: CacheMetadata;
-  dataEntityData: PlainObjectMap;
+  entityData: PlainObjectMap;
   requestFieldPathData: PlainObjectMap;
 }
 
@@ -165,7 +173,7 @@ export interface AnalyzeQueryResult {
 
 export interface CheckCacheEntryResult {
   cacheability: Cacheability;
-  entry: PlainObjectMap | any[];
+  entry: any;
 }
 
 export interface QueryResponseCacheEntry {

package/src/helpers/buildKeysAndPaths.ts

@@ -0,0 +1,71 @@
+import { FieldTypeInfo, PlainObjectMap } from "@graphql-box/core";
+import { getAlias, getArguments, getName, hashRequest } from "@graphql-box/helpers";
+import { FieldNode } from "graphql";
+import { isNumber } from "lodash";
+import { CacheManagerContext, KeysAndPaths, KeysAndPathsOptions } from "../defs";
+
+export const buildKey = (path: string, key: string | number) => {
+  const paths: (string | number)[] = [];
+
+  if (path.length) {
+    paths.push(path);
+  }
+
+  paths.push(key);
+  return paths.join(".");
+};
+
+export const buildRequestFieldCacheKey = (
+  name: string,
+  requestFieldCacheKey: string,
+  args: PlainObjectMap | undefined,
+  directives?: FieldTypeInfo["directives"],
+  index?: number,
+) => {
+  let key = `${isNumber(index) ? index : name}`;
+
+  if (args) {
+    key = `${key}(${JSON.stringify(args)})`;
+  }
+
+  if (directives?.inherited?.length) {
+    key = `${directives.inherited.join(" ")} ${key}`;
+  }
+
+  if (directives?.own?.length) {
+    key = `${key} ${directives.own.join(" ")}`;
+  }
+
+  return buildKey(requestFieldCacheKey, key);
+};
+
+export const buildFieldKeysAndPaths = (
+  field: FieldNode,
+  options: KeysAndPathsOptions,
+  context: CacheManagerContext,
+): KeysAndPaths => {
+  const name = getName(field) as FieldNode["name"]["value"];
+  const { index, requestFieldCacheKey = "", requestFieldPath = "", responseDataPath = "" } = options;
+  const fieldAliasOrName = getAlias(field) || name;
+  const updatedRequestFieldPath = isNumber(index) ? requestFieldPath : buildKey(requestFieldPath, fieldAliasOrName);
+  const fieldTypeInfo = context.fieldTypeMap.get(updatedRequestFieldPath);
+
+  const updatedRequestFieldCacheKey = buildRequestFieldCacheKey(
+    name,
+    requestFieldCacheKey,
+    getArguments(field),
+    fieldTypeInfo?.directives,
+    index,
+  );
+
+  const propNameOrIndex = isNumber(index) ? index : fieldAliasOrName;
+  const updatedResponseDataPath = buildKey(responseDataPath, propNameOrIndex);
+
+  return {
+    hashedRequestFieldCacheKey: hashRequest(updatedRequestFieldCacheKey),
+    propNameOrIndex,
+    requestFieldCacheKey: updatedRequestFieldCacheKey,
+    requestFieldPath: updatedRequestFieldPath,
+    responseDataPath: updatedResponseDataPath,
+  };
+};

package/src/helpers/checkFieldPathChecklist.ts

@@ -0,0 +1,21 @@
+import { CheckFieldPathChecklistResult, FieldPathChecklistValue } from "../defs";
+
+export default (
+  fieldPathChecklistValues: FieldPathChecklistValue[] | undefined,
+  fieldTypeName: string | undefined,
+): CheckFieldPathChecklistResult => {
+  if (!fieldPathChecklistValues || !fieldPathChecklistValues.length) {
+    return { hasData: false, typeUnused: !!fieldTypeName };
+  }
+
+  if (fieldPathChecklistValues.length === 1) {
+    const { hasData, typeName } = fieldPathChecklistValues[0];
+    const typeUnused = !typeName ? undefined : typeName !== fieldTypeName;
+    return { hasData, typeUnused };
+  }
+
+  return {
+    hasData: fieldPathChecklistValues.some(({ hasData, typeName }) => typeName === fieldTypeName && hasData),
+    typeUnused: !fieldPathChecklistValues.every(({ typeName }) => typeName === fieldTypeName),
+  };
+};

package/src/helpers/createFragmentSpreadChecklist.ts

@@ -0,0 +1,17 @@
+import { getFragmentDefinitions } from "@graphql-box/helpers";
+import { DocumentNode } from "graphql";
+import { keys } from "lodash";
+
+export type FragmentSpreadCheckist = {
+  [key: string]: {
+    deleted: number;
+    paths: string[];
+    total: number;
+  };
+};
+
+export default (ast: DocumentNode) =>
+  keys(getFragmentDefinitions(ast) ?? {}).reduce((acc: FragmentSpreadCheckist, name) => {
+    acc[name] = { deleted: 0, paths: [], total: 0 };
+    return acc;
+  }, {});

package/src/helpers/deriveOpCacheability.ts

@@ -0,0 +1,32 @@
+import { DehydratedCacheMetadata } from "@graphql-box/core";
+import Cacheability from "cacheability";
+import { isEmpty } from "lodash";
+import { HEADER_CACHE_CONTROL } from "../consts";
+
+export type Params = {
+  _cacheMetadata?: DehydratedCacheMetadata;
+  fallback: string;
+  headers?: Headers;
+};
+
+export default ({ _cacheMetadata, fallback, headers }: Params): Cacheability => {
+  if (_cacheMetadata && !isEmpty(_cacheMetadata)) {
+    const [first, ...rest] = Object.values(_cacheMetadata);
+
+    return new Cacheability({
+      metadata: rest.reduce((acc, metadata) => {
+        if (metadata.ttl < acc.ttl) {
+          return metadata;
+        }
+
+        return acc;
+      }, first),
+    });
+  }
+
+  if (headers && headers.has(HEADER_CACHE_CONTROL)) {
+    return new Cacheability({ headers });
+  }
+
+  return new Cacheability({ cacheControl: fallback });
+};

package/src/helpers/filterField.ts

@@ -0,0 +1,73 @@
+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 { CacheManagerContext, FieldPathChecklist, FragmentSpreadFieldCounter } from "../defs";
+import { buildFieldKeysAndPaths } from "./buildKeysAndPaths";
+import checkFieldPathChecklist from "./checkFieldPathChecklist";
+import { FragmentSpreadCheckist } from "./createFragmentSpreadChecklist";
+import filterFragmentSpreads from "./filterFragmentSpreads";
+import filterIDsAndTypeNames from "./filterIDsAndTypeNames";
+import filterInlineFragments from "./filterInlineFragments";
+
+const filterField = (
+  field: FieldNode | FragmentDefinitionNode,
+  fieldPathChecklist: FieldPathChecklist,
+  fragmentSpreadChecklist: FragmentSpreadCheckist,
+  ancestorRequestFieldPath: string,
+  context: CacheManagerContext,
+): boolean => {
+  const { fragmentDefinitions, typeIDKey } = context;
+  const fieldsAndTypeNames = getChildFields(field, { fragmentDefinitions });
+
+  if (!fieldsAndTypeNames) {
+    return false;
+  }
+
+  const fragmentSpreadFieldCounter: FragmentSpreadFieldCounter = {};
+
+  for (let i = fieldsAndTypeNames.length - 1; i >= 0; i -= 1) {
+    const { fieldNode: childField, fragmentKind, fragmentName, typeName: childTypeName } = fieldsAndTypeNames[i];
+
+    if (fragmentKind === FRAGMENT_SPREAD && fragmentName && !fragmentSpreadFieldCounter[fragmentName]) {
+      fragmentSpreadFieldCounter[fragmentName] = {
+        hasData: 0,
+        total: fragmentDefinitions?.[fragmentName]
+          ? getChildFields(fragmentDefinitions?.[fragmentName], { fragmentDefinitions })?.length ?? 0
+          : 0,
+      };
+    }
+
+    const childFieldName = getName(childField);
+
+    if (childFieldName === typeIDKey || childFieldName === TYPE_NAME_KEY) {
+      continue;
+    }
+
+    const { requestFieldPath } = buildFieldKeysAndPaths(
+      childField,
+      {
+        requestFieldPath: ancestorRequestFieldPath,
+      },
+      context,
+    );
+
+    const { hasData, typeUnused } = checkFieldPathChecklist(fieldPathChecklist.get(requestFieldPath), childTypeName);
+
+    if (hasData || typeUnused) {
+      if (fragmentKind === FRAGMENT_SPREAD) {
+        fragmentSpreadFieldCounter[fragmentName as string].hasData += 1;
+      } else if (!hasChildFields(childField, { fragmentDefinitions })) {
+        deleteChildFields(field, childField);
+      } else if (filterField(childField, fieldPathChecklist, fragmentSpreadChecklist, requestFieldPath, context)) {
+        deleteChildFields(field, childField);
+      }
+    }
+  }
+
+  filterFragmentSpreads(field, fragmentSpreadFieldCounter, fragmentSpreadChecklist, ancestorRequestFieldPath);
+  filterInlineFragments(field, context);
+  filterIDsAndTypeNames(field, context);
+  return !hasChildFields(field, { fragmentDefinitions });
+};
+
+export default filterField;

package/src/helpers/filterFragmentDefinitions.ts

@@ -0,0 +1,40 @@
+import { deleteFragmentDefinitions, getFragmentDefinitions } 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 (
+  ast: DocumentNode,
+  fieldPathChecklist: FieldPathChecklist,
+  fragmentSpreadChecklist: FragmentSpreadCheckist,
+  context: CacheManagerContext,
+) => {
+  const definitionsToFilter = keys(fragmentSpreadChecklist).reduce(
+    (namesAndPaths: { name: string; path: string }[], key) => {
+      const { deleted, total } = fragmentSpreadChecklist[key];
+
+      return deleted === 0 && total === 1
+        ? [...namesAndPaths, { name: key, path: fragmentSpreadChecklist[key].paths[0] as string }]
+        : namesAndPaths;
+    },
+    [],
+  );
+
+  const fragmentDefinitions = getFragmentDefinitions(ast) ?? {};
+
+  definitionsToFilter.forEach(({ name, path }) => {
+    const fragmentDefinition = fragmentDefinitions[name];
+    filterField(fragmentDefinition, fieldPathChecklist, fragmentSpreadChecklist, path, context);
+  });
+
+  const definitionsToDelete = keys(fragmentSpreadChecklist).reduce((names: string[], key) => {
+    const { deleted, total } = fragmentSpreadChecklist[key];
+    return deleted > 0 && deleted === total ? [...names, key] : names;
+  }, []);
+
+  return deleteFragmentDefinitions(ast, {
+    include: definitionsToDelete,
+  });
+};

package/src/helpers/filterFragmentSpreads.ts

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

package/src/helpers/filterIDsAndTypeNames.ts

@@ -0,0 +1,31 @@
+import { TYPE_NAME_KEY } from "@graphql-box/core";
+import { deleteChildFields, getChildFields, getName } from "@graphql-box/helpers";
+import { FieldNode, FragmentDefinitionNode } from "graphql";
+import { CacheManagerContext } from "../defs";
+
+export default (field: FieldNode | FragmentDefinitionNode, { fragmentDefinitions, typeIDKey }: CacheManagerContext) => {
+  const fieldsAndTypeNames = getChildFields(field, { fragmentDefinitions });
+
+  if (!fieldsAndTypeNames || fieldsAndTypeNames.length > 3) {
+    return false;
+  }
+
+  const fieldNames = fieldsAndTypeNames.map(({ fieldNode }) => getName(fieldNode) as FieldNode["name"]["value"]);
+
+  if (fieldNames.length === 2 && fieldNames.every(name => name === typeIDKey || name === TYPE_NAME_KEY)) {
+    deleteChildFields(
+      field,
+      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;
+  }
+
+  return false;
+};

package/src/helpers/filterInlineFragments.ts

@@ -0,0 +1,29 @@
+import { deleteInlineFragments, getChildFields, getInlineFragments, getName } from "@graphql-box/helpers";
+import { FieldNode, FragmentDefinitionNode } from "graphql";
+import { CacheManagerContext } from "..";
+
+export default (field: FieldNode | FragmentDefinitionNode, { fragmentDefinitions, typeIDKey }: CacheManagerContext) => {
+  const inlineFragments = getInlineFragments(field);
+  let filtered = false;
+
+  inlineFragments.forEach(fragment => {
+    const fieldsAndTypeNames = getChildFields(fragment, { fragmentDefinitions });
+
+    if (!fieldsAndTypeNames || !fieldsAndTypeNames.length) {
+      deleteInlineFragments(field, fragment);
+      filtered = true;
+      return;
+    }
+
+    if (fieldsAndTypeNames.length === 1) {
+      const { fieldNode } = fieldsAndTypeNames[0];
+
+      if (getName(fieldNode) === typeIDKey) {
+        deleteInlineFragments(field, fragment);
+        filtered = true;
+      }
+    }
+  });
+
+  return filtered;
+};

package/src/helpers/filterOutPropsWithArgsOrDirectives.ts

@@ -0,0 +1,30 @@
+import { PlainObjectMap } from "@graphql-box/core";
+import { getName, resolveFragments } from "@graphql-box/helpers";
+import { FieldNode, SelectionNode } from "graphql";
+import { keys } from "lodash";
+import { CacheManagerContext, KeysAndPaths } from "../defs";
+import { buildFieldKeysAndPaths } from "./buildKeysAndPaths";
+
+export default (
+  fieldData: PlainObjectMap,
+  selectionNodes: readonly SelectionNode[],
+  ancestorKeysAndPaths: KeysAndPaths,
+  context: CacheManagerContext,
+) => {
+  const fieldAndTypeName = resolveFragments(selectionNodes, context.fragmentDefinitions);
+
+  return keys(fieldData).reduce((acc: PlainObjectMap, key) => {
+    const match = fieldAndTypeName.find(({ fieldNode }) => (getName(fieldNode) as FieldNode["name"]["value"]) === key);
+
+    if (match) {
+      const { requestFieldPath } = buildFieldKeysAndPaths(match.fieldNode, ancestorKeysAndPaths, context);
+      const fieldTypeInfo = context.fieldTypeMap.get(requestFieldPath);
+
+      if (!fieldTypeInfo?.hasArguments && !fieldTypeInfo?.hasDirectives) {
+        acc[key] = fieldData[key];
+      }
+    }
+
+    return acc;
+  }, {});
+};

package/src/helpers/filterQuery.ts

@@ -0,0 +1,38 @@
+import { RequestData } from "@graphql-box/core";
+import { deleteChildFields, getChildFields, getOperationDefinitions } from "@graphql-box/helpers";
+import { CacheManagerContext, CachedResponseData } from "../defs";
+import { buildFieldKeysAndPaths } from "./buildKeysAndPaths";
+import createFragmentSpreadChecklist from "./createFragmentSpreadChecklist";
+import filterField from "./filterField";
+import filterFragmentDefinitions from "./filterFragmentDefinitions";
+
+export default ({ ast }: RequestData, { fieldPathChecklist }: CachedResponseData, context: CacheManagerContext) => {
+  const queryNode = getOperationDefinitions(ast, context.operation)[0];
+  const { fragmentDefinitions } = context;
+  const fieldsAndTypeNames = getChildFields(queryNode, { fragmentDefinitions });
+
+  if (!fieldsAndTypeNames) {
+    return ast;
+  }
+
+  const fragmentSpreadChecklist = createFragmentSpreadChecklist(ast);
+
+  for (let i = fieldsAndTypeNames.length - 1; i >= 0; i -= 1) {
+    const { fieldNode } = fieldsAndTypeNames[i];
+
+    const { requestFieldPath } = buildFieldKeysAndPaths(
+      fieldNode,
+      {
+        requestFieldPath: context.operation,
+      },
+      context,
+    );
+
+    if (filterField(fieldNode, fieldPathChecklist, fragmentSpreadChecklist, requestFieldPath, context)) {
+      deleteChildFields(queryNode, fieldNode);
+    }
+  }
+
+  context.queryFiltered = true;
+  return filterFragmentDefinitions(ast, fieldPathChecklist, fragmentSpreadChecklist, context);
+};

package/src/helpers/normalizeResponseData.ts

@@ -0,0 +1,9 @@
+import { RawResponseDataWithMaybeCacheMetadata } from "@graphql-box/core";
+import { set } from "lodash";
+
+export default ({ data, path, ...rest }: RawResponseDataWithMaybeCacheMetadata) => {
+  return {
+    ...rest,
+    data: set({}, path as (string | number)[], data),
+  };
+};

package/src/helpers/validTypeIDValue.ts

@@ -0,0 +1,11 @@
+import { FieldTypeInfo } from "@graphql-box/core";
+import { isPlainObject } from "lodash";
+
+export const getValidTypeIDValue = (
+  requestFieldPathData: any,
+  { typeIDValue }: FieldTypeInfo,
+  typeIDKey: string,
+): string | number | undefined => {
+  const requestFieldPathDataIDValue = isPlainObject(requestFieldPathData) ? requestFieldPathData[typeIDKey] : undefined;
+  return typeIDValue || requestFieldPathDataIDValue;
+};