Merge pull request #6 from AddSearch/throttled-search

Throttled search

Author: anttiai

README.md

@@ -260,6 +260,12 @@ client.setPersonalizationEvents(events);
 client.setJWT(token);
 ```
 
+#### Set API throttling
+```js
+// Set API call throttle time in milliseconds. Default is 200.
+client.setThrottleTime(500);
+```
+
 ## Supported web browsers and node.js versions
 The client is tested on
 - Chrome

src/index.js

@@ -4,6 +4,9 @@ var executeApiFetch = require('./apifetch');
 var sendStats = require('./stats');
 var Settings = require('./settings');
 var util = require('./util');
+var throttle = require('./throttle');
+
+var API_THROTTLE_TIME_MS = 200;
 
 var client = function(sitekey) {
   this.sitekey = sitekey;
@@ -44,7 +47,11 @@ var client = function(sitekey) {
 
     this.settings.setCallback(callback);
     this.settings.setKeyword(keyword);
-    executeApiFetch(this.sitekey, 'search', this.settings.getSettings(), callback);
+
+    if (!this.throttledSearchFetch) {
+      this.throttledSearchFetch = throttle(API_THROTTLE_TIME_MS, executeApiFetch);
+    }
+    this.throttledSearchFetch(this.sitekey, 'search', this.settings.getSettings(), callback);
   }
 
 
@@ -58,7 +65,11 @@ var client = function(sitekey) {
       throw "Illegal suggestions parameters. Should be (prefix, callbackFunction)";
     }
     this.settings.setSuggestionsPrefix(prefix);
-    executeApiFetch(this.sitekey, 'suggest', this.settings.getSettings(), callback);
+
+    if (!this.throttledSuggestionsFetch) {
+      this.throttledSuggestionsFetch = throttle(API_THROTTLE_TIME_MS, executeApiFetch);
+    }
+    this.throttledSuggestionsFetch(this.sitekey, 'suggest', this.settings.getSettings(), callback);
   }
 
 
@@ -72,7 +83,11 @@ var client = function(sitekey) {
       throw "Illegal autocomplete parameters. Should be (field, prefix, callbackFunction)";
     }
     this.settings.setAutocompleteParams(field, prefix);
-    executeApiFetch(this.sitekey, 'autocomplete', this.settings.getSettings(), callback);
+
+    if (!this.throttledAutocompleteFetch) {
+      this.throttledAutocompleteFetch = throttle(API_THROTTLE_TIME_MS, executeApiFetch);
+    }
+    this.throttledAutocompleteFetch(this.sitekey, 'autocomplete', this.settings.getSettings(), callback);
   }
 
 
@@ -101,6 +116,7 @@ var client = function(sitekey) {
   this.setShuffleAndLimitTo = function(shuffleAndLimitTo) { this.settings.setShuffleAndLimitTo(shuffleAndLimitTo); }
   this.setFuzzyMatch = function(fuzzy) { this.settings.setFuzzyMatch(fuzzy); }
   this.setCollectAnalytics = function(collectAnalytics) { this.settings.setCollectAnalytics(collectAnalytics); }
+  this.setThrottleTime = function(delay) { API_THROTTLE_TIME_MS = delay; }
   this.setStatsSessionId = function(id) { this.sessionId = id; }
   this.getStatsSessionId = function() { return this.sessionId; }
 

src/throttle.js

@@ -0,0 +1,47 @@
+var throttle = function(delay, callback) {
+
+  // last time callback was executed.
+  var lastExec = 0;
+
+  // returned by setTimeout
+  var timeout;
+
+  // Clear existing timeout
+  function clearExistingTimeout() {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+  }
+
+  /*
+   * Wrap the callback inside a throttled function
+   */
+  function wrapper() {
+
+    var self = this;
+    var elapsed = Date.now() - lastExec;
+    var args = arguments;
+
+    // Execute callback function
+    function exec() {
+      lastExec = Date.now();
+      callback.apply(self, args);
+    }
+
+    clearExistingTimeout();
+
+    // Execute
+    if (elapsed > delay) {
+      exec();
+    }
+    // Schedule for a later execution
+    else {
+      timeout = setTimeout(exec, delay - elapsed);
+    }
+  }
+
+  // Return the wrapper function.
+  return wrapper;
+}
+
+module.exports = throttle;

test/throttle.js

@@ -0,0 +1,49 @@
+var assert = require('assert');
+var throttle = require('../src/throttle');
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+describe('throttle', function() {
+
+  it('function shouldn\'t be throttled (30 function calls in 600ms)', async function() {
+    this.timeout(5000);
+    var functionCalls = 30;
+    var sleepTime = 20; // 30*20 = 600 ms
+    var expectedExecutions = 30; // Function called in every iteration
+    var executions = 0;
+
+    var f = function() {
+      executions++;
+    };
+
+    for (var i=0; i<functionCalls; i++) {
+      f();
+      await sleep(sleepTime);
+    }
+
+    assert.equal(expectedExecutions, executions);
+  });
+
+  it('function should be throttled (4 function calls in 600ms', async function() {
+    this.timeout(5000);
+    var functionCalls = 30;
+    var sleepTime = 20; // 30*20 = 600 ms
+    var throttleDelay = 200;
+    var expectedExecutions = 3 + 1; // Call functions for 600 ms with 200 ms throttle = 3 calls + one last call
+    var executions = 0;
+
+    var f = throttle(throttleDelay, function() {
+      executions++;
+    });
+
+    for (var i=0; i<functionCalls; i++) {
+      f();
+      await sleep(sleepTime);
+    }
+
+    assert.equal(expectedExecutions, executions);
+  });
+
+});