@graphql-box/cache-manager 3.2.0 → 3.3.0

package/src/consts/index.ts

@@ -4,7 +4,3 @@ export const NO_CACHE = "noCache";
 
 export const HEADER_CACHE_CONTROL = "cache-control";
 export const HEADER_NO_CACHE = "no-cache";
-
-export const CACHE_ENTRY_ADDED = "cache_entry_added";
-export const CACHE_ENTRY_QUERIED = "cache_entry_queried";
-export const PARTIAL_QUERY_COMPILED = "partial_query_compiled";

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

@@ -1,5 +1,4 @@
-import { RequestContext } from "@graphql-box/core";
-import { CACHE_ENTRY_ADDED } from "../../consts";
+import { CACHE_ENTRY_ADDED, RequestContext } from "@graphql-box/core";
 
 export default function logCacheEntry() {
   return (
@@ -12,7 +11,9 @@ export default function logCacheEntry() {
 
     descriptor.value = async function descriptorValue(...args: any[]): Promise<any> {
       return new Promise<void>(async resolve => {
-        const { debugManager, ...otherContext } = args[5] as RequestContext;
+        const { debugManager, requestFieldCacheKey, requestID, ...otherContext } = args[5] as RequestContext & {
+          requestFieldCacheKey?: string;
+        };
 
         if (!debugManager) {
           await method.apply(this, args);
@@ -26,15 +27,19 @@ export default function logCacheEntry() {
         const duration = endTime - startTime;
         resolve();
 
-        debugManager.emit(CACHE_ENTRY_ADDED, {
+        const payload = {
           cachemapOptions: args[3],
           cacheType: args[0],
           context: otherContext,
           hash: args[1],
           options: args[4],
+          requestID,
           stats: { duration, endTime, startTime },
           value: args[2],
-        });
+          ...(requestFieldCacheKey ? { decryptedCacheKey: requestFieldCacheKey } : {}),
+        };
+
+        debugManager.emit(CACHE_ENTRY_ADDED, payload);
       });
     };
   };

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

@@ -1,5 +1,4 @@
-import { RequestContext } from "@graphql-box/core";
-import { CACHE_ENTRY_QUERIED } from "../../consts";
+import { CACHE_ENTRY_QUERIED, RequestContext } from "@graphql-box/core";
 
 export default function logCacheQuery() {
   return (
@@ -13,7 +12,9 @@ export default function logCacheQuery() {
     descriptor.value = async function descriptorValue(...args: any[]): Promise<any> {
       try {
         return new Promise(async resolve => {
-          const { debugManager, ...otherContext } = args[3] as RequestContext;
+          const { debugManager, requestFieldCacheKey, requestID, ...otherContext } = args[3] as RequestContext & {
+            requestFieldCacheKey?: string;
+          };
 
           if (!debugManager) {
             resolve(await method.apply(this, args));
@@ -26,14 +27,18 @@ export default function logCacheQuery() {
           const duration = endTime - startTime;
           resolve(result);
 
-          debugManager.emit(CACHE_ENTRY_QUERIED, {
+          const payload = {
             cacheType: args[0],
             context: otherContext,
             hash: args[1],
             options: args[2],
+            requestID,
             result,
             stats: { duration, endTime, startTime },
-          });
+            ...(requestFieldCacheKey ? { decryptedCacheKey: requestFieldCacheKey } : {}),
+          };
+
+          debugManager.emit(CACHE_ENTRY_QUERIED, payload);
         });
       } catch (error) {
         return Promise.reject(error);

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

@@ -1,5 +1,4 @@
-import { RequestContext } from "@graphql-box/core";
-import { PARTIAL_QUERY_COMPILED } from "../../consts";
+import { PARTIAL_QUERY_COMPILED, RequestContext } from "@graphql-box/core";
 
 export default function logPartialCompiled() {
   return (
@@ -12,7 +11,7 @@ export default function logPartialCompiled() {
 
     descriptor.value = async function descriptorValue(...args: any[]): Promise<any> {
       return new Promise<void>(async resolve => {
-        const { debugManager, ...otherContext } = args[3] as RequestContext;
+        const { debugManager, requestID, ...otherContext } = args[3] as RequestContext;
 
         if (!debugManager) {
           await method.apply(this, args);
@@ -31,6 +30,7 @@ export default function logPartialCompiled() {
           hash: args[0],
           options: args[2],
           partialQueryResponse: args[1],
+          requestID,
           stats: { duration, endTime, startTime },
         });
       });

package/src/index.ts

@@ -1,3 +1,2 @@
-export { CACHE_ENTRY_ADDED, CACHE_ENTRY_QUERIED, PARTIAL_QUERY_COMPILED } from "./consts";
 export * from "./defs";
 export { default, CacheManager } from "./main";

package/src/main/index.ts

@@ -317,7 +317,7 @@ export class CacheManager implements CacheManagerDef {
     cacheType: CacheTypes,
     hash: string,
     options: RequestOptions,
-    context: RequestContext,
+    context: RequestContext & { requestFieldCacheKey?: string },
   ): Promise<CheckCacheEntryResult | false> {
     return this._checkCacheEntry(cacheType, hash, options, context);
   }
@@ -376,7 +376,7 @@ export class CacheManager implements CacheManagerDef {
     context: CacheManagerContext,
   ): Promise<void> {
     const keysAndPaths = buildFieldKeysAndPaths(fieldNode, cachedAncestorFieldData, context);
-    const { hashedRequestFieldCacheKey, propNameOrIndex, requestFieldPath } = keysAndPaths;
+    const { hashedRequestFieldCacheKey, propNameOrIndex, requestFieldCacheKey, requestFieldPath } = keysAndPaths;
     const fieldTypeInfo = context.fieldTypeMap.get(requestFieldPath);
     const { entityData, fragmentKind, fragmentName, requestFieldPathData, typeName } = cachedAncestorFieldData;
 
@@ -390,6 +390,7 @@ export class CacheManager implements CacheManagerDef {
     if (CacheManager._isNodeRequestFieldPath(fieldTypeInfo)) {
       const { cacheability, entry } = await this._retrieveCachedRequestFieldPathData(
         hashedRequestFieldCacheKey,
+        requestFieldCacheKey,
         options,
         context,
       );
@@ -609,7 +610,7 @@ export class CacheManager implements CacheManagerDef {
     cacheType: CacheTypes,
     hash: string,
     options: RequestOptions,
-    context: CacheManagerContext,
+    context: CacheManagerContext & { requestFieldCacheKey?: string },
   ): Promise<CheckCacheEntryResult | false> {
     try {
       const cacheability = await this._hasCacheEntry(cacheType, hash);
@@ -656,7 +657,7 @@ export class CacheManager implements CacheManagerDef {
     cacheType: CacheTypes,
     hash: string,
     _options: RequestOptions,
-    _context: CacheManagerContext,
+    _context: CacheManagerContext & { requestFieldCacheKey?: string },
   ): Promise<any> {
     try {
       return await this._cache.get(`${cacheType}::${hash}`);
@@ -797,7 +798,7 @@ export class CacheManager implements CacheManagerDef {
 
   private async _retrieveCachedParentNodeData(
     { entityData: ancestorEntityData, requestFieldPathData: ancestorRequestFieldPathData }: CachedAncestorFieldData,
-    { hashedRequestFieldCacheKey, propNameOrIndex }: KeysAndPaths,
+    { hashedRequestFieldCacheKey, propNameOrIndex, requestFieldCacheKey }: KeysAndPaths,
     fieldTypeInfo: FieldTypeInfo,
     options: RequestOptions,
     context: CacheManagerContext,
@@ -809,6 +810,7 @@ export class CacheManager implements CacheManagerDef {
     if (CacheManager._isNodeRequestFieldPath(fieldTypeInfo)) {
       const { cacheability: entryCacheability, entry } = await this._retrieveCachedRequestFieldPathData(
         hashedRequestFieldCacheKey,
+        requestFieldCacheKey,
         options,
         context,
       );
@@ -856,10 +858,12 @@ export class CacheManager implements CacheManagerDef {
 
   private async _retrieveCachedRequestFieldPathData(
     hash: string,
+    requestFieldCacheKey: string,
     options: RequestOptions,
     context: CacheManagerContext,
   ) {
-    return (this._checkCacheEntry(REQUEST_FIELD_PATHS, hash, options, context) || {}) as Partial<CheckCacheEntryResult>;
+    return (this._checkCacheEntry(REQUEST_FIELD_PATHS, hash, options, { ...context, requestFieldCacheKey }) ||
+      {}) as Partial<CheckCacheEntryResult>;
   }
 
   private async _retrieveCachedResponseData(
@@ -902,10 +906,10 @@ export class CacheManager implements CacheManagerDef {
     context: CacheManagerContext,
   ) {
     const responseChunks = this._responseChunksAwaitingCaching.get(
-      context.boxID,
+      context.requestID,
     ) as RawResponseDataWithMaybeCacheMetadata[];
 
-    this._responseChunksAwaitingCaching.delete(context.boxID);
+    this._responseChunksAwaitingCaching.delete(context.requestID);
     return mergeResponseDataSets([...responseChunks, normalizedResponseData]);
   }
 
@@ -916,7 +920,7 @@ export class CacheManager implements CacheManagerDef {
     value: any,
     cachemapOptions: CachemapOptions,
     _options: RequestOptions,
-    _context: CacheManagerContext,
+    _context: CacheManagerContext & { requestFieldCacheKey?: string },
   ): Promise<void> {
     try {
       await this._cache.set(`${cacheType}::${hash}`, cloneDeep(value), cachemapOptions);
@@ -1124,7 +1128,7 @@ export class CacheManager implements CacheManagerDef {
     options: RequestOptions,
     context: CacheManagerContext,
   ): Promise<void> {
-    const { hashedRequestFieldCacheKey, responseDataPath } = keysAndPaths;
+    const { hashedRequestFieldCacheKey, requestFieldCacheKey, responseDataPath } = keysAndPaths;
     let fieldData = get(data, responseDataPath);
     const isEntity = this._isFieldEntity(fieldData, fieldTypeInfo);
     const hasArgsOrDirectives = fieldTypeInfo.hasArguments || fieldTypeInfo.hasDirectives;
@@ -1134,7 +1138,10 @@ export class CacheManager implements CacheManagerDef {
         fieldData = filterOutPropsWithArgsOrDirectives(fieldData, field.selectionSet.selections, keysAndPaths, context);
       }
 
-      const result = await this._checkCacheEntry(REQUEST_FIELD_PATHS, hashedRequestFieldCacheKey, options, context);
+      const result = await this._checkCacheEntry(REQUEST_FIELD_PATHS, hashedRequestFieldCacheKey, options, {
+        ...context,
+        requestFieldCacheKey,
+      });
 
       if (result && isObjectLike(fieldData)) {
         fieldData = this._mergeObjects(result.entry, fieldData);
@@ -1146,7 +1153,7 @@ export class CacheManager implements CacheManagerDef {
         fieldData,
         { cacheHeaders: { cacheControl: cacheability.printCacheControl() }, tag: options.tag },
         options,
-        context,
+        { ...context, requestFieldCacheKey },
       );
 
       if (hasChildFields(field, { fragmentDefinitions: context.fragmentDefinitions })) {
@@ -1163,12 +1170,12 @@ export class CacheManager implements CacheManagerDef {
     normalizedResponseData: RawResponseDataWithMaybeCacheMetadata,
     context: CacheManagerContext,
   ) {
-    const responseChunks = this._responseChunksAwaitingCaching.get(context.boxID);
+    const responseChunks = this._responseChunksAwaitingCaching.get(context.requestID);
 
     if (responseChunks) {
-      this._responseChunksAwaitingCaching.set(context.boxID, [...responseChunks, normalizedResponseData]);
+      this._responseChunksAwaitingCaching.set(context.requestID, [...responseChunks, normalizedResponseData]);
     } else {
-      this._responseChunksAwaitingCaching.set(context.boxID, [normalizedResponseData]);
+      this._responseChunksAwaitingCaching.set(context.requestID, [normalizedResponseData]);
     }
   }
 }