@graphql-box/cache-manager 5.1.0 → 5.2.4

package/src/main.ts

@@ -36,19 +36,16 @@ import {
 } from '@graphql-box/helpers';
 import { Cacheability } from 'cacheability';
 import { type FieldNode, Kind, OperationTypeNode, print } from 'graphql';
-import { assign, get, isEqual, isNumber, isUndefined, set, unset } from 'lodash-es';
+import { assign, cloneDeep, get, isEqual, isNumber, isUndefined, set, unset } from 'lodash-es';
 import { CACHE_CONTROL, HEADER_NO_CACHE, METADATA, NO_CACHE } from './constants.ts';
 import { logCacheEntry, logCacheQuery, logPartialCompiled } from './debug/index.ts';
 import { areOnlyPopulatedFieldsTypeIdKeys } from './helpers/areOnlyPopulatedFieldsTypeIdKeys.ts';
 import { combineDataSets } from './helpers/combineData.ts';
-import { createEntityDataKey } from './helpers/createEntityDataKey.ts';
 import { deriveOpCacheability } from './helpers/deriveOpCacheability.ts';
-import { filterOutPropsWithEntityArgsOrDirectives } from './helpers/filterOutPropsWithEntityArgsOrDirectives.ts';
-import { filterOutPropsWithEntityOrArgs } from './helpers/filterOutPropsWithEntityOrArgs.ts';
+import { filterOutPropsWithArgsOrDirectives } from './helpers/filterOutPropsWithArgsOrDirectives.ts';
 import { filterQuery } from './helpers/filterQuery.ts';
 import { getDataValue } from './helpers/getDataValue.ts';
 import { hasTypename } from './helpers/hasTypename.ts';
-import { isFieldEntity } from './helpers/isFieldEntity.ts';
 import { isLastResponseChunk } from './helpers/isLastResponseChunk.ts';
 import { isNotLastResponseChunk } from './helpers/isNotLastResponseChunk.ts';
 import { isNotResponseChunk } from './helpers/isNotResponseChunk.ts';
