all files / lib/ constructor.js

100% Statements 119/119
97.87% Branches 46/47
100% Functions 14/14
100% Lines 118/118
9 statements, 5 branches Ignored     
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212                                          6810×                             6844× 6844× 6844×   3976×   3976×     6648× 6648×     6844×     6844× 3867×   6844×       6855×   6853× 6853× 5663× 5663×     6853×   6853× 6810×   6853× 6853×   6853× 6853× 6853× 6853× 6853× 6853× 6853× 6853× 6853×   6844×   6844× 6844×     6853× 6853× 6853× 6853× 6853×   6853×     6845×   6845× 6845× 6845×   6845× 6845× 6845×   6845× 6845×       6844×         6853×   6844×     6844×   6844× 308×     6844× 388×     6844× 94×     6844×   6844×   6844×   6844×   6844× 6844× 6844× 6844×       6844×       6853× 6844×   6853× 6853×      
'use strict';
 
Object.defineProperty(exports, "__esModule", {
  value: true
});
 
var _debug = require('debug');
 
var _debug2 = _interopRequireDefault(_debug);
 
var _inherits = require('inherits');
 
var _inherits2 = _interopRequireDefault(_inherits);
 
var _adapter = require('./adapter');
 
var _adapter2 = _interopRequireDefault(_adapter);
 
var _taskqueue = require('./taskqueue');
 
var _taskqueue2 = _interopRequireDefault(_taskqueue);
 
var _isCordova = require('./deps/isCordova');
 
var _isCordova2 = _interopRequireDefault(_isCordova);
 
var _promise = require('./deps/promise');
 
var _promise2 = _interopRequireDefault(_promise);
 
var _clone = require('./deps/clone');
 
var _clone2 = _interopRequireDefault(_clone);
 
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
function defaultCallback(err) {
  /* istanbul ignore next */
  Iif (err && global.debug) {
    console.error(err);
  }
}
 
// OK, so here's the deal. Consider this code:
//     var db1 = new PouchDB('foo');
//     var db2 = new PouchDB('foo');
//     db1.destroy();
// ^ these two both need to emit 'destroyed' events,
// as well as the PouchDB constructor itself.
// So we have one db object (whichever one got destroy() called on it)
// responsible for emitting the initial event, which then gets emitted
// by the constructor, which then broadcasts it to any other dbs
// that may have been created with the same name.
/*globals cordova */
function prepareForDestruction(self, opts) {
  var name = opts.originalName;
  var ctor = self.constructor;
  var destructionListeners = ctor._destructionListeners;
 
  function onDestroyed() {
    ctor.emit('destroyed', name);
    //so we don't have to sift through all dbnames
    ctor.emit(name, 'destroyed');
  }
 
  function onConstructorDestroyed() {
    self.removeListener('destroyed', onDestroyed);
    self.emit('destroyed', self);
  }
 
  self.once('destroyed', onDestroyed);
 
  // in setup.js, the constructor is primed to listen for destroy events
  if (!destructionListeners.has(name)) {
    destructionListeners.set(name, []);
  }
  destructionListeners.get(name).push(onConstructorDestroyed);
}
 
(0, _inherits2.default)(PouchDB, _adapter2.default);
function PouchDB(name, opts, callback) {
 
  if (!(this instanceof PouchDB)) {
    return new PouchDB(name, opts, callback);
  }
  var self = this;
  if (typeof opts === 'function' || typeof opts === 'undefined') {
    callback = opts;
    opts = {};
  }
 
  if (name && typeof name === 'object') {
    opts = name;
    name = undefined;
  }
  if (typeof callback === 'undefined') {
    callback = defaultCallback;
  }
  name = name || opts.name;
  opts = (0, _clone2.default)(opts);
  // if name was specified via opts, ignore for the sake of dependentDbs
  delete opts.name;
  this.__opts = opts;
  var oldCB = callback;
  self.auto_compaction = opts.auto_compaction;
  self.prefix = PouchDB.prefix;
  _adapter2.default.call(self);
  self.taskqueue = new _taskqueue2.default();
  var promise = new _promise2.default(function (fulfill, reject) {
    callback = function (err, resp) {
      /* istanbul ignore if */
      Iif (err) {
        return reject(err);
      }
      delete resp.then;
      fulfill(resp);
    };
 
    opts = (0, _clone2.default)(opts);
    var originalName = opts.name || name;
    var backend, error;
    (function () {
      try {
 
        if (typeof originalName !== 'string') {
          error = new Error('Missing/invalid DB name');
          error.code = 400;
          throw error;
        }
 
        backend = PouchDB.parseAdapter(originalName, opts);
 
        opts.originalName = originalName;
        opts.name = backend.name;
        if (opts.prefix && backend.adapter !== 'http' && backend.adapter !== 'https') {
          opts.name = opts.prefix + opts.name;
        }
        opts.adapter = opts.adapter || backend.adapter;
        self._adapter = opts.adapter;
        (0, _debug2.default)('pouchdb:adapter')('Picked adapter: ' + opts.adapter);
 
        self._db_name = originalName;
        if (!PouchDB.adapters[opts.adapter]) {
          error = new Error('Adapter is missing');
          error.code = 404;
          throw error;
        }
 
        /* istanbul ignore if */
        Iif (!PouchDB.adapters[opts.adapter].valid()) {
          error = new Error('Invalid Adapter');
          error.code = 404;
          throw error;
        }
      } catch (err) {
        self.taskqueue.fail(err);
      }
    })();
    if (error) {
      return reject(error); // constructor error, see above
    }
    self.adapter = opts.adapter;
 
    // needs access to PouchDB;
    self.replicate = {};
 
    self.replicate.from = function (url, opts, callback) {
      return self.constructor.replicate(url, self, opts, callback);
    };
 
    self.replicate.to = function (url, opts, callback) {
      return self.constructor.replicate(self, url, opts, callback);
    };
 
    self.sync = function (dbName, opts, callback) {
      return self.constructor.sync(self, dbName, opts, callback);
    };
 
    self.replicate.sync = self.sync;
 
    PouchDB.adapters[opts.adapter].call(self, opts, function (err) {
      /* istanbul ignore if */
      Iif (err) {
        self.taskqueue.fail(err);
        callback(err);
        return;
      }
      prepareForDestruction(self, opts);
 
      self.emit('created', self);
      PouchDB.emit('created', opts.originalName);
      self.taskqueue.ready(self);
      callback(null, self);
    });
 
    /* istanbul ignore next */
    Iif ((0, _isCordova2.default)()) {
      //to inform websql adapter that we can use api
      cordova.fireWindowEvent(opts.name + "_pouch", {});
    }
  });
  promise.then(function (resp) {
    oldCB(null, resp);
  }, oldCB);
  self.then = promise.then.bind(promise);
  self.catch = promise.catch.bind(promise);
}
 
PouchDB.debug = _debug2.default;
 
exports.default = PouchDB;
module.exports = exports['default'];