@graphql-box/cache-manager 4.1.4 → 5.0.0

package/src/helpers/filterOperationAndFragmentDefinitions.ts

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

package/src/helpers/filterOutPropsWithArgsOrDirectives.ts

@@ -1,19 +1,19 @@
-import { PlainObjectMap } from "@graphql-box/core";
-import { KeysAndPaths, buildFieldKeysAndPaths, getName, resolveFragments } from "@graphql-box/helpers";
-import { FieldNode, SelectionNode } from "graphql";
-import { keys } from "lodash";
-import { CacheManagerContext } from "../defs";
+import { type PlainObject } from '@graphql-box/core';
+import { type KeysAndPaths, buildFieldKeysAndPaths, getName, resolveFragments } from '@graphql-box/helpers';
+import { type SelectionNode } from 'graphql';
+import { keys } from 'lodash-es';
+import { type CacheManagerContext } from '../types.ts';
 
-export default (
-  fieldData: PlainObjectMap,
+export const filterOutPropsWithArgsOrDirectives = (
+  fieldData: PlainObject,
   selectionNodes: readonly SelectionNode[],
   ancestorKeysAndPaths: KeysAndPaths,
-  context: CacheManagerContext,
+  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);
+  return keys(fieldData).reduce<PlainObject>((acc, key) => {
+    const match = fieldAndTypeName.find(({ fieldNode }) => getName(fieldNode) === key);
 
     if (match) {
       const { requestFieldPath } = buildFieldKeysAndPaths(match.fieldNode, ancestorKeysAndPaths, context);

package/src/helpers/filterQuery.ts

@@ -1,19 +1,28 @@
-import { RequestData } from "@graphql-box/core";
+import { type RequestData } from '@graphql-box/core';
 import {
   buildFieldKeysAndPaths,
   deleteChildFields,
   getChildFields,
   getOperationDefinitions,
-} from "@graphql-box/helpers";
-import { CacheManagerContext, CachedResponseData } from "../defs";
-import createFragmentSpreadChecklist from "./createFragmentSpreadChecklist";
-import filterField from "./filterField";
-import filterFragmentDefinitions from "./filterFragmentDefinitions";
+} from '@graphql-box/helpers';
+import { type CacheManagerContext, type CachedResponseData } from '../types.ts';
+import { createFragmentSpreadChecklist } from './createFragmentSpreadChecklist.ts';
+import { filterField } from './filterField.ts';
+import { filterFragmentDefinitions } from './filterFragmentDefinitions.ts';
 
-export default (requestData: RequestData, { fieldPathChecklist }: CachedResponseData, context: CacheManagerContext) => {
+export const filterQuery = (
+  requestData: RequestData,
+  { fieldPathChecklist }: CachedResponseData,
+  context: CacheManagerContext
+) => {
   const { ast } = requestData;
   const queryNode = getOperationDefinitions(ast, context.operation)[0];
-  const { fragmentDefinitions } = context;
+
+  if (!queryNode) {
+    return ast;
+  }
+
+  const { fragmentDefinitions, operation } = context;
   const fieldsAndTypeNames = getChildFields(queryNode, { fragmentDefinitions });
 
   if (!fieldsAndTypeNames) {
@@ -22,15 +31,15 @@ export default (requestData: RequestData, { fieldPathChecklist }: CachedResponse
 
   const fragmentSpreadChecklist = createFragmentSpreadChecklist(requestData, context);
 
-  for (let i = fieldsAndTypeNames.length - 1; i >= 0; i -= 1) {
-    const { fieldNode } = fieldsAndTypeNames[i];
+  for (let index = fieldsAndTypeNames.length - 1; index >= 0; index -= 1) {
+    const { fieldNode } = fieldsAndTypeNames[index]!;
 
     const { requestFieldPath } = buildFieldKeysAndPaths(
       fieldNode,
       {
-        requestFieldPath: context.operation,
+        requestFieldPath: operation,
       },
-      context,
+      context
     );
 
     if (filterField(fieldNode, fieldPathChecklist, fragmentSpreadChecklist, requestFieldPath, context)) {

package/src/helpers/getDataValue.ts

@@ -0,0 +1,14 @@
+import { isArray, isPlainObject } from '@graphql-box/helpers';
+import { isNumber, isString } from 'lodash-es';
+
+export const getDataValue = <T>(value: unknown, key: string | number): T | undefined => {
+  if (isArray(value) && isNumber(key)) {
+    return value[key] as T;
+  }
+
+  if (isPlainObject(value) && isString(key)) {
+    return value[key] as T;
+  }
+
+  return;
+};

package/src/helpers/hasTypename.ts

@@ -0,0 +1,11 @@
+import { TYPE_NAME_KEY, type TypedData } from '@graphql-box/core';
+import { isObjectLike } from '@graphql-box/helpers';
+import { isString } from 'lodash-es';
+
+export const hasTypename = (value: unknown): value is TypedData => {
+  if (!isObjectLike(value)) {
+    return false;
+  }
+
+  return TYPE_NAME_KEY in value && isString(value[TYPE_NAME_KEY]);
+};

package/src/helpers/isFirstResponseChunk.ts

@@ -1,5 +1,7 @@
-import { RawResponseDataWithMaybeCacheMetadata } from "@graphql-box/core";
-import { CacheManagerContext } from "..";
+import { type RawResponseDataWithMaybeCacheMetadata } from '@graphql-box/core';
+import { type CacheManagerContext } from '../types.ts';
 
-export default (rawResponseData: RawResponseDataWithMaybeCacheMetadata, context: CacheManagerContext) =>
-  context.hasDeferOrStream && rawResponseData.hasNext && !rawResponseData.paths;
+export const isFirstResponseChunk = (
+  rawResponseData: RawResponseDataWithMaybeCacheMetadata,
+  context: CacheManagerContext
+) => context.hasDeferOrStream && rawResponseData.hasNext && !rawResponseData.paths;

package/src/helpers/isLastResponseChunk.ts

@@ -1,5 +1,7 @@
-import { RawResponseDataWithMaybeCacheMetadata } from "@graphql-box/core";
-import { CacheManagerContext } from "..";
+import { type RawResponseDataWithMaybeCacheMetadata } from '@graphql-box/core';
+import { type CacheManagerContext } from '../types.ts';
 
-export default (rawResponseData: RawResponseDataWithMaybeCacheMetadata, context: CacheManagerContext) =>
-  context.hasDeferOrStream && !rawResponseData.hasNext && rawResponseData.paths;
+export const isLastResponseChunk = (
+  rawResponseData: RawResponseDataWithMaybeCacheMetadata,
+  context: CacheManagerContext
+) => context.hasDeferOrStream && !rawResponseData.hasNext && rawResponseData.paths;

package/src/helpers/isNotLastResponseChunk.ts

@@ -1,5 +1,7 @@
-import { RawResponseDataWithMaybeCacheMetadata } from "@graphql-box/core";
-import { CacheManagerContext } from "..";
+import { type RawResponseDataWithMaybeCacheMetadata } from '@graphql-box/core';
+import { type CacheManagerContext } from '../types.ts';
 
-export default (rawResponseData: RawResponseDataWithMaybeCacheMetadata, context: CacheManagerContext) =>
-  context.hasDeferOrStream && rawResponseData.hasNext;
+export const isNotLastResponseChunk = (
+  rawResponseData: RawResponseDataWithMaybeCacheMetadata,
+  context: CacheManagerContext
+) => context.hasDeferOrStream && rawResponseData.hasNext;

package/src/helpers/isNotResponseChunk.ts

@@ -1,5 +1,7 @@
-import { RawResponseDataWithMaybeCacheMetadata } from "@graphql-box/core";
-import { CacheManagerContext } from "..";
+import { type RawResponseDataWithMaybeCacheMetadata } from '@graphql-box/core';
+import { type CacheManagerContext } from '../types.ts';
 
-export default (rawResponseData: RawResponseDataWithMaybeCacheMetadata, context: CacheManagerContext) =>
-  !context.hasDeferOrStream && !rawResponseData.hasNext && !rawResponseData.paths;
+export const isNotResponseChunk = (
+  rawResponseData: RawResponseDataWithMaybeCacheMetadata,
+  context: CacheManagerContext
+) => !context.hasDeferOrStream && !rawResponseData.hasNext && !rawResponseData.paths;

package/src/helpers/mergeObjects.ts

@@ -0,0 +1,7 @@
+import { isPlainObject, mergeObjects } from '@graphql-box/helpers';
+
+export const mergeDataSets = <T extends object>(obj: T, source: T, typeIDKey: string): T => {
+  return mergeObjects<T>(obj, source, (_key: string, value: unknown): string | number | undefined => {
+    return isPlainObject(value) && value[typeIDKey] ? (value[typeIDKey] as string | number) : undefined;
+  });
+};

package/src/helpers/mergeResponseDataSets.ts

@@ -1,16 +1,16 @@
-import { RawResponseDataWithMaybeCacheMetadata } from "@graphql-box/core";
-import { merge } from "lodash";
+import { type RawResponseDataWithMaybeCacheMetadata } from '@graphql-box/core';
+import { merge } from 'lodash-es';
 
-export default (responseDataSets: RawResponseDataWithMaybeCacheMetadata[]) => {
-  return responseDataSets.reduce(
-    (acc: RawResponseDataWithMaybeCacheMetadata, dataSet, index) => {
+export const mergeResponseDataSets = (responseDataSets: RawResponseDataWithMaybeCacheMetadata[]) => {
+  return responseDataSets.reduce<RawResponseDataWithMaybeCacheMetadata>(
+    (acc, dataSet, index) => {
       const { _cacheMetadata, data, hasNext, headers, paths } = dataSet;
 
       if (_cacheMetadata) {
         acc._cacheMetadata = acc._cacheMetadata ? { ...acc._cacheMetadata, ..._cacheMetadata } : _cacheMetadata;
       }
 
-      acc.data = acc.data ? merge(acc.data, data) : data;
+      acc.data = merge(acc.data, data);
 
       if (index === 0) {
         acc.headers = headers;
@@ -25,11 +25,11 @@ export default (responseDataSets: RawResponseDataWithMaybeCacheMetadata[]) => {
           acc.paths = [];
         }
 
-        acc.paths.push(paths[0]);
+        acc.paths.push(...paths);
       }
 
       return acc;
     },
-    { data: {} },
+    { data: {} }
   );
 };

package/src/helpers/normalizePatchResponseData.ts

@@ -1,17 +1,24 @@
-import { RawResponseDataWithMaybeCacheMetadata } from "@graphql-box/core";
-import { set } from "lodash";
-import { CacheManagerContext } from "..";
+import { type RawResponseDataWithMaybeCacheMetadata } from '@graphql-box/core';
+import { isString, set } from 'lodash-es';
+import { type CacheManagerContext } from '../types.ts';
 
-export default (rawResponseData: RawResponseDataWithMaybeCacheMetadata, context: CacheManagerContext) => {
+export const normalizePatchResponseData = (
+  rawResponseData: RawResponseDataWithMaybeCacheMetadata,
+  context: CacheManagerContext
+) => {
   if (!context.normalizePatchResponseData) {
     return rawResponseData;
   }
 
   const { data, paths, ...rest } = rawResponseData;
 
+  if (!paths?.length || !isString(paths[0])) {
+    return rawResponseData;
+  }
+
   return {
     ...rest,
-    data: set({}, (paths as string[])[0], data),
+    data: set({}, paths[0], data),
     paths,
   };
 };

package/src/helpers/validTypeIdValue.ts

@@ -0,0 +1,18 @@
+import { type FieldTypeInfo } from '@graphql-box/core';
+import { isPlainObject } from '@graphql-box/helpers';
+
+export const getValidTypeIdValue = (
+  requestFieldPathData: unknown,
+  { typeIDValue }: FieldTypeInfo,
+  typeIDKey: string
+): string | number | undefined => {
+  if (typeIDValue) {
+    return typeIDValue;
+  }
+
+  if (isPlainObject(requestFieldPathData)) {
+    return requestFieldPathData[typeIDKey] as string | number | undefined;
+  }
+
+  return;
+};