@@ -91,7 +88,7 @@ export class CacheManager implements CacheManagerDef {
 
   private static _getFieldDataFromAncestor<T>(ancestorFieldData: unknown, propNameOrIndex: string | number) {
     const dataValue = getDataValue<T>(ancestorFieldData, propNameOrIndex);
-    return isObjectLike(dataValue) ? structuredClone(dataValue) : dataValue;
+    return isObjectLike(dataValue) ? cloneDeep(dataValue) : dataValue;
   }
 
   private static _getOperationCacheControl(cacheMetadata: CacheMetadata | undefined, operation: string): string {
@@ -279,12 +276,18 @@ export class CacheManager implements CacheManagerDef {
     }
 
     if (!fieldCount.missing) {
-      this._setQueryResponseCacheEntry(hash, { cacheMetadata, data }, options, cacheManagerContext);
+      const dataCaching = this._setQueryResponseCacheEntry(hash, { cacheMetadata, data }, options, cacheManagerContext);
+
+      if (options.awaitDataCaching) {
+        await dataCaching;
+      }
+
       return { response: { cacheMetadata, data } };
     }
 
     const filteredAST = filterQuery(requestData, cachedResponseData, cacheManagerContext);
     const filteredRequest = print(filteredAST);
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     const { fragmentDefinitions, typeIDKey, ...rest } = cacheManagerContext;
     assign(context, { ...rest, filteredRequest });
     this._setPartialQueryResponse(hash, { cacheMetadata, data }, options, context);
@@ -298,13 +301,13 @@ export class CacheManager implements CacheManagerDef {
     return this._cache;
   }
 
-  public cacheQuery(
+  public async cacheQuery(
     requestData: RequestData,
     updatedRequestData: RequestData | undefined,
     rawResponseData: RawResponseDataWithMaybeCacheMetadata,
     options: RequestOptions,
     context: RequestContext
-  ): ResponseData {
+  ): Promise<ResponseData> {
     const cacheManagerContext: CacheManagerContext = {
       ...context,
       fragmentDefinitions: getFragmentDefinitions((updatedRequestData ?? requestData).ast),
@@ -314,12 +317,12 @@ export class CacheManager implements CacheManagerDef {
     return this._cacheResponse(requestData, updatedRequestData, rawResponseData, options, cacheManagerContext);
   }
 
-  public cacheResponse(
+  public async cacheResponse(
     requestData: RequestData,
     rawResponseData: RawResponseDataWithMaybeCacheMetadata,
     options: RequestOptions,
     context: RequestContext
-  ): ResponseData {
+  ): Promise<ResponseData> {
     const cacheManagerContext: CacheManagerContext = {
       ...context,
       fragmentDefinitions: getFragmentDefinitions(requestData.ast),
@@ -361,13 +364,13 @@ export class CacheManager implements CacheManagerDef {
     this._partialQueryResponses.delete(hash);
   }
 
-  public setQueryResponseCacheEntry(
+  public async setQueryResponseCacheEntry(
     requestData: RequestData,
     responseData: ResponseData,
     options: RequestOptions,
     context: CacheManagerContext
-  ): void {
-    this._setQueryResponseCacheEntry(requestData.hash, responseData, options, context);
+  ): Promise<void> {
+    return this._setQueryResponseCacheEntry(requestData.hash, responseData, options, context);
   }
 
   private async _analyzeFieldNode(
@@ -448,7 +451,7 @@ export class CacheManager implements CacheManagerDef {
   ): Promise<void> {
     const keysAndPaths = buildFieldKeysAndPaths(fieldNode, cachedAncestorFieldData, context);
     const { propNameOrIndex, requestFieldCacheKey, requestFieldPath } = keysAndPaths;
-    const fieldTypeInfo = context.fieldTypeMap.get(requestFieldPath);
+    const fieldTypeInfo = context.fieldTypeMap.get(requestFieldPath)!;
 
     const { cacheability, data, entityData, requestFieldPathData } = await this._retrieveCachedParentNodeData(
       cachedAncestorFieldData,
@@ -551,13 +554,13 @@ export class CacheManager implements CacheManagerDef {
     return cacheMetadata;
   }
 
-  private _cacheResponse(
+  private async _cacheResponse(
     requestData: RequestData,
     updatedRequestData: RequestData | undefined,
     rawResponseData: RawResponseDataWithMaybeCacheMetadata,
     options: RequestOptions,
     context: CacheManagerContext
-  ): ResponseData {
+  ): Promise<ResponseData> {
     const normalizedResponseData = normalizePatchResponseData(rawResponseData, context);
     let responseDataForCaching: RawResponseDataWithMaybeCacheMetadata | undefined = normalizedResponseData;
 
@@ -570,22 +573,24 @@ export class CacheManager implements CacheManagerDef {
       responseDataForCaching = this._retrieveResponseDataForCaching(normalizedResponseData, context);
     }
 
+    const dataCaching: Promise<void>[] = [];
+
     if (responseDataForCaching) {
       const { data } = responseDataForCaching;
       const cacheMetadata = this._buildCacheMetadata(requestData, responseDataForCaching, options, context);
 
-      void new Promise(() => {
+      dataCaching.push(
         this._setEntityAndRequestFieldPathCacheEntries(
           requestData,
           {
             cacheMetadata,
-            entityData: structuredClone(data),
-            requestFieldPathData: structuredClone(data),
+            entityData: cloneDeep(data),
+            requestFieldPathData: cloneDeep(data),
           },
           options,
           context
-        );
-      });
+        )
+      );
 
       let queryCacheMetadata: CacheMetadata | undefined;
       let queryData: PlainData | undefined;
@@ -594,21 +599,30 @@ export class CacheManager implements CacheManagerDef {
         let partialQueryResponse: PartialQueryResponse | undefined;
 
         if (context.queryFiltered && updatedRequestData) {
-          this._setQueryResponseCacheEntry(updatedRequestData.hash, { cacheMetadata, data }, options, context);
+          dataCaching.push(
+            this._setQueryResponseCacheEntry(updatedRequestData.hash, { cacheMetadata, data }, options, context)
+          );
+
           partialQueryResponse = this._getPartialQueryResponse(requestData.hash);
         }
 
         queryCacheMetadata = CacheManager._mergeResponseCacheMetadata(cacheMetadata, partialQueryResponse);
         queryData = this._mergeResponseData(data, partialQueryResponse);
 
-        this._setQueryResponseCacheEntry(
-          requestData.hash,
-          { cacheMetadata: queryCacheMetadata, data: queryData },
-          options,
-          context
+        dataCaching.push(
+          this._setQueryResponseCacheEntry(
+            requestData.hash,
+            { cacheMetadata: queryCacheMetadata, data: queryData },
+            options,
+            context
+          )
         );
       }
 
+      if (options.awaitDataCaching) {
+        await Promise.all(dataCaching);
+      }
+
       if (isNotResponseChunk(normalizedResponseData, context) && queryCacheMetadata && queryData) {
         return {
           cacheMetadata: queryCacheMetadata,
@@ -697,6 +711,22 @@ export class CacheManager implements CacheManagerDef {
     }
   }
 
+  private _isFieldEntity(fieldData: unknown, { isEntity, possibleTypes }: FieldTypeInfo): boolean {
+    if (!isPlainObject(fieldData) || !(this._typeIDKey in fieldData)) {
+      return false;
+    }
+
+    if (isEntity) {
+      return true;
+    }
+
+    if (possibleTypes.length === 0) {
+      return false;
+    }
+
+    return possibleTypes.some(type => type.typeName === fieldData.__typename);
+  }
+
   private _mergeResponseData(responseData: PlainData, partialQueryResponse?: PartialQueryResponse): PlainData {
     if (!partialQueryResponse) {
       return responseData;
@@ -705,24 +735,25 @@ export class CacheManager implements CacheManagerDef {
     return mergeDataSets(partialQueryResponse.data, responseData, this._typeIDKey);
   }
 
-  private _parseEntityAndRequestFieldPathCacheEntryData(
+  private async _parseEntityAndRequestFieldPathCacheEntryData(
     field: FieldNode,
     ancestorKeysAndPaths: AncestorKeysAndPaths,
     { cacheMetadata, entityData, requestFieldPathData }: ResponseDataForCaching,
     options: RequestOptions,
     context: CacheManagerContext
-  ): void {
+  ): Promise<void> {
     const keysAndPaths = buildFieldKeysAndPaths(field, ancestorKeysAndPaths, context);
-    const { hashedRequestFieldCacheKey, requestFieldCacheKey, requestFieldPath, responseDataPath } = keysAndPaths;
+    const { requestFieldCacheKey, requestFieldPath, responseDataPath } = keysAndPaths;
     const fieldData = get(requestFieldPathData, responseDataPath) as unknown;
     const fieldTypeInfo = context.fieldTypeMap.get(requestFieldPath);
-    const cacheability = cacheMetadata.get(requestFieldPath);
 
     if (!isObjectLike(fieldData) && !fieldTypeInfo?.hasDirectives) {
       return;
     }
 
     if (isObjectLike(fieldData)) {
+      const promises: Promise<void>[] = [];
+
       iterateChildFields(
         field,
         fieldData,
@@ -734,81 +765,41 @@ export class CacheManager implements CacheManagerDef {
           _fragmentName: string | undefined,
           childIndex?: number
         ) => {
-          this._parseEntityAndRequestFieldPathCacheEntryData(
-            childField,
-            { index: childIndex, requestFieldCacheKey, requestFieldPath, responseDataPath },
-            { cacheMetadata, entityData, requestFieldPathData },
-            options,
-            context
+          promises.push(
+            this._parseEntityAndRequestFieldPathCacheEntryData(
+              childField,
+              { index: childIndex, requestFieldCacheKey, requestFieldPath, responseDataPath },
+              { cacheMetadata, entityData, requestFieldPathData },
+              options,
+              context
+            )
           );
         }
       );
-    }
-
-    if (isUndefined(fieldData) || !fieldTypeInfo || !cacheability) {
-      return;
-    }
-
-    const isEntity = isFieldEntity(fieldData, fieldTypeInfo, this._typeIDKey);
-    const hasArgsOrDirectives = !!fieldTypeInfo.hasArguments || !!fieldTypeInfo.hasDirectives;
 
-    if (context.operation === OperationTypeNode.QUERY && (isEntity || hasArgsOrDirectives)) {
-      void this._setRequestFieldPathCacheEntry(
-        keysAndPaths,
-        {
-          cacheability,
-          fieldData: filterOutPropsWithEntityArgsOrDirectives(structuredClone(fieldData), field, keysAndPaths, context),
-          fieldTypeInfo,
-        },
-        options,
-        context
-      );
-
-      if (hasChildFields(field, { fragmentDefinitions: context.fragmentDefinitions })) {
-        if (isEntity) {
-          set(requestFieldPathData, responseDataPath, {
-            __cacheKey: `${REQUEST_FIELD_PATHS}::${hashedRequestFieldCacheKey}`,
-          });
-        } else {
-          unset(requestFieldPathData, responseDataPath);
-        }
-      }
+      await Promise.all(promises);
     }
 
-    if (isEntity) {
-      void this._setEntityCacheEntry(
-        {
-          cacheability,
-          fieldData: filterOutPropsWithEntityOrArgs(
-            structuredClone(get(entityData, responseDataPath)) as EntityData,
-            field,
-            keysAndPaths,
-            context
-          ),
-          fieldTypeInfo,
-        },
-        options,
-        context
-      );
-
-      set(entityData, responseDataPath, {
-        __cacheKey: `${DATA_ENTITIES}::${createEntityDataKey(fieldData, fieldTypeInfo, context)}`,
-      });
-    }
+    await this._setEntityAndRequestFieldPathCacheEntry(
+      field,
+      keysAndPaths,
+      { cacheMetadata, entityData, requestFieldPathData },
+      options,
+      context
+    );
   }
 
   private async _retrieveCachedEntityData(
     validTypeIDValue: string | number,
-    fieldTypeInfo: FieldTypeInfo | undefined,
+    { possibleTypes, typeName }: FieldTypeInfo,
     options: RequestOptions,
     context: CacheManagerContext
   ): Promise<Partial<CheckCacheEntryResult<EntityData>>> {
-    const { possibleTypes = [], typeName } = fieldTypeInfo ?? {};
     const typeNames = [...possibleTypes.map(type => type.typeName), typeName];
 
     const checkResults = await Promise.all(
       typeNames.map(name =>
-        this._checkCacheEntry<EntityData>(DATA_ENTITIES, `${String(name)}::${validTypeIDValue}`, options, context)
+        this._checkCacheEntry<EntityData>(DATA_ENTITIES, `${name}::${validTypeIDValue}`, options, context)
       )
     );
 
@@ -835,7 +826,7 @@ export class CacheManager implements CacheManagerDef {
   private async _retrieveCachedParentNodeData(
     { entityData: ancestorEntityData, requestFieldPathData: ancestorRequestFieldPathData }: CachedAncestorFieldData,
     { hashedRequestFieldCacheKey, propNameOrIndex, requestFieldCacheKey }: KeysAndPaths,
-    fieldTypeInfo: FieldTypeInfo | undefined,
+    fieldTypeInfo: FieldTypeInfo,
     options: RequestOptions,
     context: CacheManagerContext
   ) {
@@ -952,18 +943,18 @@ export class CacheManager implements CacheManagerDef {
     _context: CacheManagerContext & { requestFieldCacheKey?: string }
   ): Promise<void> {
     try {
-      await this._cache.set(`${cacheType}::${hash}`, value, cachemapOptions);
+      await this._cache.set(`${cacheType}::${hash}`, cloneDeep(value), cachemapOptions);
     } catch {
       // no catch
     }
   }
 
-  private _setEntityAndRequestFieldPathCacheEntries(
+  private async _setEntityAndRequestFieldPathCacheEntries(
     requestData: RequestData,
     responseData: ResponseDataForCaching,
     options: RequestOptions,
     context: CacheManagerContext
-  ): void {
+  ): Promise<void> {
     const operationNode = getOperationDefinitions(requestData.ast, context.operation)[0];
 
     if (!operationNode) {
@@ -976,22 +967,69 @@ export class CacheManager implements CacheManagerDef {
       return;
     }
 
-    fieldsAndTypeNames.map(({ fieldNode }) => {
-      this._parseEntityAndRequestFieldPathCacheEntryData(
-        fieldNode,
-        { requestFieldPath: context.operation },
-        responseData,
+    await Promise.all(
+      fieldsAndTypeNames.map(({ fieldNode }) => {
+        return this._parseEntityAndRequestFieldPathCacheEntryData(
+          fieldNode,
+          { requestFieldPath: context.operation },
+          responseData,
+          options,
+          context
+        );
+      })
+    );
+  }
+
+  private async _setEntityAndRequestFieldPathCacheEntry(
+    field: FieldNode,
+    keysAndPaths: KeysAndPaths,
+    { cacheMetadata, entityData, requestFieldPathData }: ResponseDataForCaching,
+    options: RequestOptions,
+    context: CacheManagerContext
+  ) {
+    const { requestFieldPath, responseDataPath } = keysAndPaths;
+    const fieldData = get(entityData, responseDataPath) as unknown;
+    const fieldTypeInfo = context.fieldTypeMap.get(requestFieldPath);
+    const cacheability = cacheMetadata.get(requestFieldPath);
+
+    if (isUndefined(fieldData) || !fieldTypeInfo || !cacheability) {
+      return;
+    }
+
+    const promises: Promise<void>[] = [];
+
+    promises.push(
+      this._setRequestFieldPathCacheEntry(
+        field,
+        keysAndPaths,
+        { cacheability, data: requestFieldPathData, fieldTypeInfo },
         options,
         context
+      )
+    );
+
+    const isEntity = this._isFieldEntity(fieldData, fieldTypeInfo);
+
+    if (!isEntity && fieldTypeInfo.hasArguments) {
+      unset(entityData, responseDataPath);
+    }
+
+    if (isEntity) {
+      promises.push(
+        this._setEntityCacheEntry(keysAndPaths, { cacheability, data: entityData, fieldTypeInfo }, options, context)
       );
-    });
+    }
+
+    await Promise.all(promises);
   }
 
   private async _setEntityCacheEntry(
-    { cacheability, fieldData, fieldTypeInfo }: DataForCachingEntry<EntityData>,
+    { responseDataPath }: KeysAndPaths,
+    { cacheability, data, fieldTypeInfo }: DataForCachingEntry,
     options: RequestOptions,
     context: CacheManagerContext
   ) {
+    let fieldData = get(data, responseDataPath) as EntityData;
     const fieldTypeName = fieldTypeInfo.isEntity ? fieldTypeInfo.typeName : fieldData.__typename;
     const entityDataKey = `${fieldTypeName}::${String(fieldData[this._typeIDKey])}`;
     const result = await this._checkCacheEntry<EntityData>(DATA_ENTITIES, entityDataKey, options, context);
@@ -1000,7 +1038,7 @@ export class CacheManager implements CacheManagerDef {
       fieldData = mergeDataSets(result.entry, fieldData, this._typeIDKey);
     }
 
-    void this._setCacheEntry(
+    await this._setCacheEntry(
       DATA_ENTITIES,
       entityDataKey,
       fieldData,
@@ -1008,6 +1046,8 @@ export class CacheManager implements CacheManagerDef {
       options,
       context
     );
+
+    set(data, responseDataPath, { __cacheKey: `${DATA_ENTITIES}::${entityDataKey}` });
   }
 
   private _setFieldCacheability(
@@ -1092,16 +1132,16 @@ export class CacheManager implements CacheManagerDef {
     this._partialQueryResponses.set(hash, partialQueryResponse);
   }
 
-  private _setQueryResponseCacheEntry(
+  private async _setQueryResponseCacheEntry(
     hash: string,
     { cacheMetadata, data }: ResponseData,
     options: RequestOptions,
     context: CacheManagerContext
-  ): void {
+  ): Promise<void> {
     const dehydratedCacheMetadata = dehydrateCacheMetadata(cacheMetadata);
     const cacheControl = CacheManager._getOperationCacheControl(cacheMetadata, context.operation);
 
-    void this._setCacheEntry(
+    await this._setCacheEntry(
       QUERY_RESPONSES,
       hash,
       { cacheMetadata: dehydratedCacheMetadata, data },
@@ -1112,30 +1152,48 @@ export class CacheManager implements CacheManagerDef {
   }
 
   private async _setRequestFieldPathCacheEntry(
+    field: FieldNode,
     keysAndPaths: KeysAndPaths,
-    { cacheability, fieldData }: DataForCachingEntry,
+    { cacheability, data, fieldTypeInfo }: DataForCachingEntry,
     options: RequestOptions,
     context: CacheManagerContext
   ): Promise<void> {
-    const { hashedRequestFieldCacheKey, requestFieldCacheKey } = keysAndPaths;
+    const { hashedRequestFieldCacheKey, requestFieldCacheKey, responseDataPath } = keysAndPaths;
+    let fieldData = get(data, responseDataPath) as unknown;
+    const isEntity = this._isFieldEntity(fieldData, fieldTypeInfo);
+    const hasArgsOrDirectives = fieldTypeInfo.hasArguments || fieldTypeInfo.hasDirectives;
 
-    const result = await this._checkCacheEntry(REQUEST_FIELD_PATHS, hashedRequestFieldCacheKey, options, {
-      ...context,
-      requestFieldCacheKey,
-    });
+    if (context.operation === OperationTypeNode.QUERY && (isEntity || hasArgsOrDirectives)) {
+      if (isPlainObject(fieldData) && field.selectionSet?.selections) {
+        fieldData = filterOutPropsWithArgsOrDirectives(fieldData, field.selectionSet.selections, keysAndPaths, context);
+      }
 
-    if (result && isObjectLike(result.entry) && isObjectLike(fieldData)) {
-      fieldData = mergeDataSets(result.entry, fieldData, this._typeIDKey);
-    }
+      const result = await this._checkCacheEntry(REQUEST_FIELD_PATHS, hashedRequestFieldCacheKey, options, {
+        ...context,
+        requestFieldCacheKey,
+      });
 
-    void this._setCacheEntry(
-      REQUEST_FIELD_PATHS,
-      hashedRequestFieldCacheKey,
-      fieldData,
-      { cacheHeaders: { cacheControl: cacheability.printCacheControl() }, tag: options.tag },
-      options,
-      { ...context, requestFieldCacheKey }
-    );
+      if (result && isObjectLike(result.entry) && isObjectLike(fieldData)) {
+        fieldData = mergeDataSets(result.entry, fieldData, this._typeIDKey);
+      }
+
+      await this._setCacheEntry(
+        REQUEST_FIELD_PATHS,
+        hashedRequestFieldCacheKey,
+        fieldData,
+        { cacheHeaders: { cacheControl: cacheability.printCacheControl() }, tag: options.tag },
+        options,
+        { ...context, requestFieldCacheKey }
+      );
+
+      if (hasChildFields(field, { fragmentDefinitions: context.fragmentDefinitions })) {
+        if (isEntity) {
+          set(data, responseDataPath, { __cacheKey: `${REQUEST_FIELD_PATHS}::${hashedRequestFieldCacheKey}` });
+        } else {
+          unset(data, responseDataPath);
+        }
+      }
+    }
   }
 
   private _setResponseChunksAwaitingCaching(

package/src/types.ts

@@ -122,9 +122,9 @@ export interface ResponseDataForCaching {
   requestFieldPathData: PlainData;
 }
 
-export interface DataForCachingEntry<Data = unknown> {
+export interface DataForCachingEntry {
   cacheability: Cacheability;
-  fieldData: Data;
+  data: PlainData;
   fieldTypeInfo: FieldTypeInfo;
 }
 
@@ -157,13 +157,13 @@ export interface CacheManagerDef {
     responseData: RawResponseDataWithMaybeCacheMetadata,
     options: RequestOptions,
     context: RequestContext
-  ): ResponseData;
+  ): Promise<ResponseData>;
   cacheResponse(
     requestData: RequestData,
     responseData: RawResponseDataWithMaybeCacheMetadata,
     options: RequestOptions,
     context: RequestContext
-  ): ResponseData;
+  ): Promise<ResponseData>;
   checkCacheEntry(
     cacheType: CacheTypes,
     hash: string,
@@ -181,5 +181,5 @@ export interface CacheManagerDef {
     responseData: ResponseData,
     options: RequestOptions,
     context: CacheManagerContext
-  ): void;
+  ): Promise<void>;
 }

package/dist/types/cjs/helpers/createEntityDataKey.d.cts

@@ -1,4 +0,0 @@
-import type { EntityData, FieldTypeInfo } from '@graphql-box/core';
-import type { CacheManagerContext } from '../types.cts';
-export declare const createEntityDataKey: (fieldData: EntityData, fieldTypeInfo: FieldTypeInfo, context: CacheManagerContext) => string;
-//# sourceMappingURL=createEntityDataKey.d.cts.map

package/dist/types/cjs/helpers/createEntityDataKey.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createEntityDataKey.d.cts","sourceRoot":"","sources":["../../../../src/helpers/createEntityDataKey.cts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACnE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAEvD,eAAO,MAAM,mBAAmB,cACnB,UAAU,iBACN,aAAa,WACnB,mBAAmB,WAI7B,CAAC"}

package/dist/types/cjs/helpers/filterOutPropsWithEntityArgsOrDirectives.d.cts

@@ -1,5 +0,0 @@
-import { type KeysAndPaths } from '@graphql-box/helpers';
-import { type FieldNode } from 'graphql';
-import { type CacheManagerContext } from '../types.cts';
-export declare const filterOutPropsWithEntityArgsOrDirectives: (fieldData: unknown, field: FieldNode, ancestorKeysAndPaths: KeysAndPaths, context: CacheManagerContext) => unknown;
-//# sourceMappingURL=filterOutPropsWithEntityArgsOrDirectives.d.cts.map

package/dist/types/cjs/helpers/filterOutPropsWithEntityArgsOrDirectives.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"filterOutPropsWithEntityArgsOrDirectives.d.cts","sourceRoot":"","sources":["../../../../src/helpers/filterOutPropsWithEntityArgsOrDirectives.cts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,YAAY,EAKlB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,SAAS,CAAC;AAEzC,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAGvD,eAAO,MAAM,wCAAwC,cACxC,OAAO,SACX,SAAS,wBACM,YAAY,WACzB,mBAAmB,YA2B7B,CAAC"}

package/dist/types/cjs/helpers/filterOutPropsWithEntityOrArgs.d.cts

@@ -1,6 +0,0 @@
-import { type EntityData } from '@graphql-box/core';
-import { type KeysAndPaths } from '@graphql-box/helpers';
-import { type FieldNode } from 'graphql';
-import { type CacheManagerContext } from '../types.cts';
-export declare const filterOutPropsWithEntityOrArgs: (fieldData: EntityData, field: FieldNode, ancestorKeysAndPaths: KeysAndPaths, context: CacheManagerContext) => EntityData;
-//# sourceMappingURL=filterOutPropsWithEntityOrArgs.d.cts.map

package/dist/types/cjs/helpers/filterOutPropsWithEntityOrArgs.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"filterOutPropsWithEntityOrArgs.d.cts","sourceRoot":"","sources":["../../../../src/helpers/filterOutPropsWithEntityOrArgs.cts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,KAAK,YAAY,EAAqD,MAAM,sBAAsB,CAAC;AAC5G,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,SAAS,CAAC;AAEzC,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAGvD,eAAO,MAAM,8BAA8B,cAC9B,UAAU,SACd,SAAS,wBACM,YAAY,WACzB,mBAAmB,eAmB7B,CAAC"}

package/dist/types/cjs/helpers/isFieldEntity.d.cts

@@ -1,3 +0,0 @@
-import type { EntityData, FieldTypeInfo } from '@graphql-box/core';
-export declare const isFieldEntity: (fieldData: unknown, fieldTypeInfo: FieldTypeInfo | undefined, typeIDKey: string) => fieldData is EntityData;
-//# sourceMappingURL=isFieldEntity.d.cts.map

package/dist/types/cjs/helpers/isFieldEntity.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"isFieldEntity.d.cts","sourceRoot":"","sources":["../../../../src/helpers/isFieldEntity.cts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAGnE,eAAO,MAAM,aAAa,cACb,OAAO,iBACH,aAAa,GAAG,SAAS,aAC7B,MAAM,4BAiBlB,CAAC"}

package/dist/types/esm/helpers/createEntityDataKey.d.ts

@@ -1,4 +0,0 @@
-import type { EntityData, FieldTypeInfo } from '@graphql-box/core';
-import type { CacheManagerContext } from '../types.ts';
-export declare const createEntityDataKey: (fieldData: EntityData, fieldTypeInfo: FieldTypeInfo, context: CacheManagerContext) => string;
-//# sourceMappingURL=createEntityDataKey.d.ts.map

package/dist/types/esm/helpers/createEntityDataKey.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createEntityDataKey.d.ts","sourceRoot":"","sources":["../../../../src/helpers/createEntityDataKey.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACnE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAEvD,eAAO,MAAM,mBAAmB,cACnB,UAAU,iBACN,aAAa,WACnB,mBAAmB,WAI7B,CAAC"}

package/dist/types/esm/helpers/filterOutPropsWithEntityArgsOrDirectives.d.ts

@@ -1,5 +0,0 @@
-import { type KeysAndPaths } from '@graphql-box/helpers';
-import { type FieldNode } from 'graphql';
-import { type CacheManagerContext } from '../types.ts';
-export declare const filterOutPropsWithEntityArgsOrDirectives: (fieldData: unknown, field: FieldNode, ancestorKeysAndPaths: KeysAndPaths, context: CacheManagerContext) => unknown;
-//# sourceMappingURL=filterOutPropsWithEntityArgsOrDirectives.d.ts.map

package/dist/types/esm/helpers/filterOutPropsWithEntityArgsOrDirectives.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"filterOutPropsWithEntityArgsOrDirectives.d.ts","sourceRoot":"","sources":["../../../../src/helpers/filterOutPropsWithEntityArgsOrDirectives.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,YAAY,EAKlB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,SAAS,CAAC;AAEzC,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAGvD,eAAO,MAAM,wCAAwC,cACxC,OAAO,SACX,SAAS,wBACM,YAAY,WACzB,mBAAmB,YA2B7B,CAAC"}

package/dist/types/esm/helpers/filterOutPropsWithEntityOrArgs.d.ts

@@ -1,6 +0,0 @@
-import { type EntityData } from '@graphql-box/core';
-import { type KeysAndPaths } from '@graphql-box/helpers';
-import { type FieldNode } from 'graphql';
-import { type CacheManagerContext } from '../types.ts';
-export declare const filterOutPropsWithEntityOrArgs: (fieldData: EntityData, field: FieldNode, ancestorKeysAndPaths: KeysAndPaths, context: CacheManagerContext) => EntityData;
-//# sourceMappingURL=filterOutPropsWithEntityOrArgs.d.ts.map

package/dist/types/esm/helpers/filterOutPropsWithEntityOrArgs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"filterOutPropsWithEntityOrArgs.d.ts","sourceRoot":"","sources":["../../../../src/helpers/filterOutPropsWithEntityOrArgs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,KAAK,YAAY,EAAqD,MAAM,sBAAsB,CAAC;AAC5G,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,SAAS,CAAC;AAEzC,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAGvD,eAAO,MAAM,8BAA8B,cAC9B,UAAU,SACd,SAAS,wBACM,YAAY,WACzB,mBAAmB,eAmB7B,CAAC"}

package/dist/types/esm/helpers/isFieldEntity.d.ts

@@ -1,3 +0,0 @@
-import type { EntityData, FieldTypeInfo } from '@graphql-box/core';
-export declare const isFieldEntity: (fieldData: unknown, fieldTypeInfo: FieldTypeInfo | undefined, typeIDKey: string) => fieldData is EntityData;
-//# sourceMappingURL=isFieldEntity.d.ts.map