added some dependencies to package.json

1 files changed, 0 insertions, 379 deletions

diff --git a/node_modules/connect-mongo/src-es5/index.js b/node_modules/connect-mongo/src-es5/index.js
deleted file mode 100644
index 0e1b473..0000000
--- a/node_modules/connect-mongo/src-es5/index.js
+++ /dev/null
@@ -1,379 +0,0 @@
-'use strict';
-/* eslint indent: [error, 4] */
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-var Promise = require('bluebird');
-var MongoClient = require('mongodb');
-
-function defaultSerializeFunction(session) {
-    // Copy each property of the session to a new object
-    var obj = {};
-    var prop = void 0;
-
-    for (prop in session) {
-        if (prop === 'cookie') {
-            // Convert the cookie instance to an object, if possible
-            // This gets rid of the duplicate object under session.cookie.data property
-            obj.cookie = session.cookie.toJSON ? session.cookie.toJSON() : session.cookie;
-        } else {
-            obj[prop] = session[prop];
-        }
-    }
-
-    return obj;
-}
-
-function computeTransformFunctions(options, defaultStringify) {
-    if (options.serialize || options.unserialize) {
-        return {
-            serialize: options.serialize || defaultSerializeFunction,
-            unserialize: options.unserialize || function (x) {
-                return x;
-            }
-        };
-    }
-
-    if (options.stringify === false || defaultStringify === false) {
-        return {
-            serialize: defaultSerializeFunction,
-            unserialize: function (x) {
-                return x;
-            }
-        };
-    }
-
-    if (options.stringify === true || defaultStringify === true) {
-        return {
-            serialize: JSON.stringify,
-            unserialize: JSON.parse
-        };
-    }
-}
-
-module.exports = function connectMongo(connect) {
-    var Store = connect.Store || connect.session.Store;
-    var MemoryStore = connect.MemoryStore || connect.session.MemoryStore;
-
-    var MongoStore = function (_Store) {
-        _inherits(MongoStore, _Store);
-
-        function MongoStore(options) {
-            _classCallCheck(this, MongoStore);
-
-            options = options || {};
-
-            /* Fallback */
-            if (options.fallbackMemory && MemoryStore) {
-                var _ret;
-
-                return _ret = new MemoryStore(), _possibleConstructorReturn(_this, _ret);
-            }
-
-            /* Options */
-            var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(MongoStore).call(this, options));
-
-            _this.ttl = options.ttl || 1209600; // 14 days
-            _this.collectionName = options.collection || 'sessions';
-            _this.autoRemove = options.autoRemove || 'native';
-            _this.autoRemoveInterval = options.autoRemoveInterval || 10;
-            _this.transformFunctions = computeTransformFunctions(options, true);
-
-            _this.options = options;
-
-            _this.changeState('init');
-
-            var newConnectionCallback = function (err, db) {
-                if (err) {
-                    _this.connectionFailed(err);
-                } else {
-                    _this.handleNewConnectionAsync(db);
-                }
-            };
-
-            if (options.url) {
-                // New native connection using url + mongoOptions
-                MongoClient.connect(options.url, options.mongoOptions || {}, newConnectionCallback);
-            } else if (options.mongooseConnection) {
-                // Re-use existing or upcoming mongoose connection
-                if (options.mongooseConnection.readyState === 1) {
-                    _this.handleNewConnectionAsync(options.mongooseConnection.db);
-                } else {
-                    options.mongooseConnection.once('open', function () {
-                        return _this.handleNewConnectionAsync(options.mongooseConnection.db);
-                    });
-                }
-            } else if (options.db && options.db.listCollections) {
-                // Re-use existing or upcoming native connection
-                if (options.db.openCalled || options.db.openCalled === undefined) {
-                    // openCalled is undefined in mongodb@2.x
-                    _this.handleNewConnectionAsync(options.db);
-                } else {
-                    options.db.open(newConnectionCallback);
-                }
-            } else if (options.dbPromise) {
-                options.dbPromise.then(function (db) {
-                    return _this.handleNewConnectionAsync(db);
-                }).catch(function (err) {
-                    return _this.connectionFailed(err);
-                });
-            } else {
-                throw new Error('Connection strategy not found');
-            }
-
-            _this.changeState('connecting');
-
-            return _this;
-        }
-
-        _createClass(MongoStore, [{
-            key: 'connectionFailed',
-            value: function connectionFailed(err) {
-                this.changeState('disconnected');
-                throw err;
-            }
-        }, {
-            key: 'handleNewConnectionAsync',
-            value: function handleNewConnectionAsync(db) {
-                var _this2 = this;
-
-                this.db = db;
-                return this.setCollection(db.collection(this.collectionName)).setAutoRemoveAsync().then(function () {
-                    return _this2.changeState('connected');
-                });
-            }
-        }, {
-            key: 'setAutoRemoveAsync',
-            value: function setAutoRemoveAsync() {
-                var _this3 = this;
-
-                var removeQuery = { expires: { $lt: new Date() } };
-                switch (this.autoRemove) {
-                    case 'native':
-                        return this.collection.ensureIndexAsync({ expires: 1 }, { expireAfterSeconds: 0 });
-                    case 'interval':
-                        this.timer = setInterval(function () {
-                            return _this3.collection.remove(removeQuery, { w: 0 });
-                        }, this.autoRemoveInterval * 1000 * 60);
-                        this.timer.unref();
-                        return Promise.resolve();
-                    default:
-                        return Promise.resolve();
-                }
-            }
-        }, {
-            key: 'changeState',
-            value: function changeState(newState) {
-                if (newState !== this.state) {
-                    this.state = newState;
-                    this.emit(newState);
-                }
-            }
-        }, {
-            key: 'setCollection',
-            value: function setCollection(collection) {
-                if (this.timer) {
-                    clearInterval(this.timer);
-                }
-                this.collectionReadyPromise = undefined;
-                this.collection = collection;
-
-                // Promisify used collection methods
-                ['count', 'findOne', 'remove', 'drop', 'ensureIndex'].forEach(function (method) {
-                    collection[method + 'Async'] = Promise.promisify(collection[method], { context: collection });
-                });
-                collection.updateAsync = Promise.promisify(collection.update, { context: collection, multiArgs: true });
-
-                return this;
-            }
-        }, {
-            key: 'collectionReady',
-            value: function collectionReady() {
-                var _this4 = this;
-
-                var promise = this.collectionReadyPromise;
-                if (!promise) {
-                    promise = new Promise(function (resolve, reject) {
-                        switch (_this4.state) {
-                            case 'connected':
-                                resolve(_this4.collection);
-                                break;
-                            case 'connecting':
-                                _this4.once('connected', function () {
-                                    return resolve(_this4.collection);
-                                });
-                                break;
-                            case 'disconnected':
-                                reject(new Error('Not connected'));
-                                break;
-                        }
-                    });
-                    this.collectionReadyPromise = promise;
-                }
-                return promise;
-            }
-        }, {
-            key: 'computeStorageId',
-            value: function computeStorageId(sessionId) {
-                if (this.options.transformId && typeof this.options.transformId === 'function') {
-                    return this.options.transformId(sessionId);
-                } else {
-                    return sessionId;
-                }
-            }
-
-            /* Public API */
-
-        }, {
-            key: 'get',
-            value: function get(sid, callback) {
-                var _this5 = this;
-
-                return this.collectionReady().then(function (collection) {
-                    return collection.findOneAsync({
-                        _id: _this5.computeStorageId(sid),
-                        $or: [{ expires: { $exists: false } }, { expires: { $gt: new Date() } }]
-                    });
-                }).then(function (session) {
-                    if (session) {
-                        var s = _this5.transformFunctions.unserialize(session.session);
-                        if (_this5.options.touchAfter > 0 && session.lastModified) {
-                            s.lastModified = session.lastModified;
-                        }
-                        _this5.emit('touch', sid);
-                        return s;
-                    }
-                }).asCallback(callback);
-            }
-        }, {
-            key: 'set',
-            value: function set(sid, session, callback) {
-                var _this6 = this;
-
-                // removing the lastModified prop from the session object before update
-                if (this.options.touchAfter > 0 && session && session.lastModified) {
-                    delete session.lastModified;
-                }
-
-                var s = void 0;
-
-                try {
-                    s = { _id: this.computeStorageId(sid), session: this.transformFunctions.serialize(session) };
-                } catch (err) {
-                    return callback(err);
-                }
-
-                if (session && session.cookie && session.cookie.expires) {
-                    s.expires = new Date(session.cookie.expires);
-                } else {
-                    // If there's no expiration date specified, it is
-                    // browser-session cookie or there is no cookie at all,
-                    // as per the connect docs.
-                    //
-                    // So we set the expiration to two-weeks from now
-                    // - as is common practice in the industry (e.g Django) -
-                    // or the default specified in the options.
-                    s.expires = new Date(Date.now() + this.ttl * 1000);
-                }
-
-                if (this.options.touchAfter > 0) {
-                    s.lastModified = new Date();
-                }
-
-                return this.collectionReady().then(function (collection) {
-                    return collection.updateAsync({ _id: _this6.computeStorageId(sid) }, s, { upsert: true });
-                }).then(function (responseArray) {
-                    var rawResponse = responseArray.length === 2 ? responseArray[1] : responseArray[0].result;
-                    if (rawResponse.upserted) {
-                        _this6.emit('create', sid);
-                    } else {
-                        _this6.emit('update', sid);
-                    }
-                    _this6.emit('set', sid);
-                }).asCallback(callback);
-            }
-        }, {
-            key: 'touch',
-            value: function touch(sid, session, callback) {
-                var _this7 = this;
-
-                var updateFields = {},
-                    touchAfter = this.options.touchAfter * 1000,
-                    lastModified = session.lastModified ? session.lastModified.getTime() : 0,
-                    currentDate = new Date();
-
-                // if the given options has a touchAfter property, check if the
-                // current timestamp - lastModified timestamp is bigger than
-                // the specified, if it's not, don't touch the session
-                if (touchAfter > 0 && lastModified > 0) {
-
-                    var timeElapsed = currentDate.getTime() - session.lastModified;
-
-                    if (timeElapsed < touchAfter) {
-                        return callback();
-                    } else {
-                        updateFields.lastModified = currentDate;
-                    }
-                }
-
-                if (session && session.cookie && session.cookie.expires) {
-                    updateFields.expires = new Date(session.cookie.expires);
-                } else {
-                    updateFields.expires = new Date(Date.now() + this.ttl * 1000);
-                }
-
-                return this.collectionReady().then(function (collection) {
-                    return collection.updateAsync({ _id: _this7.computeStorageId(sid) }, { $set: updateFields });
-                }).then(function (result) {
-                    if (result.nModified === 0) {
-                        throw new Error('Unable to find the session to touch');
-                    } else {
-                        _this7.emit('touch', sid);
-                    }
-                }).asCallback(callback);
-            }
-        }, {
-            key: 'destroy',
-            value: function destroy(sid, callback) {
-                var _this8 = this;
-
-                return this.collectionReady().then(function (collection) {
-                    return collection.removeAsync({ _id: _this8.computeStorageId(sid) });
-                }).then(function () {
-                    return _this8.emit('destroy', sid);
-                }).asCallback(callback);
-            }
-        }, {
-            key: 'length',
-            value: function length(callback) {
-                return this.collectionReady().then(function (collection) {
-                    return collection.countAsync({});
-                }).asCallback(callback);
-            }
-        }, {
-            key: 'clear',
-            value: function clear(callback) {
-                return this.collectionReady().then(function (collection) {
-                    return collection.dropAsync();
-                }).asCallback(callback);
-            }
-        }, {
-            key: 'close',
-            value: function close() {
-                if (this.db) {
-                    this.db.close();
-                }
-            }
-        }]);
-
-        return MongoStore;
-    }(Store);
-
-    return MongoStore;
-};
\ No newline at end of file