feat: create new cache directive

Author: thuoe

server/index.ts

@@ -3,12 +3,13 @@ import { startStandaloneServer } from '@apollo/server/standalone';
 import { makeExecutableSchema } from '@graphql-tools/schema';
 import encodingDirective from '@src/directives/encode';
 import regexDirective from '@src/directives/regex';
+import cacheDirective from '@src/directives/cache';
 
 const typeDefs = String.raw`#graphql
   type User {
     firstName: String @regex(pattern: "(Eddie|Sam)")
     lastName: String @regex(pattern: "\\b[A-Z]\\w+\\b")
-    age: Int
+    age: Int @cache(key: "user_age", ttl: 3000)
   }
 
   type Query {
@@ -28,16 +29,19 @@ const resolvers = {
 
 const { encodingDirectiveTypeDefs, encodingDirectiveTransformer } = encodingDirective('encode')
 const { regexDirectiveTypeDefs, regexDirectiveTransformer } = regexDirective('regex')
+const { cacheDirectiveTypeDefs, cacheDirectiveTransformer } = cacheDirective('cache')
 
 const transformers = [
   encodingDirectiveTransformer,
   regexDirectiveTransformer,
+  cacheDirectiveTransformer,
 ]
 
 let schema = makeExecutableSchema(({
   typeDefs: [
     encodingDirectiveTypeDefs,
     regexDirectiveTypeDefs,
+    cacheDirectiveTypeDefs,
     typeDefs
   ],
   resolvers

src/directives/cache.ts

@@ -0,0 +1,52 @@
+import { MapperKind, getDirective, mapSchema } from '@graphql-tools/utils'
+import { GraphQLSchema, defaultFieldResolver } from 'graphql'
+
+interface CachingImpl {
+  has: (key: string) => boolean
+  get: (key: string) => string
+  set: (key: string, value: string) => void
+  delete: (key: string) => boolean
+}
+
+const cacheDirective = (directiveName: string, cache: CachingImpl = new Map<string, string>()) => {
+  return {
+    cacheDirectiveTypeDefs: `directive @${directiveName}(key: String, ttl: Int) on FIELD_DEFINITION`,
+    cacheDirectiveTransformer: (schema: GraphQLSchema) => mapSchema(schema, {
+      [MapperKind.OBJECT_FIELD]: fieldConfig => {
+        const { resolve = defaultFieldResolver } = fieldConfig
+        const cacheDirective = getDirective(schema, fieldConfig, directiveName)?.[0]
+        if (cacheDirective) {
+          const { ttl, key } = cacheDirective
+          return {
+            ...fieldConfig,
+            resolve: async (source, args, context, info) => {
+              const { returnType } = info
+              if (cache.has(key)) {
+                const value = cache.get(key)
+                if (returnType.toString() === 'string') {
+                  return value
+                }
+                if (returnType.toString() === 'boolean') {
+                  const boolValue = (/true/).test(value);
+                  return boolValue
+                }
+                if (returnType.toString() === 'Int') {
+                  return Number(value)
+                }
+              }
+              const result = await resolve(source, args, context, info)
+              cache.set(key, JSON.stringify(result))
+              setTimeout(() => {
+                cache.delete(key)
+              }, ttl)
+              return result
+            }
+          }
+        }
+      }
+    }
+    )
+  }
+}
+
+export default cacheDirective

src/directives/index.ts

@@ -1,7 +1,9 @@
+import cacheDirective from '@src/directives/cache'
 import encodingDirective from '@src/directives/encode'
 import regexDirective from '@src/directives/regex'
 
 const directives = Object.freeze({
+  cacheDirective,
   encodingDirective,
   regexDirective,
 })

test/cache.test.ts

@@ -0,0 +1,116 @@
+import { ApolloServer } from '@apollo/server';
+import cacheDirective from '@src/directives/cache';
+import { buildSchema } from './util';
+import assert from 'assert';
+
+jest.useFakeTimers();
+jest.spyOn(global, 'setTimeout');
+
+const cache = new Map<string, string>()
+
+const cacheCallback = {
+  has: jest.fn(key => cache.has(key)),
+  get: jest.fn(key => cache.get(key)),
+  delete: jest.fn(key => cache.delete(key)),
+  set: jest.fn((key: string, value: string) => {
+    cache.set(key, value)
+  }),
+}
+
+const { cacheDirectiveTypeDefs, cacheDirectiveTransformer } = cacheDirective('cache', cacheCallback)
+
+describe('@cache directive', () => {
+  let testServer: ApolloServer;
+
+  const resolvers = {
+    Query: {
+      user: () => ({
+        age: 28
+      })
+    },
+  };
+
+  const testQuery = `
+  query ExampleQuery {
+    user {
+      age
+    }
+  }
+  `
+
+  afterEach(async () => {
+    if (testServer) {
+      await testServer.stop()
+    }
+  })
+
+  it('will cache a field value before returning a response with correct ttl', async () => {
+    const ttl = 8000
+    const schema = buildSchema({
+      typeDefs: [
+        `type User {
+          age: Int @cache(key: "user_age", ttl: ${ttl})
+        }
+    
+        type Query {
+          user: User
+        }
+        `,
+        cacheDirectiveTypeDefs,
+      ],
+      resolvers,
+      transformers: [cacheDirectiveTransformer],
+    })
+
+    testServer = new ApolloServer({ schema })
+
+    const response = await testServer.executeOperation<{ user: { age: number } }>({
+      query: testQuery
+    })
+
+    assert(response.body.kind === 'single');
+    expect(response.body.singleResult.errors).toBeUndefined();
+    expect(response.body.singleResult.data.user.age).toEqual(28);
+    expect(setTimeout).toHaveBeenCalledTimes(1);
+    expect(setTimeout).toHaveBeenLastCalledWith(expect.any(Function), ttl);
+    expect(cacheCallback.set).toHaveBeenCalled()
+  })
+
+  it('will delete a cache field value if the ttl has long expired', async () => {
+    const ttl = 3000
+    const key = 'user_age'
+    const schema = buildSchema({
+      typeDefs: [
+        `type User {
+          age: Int @cache(key: "${key}", ttl: ${ttl})
+        }
+    
+        type Query {
+          user: User
+        }
+        `,
+        cacheDirectiveTypeDefs,
+      ],
+      resolvers,
+      transformers: [cacheDirectiveTransformer],
+    })
+
+    testServer = new ApolloServer({ schema })
+
+    const response = await testServer.executeOperation<{ user: { age: number } }>({
+      query: testQuery
+    })
+
+    assert(response.body.kind === 'single');
+    expect(response.body.singleResult.errors).toBeUndefined();
+    expect(response.body.singleResult.data.user.age).toEqual(28);
+
+    expect(cacheCallback.set).toHaveBeenCalled()
+    expect(cacheCallback.set).toHaveBeenCalledWith(key, JSON.stringify(response.body.singleResult.data.user.age))
+
+    jest.advanceTimersByTime(ttl + 5000)
+
+    expect(cacheCallback.delete).toHaveBeenCalled()
+    expect(cacheCallback.delete).toHaveBeenCalledWith(key)
+  })
+})