@graphql-box/connection-resolver 5.4.2 → 5.4.4

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@graphql-box/connection-resolver",
   "description": "The GraphQL Box connection resolver module.",
-  "version": "5.4.2",
+  "version": "5.4.4",
   "author": "Dylan Aubrey",
   "license": "MIT",
   "homepage": "https://github.com/badbatch/graphql-box",
@@ -41,14 +41,16 @@
     "@graphql-box/core": "5.4.2"
   },
   "peerDependencies": {
-    "graphql": "<17"
+    "graphql": "<17",
+    "winston": "<4"
   },
   "devDependencies": {
     "@cachemap/map": "^5.0.8",
     "@jest/globals": "^29.3.1",
     "cts-types": "^0.0.8",
     "del-cli": "^6.0.0",
-    "graphql": "^16.9.0"
+    "graphql": "^16.9.0",
+    "winston": "^3.17.0"
   },
   "keywords": [
     "client",

package/src/helpers/requestAndCachePages.ts

@@ -1,20 +1,30 @@
 import { type Core } from '@cachemap/core';
 import { type PlainObject } from '@graphql-box/core';
-import { type Getters, type Node, type ResourceResolver } from '../types.ts';
+import { type Getters, type Node, type ResourceResolver, type SetCacheMetadata } from '../types.ts';
 import { cacheCursors } from './cacheCursors.ts';
 import { makeEdges } from './makeEdges.ts';
 
 export type Context<Resource extends PlainObject, ResourceNode extends Node> = {
   cursorCache: Core;
+  fieldPath: string;
   getters: Getters<Resource, ResourceNode>;
   groupCursor: string;
   makeIDCursor: (id: string | number) => string;
   resourceResolver: ResourceResolver<Resource>;
+  setCacheMetadata: SetCacheMetadata | undefined;
 };
 
 export const requestAndCachePages = async <Resource extends PlainObject, ResourceNode extends Node>(
   pages: number[],
-  { cursorCache, getters, groupCursor, makeIDCursor, resourceResolver }: Context<Resource, ResourceNode>,
+  {
+    cursorCache,
+    fieldPath,
+    getters,
+    groupCursor,
+    makeIDCursor,
+    resourceResolver,
+    setCacheMetadata,
+  }: Context<Resource, ResourceNode>,
 ) => {
   const errors: Error[] = [];
 
@@ -28,6 +38,10 @@ export const requestAndCachePages = async <Resource extends PlainObject, Resourc
         page,
       });
 
