firebase-document.html

<!--
@license
Copyright 2016 Google Inc. All Rights Reserved.
Use of this source code is governed by a BSD-style
license that can be found in the LICENSE file or at
https://github.com/firebase/polymerfire/blob/master/LICENSE
-->

<link rel="import" href="../polymer/polymer.html">
<link rel="import" href="firebase-database-behavior.html">
<link rel="import" href="firebase.html">
<script>
  'use strict';

  /**
   * The firebase-document element is an easy way to interact with a firebase
   * location as an object and expose it to the Polymer databinding system.
   *
   * For example:
   *
   *     <firebase-document
   *       path="/users/{{userId}}/notes/{{noteId}}"
   *       data="{{noteData}}">
   *     </firebase-document>
   *
   * This fetches the `noteData` object from the firebase location at
   * `/users/${userId}/notes/${noteId}` and exposes it to the Polymer
   * databinding system. Changes to `noteData` will likewise be, sent back up
   * and stored.
   *
   * `<firebase-document>` needs some information about how to talk to Firebase.
   * Set this configuration by adding a `<firebase-app>` element anywhere in your
   * app.
   */
  Polymer({
    is: 'firebase-document',

    behaviors: [
      Polymer.FirebaseDatabaseBehavior
    ],

    attached: function() {
      this.__refChanged(this.ref, this.ref);
    },

    detached: function() {
      if (this.ref) {
        this.ref.off();
      }
    },

    observers: [
      '__refChanged(ref)'
    ],

    /**
     * @override
     */
    get isNew() {
      return !this.path;
    },

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

    /**
     * Update the path and write this.data to that new location.
     *
     * Important note: `this.path` is updated asynchronously.
     *
     * @param {string} parentPath The new firebase location to write to.
     * @param {string=} key The key within the parentPath to write `data` to. If
     *     not given, a random key will be generated and used.
     * @return {Promise} A promise that resolves once this.data has been
     *     written to the new path.
     * @override
     */
    save: function(parentPath, key) {
      return new Promise(function(resolve, reject) {
        var path;

        if (!this.app) {
          reject(new Error('No app configured!'));
        }

        if (key) {
          path = parentPath + '/' + key;
          resolve(this._setFirebaseValue(path, this.data));
        } else {
          path = firebase.database(this.app).ref(parentPath)
              .push(this.data, function(error) {
                if (error) {
                  reject(error);
                  return;
                }

                resolve();
              }).path.toString();
        }

        this.path = path;
      }.bind(this));
    },

    /**
     * @override
     */
    reset: function() {
      this.path = null;
      return Promise.resolve();
    },

    /**
     * @override
     */
    destroy: function() {
      return this._setFirebaseValue(this.path, null).then(function() {
        return this.reset();
      }.bind(this));
    },

    /**
     * @override
     */
    memoryPathToStoragePath: function(path) {
      var storagePath = this.path;

      if (path !== 'data') {
        storagePath += path.replace(/^data\.?/, '/').split('.').join('/');
      }

      return storagePath;
    },

    /**
     * @override
     */
    storagePathToMemoryPath: function(storagePath) {
      var path = 'data';

      storagePath =
          storagePath.replace(this.path, '').split('/').join('.');

      if (storagePath) {
        path += '.' + storagePath;
      }

      return path;
    },

    /**
     * @override
     */
    getStoredValue: function(path) {
      return new Promise(function(resolve, reject) {
          this.ref.child(path).once('value', function(snapshot) {
            var value = snapshot.val();
            if (value == null) {
              resolve(this.zeroValue);
            }
            resolve(value);
          }, this);
        }.bind(this));
    },

    /**
     * @override
     */
    setStoredValue: function(path, value) {
      return this._setFirebaseValue(path, value);
    },

    __refChanged: function(ref, oldRef) {
      if (oldRef) {
        oldRef.off('value', this.__onFirebaseValue, this);
      }

      if (ref) {
        ref.on('value', this.__onFirebaseValue, this);
      }
    },

    __onFirebaseValue: function(snapshot) {
      var value = snapshot.val();

      if (value == null) {
        value = this.zeroValue;
      }

      if (!this.new) {
        this.async(function() {
          this.syncToMemory(function() {
            this._log('Updating data from Firebase value:', value);
            this.set('data', value);
          });
        });
      }
    }
  });
</script>