auto-batching functionality

src/autoBatchNode.js

@@ -0,0 +1,86 @@
+
+const Endpoint = require('./endpoint')
+const _ = require('lodash')
+
+// This helper function returns all method names including those inherited from extending classes
+function getClassMethodNames(klass) {
+  const isFunction = (x, name) => typeof x[name] === 'function';
+  const deepFunctions = x =>
+      x !== Object.prototype &&
+      Object.getOwnPropertyNames(x)
+          .filter(name =>  isFunction(x, name))
+          .concat(deepFunctions(Object.getPrototypeOf(x)) || []);
+  const distinctDeepFunctions = klass => Array.from(new Set(deepFunctions(klass)));
+  return distinctDeepFunctions(klass).filter(name => name !== 'constructor' && !name.startsWith('__'))
+}
+
+module.exports = class AutoBatchNode {
+  constructor(parent, client) {
+    this.parent = parent
+    this.client = client
+    this.children = {}
+
+    getClassMethodNames(parent).forEach((key) => {
+      this[key] = (...args) => {
+        // Enforce settings from the Client
+        this._syncSettingsFromClient()
+
+        // Return endpoint node from the child pool, if available
+        const child = this._getChildNode(key, args)
+        if (child) {
+          return child
+        }
+
+        // Call the parent's method
+        const result = parent[key](...args)
+
+        // If the method returns parent, return this
+        if (result === this.parent) {
+          return this
+        } 
+        // If method returns a new Endpoint, add it to the child pool and return it
+        else if (result instanceof Endpoint) {
+          return this._newChildNode(key, args, result)
+        }
+        // Otherwise, return the result of the method
+        else {
+          return result
+        }
+      }
+    })
+  }
+
+  _syncSettingsFromClient() {
+    // If this is the client, don't need to change settings
+    if (this.parent === this.client) {
+      return 
+    }
+    // Copy the settings from client to this endpoint
+    this.parent
+      .schema(this.client.schemaVersion)
+      .language(this.client.lang)
+      .authenticate(this.client.apiKey)
+      .debugging(this.client.debug)
+    // Autobatching endpoints should always use cache
+    this.parent._skipCache = false
+
+    return this
+  }
+
+  _newChildNode(endpointName, args, endpoint) {
+    endpoint.enableAutoBatch()
+
+    const childNode = new AutoBatchNode(endpoint, this.client)
+    const nameList = [endpointName, ...args]
+    const childName = nameList.join('_')
+    this.children[childName] = childNode
+    return childNode
+  }
+
+  _getChildNode(endpointName, args) {
+    const nameList = [endpointName, ...args]
+    const childName = nameList.join('_')
+    return this.children[childName]   
+  }
+
+}

src/client.js

@@ -2,6 +2,7 @@ const fetch = require('lets-fetch')
 const nullCache = require('./cache/null')
 const endpoints = require('./endpoints')
 const flow = require('./flow')
+const AutoBatchNode = require('./autoBatchNode')
 
 module.exports = class Client {
   constructor () {
@@ -12,6 +13,7 @@ module.exports = class Client {
     this.caches = [nullCache()]
     this.debug = false
     this.client = this
+    this.autoBatchPool = new AutoBatchNode(this, this)
   }
 
   // Set the schema version
@@ -79,6 +81,11 @@ module.exports = class Client {
     })
   }
 
