app-pouchdb-sync.html

<!--
@license
Copyright (c) 2016 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
Code distributed by Google as part of the polymer project is also
subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
-->
<link rel="import" href="../polymer/polymer.html">
<link rel="import" href="pouchdb.html">
<!--
`app-pouchdb-sync` arranges for one-directional or bi-directional
synchronization between two PouchDB databases. For one-directional
synchronization, it forwards to `PouchDB.replicate`, and for bi-directional
synchronization, it forwards to `PouchDB.sync`.

Here is an example of bi-directional synchronization between a local database
and a remote one:

```html
<app-pouchdb-sync
    src="cats"
    target="https://example.com:5678/cats"
    bidirectional>
</app-pouchdb-sync>
```

For more information on PouchDB synchronization topics, please refer to the
documentation [here](https://pouchdb.com/guides/replication.html).
-->
<script>
  (function() {
  'use strict';

  Polymer({
    is: 'app-pouchdb-sync',

    properties: {
      /**
       * The source to sync from. If this sync is `bidirectional`, then the
       * `src` and `target` values are interchangeable.
       */
      src: {type: String},

      /**
       * The `target` to sync to. If this sync is `bidirectional`, then the
       * `src` and `target` values are interchangeable.
       */
      target: {type: String},

      /**
       * While `false`, synchronization will only happen from the `src` to the
       * `target`. One-directional synchronization follows the semantics of
       * `PouchDB.replicate`. Set to `true` to make the sync bidirectional,
       * which uses `PouchDB.sync` instead.
       */
      bidirectional: {type: Boolean, value: false},

      /**
       * An event emitter that notifies of events in the synchronization
       * process.
       */
      sync: {
        type: Object,
        computed: '__computeSync(src, target, bidirectional)',
        observer: '__syncChanged'
      },

      /**
       * Set to true to log change events that are emitted by the `sync`
       * instance.
       */
      log: {type: Boolean, value: false}
    },

    __computeSync: function(src, target, bidirectional) {
      var options = {live: true, retry: true};

      return bidirectional ? PouchDB.sync(src, target, options) :
                             PouchDB.replicate(src, target, options);
    },

    __syncChanged: function(sync, oldSync) {
      if (oldSync) {
        oldSync.removeAllListeners();
        oldSync.cancel();
      }

      if (sync) {
        sync.on('change', this.__onSyncChange.bind(this));
        sync.on('error', this.__onSyncError.bind(this));
      }
    },

    __onSyncChange: function(change) {
      if (this.log) {
        console.log(change);
      }
    },

    __onSyncError: function(error) {
      console.error(error);
    }
  });
  })();
</script>