BatchMaxQueries

src/transport/batchedNetworkInterface.ts

@@ -46,15 +46,20 @@ export class HTTPBatchedNetworkInterface extends BaseNetworkInterface {
   public _afterwares: BatchAfterwareInterface[];
   private batcher: QueryBatcher;
 
-  constructor(uri: string, batchInterval: number, fetchOpts: RequestInit) {
+  constructor(uri: string, batchInterval: number, batchMax: number, fetchOpts: RequestInit) {
     super(uri, fetchOpts);
 
     if (typeof batchInterval !== 'number') {
       throw new Error(`batchInterval must be a number, got ${batchInterval}`);
     }
 
+    if (typeof batchMax !== 'number') {
+      throw new Error(`batchMax must be a number, got ${batchMax}`);
+    }
+
     this.batcher = new QueryBatcher({
       batchInterval: batchInterval,
+      batchMax: batchMax,
       batchFetchFunction: this.batchQuery.bind(this),
     });
   }
@@ -218,12 +223,13 @@ export class HTTPBatchedNetworkInterface extends BaseNetworkInterface {
 export interface BatchingNetworkInterfaceOptions {
   uri: string;
   batchInterval: number;
+  batchMax: number;
   opts?: RequestInit;
 }
 
 export function createBatchingNetworkInterface(options: BatchingNetworkInterfaceOptions): HTTPNetworkInterface {
   if (! options) {
     throw new Error('You must pass an options argument to createNetworkInterface.');
   }
-  return new HTTPBatchedNetworkInterface(options.uri, options.batchInterval, options.opts || {});
+  return new HTTPBatchedNetworkInterface(options.uri, options.batchInterval, options.batchMax, options.opts || {});
 }

src/transport/batching.ts

@@ -24,20 +24,24 @@ export class QueryBatcher {
   // Queue on which the QueryBatcher will operate on a per-tick basis.
   public queuedRequests: QueryFetchRequest[] = [];
 
-  private batchInterval: Number;
+  private batchInterval: number;
+  private batchMax: number;
 
   //This function is called to the queries in the queue to the server.
   private batchFetchFunction: (request: Request[]) => Promise<ExecutionResult[]>;
 
   constructor({
     batchInterval,
+    batchMax,
     batchFetchFunction,
   }: {
     batchInterval: number,
+    batchMax: number,
     batchFetchFunction: (request: Request[]) => Promise<ExecutionResult[]>,
   }) {
     this.queuedRequests = [];
     this.batchInterval = batchInterval;
+    this.batchMax = batchMax;
     this.batchFetchFunction = batchFetchFunction;
   }
 
@@ -62,20 +66,20 @@ export class QueryBatcher {
   // Consumes the queue.
   // Returns a list of promises (one for each query).
   public consumeQueue(): (Promise<ExecutionResult> | undefined)[] | undefined {
-    const requests: Request[] = this.queuedRequests.map(
+    const queueSlice = this.queuedRequests.splice(0, this.batchMax);
+    const requests: Request[] = queueSlice.map(
       (queuedRequest) => queuedRequest.request,
     );
 
     const promises: (Promise<ExecutionResult> | undefined)[] = [];
     const resolvers: any[] = [];
     const rejecters: any[] = [];
-    this.queuedRequests.forEach((fetchRequest, index) => {
+    queueSlice.forEach((fetchRequest, index) => {
       promises.push(fetchRequest.promise);
       resolvers.push(fetchRequest.resolve);
       rejecters.push(fetchRequest.reject);
     });
 
-    this.queuedRequests = [];
     const batchedPromise = this.batchFetchFunction(requests);
 
     batchedPromise.then((results) => {
@@ -87,6 +91,11 @@ export class QueryBatcher {
         rejecters[index](error);
       });
     });
+
+    if (this.queuedRequests.length) {
+      promises.concat(this.consumeQueue());
+    }
+
     return promises;
   }
 

test/batchedNetworkInterface.ts

@@ -47,7 +47,7 @@ describe('HTTPBatchedNetworkInterface', () => {
     opts?: RequestInit,
   }) => {
     const url = 'http://fake.com/graphql';
-    const batchedNetworkInterface = new HTTPBatchedNetworkInterface(url, 10, opts);
+    const batchedNetworkInterface = new HTTPBatchedNetworkInterface(url, 10, 10, opts);
 
     batchedNetworkInterface.use(middlewares);
     batchedNetworkInterface.useAfter(afterwares);
@@ -113,7 +113,7 @@ describe('HTTPBatchedNetworkInterface', () => {
   it('should construct itself correctly', () => {
     const url = 'http://notreal.com/graphql';
     const opts = {};
-    const batchedNetworkInterface = new HTTPBatchedNetworkInterface(url, 10, opts);
+    const batchedNetworkInterface = new HTTPBatchedNetworkInterface(url, 10, 10, opts);
     assert(batchedNetworkInterface);
     assert.equal(batchedNetworkInterface._uri, url);
     assert.deepEqual(batchedNetworkInterface._opts, opts);

test/batching.ts

@@ -16,6 +16,7 @@ describe('QueryBatcher', () => {
     assert.doesNotThrow(() => {
       const querySched = new QueryBatcher({
         batchInterval: 10,
+        batchMax: 10,
         batchFetchFunction: networkInterface.batchQuery.bind(networkInterface),
       });
       querySched.consumeQueue();
@@ -25,6 +26,7 @@ describe('QueryBatcher', () => {
   it('should not do anything when faced with an empty queue', () => {
     const batcher = new QueryBatcher({
       batchInterval: 10,
+      batchMax: 10,
       batchFetchFunction: networkInterface.batchQuery.bind(networkInterface),
     });
 
@@ -36,6 +38,7 @@ describe('QueryBatcher', () => {
   it('should be able to add to the queue', () => {
     const batcher = new QueryBatcher({
       batchInterval: 10,
+      batchMax: 10,
       batchFetchFunction: networkInterface.batchQuery.bind(networkInterface),
     });
 
@@ -84,6 +87,7 @@ describe('QueryBatcher', () => {
     );
     const batcher = new QueryBatcher({
       batchInterval: 10,
+      batchMax: 10,
       batchFetchFunction: myNetworkInterface.batchQuery.bind(myNetworkInterface),
     });
     const request: Request = {
@@ -93,6 +97,7 @@ describe('QueryBatcher', () => {
     it('should be able to consume from a queue containing a single query', (done) => {
       const myBatcher = new QueryBatcher({
         batchInterval: 10,
+        batchMax: 10,
         batchFetchFunction: myNetworkInterface.batchQuery.bind(myNetworkInterface),
       });
 
@@ -123,6 +128,7 @@ describe('QueryBatcher', () => {
 
       const myBatcher = new QueryBatcher({
         batchInterval: 10,
+        batchMax: 10,
         batchFetchFunction: NI.batchQuery.bind(NI),
       });
       myBatcher.enqueueRequest(request);
@@ -148,6 +154,7 @@ describe('QueryBatcher', () => {
         );
       const myBatcher = new QueryBatcher({
         batchInterval: 10,
+        batchMax: 10,
         batchFetchFunction: NI.batchQuery.bind(NI),
       });
       const promise = myBatcher.enqueueRequest(request);
@@ -162,6 +169,7 @@ describe('QueryBatcher', () => {
   it('should work when single query', (done) => {
     const batcher = new QueryBatcher({
       batchInterval: 10,
+      batchMax: 10,
       batchFetchFunction: networkInterface.batchQuery.bind(networkInterface),
     });
     const query = gql`
@@ -185,6 +193,7 @@ describe('QueryBatcher', () => {
   it('should correctly batch multiple queries', (done) => {
     const batcher = new QueryBatcher({
       batchInterval: 10,
+      batchMax: 10,
       batchFetchFunction: networkInterface.batchQuery.bind(networkInterface),
     });
     const query = gql`
@@ -233,6 +242,7 @@ describe('QueryBatcher', () => {
     );
     const batcher = new QueryBatcher({
       batchInterval: 10,
+      batchMax: 10,
       batchFetchFunction: myNetworkInterface.batchQuery.bind(myNetworkInterface),
     });
     const promise = batcher.enqueueRequest(request);

test/client.ts

@@ -2025,6 +2025,7 @@ describe('client', () => {
     const networkInterface = createBatchingNetworkInterface({
       uri: 'http://not-a-real-url.com',
       batchInterval: 5,
+      batchMax: 5,
       opts: {},
     });
     Promise.all([
@@ -2086,6 +2087,7 @@ describe('client', () => {
     const networkInterface = createBatchingNetworkInterface({
       uri: 'http://not-a-real-url.com',
       batchInterval: 5,
+      batchMax: 5,
       opts: {},
     });
     Promise.all([
@@ -2166,6 +2168,7 @@ describe('client', () => {
     const networkInterface = createBatchingNetworkInterface({
       uri: 'http://not-a-real-url.com',
       batchInterval: 5,
+      batchMax: 5,
       opts: {},
     });
     Promise.all([
@@ -2181,6 +2184,101 @@ describe('client', () => {
     });
   });
 
+  it('should limit the amount of queries in a batch according to the batchMax value', (done) => {
+    const firstQuery = gql`
+      query {
+        author {
+          firstName
+          lastName
+        }
+      }`;
+    const firstResult = {
+      data: {
+        author: {
+          firstName: 'John',
+          lastName: 'Smith',
+        },
+      },
+      loading: false,
+    };
+    const secondQuery = gql`
+      query {
+        person {
+          name
+        }
+      }`;
+    const secondResult = {
+      data: {
+        person: {
+          name: 'Jane Smith',
+        },
+      },
+    };
+    const url = 'http://not-a-real-url.com';
+
+    const networkInterface = createBatchingNetworkInterface({
+      uri: 'http://fake-url.com',
+      batchInterval: 5,
+      batchMax: 1,
+      opts: {},
+    });
+
+    const oldFetch = fetch;
+    fetch = createMockFetch({
+      url,
+      opts: {
+        body: JSON.stringify([
+          {
+            query: print(firstQuery),
+          },
+        ]),
+        headers: {
+          Accept: '*/*',
+          'Content-Type': 'application/json',
+        },
+        method: 'POST',
+      },
+      result: createMockedIResponse([firstResult]),
+    });
+
+    const firstFetch = networkInterface.query({ query: firstQuery });
+    firstFetch.then((results) => {
+      console.log('first results', results);
+      assert.deepEqual(results, [firstResult]);
+      fetch = oldFetch;
+    }).catch( e => {
+      console.error(e);
+    });
+
+    fetch = createMockFetch({
+      url,
+      opts: {
+        body: JSON.stringify([
+          {
+            query: print(secondQuery),
+          },
+        ]),
+        headers: {
+          Accept: '*/*',
+          'Content-Type': 'application/json',
+        },
+        method: 'POST',
+      },
+      result: createMockedIResponse([secondResult]),
+    });
+
+    const secondFetch = networkInterface.query({ query: secondQuery });
+    secondFetch.then((results) => {
+      console.log('second results', results);
+      assert.deepEqual(results, [secondResult]);
+      fetch = oldFetch;
+    }).catch( e => {
+      console.error(e);
+    });
+
+    done();
+  });
+
   it('should enable dev tools logging', () => {
     const query = gql`
       query people {