app-pouchdb-document.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="../app-storage/app-storage-behavior.html">
<link rel="import" href="app-pouchdb-database-behavior.html">
<link rel="import" href="pouchdb.html">

<!--
`app-pouchdb-document` is an implementation of `Polymer.AppStorageBehavior`
for reading and writing to individual PouchDB documents.

In order to refer to a PouchDB document, provide the name of the database
(both local and remote databases are supported) and the ID of the document.

For example:

```html
<app-pouchdb-document
    db-name="cats"
    doc-id="parsnip">
</app-pouchdb-document>
```

In the above example, a PouchDB instance will be created to connect to the
local database named "cats". Then it will check to see if a document with the
ID "parsnip" exists. If it does, the `data` property of the document will be
set to the value of the document. If it does not, then any subsequent
assignments to the `data` property will cause a document with ID "parsnip" to
be created.

Here is an example of a simple form that can be used to read and write to a
PouchDB document:

```html
<app-pouchdb-document
    db-name="cats"
    doc-id="parsnip"
    data="{{cat}}">
</app-pouchdb-document>
<input
    is="iron-input"
    bind-value="{{cat.name}}">
</input>
```
-->
<script>
  (function() {
    'use strict';

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

      behaviors: [
        Polymer.AppStorageBehavior,
        Polymer.AppPouchDBDatabaseBehavior
      ],

      properties: {
        /**
         * The value of the _id (Pouch/Couch unique identifier) of the PouchDB
         * document that this element's data should refer to.
         */
        docId: {
          type: String,
          value: null
        },

        /**
         * The current _rev (revision) of the PouchDB document that this
         * element's data refers to, if the document is not new.
         */
        rev: {
          type: String,
          readOnly: true,
          value: null
        },

        /**
         * A changes event emitter. Notifies of changes to the PouchDB document
         * referred to by `docId`, if a `docId` has been provided.
         */
        changes: {
          type: Object,
          computed: '__computeChanges(db, docId)'
        }
      },

      observers: [
        '__docRevChanged(data._rev)',
        '__docChanged(db, data, docId, _readied)'
      ],

      /** @override */
      get isNew() {
        return this.docId == null;
      },

      /** @override */
      get zeroValue() {
        return {};
      },

      /** @override */
      save: function() {
        if (!this.db) {
          return Promise.reject('No PouchDB instance available!');
        }

        if (this.docId) {
          this.data._id = this.docId;
        }

        return this._upsert('data', this.data, this.data)
            .then(function(response) {
              this.syncToMemory(function() {
                this.docId = response.id;
                this.set('data._id', response.id);
                this.set('data._rev', response.rev);
              });
            }.bind(this));
      },

      /** @override */
      reset: function() {
        this.docId = null;
        this.data = this.zeroValue;
      },

      /** @override */
      destroy: function() {
        this.set('data._deleted', true);
        return this.transactionsComplete.then(function() {
          return this.reset();
        });
      },

      /** @override */
      getStoredValue: function(storagePath) {
        return this.db.get(this.docId).then(function(doc) {
          return this.get(storagePath, {
            data: doc
          });
        }.bind(this)).catch(function(error) {
          if (error && error.status === 404) {
            return;
          } else {
            throw error;
          }
        });
      },

      /** @override */
      setStoredValue: function(storagePath, value) {
        if (storagePath === 'data' && value == null) {
          return Promise.reject(
              ['Unsupported attempt to unset PouchDB document by assigning null value.',
               'Perhaps you meant to set `data._deleted = true`?'].join(' '));
        }

        return this._put(storagePath, value, this.data);
      },

      __docChanged: function(db, doc, docId) {
        this._log('Doc / ID changed', doc, docId);
        if (db && doc != null && docId != null && doc._id != docId) {
          doc._id = docId;
          this._initializeStoredValue();
        }
      },

      __docRevChanged: function() {
        this._setRev(this.data != null ? this.data._rev : null);
      },

      __computeChanges: function(db, docId) {
        if (this.changes) {
          this.changes.removeAllListeners();
        }

        if (db == null || docId == null) {
          return null;
        }

        return db.changes({
          since: 'now',
          live: true,
          doc_ids: [docId],
          include_docs: true,
        }).on('change', function(change) {
          var doc = change.doc;
          this.syncToMemory(function() {
            this.set('data', doc);
          });
        }.bind(this));
      }
    });
  })();
</script>