Merge branch 'master' of https://github.com/HumairAK/solutions_repo

1 files changed, 372 insertions, 0 deletions

diff --git a/node_modules/connect-mongo/src-es5/index.js b/node_modules/connect-mongo/src-es5/index.js
new file mode 100644
index 0000000..eaa929c
--- /dev/null
+++ b/node_modules/connect-mongo/src-es5/index.js
@@ -0,0 +1,372 @@
+'use strict';
+
+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;
+
+                switch (this.autoRemove) {
+                    case 'native':
+                        return this.collection.ensureIndexAsync({ expires: 1 }, { expireAfterSeconds: 0 });
+                    case 'interval':
+                        var removeQuery = { expires: { $lt: new Date() } };
+                        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', 'update', 'ensureIndex'].forEach(function (method) {
+                    collection[method + 'Async'] = Promise.promisify(collection[method], collection);
+                });
+
+                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;
+                    }
+                }).nodeify(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;
+
+                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 () {
+                    return _this6.emit('set', sid);
+                }).nodeify(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);
+                    }
+                }).nodeify(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);
+                }).nodeify(callback);
+            }
+        }, {
+            key: 'length',
+            value: function length(callback) {
+                return this.collectionReady().then(function (collection) {
+                    return collection.countAsync({});
+                }).nodeify(callback);
+            }
+        }, {
+            key: 'clear',
+            value: function clear(callback) {
+                return this.collectionReady().then(function (collection) {
+                    return collection.dropAsync();
+                }).nodeify(callback);
+            }
+        }, {
+            key: 'close',
+            value: function close() {
+                if (this.db) {
+                    this.db.close();
+                }
+            }
+        }]);
+
+        return MongoStore;
+    }(Store);
+
+    return MongoStore;
+};
\ No newline at end of file