Merge branch 'bitops-master'

Author: lorensr

README.md

@@ -71,7 +71,7 @@ const server = new ApolloServer({
 })
 ```
 
-Inside the data source, the collection is available at `this.collection` (e.g. `this.collection.update({_id: 'foo, { $set: { name: 'me' }}})`). The model (if applicable) is available at `this.model` (`new this.model({ name: 'Alice' })`). The request's context is available at `this.context`. For example, if you put the logged-in user's ID on context as `context.currentUserId`:
+Inside the data source, the collection is available at `this.collection` (e.g. `this.collection.update({_id: 'foo, { $set: { name: 'me' }}})`). The model (if you're using Mongoose) is available at `this.model` (`new this.model({ name: 'Alice' })`). The request's context is available at `this.context`. For example, if you put the logged-in user's ID on context as `context.currentUserId`:
 
 ```js
 class Users extends MongoDataSource {
@@ -98,7 +98,7 @@ class Users extends MongoDataSource {
 }
 ```
 
-If you're passing a Mongoose model rather than a collection, Mongoose will be used for data fetching. All transformations definded on that model (virtuals, plugins, etc.) will be applied to your data before caching, just like you would expect it. If you're using reference fields, you might be interested in checking out [mongoose-autopopulate](https://www.npmjs.com/package/mongoose-autopopulate).
+If you're passing a Mongoose model rather than a collection, Mongoose will be used for data fetching. All transformations defined on that model (virtuals, plugins, etc.) will be applied to your data before caching, just like you would expect it. If you're using reference fields, you might be interested in checking out [mongoose-autopopulate](https://www.npmjs.com/package/mongoose-autopopulate).
 
 ### Batching
 
@@ -287,3 +287,9 @@ this.findByFields({
 `this.deleteFromCacheById(id)`
 
 Deletes a document from the cache that was fetched with `findOneById` or `findManyByIds`.
+
+### deleteFromCacheByFields
+
+`this.deleteFromCacheByFields(fields)`
+
+Deletes a document from the cache that was fetched with `findByFields`. Fields should be passed in exactly the same way they were used to find with.

index.d.ts

@@ -57,5 +57,6 @@ declare module 'apollo-datasource-mongodb' {
     ): Promise<(TData | null | undefined)[]>
 
     deleteFromCacheById(id: ObjectId | string): Promise<void>
+    deleteFromCacheByFields(fields: Fields): Promise<void>
   }
 }

src/__tests__/cache.test.js

@@ -6,9 +6,12 @@ import { EJSON } from 'bson'
 import {
   createCachingMethods,
   idToString,
-  isValidObjectIdString
+  isValidObjectIdString,
+  prepFields
 } from '../cache'
 
+import { log } from '../helpers'
+
 const hexId = '5cf82e14a220a607eb64a7d4'
 
 const docs = {
@@ -31,17 +34,9 @@ const stringDoc = {
 const collectionName = 'test'
 const cacheKeyById = id => `mongo-${collectionName}-${idToString(id)}`
 const cacheKeyByFields = fields => {
-  const cleanedFields = {}
-
-  Object.keys(fields).forEach(key => {
-    if (typeof key !== 'undefined') {
-      cleanedFields[key] = Array.isArray(fields[key])
-        ? fields[key]
-        : [fields[key]]
-    }
-  })
+  const { loaderKey } = prepFields(fields)
 
-  return `mongo-${collectionName}-${JSON.stringify(cleanedFields)}`
+  return `mongo-${collectionName}-${loaderKey}`
 }
 
 describe('createCachingMethods', () => {
@@ -111,8 +106,10 @@ describe('createCachingMethods', () => {
   it('adds the right methods', () => {
     expect(api.findOneById).toBeDefined()
     expect(api.findManyByIds).toBeDefined()
-    expect(api.findByFields).toBeDefined()
     expect(api.deleteFromCacheById).toBeDefined()
+
+    expect(api.findByFields).toBeDefined()
+    expect(api.deleteFromCacheByFields).toBeDefined()
   })
 
   it('finds one with ObjectId', async () => {
@@ -171,7 +168,7 @@ describe('createCachingMethods', () => {
     expect(collection.find.mock.calls.length).toBe(1)
   })
 
-  it('finds by mutiple fields', async () => {
+  it('finds by multiple fields', async () => {
     const foundDocs = await api.findByFields({
       tags: ['foo', 'bar'],
       foo: 'bar'
@@ -222,7 +219,7 @@ describe('createCachingMethods', () => {
     expect(value).toBeUndefined()
   })
 
-  it(`caches`, async () => {
+  it(`caches by ID`, async () => {
     await api.findOneById(docs.one._id, { ttl: 1 })
     const value = await cache.get(cacheKeyById(docs.one._id))
     expect(value).toEqual(EJSON.stringify(docs.one))
@@ -241,15 +238,15 @@ describe('createCachingMethods', () => {
     expect(collection.find.mock.calls.length).toBe(1)
   })
 
-  it(`caches with ttl`, async () => {
+  it(`caches ID with ttl`, async () => {
     await api.findOneById(docs.one._id, { ttl: 1 })
     await wait(1001)
 
     const value = await cache.get(cacheKeyById(docs.one._id))
     expect(value).toBeUndefined()
   })
 
-  it(`deletes from cache`, async () => {
+  it(`deletes from cache by ID`, async () => {
     for (const doc of [docs.one, docs.two, stringDoc]) {
       await api.findOneById(doc._id, { ttl: 1 })
 
@@ -263,7 +260,7 @@ describe('createCachingMethods', () => {
     }
   })
 
-  it('deletes from DataLoader cache', async () => {
+  it('deletes from DataLoader cache by ID', async () => {
     for (const id of [docs.one._id, docs.two._id, stringDoc._id]) {
       await api.findOneById(id)
       expect(collection.find).toHaveBeenCalled()
@@ -277,6 +274,19 @@ describe('createCachingMethods', () => {
       expect(collection.find).toHaveBeenCalled()
     }
   })
+
+  it(`deletes from cache by fields`, async () => {
+    const fields = { foo: 'bar' }
+    await api.findByFields(fields, { ttl: 1 })
+
+    const valueBefore = await cache.get(cacheKeyByFields(fields))
+    expect(valueBefore).toEqual(EJSON.stringify([docs.one, docs.two]))
+
+    await api.deleteFromCacheByFields(fields)
+
+    const valueAfter = await cache.get(cacheKeyByFields(fields))
+    expect(valueAfter).toBeUndefined()
+  })
 })
 
 describe('isValidObjectIdString', () => {

src/__tests__/datasource.test.js

@@ -18,6 +18,9 @@ describe('MongoDataSource', () => {
     const source = new Users(users)
     source.initialize()
     expect(source.findOneById).toBeDefined()
+    expect(source.findByFields).toBeDefined()
+    expect(source.deleteFromCacheById).toBeDefined()
+    expect(source.deleteFromCacheByFields).toBeDefined()
     expect(source.collection).toEqual(users)
   })
 })

src/cache.js

@@ -2,9 +2,15 @@ import DataLoader from 'dataloader'
 import { ObjectId } from 'mongodb'
 import { EJSON } from 'bson'
 
-import { getCollection } from './helpers'
+import { getCollection, log } from './helpers'
 
-export const idToString = id => (id instanceof ObjectId ? id.toHexString() : id)
+export const idToString = id => {
+  if (id instanceof ObjectId) {
+    return id.toHexString()
+  } else {
+    return id && id.toString ? id.toString() : id
+  }
+}
 
 // https://www.geeksforgeeks.org/how-to-check-if-a-string-is-valid-mongodb-objectid-in-nodejs/
 export const isValidObjectIdString = string =>
@@ -22,7 +28,21 @@ export const stringToId = string => {
   return string
 }
 
-const fieldToDocField = key => (key === 'id' ? '_id' : key)
+export function prepFields(fields) {
+  const cleanedFields = {}
+
+  Object.keys(fields)
+    .sort()
+    .forEach(key => {
+      if (typeof key !== 'undefined') {
+        cleanedFields[key] = Array.isArray(fields[key])
+          ? fields[key]
+          : [fields[key]]
+      }
+    })
+
+  return { loaderKey: EJSON.stringify(cleanedFields), cleanedFields }
+}
 
 // https://github.com/graphql/dataloader#batch-function
 // "The Array of values must be the same length as the Array of keys."
@@ -32,82 +52,97 @@ const orderDocs = fieldsArray => docs =>
     docs.filter(doc => {
       for (let fieldName of Object.keys(fields)) {
         const fieldValue = fields[fieldName]
+
         if (typeof fieldValue === 'undefined') continue
+
         const filterValuesArr = Array.isArray(fieldValue)
           ? fieldValue.map(val => idToString(val))
           : [idToString(fieldValue)]
-        const docValue = doc[fieldToDocField(fieldName)]
+
+        const docValue = doc[fieldName]
         const docValuesArr = Array.isArray(docValue)
           ? docValue.map(val => idToString(val))
           : [idToString(docValue)]
+
         let isMatch = false
         for (const filterVal of filterValuesArr) {
           if (docValuesArr.includes(filterVal)) {
             isMatch = true
           }
         }
+
         if (!isMatch) return false
       }
       return true
     })
   )
 
 export const createCachingMethods = ({ collection, model, cache }) => {
-  const loader = new DataLoader(jsonArray => {
-    const fieldsArray = jsonArray.map(JSON.parse)
+  const loader = new DataLoader(async ejsonArray => {
+    const fieldsArray = ejsonArray.map(EJSON.parse)
+    log('fieldsArray', fieldsArray)
+
     const filterArray = fieldsArray.reduce((filterArray, fields) => {
       const existingFieldsFilter = filterArray.find(
         filter =>
           [...Object.keys(filter)].sort().join() ===
           [...Object.keys(fields)].sort().join()
       )
       const filter = existingFieldsFilter || {}
+
       for (const fieldName in fields) {
         if (typeof fields[fieldName] === 'undefined') continue
-        const docFieldName = fieldToDocField(fieldName)
-        if (!filter[docFieldName]) filter[docFieldName] = { $in: [] }
+        if (!filter[fieldName]) filter[fieldName] = { $in: [] }
         let newVals = Array.isArray(fields[fieldName])
           ? fields[fieldName]
           : [fields[fieldName]]
 
-        filter[docFieldName].$in = [
-          ...filter[docFieldName].$in,
+        filter[fieldName].$in = [
+          ...filter[fieldName].$in,
           ...newVals
             .map(stringToId)
-            .filter(val => !filter[docFieldName].$in.includes(val))
+            .filter(val => !filter[fieldName].$in.includes(val))
         ]
       }
       if (existingFieldsFilter) return filterArray
       return [...filterArray, filter]
     }, [])
+
     const filter =
       filterArray.length === 1
         ? filterArray[0]
         : {
             $or: filterArray
           }
-    const promise = model
+
+    const findPromise = model
       ? model.find(filter).exec()
       : collection.find(filter).toArray()
 
-    return promise.then(orderDocs(fieldsArray))
+    const results = await findPromise
+    const orderedDocs = orderDocs(fieldsArray)(results)
+    log('orderedDocs: ', orderedDocs)
+    return orderedDocs
   })
 
   const cachePrefix = `mongo-${getCollection(collection).collectionName}-`
 
   const methods = {
-    findOneById: async (id, { ttl } = {}) => {
-      const key = cachePrefix + idToString(id)
+    findOneById: async (_id, { ttl } = {}) => {
+      const cacheKey = cachePrefix + idToString(_id)
 
-      const cacheDoc = await cache.get(key)
+      const cacheDoc = await cache.get(cacheKey)
+      log('findOneById found in cache:', cacheDoc)
       if (cacheDoc) {
         return EJSON.parse(cacheDoc)
       }
 
-      const docs = await loader.load(JSON.stringify({ id }))
+      log(`Dataloader.load: ${EJSON.stringify({ _id })}`)
+      const docs = await loader.load(EJSON.stringify({ _id }))
+      log('Dataloader.load returned: ', docs)
       if (Number.isInteger(ttl)) {
         // https://github.com/apollographql/apollo-server/tree/master/packages/apollo-server-caching#apollo-server-caching
-        cache.set(key, EJSON.stringify(docs[0]), { ttl })
+        cache.set(cacheKey, EJSON.stringify(docs[0]), { ttl })
       }
 
       return docs[0]
@@ -116,23 +151,10 @@ export const createCachingMethods = ({ collection, model, cache }) => {
       return Promise.all(ids.map(id => methods.findOneById(id, { ttl })))
     },
     findByFields: async (fields, { ttl } = {}) => {
-      const cleanedFields = {}
-
-      Object.keys(fields)
-        .sort()
-        .forEach(key => {
-          if (typeof key !== 'undefined') {
-            cleanedFields[key] = Array.isArray(fields[key])
-              ? fields[key]
-              : [fields[key]]
-          }
-        })
-
-      const loaderJSON = JSON.stringify(cleanedFields)
-
-      const key = cachePrefix + loaderJSON
+      const { cleanedFields, loaderKey } = prepFields(fields)
+      const cacheKey = cachePrefix + loaderKey
 
-      const cacheDoc = await cache.get(key)
+      const cacheDoc = await cache.get(cacheKey)
       if (cacheDoc) {
         return EJSON.parse(cacheDoc)
       }
@@ -147,24 +169,33 @@ export const createCachingMethods = ({ collection, model, cache }) => {
           fieldArray.map(value => {
             const filter = {}
             filter[fieldNames[0]] = value
-            return loader.load(JSON.stringify(filter))
+            return loader.load(EJSON.stringify(filter))
           })
         )
         docs = [].concat(...docsArray)
       } else {
-        docs = await loader.load(loaderJSON)
+        docs = await loader.load(loaderKey)
       }
 
       if (Number.isInteger(ttl)) {
         // https://github.com/apollographql/apollo-server/tree/master/packages/apollo-server-caching#apollo-server-caching
-        cache.set(key, EJSON.stringify(docs), { ttl })
+        cache.set(cacheKey, EJSON.stringify(docs), { ttl })
       }
 
       return docs
     },
-    deleteFromCacheById: async id => {
-      loader.clear(JSON.stringify({ id }))
-      await cache.delete(cachePrefix + idToString(id))
+    deleteFromCacheById: async _id => {
+      loader.clear(EJSON.stringify({ _id }))
+      const cacheKey = cachePrefix + idToString(_id)
+      log('Deleting cache key: ', cacheKey)
+      await cache.delete(cacheKey)
+    },
+    deleteFromCacheByFields: async fields => {
+      const { loaderKey } = prepFields(fields)
+      const cacheKey = cachePrefix + loaderKey
+
+      loader.clear(loaderKey)
+      await cache.delete(cacheKey)
     }
   }
 

src/helpers.js

@@ -14,3 +14,7 @@ export const isCollectionOrModel = x =>
   Boolean(x && (typeof x === TYPEOF_COLLECTION || isModel(x)))
 
 export const getCollection = x => (isModel(x) ? x.collection : x)
+
+const DEBUG = false
+
+export const log = (...args) => DEBUG && console.log(...args)