Add support for cache tag invalidation

.vscode/settings.json

@@ -5,6 +5,7 @@
   "files.trimTrailingWhitespace": true,
   "files.insertFinalNewline": true,
   "editor.wordWrapColumn": 110,
+  "editor.formatOnSave": true,
   "prettier.singleQuote": true,
   "prettier.printWidth": 110,
   "files.exclude": {

packages/apollo-server-caching/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "apollo-server-caching",
+  "version": "2.0.0-beta.7",
+  "author": "opensource@apollographql.com",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/apollographql/apollo-server/tree/master/packages/apollo-server-caching"
+  },
+  "homepage": "https://github.com/apollographql/apollo-server#readme",
+  "bugs": {
+    "url": "https://github.com/apollographql/apollo-server/issues"
+  },
+  "scripts": {
+    "clean": "rm -rf lib",
+    "compile": "tsc",
+    "prepare": "npm run clean && npm run compile",
+    "test": "jest --verbose"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "engines": {
+    "node": ">=8"
+  },
+  "dependencies": {
+    "http-cache-semantics": "^4.0.0",
+    "memcached": "^2.2.2",
+    "redis": "^2.8.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^23.0.0",
+    "@types/memcached": "^2.2.5",
+    "@types/redis": "^2.8.6",
+    "jest": "^23.1.0",
+    "jest-each": "^23.1.0",
+    "ts-jest": "^22.4.6"
+  },
+  "jest": {
+    "testEnvironment": "node",
+    "transform": {
+      "^.+\\.(ts|js)$": "ts-jest"
+    },
+    "moduleFileExtensions": [
+      "ts",
+      "js",
+      "json"
+    ],
+    "testRegex": "/__tests__/.*$",
+    "setupFiles": [
+      "<rootDir>/src/polyfills/fetch.ts",
+      "<rootDir>/src/polyfills/url.ts"
+    ],
+    "globals": {
+      "ts-jest": {
+        "skipBabel": true
+      }
+    }
+  }
+}

packages/apollo-server-caching/src/__mocks__/common.ts

@@ -0,0 +1,6 @@
+export const servers = {
+  memcachedHost: process.env.MEMCACHED_HOST || 'localhost:11211',
+  redisHost: process.env.REDIS_HOST || 'localhost',
+};
+
+export const delay = ms => new Promise(res => setTimeout(res, ms));

packages/apollo-server-caching/src/__mocks__/date.ts

@@ -0,0 +1,32 @@
+const RealDate = global.Date;
+
+export function mockDate() {
+  global.Date = new Proxy(RealDate, handler);
+}
+
+export function unmockDate() {
+  global.Date = RealDate;
+}
+
+let now = Date.now();
+
+export function advanceTimeBy(ms: number) {
+  now += ms;
+}
+
+const handler = {
+  construct(target, args) {
+    if (args.length === 0) {
+      return new Date(now);
+    } else {
+      return new target(...args);
+    }
+  },
+  get(target, propKey, receiver) {
+    if (propKey === 'now') {
+      return () => now;
+    } else {
+      return target[propKey];
+    }
+  },
+};

packages/apollo-server-caching/src/__mocks__/fetch.ts

@@ -0,0 +1,51 @@
+declare global {
+  namespace NodeJS {
+    interface Global {
+      fetch: typeof fetch;
+    }
+  }
+}
+
+type Headers = { [name: string]: string };
+
+interface FetchMock extends jest.Mock<typeof fetch> {
+  mockResponseOnce(data?: any, headers?: Headers, status?: number);
+  mockJSONResponseOnce(data?: object, headers?: Headers);
+}
+
+const fetchMock = jest.fn<typeof fetch>() as FetchMock;
+
+fetchMock.mockResponseOnce = (
+  data?: BodyInit,
+  headers?: Headers,
+  status: number = 200,
+) => {
+  return fetchMock.mockImplementationOnce(async () => {
+    return new Response(data, {
+      status,
+      headers,
+    });
+  });
+};
+
+fetchMock.mockJSONResponseOnce = (
+  data = {},
+  headers?: Headers,
+  status?: number,
+) => {
+  return fetchMock.mockResponseOnce(
+    JSON.stringify(data),
+    Object.assign({ 'Content-Type': 'application/json' }, headers),
+    status,
+  );
+};
+
+export default fetchMock;
+
+export function mockFetch() {
+  global.fetch = fetchMock;
+}
+
+export function unmockFetch() {
+  global.fetch = fetch;
+}

packages/apollo-server-caching/src/__tests__/connectors.test.ts

@@ -0,0 +1,32 @@
+import { servers, delay } from '../__mocks__/common';
+import MemcachedKeyValueCache from '../connectors/memcached';
+import RedisKeyValueCache from '../connectors/redis';
+import each from 'jest-each';
+
+// run test suite against each implementation of KeyValueCache
+each([
+  [new MemcachedKeyValueCache(servers.memcachedHost)],
+  [new RedisKeyValueCache({ host: servers.redisHost })],
+]).describe('%s', keyValueCache => {
+  beforeEach(() => {
+    keyValueCache.flush();
+  });
+
+  afterAll(() => {
+    keyValueCache.close();
+  });
+
+  it('can do a basic get and set', async () => {
+    await keyValueCache.set('hello', 'world');
+    expect(await keyValueCache.get('hello')).toBe('world');
+    expect(await keyValueCache.get('missing')).not.toBeDefined();
+  });
+
+  it('is able to expire keys based on ttl', async () => {
+    await keyValueCache.set('short', 's', { ttl: 1 });
+    await keyValueCache.set('long', 'l', { ttl: 5 });
+    await delay(1500);
+    expect(await keyValueCache.get('short')).not.toBeDefined();
+    expect(await keyValueCache.get('long')).toBe('l');
+  });
+});