+  // Maintains a pool of static endpoints with auto-batching enabled
+  autoBatch() {
+    return this.autoBatchPool
+  }
+
   // All the different API endpoints
   account () {
     return new endpoints.AccountEndpoint(this)

src/endpoint.js

@@ -25,6 +25,9 @@ module.exports = class AbstractEndpoint {
     this.isOptionallyAuthenticated = false
     this.credentials = false
 
+    this._autoBatch = null
+    this.autoBatchDelay = 50
+
     this._skipCache = false
   }
 
@@ -74,6 +77,23 @@ module.exports = class AbstractEndpoint {
     return this
   }
 
+  // Turn on auto-batching for this endpoint
+  enableAutoBatch (autoBatchDelay) {
+    if (this._autoBatch === null) {
+      if (!this.isBulk) {
+        this.debugMessage(`${this.url} is not bulk expanding, endpoint will not have any autobatch behavior`)
+        return this
+      }
+      this._autoBatch = {
+        // autoBatchDelay: autoBatchDelay,
+        idsForNextBatch: new Set(),
+        nextBatchPromise: null,
+      }
+    }
+    this.autoBatchDelay = autoBatchDelay || this.autoBatchDelay
+    return this
+  }
+
   // Get all ids
   ids () {
     this.debugMessage(`ids(${this.url}) called`)
@@ -156,7 +176,14 @@ module.exports = class AbstractEndpoint {
 
     // Request the single id if the endpoint a bulk endpoint
     if (this.isBulk && !url) {
-      return this._request(`${this.url}?id=${id}`)
+      if (this._autoBatch === null) {
+        return this._request(`${this.url}?id=${id}`)
+      }
+      else {
+        return this._autoBatchMany([id]).then((items) => {
+          return items[0]?items[0]:null
+        })
+      }
     }
 
     // We are dealing with a custom url instead
@@ -168,8 +195,34 @@ module.exports = class AbstractEndpoint {
     return this._request(this.url)
   }
 
+  _autoBatchMany (ids) {
+    if (this._autoBatch.idsForNextBatch.size === 0) {
+      this._autoBatch.nextBatchPromise = new Promise((resolve, reject) => {
+        setTimeout(() => {
+          const batchedIds = Array.from(this._autoBatch.idsForNextBatch)
+          this.debugMessage(`autoBatchMany called (${batchedIds.length} ids)`)
+          this._autoBatch.idsForNextBatch.clear()
+          return resolve(this.many(batchedIds, true))
+        }, this.autoBatchDelay) 
+      }).then(items => {
+        const indexedItems = {}
+        items.forEach(item => {
+          indexedItems[item.id] = item
+        })
+        return indexedItems
+      })
+    }
+
+    // Add the requested ids to the pending ids
+    ids.forEach(id => this._autoBatch.idsForNextBatch.add(id))
+    // Return the results based on the requested ids
+    return this._autoBatch.nextBatchPromise.then(indexedItems => {
+      return ids.map(id => indexedItems[id]).filter(x => x)
+    })
+  }
+
   // Get multiple entries by ids
-  many (ids) {
+  many (ids, skipAutoBatch) {
     this.debugMessage(`many(${this.url}) called (${ids.length} ids)`)
 
     if (!this.isBulk) {
@@ -186,7 +239,7 @@ module.exports = class AbstractEndpoint {
 
     // There is no cache time set, so always use the live data
     if (!this.cacheTime) {
-      return this._many(ids)
+      return this._many(ids, undefined, skipAutoBatch)
     }
 
     // Get as much as possible out of the cache
@@ -201,7 +254,7 @@ module.exports = class AbstractEndpoint {
 
       this.debugMessage(`many(${this.url}) resolving partially from cache (${cached.length} ids)`)
       const missingIds = getMissingIds(ids, cached)
-      return this._many(missingIds, cached.length > 0).then(content => {
+      return this._many(missingIds, cached.length > 0, skipAutoBatch).then(content => {
         const cacheContent = content.map(value => [this._cacheHash(value.id), value])
         this._cacheSetMany(cacheContent)
 
@@ -230,9 +283,17 @@ module.exports = class AbstractEndpoint {
   }
 
   // Get multiple entries by ids from the live API
-  _many (ids, partialRequest = false) {
+  _many (ids, partialRequest = false, skipAutoBatch) {
     this.debugMessage(`many(${this.url}) requesting from api (${ids.length} ids)`)
 
+    if (this._autoBatch !== null) {
+      if (!skipAutoBatch) {
+        return this._autoBatchMany(ids)
+      }
+    }
+
+
+
     // Chunk the requests to the max page size
     const pages = chunk(ids, this.maxPageSize)
     const requests = pages.map(page => `${this.url}?ids=${page.join(',')}`)

tests/autoBatchNode.spec.js

@@ -0,0 +1,71 @@
+/* eslint-env jest */
+const Client = require('../src/client')
+const AutoBatchNode = require('../src/autoBatchNode')
+
+
+describe('autoBatchNode', () => {
+  let client
+  let autoBatchNode
+  beforeEach(() => {
+    client = new Client()
+    autoBatchNode = new AutoBatchNode(client, client)
+  })
+
+  it(`calls the method of the wrapped client or endpoint`, () => {
+    let parentCalled = false
+    client.schema = () => {parentCalled = true}
+    autoBatchNode.schema()
+    expect(parentCalled).toEqual(true)
+  })
+
+
+  it(`method returns client (with changed setting)`, () => {
+    const resultNode = autoBatchNode.schema('new setting')
+    expect(resultNode === autoBatchNode).toEqual(true)
+    expect(autoBatchNode.parent.schemaVersion).toEqual('new setting')
+  })
+
+  describe(`method returns a new endpoint`, () => {
+    let itemsNode
+    beforeEach(() => {
+      itemsNode = autoBatchNode.items()
+    })
+
+    it(`is a new instance of AutoBatchNode`,() => {
+      expect(itemsNode).toBeInstanceOf(AutoBatchNode)
+      expect(itemsNode === autoBatchNode).toEqual(false)
+    })
+
+    it(`all method calls sync settings from client, and force caching`, () => {
+      client.schema('a')
+        .language('b')
+        .authenticate('c')
+        .debugging('d')
+
+      itemsNode.live()
+      itemsNode.debugMessage('syncs settings with client TEST')
+      expect(itemsNode.parent.schemaVersion).toEqual('a')
+      expect(itemsNode.parent.lang).toEqual('b')
+      expect(itemsNode.parent.apiKey).toEqual('c')
+      expect(itemsNode.parent.debug).toEqual('d')
+      expect(itemsNode.parent._skipCache).toEqual(false)
+    })
+
+    it(`saves child endpoints for later calls`, () => {
+      let charNode1 = autoBatchNode.characters('1')
+      let charNode2 = autoBatchNode.characters('2')
+
+      expect(charNode1 === charNode2).toEqual(false)
+      expect(autoBatchNode.characters('1') === charNode1).toEqual(true)
+      expect(autoBatchNode.characters('2') === charNode2).toEqual(true)
+      expect(autoBatchNode.items() === itemsNode).toEqual(true)
+      expect(Object.keys(autoBatchNode.children).length).toEqual(3)
+    })
+
+    it(`turns on autoBatching for new endpoint`, () => {
+      expect(itemsNode.parent._autoBatch).not.toBeNull()
+    })
+
+  })
+
+})

tests/client.spec.js

@@ -1,9 +1,21 @@
 /* eslint-env jest */
 const nullCache = require('../src/cache/null')
 const memoryCache = require('../src/cache/memory')
+const AutoBatchNode = require('../src/autoBatchNode')
 const Module = require('../src/client')
 const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms))
 
+// async function expectError (callback) {
+//   let err
+//   try {
+//     await callback()
+//   } catch (e) {
+//     err = e
+//   }
+
+//   expect(err).toBeInstanceOf(Error)
+// }
+
 describe('client', () => {
   let client
   beforeEach(() => {
@@ -123,6 +135,22 @@ describe('client', () => {
     client.build = tmp
   })
 
+  describe('autobatch', () => {
+
+    it(`can get the autoBatchNode wrapped Client`, () => {
+      expect(client.autoBatch()).toBeInstanceOf(AutoBatchNode)
+      expect(client.autoBatch()).toBeInstanceOf(AutoBatchNode)
+      expect(client.autoBatch().parent).toBeInstanceOf(Module)
+      expect(client.autoBatch().parent === client).toEqual(true)
+    })
+
+    it('can get an autobatching endpoint', () => {
+      let endpoint = client.autoBatch().items().parent
+      expect(endpoint.url).toEqual('/v2/items')
+      expect(endpoint._autoBatch).not.toBeNull()
+    })
+  })
+
   it('can get the account endpoint', () => {
     let endpoint = client.account()
     expect(endpoint.url).toEqual('/v2/account')