+      if (pageResultData) {
+        setCacheMetadata?.(fieldPath, pageResultHeaders);
+      }
+
       if (pageResultData && !pageResultErrors?.length) {
         const edges = makeEdges(getters.nodes(pageResultData), node => makeIDCursor(node.id));
 

package/src/helpers/resolveConnection.ts

@@ -1,6 +1,13 @@
 import { type Core } from '@cachemap/core';
 import { type PlainObject } from '@graphql-box/core';
-import { type ConnectionInputOptions, type Getters, type Node, type ResourceResolver } from '../types.ts';
+import { type Logger } from 'winston';
+import {
+  type ConnectionInputOptions,
+  type Getters,
+  type Node,
+  type ResourceResolver,
+  type SetCacheMetadata,
+} from '../types.ts';
 import { extractEdges } from './extractEdges.ts';
 import { extractNodes } from './extractNodes.ts';
 import { getInRangeCachedEdges } from './getInRangeCachedEdges.ts';
@@ -11,22 +18,28 @@ import { retrieveCachedConnection } from './retrieveCachedConnection.ts';
 
 export type Context<Resource extends PlainObject, ResourceNode extends Node> = {
   cursorCache: Core;
+  fieldPath: string;
   getters: Getters<Resource, ResourceNode>;
   groupCursor: string;
+  logger: Logger | undefined;
   makeIDCursor: (id: string | number) => string;
   resourceResolver: ResourceResolver<Resource>;
   resultsPerPage: number;
+  setCacheMetadata: SetCacheMetadata | undefined;
 };
 
 export const resolveConnection = async <Resource extends PlainObject, ResourceNode extends Node>(
   args: PlainObject & ConnectionInputOptions,
   {
     cursorCache,
+    fieldPath,
     getters,
     groupCursor,
+    logger,
     makeIDCursor,
     resourceResolver,
     resultsPerPage,
+    setCacheMetadata,
   }: Context<Resource, ResourceNode>,
 ) => {
   const { cachedEdges, hasNextPage, hasPreviousPage, indexes, missingPages, totalResults } =
@@ -38,6 +51,7 @@ export const resolveConnection = async <Resource extends PlainObject, ResourceNo
 
   if (missingPages.length === 0) {
     const edges = extractEdges(cachedEdges);
+    logger?.info(`Successfully resolved ${fieldPath} from cache`);
 
     return {
       edges,
@@ -55,10 +69,12 @@ export const resolveConnection = async <Resource extends PlainObject, ResourceNo
 
   const { cachedEdges: missingCachedEdges, errors } = await requestAndCachePages<Resource, ResourceNode>(missingPages, {
     cursorCache,
+    fieldPath,
     getters,
     groupCursor,
     makeIDCursor,
     resourceResolver,
+    setCacheMetadata,
   });
 
   const mergedCachedEdges = getInRangeCachedEdges(mergeCachedEdges(cachedEdges, missingCachedEdges), {
@@ -68,6 +84,7 @@ export const resolveConnection = async <Resource extends PlainObject, ResourceNo
   });
 
   const edges = extractEdges(mergedCachedEdges);
+  logger?.info(`Successfully resolved ${fieldPath} from api`);
 
   return {
     edges,

package/src/main/index.ts

@@ -8,6 +8,7 @@ import {
   type Connection,
   type ConnectionInputOptions,
   type ConnectionResolverUserOptions,
+  type Context,
   type Node,
 } from '../types.ts';
 
@@ -15,7 +16,7 @@ export const makeConnectionResolver =
   <
     Source extends PlainObject | undefined,
     Args extends PlainObject,
-    Ctx extends PlainObject,
+    Ctx extends Context,
     Resource extends PlainObject,
     ResourceNode extends Node,
   >({
@@ -35,6 +36,19 @@ export const makeConnectionResolver =
     const { makeGroupCursor, makeIDCursor } = createMakeCursors(source, args, context, info);
     const resourceResolver = createResourceResolver(source, args, context, info);
     const groupCursor = makeGroupCursor();
+    const { logger, operationName, requestID, setCacheMetadata, tmdbGuestSessionId } = context;
+    const { fieldName: fieldPath } = info;
+
+    const childLogger = logger?.child({
+      args,
+      fieldPath,
+      groupCursor,
+      operationName,
+      requestID,
+      tmdbGuestSessionId,
+    });
+
+    childLogger?.info(`Resolving ${fieldPath}`);
 
     if (isCursorSupplied(args)) {
       const cursorError = await validateCursor(args, info, {
@@ -44,6 +58,10 @@ export const makeConnectionResolver =
       });
 
       if (cursorError) {
+        childLogger?.error(`Failed to resolve ${fieldPath}, validation cursor error`, {
+          errors: [cursorError],
+        });
+
         return resolver({
           edges: [],
           errors: [cursorError],
@@ -59,11 +77,14 @@ export const makeConnectionResolver =
       return resolver(
         await resolveConnection(args, {
           cursorCache,
+          fieldPath,
           getters,
           groupCursor,
+          logger: childLogger,
           makeIDCursor,
           resourceResolver,
           resultsPerPage,
+          setCacheMetadata,
         }),
       );
     }
@@ -72,31 +93,39 @@ export const makeConnectionResolver =
       return resolver(
         await resolveConnection(args, {
           cursorCache,
+          fieldPath,
           getters,
           groupCursor,
+          logger: childLogger,
           makeIDCursor,
           resourceResolver,
           resultsPerPage,
+          setCacheMetadata,
         }),
       );
     }
 
     await requestAndCachePages<Resource, ResourceNode>([1], {
       cursorCache,
+      fieldPath,
       getters,
       groupCursor,
       makeIDCursor,
       resourceResolver,
+      setCacheMetadata,
     });
 
     return resolver(
       await resolveConnection(args, {
         cursorCache,
+        fieldPath,
         getters,
         groupCursor,
+        logger: childLogger,
         makeIDCursor,
         resourceResolver,
         resultsPerPage,
+        setCacheMetadata,
       }),
     );
   };

package/src/types.ts

@@ -1,7 +1,8 @@
 import { type Core } from '@cachemap/core';
 import { type PlainObject } from '@graphql-box/core';
-import { type GraphQLResolveInfo } from 'graphql';
+import { type GraphQLResolveInfo, type OperationTypeNode } from 'graphql';
 import { type SetOptional } from 'type-fest';
+import { type Logger } from 'winston';
 
 export type Direction = 'backward' | 'forward';
 
@@ -60,10 +61,17 @@ export type ResourceResolver<Resource extends PlainObject> = (args: {
   page: number;
 }) => Promise<ResourceResponse<Resource>>;
 
+export type SetCacheMetadata = (key: string, headers: Headers, operation?: OperationTypeNode) => void;
+
+export type Context = PlainObject & {
+  logger?: Logger;
+  setCacheMetadata?: SetCacheMetadata;
+};
+
 export type CreateResourceResolver<
   Source extends PlainObject | undefined,
   Args extends PlainObject,
-  Ctx extends PlainObject,
+  Ctx extends Context,
   Resource extends PlainObject,
 > = (source: Source, args: Args, context: Ctx, info: GraphQLResolveInfo) => ResourceResolver<Resource>;
 
@@ -77,7 +85,7 @@ export interface Getters<Resource extends PlainObject, ResourceNode extends Node
 export interface ConnectionResolverUserOptions<
   Source extends PlainObject | undefined,
   Args extends PlainObject,
-  Ctx extends PlainObject,
+  Ctx extends Context,
   Resource extends PlainObject,
   ResourceNode extends Node,
 > {
@@ -100,7 +108,7 @@ export interface ConnectionResolverUserOptions<
 export type ConnectionResolver = (
   source: PlainObject,
   args: PlainObject & ConnectionInputOptions,
-  context: PlainObject,
+  context: Context,
   info: GraphQLResolveInfo,
 ) => Promise<Connection>;