Added options to disable live sync and support for periodic polling for changes

README.md

@@ -99,6 +99,27 @@ PouchDB.debug.enable('*');
 
 See the [PouchDB sync API](http://pouchdb.com/api.html#sync) for full usage instructions.
 
+### Live sync
+
+PouchDB's live sync uses a long-polling socket, so you may find that you hit the browser's
+limit of HTTP connections to a given host. In this case you may find that a periodic
+sync is better for your needs.
+
+If you are connecting directly to a database over HTTP without syncing to a local database
+then ember-pouch's change detection will use a long-polling socket. The following will
+poll for changes rather than using live sync.
+
+```js
+export default Adapter.extend({
+  db: db,
+  liveSync: false,
+  syncInterval: 5000
+});
+```
+
+You can also sync manually by calling `adapter.sync()`, which returns a Promise that is
+fulfilled on the `complete` event from PouchDB.
+
 ## EmberPouch Blueprints
 
 ### Model

addon/adapters/pouch.js

@@ -6,43 +6,106 @@ import {
 } from 'ember-pouch/utils';
 
 const {
+  assert,
   run: {
-    bind
+    bind,
+    later,
+    cancel
   },
   on,
+  observer,
   String: {
     pluralize,
     camelize,
     classify
-  }
+  },
+  RSVP
 } = Ember;
 
 export default DS.RESTAdapter.extend({
   coalesceFindRequests: true,
+  liveSync: true,
+  syncInterval: null,
+
+  liveChanges: null,
+  syncChanges: null,
+  syncTimer: null,
+  lastSeq: null,
 
   // The change listener ensures that individual records are kept up to date
   // when the data in the database changes. This makes ember-data 2.0's record
   // reloading redundant.
   shouldReloadRecord: function () { return false; },
   shouldBackgroundReloadRecord: function () { return false; },
-  _onInit : on('init', function()  {
-    this._startChangesToStoreListener();
-  }),
-  _startChangesToStoreListener: function () {
+  _liveSyncHandler: observer('liveSync', 'db', function () {
+    if (this.liveChanges) {
+      this.liveChanges.cancel();
+    }
     var db = this.get('db');
-    if (db) {
-      this.changes = db.changes({
+    if (this.get('liveSync') && db) {
+      this.liveChanges = db.changes({
         since: 'now',
         live: true,
         returnDocs: false
       }).on('change', bind(this, 'onChange'));
     }
+  }),
+  _syncIntervalHandler: observer('syncInterval', 'db', function () {
+    cancel(this.syncTimer);
+    if (this.get('syncInterval')) {
+      assert("Only one of liveSync or syncInterval should be used for a given adapter",
+        !this.get('liveSync')
+      );
+      this._scheduleSync();
+    }
+  }),
+  _scheduleSync() {
+    cancel(this.syncTimer);
+    this.syncTimer = later(() => {
+      this.sync();
+      this._scheduleSync();
+    }, this.get('syncInterval'));
   },
-  changeDb: function(db) {
-    if (this.changes) {
-      this.changes.cancel();
+  sync() {
+    var db = this.get('db');
+    if (!db) {
+      throw new Error("Can't sync without a db");
     }
-
+    return (this.lastSeq ? RSVP.resolve(this.lastSeq) :
+      db.info().then(info => info.update_seq)
+    ).then(sinceSeq => new RSVP.Promise((resolve, reject) => {
+      if (this.syncChanges) {
+        this.syncChanges.cancel();
+      }
+      this.syncChanges = db.changes({
+        since: sinceSeq,
+        returnDocs: false
+      }).on('complete', ev => {
+        this.lastSeq = ev.last_seq;
+        resolve(ev);
+      }).on('error', reject);
+      if (!this.get('liveSync')) {
+        this.syncChanges.on('change', bind(this, 'onChange'));
+      }
+    }));
+  },
+  _startSyncing: on('init', function() {
+    this._liveSyncHandler();
+    this._syncIntervalHandler();
+  }),
+  _stopSyncing() {
+    if (this.liveChanges) {
+      this.liveChanges.cancel();
+    }
+    if (this.syncTimer) {
+      cancel(this.syncTimer);
+    }
+    if (this.syncChanges) {
+      this.syncChanges.cancel();
+    }
+  },
+  changeDb: function(db) {
+    this._stopSyncing();
     var store = this.store;
     var schema = this._schema || [];
 
@@ -52,7 +115,6 @@ export default DS.RESTAdapter.extend({
 
     this._schema = null;
     this.set('db', db);
-    this._startChangesToStoreListener();
   },
   onChange: function (change) {
     // If relational_pouch isn't initialized yet, there can't be any records
@@ -107,9 +169,7 @@ export default DS.RESTAdapter.extend({
   },
 
   willDestroy: function() {
-    if (this.changes) {
-      this.changes.cancel();
-    }
+    this._stopSyncing();
   },
 
   _init: function (store, type) {

tests/dummy/app/adapters/hot-sauce.js

@@ -0,0 +1,14 @@
+import { Adapter } from 'ember-pouch/index';
+import PouchDB from 'pouchdb';
+
+function createDb() {
+  return new PouchDB('hot-sauces');
+}
+
+export default Adapter.extend({
+  liveSync: false,
+  init() {
+    this._super(...arguments);
+    this.set('db', createDb());
+  }
+});

tests/dummy/app/models/hot-sauce.js

@@ -0,0 +1,6 @@
+import DS from 'ember-data';
+
+export default DS.Model.extend({
+  rev: DS.attr('string'),
+  name: DS.attr('string')
+});

tests/helpers/async.js

@@ -0,0 +1,11 @@
+import Ember from 'ember';
+
+export function promiseToRunLater(callback, timeout) {
+  return new Ember.RSVP.Promise((resolve) => {
+    Ember.run.later(() => {
+      callback();
+      resolve();
+    }, timeout);
+  });
+}
+

tests/integration/adapters/pouch-default-change-watcher-test.js

@@ -1,6 +1,6 @@
 import { test } from 'qunit';
 import moduleForIntegration from '../../helpers/module-for-acceptance';
-
+import { promiseToRunLater } from '../../helpers/async';
 import Ember from 'ember';
 
 /*
@@ -23,15 +23,6 @@ moduleForIntegration('Integration | Adapter | Default Change Watcher', {
   }
 });
 
-function promiseToRunLater(callback, timeout) {
-  return new Ember.RSVP.Promise((resolve) => {
-    Ember.run.later(() => {
-      callback();
-      resolve();
-    }, timeout);
-  });
-}
-
 test('a loaded instance automatically reflects directly-made database changes', function (assert) {
   assert.expect(2);
   var done = assert.async();
@@ -193,4 +184,3 @@ test('a new record is automatically loaded', function (assert) {
     }, 15);
   }).finally(done);
 });
-

tests/integration/adapters/without-live-sync-test.js

@@ -0,0 +1,118 @@
+import Ember from 'ember';
+import { test } from 'qunit';
+import moduleForIntegration from '../../helpers/module-for-acceptance';
+import { promiseToRunLater } from '../../helpers/async';
+
+moduleForIntegration('Integration | Adapter | Without live sync', {
+  beforeEach(assert) {
+    var done = assert.async();
+
+    this.adapter = function adapter() {
+      return this.store().adapterFor('hot-sauce');
+    };
+    this.db = function db() {
+      return this.adapter().get('db');
+    };
+    Ember.RSVP.Promise.resolve().then(() => {
+      return this.db().bulkDocs([
+        { _id: 'hotSauce_2_A', data: { name: 'Cholula' } },
+        { _id: 'hotSauce_2_B', data: { name: 'Melbourne Hot Sauce' } },
+      ]);
+    }).finally(done);
+  },
+  afterEach(assert) {
+    var done = assert.async();
+    this.db().destroy().then(() => {
+      Ember.run(() => this.adapter().destroy());
+      done();
+    });
+  }
+});
+
+test('changes are not synced', function (assert) {
+  assert.expect(2);
+  var done = assert.async();
+
+  Ember.RSVP.resolve().then(() => {
+    return this.store().find('hot-sauce', 'A');
+  }).then((hotSauce) => {
+    assert.equal('Cholula', hotSauce.get('name'),
+      'the loaded instance should reflect the initial test data');
+
+    return this.db().get('hotSauce_2_A');
+  }).then((hotSauceRecord) => {
+    hotSauceRecord.data.name = 'Death Sauce';
+    return this.db().put(hotSauceRecord);
+  }).then(() => {
+    return promiseToRunLater(() => {
+      var alreadyLoadedHotSauce = this.store().peekRecord('hot-sauce', 'A');
+      assert.equal(alreadyLoadedHotSauce.get('name'), 'Cholula',
+        'the loaded instance should not automatically reflect the change in the database');
+    }, 15);
+  }).finally(done);
+});
+
+test('changes can be manually synced', function (assert) {
+  assert.expect(3);
+  var done = assert.async();
+
+  this.adapter().set('liveSync', false);
+  Ember.RSVP.resolve().then(() => {
+    return this.adapter().sync(); // perform initial sync to get update_seq
+  }).then(() => {
+    return this.store().find('hot-sauce', 'A');
+  }).then((hotSauce) => {
+    assert.equal('Cholula', hotSauce.get('name'),
+      'the loaded instance should reflect the initial test data');
+    return this.db().get('hotSauce_2_A');
+  }).then((hotSauceRecord) => {
+    hotSauceRecord.data.name = 'Death Sauce';
+    return this.db().put(hotSauceRecord);
+  }).then(() => {
+    return this.store().find('hot-sauce', 'A');
+  }).then((hotSauce) => {
+    assert.equal('Cholula', hotSauce.get('name'),
+      'the loaded instance does not reflect the changes');
+    return this.adapter().sync();
+  })
+  .then(() => {
+    return promiseToRunLater(() => {
+      var alreadyLoadedHotSauce = this.store().peekRecord('hot-sauce', 'A');
+      assert.equal(alreadyLoadedHotSauce.get('name'), 'Death Sauce',
+        'the loaded instance reflects the change in the database');
+    }, 500);
+  }).finally(done);
+});
+
+test('changes can be synced periodically', function (assert) {
+  assert.expect(3);
+  var done = assert.async();
+
+  this.adapter().set('liveSync', false);
+  Ember.RSVP.resolve().then(() => {
+    return this.adapter().sync(); // perform initial sync to get update_seq
+  }).then(() => {
+    return this.store().find('hot-sauce', 'A');
+  }).then((hotSauce) => {
+    assert.equal('Cholula', hotSauce.get('name'),
+      'the loaded instance should reflect the initial test data');
+    return this.db().get('hotSauce_2_A');
+  }).then((hotSauceRecord) => {
+    hotSauceRecord.data.name = 'Death Sauce';
+    return this.db().put(hotSauceRecord);
+  }).then(() => {
+    return this.store().find('hot-sauce', 'A');
+  }).then((hotSauce) => {
+    assert.equal('Cholula', hotSauce.get('name'),
+      'the loaded instance does not reflect the changes');
+    this.adapter().set('syncInterval', 100);
+  })
+  .then(() => {
+    return promiseToRunLater(() => {
+      var alreadyLoadedHotSauce = this.store().peekRecord('hot-sauce', 'A');
+      assert.equal(alreadyLoadedHotSauce.get('name'), 'Death Sauce',
+        'the loaded instance reflects the change in the database');
+    }, 500);
+  }).finally(done);
+});
+