deployd/lib/session.js

var Store = require('./db').Store
, util = require('util')
,	uuid = require('./util/uuid')
, Cookies = require('cookies')
, EventEmitter = require('events').EventEmitter
, debug = require('debug')('session');

/*!
* A simple index for storing sesssions in memory.
*/

var sessionIndex = {}
  , userSessionIndex = {};

/**
* A store for persisting sessions inbetween connection / disconnection. 
* Automatically creates session IDs on inserted objects.
*/

function SessionStore(namespace, db, sockets) {
  this.sockets = sockets;

  // socket queue
  var socketQueue = this.socketQueue = new EventEmitter()
    , socketIndex = this.socketIndex = {};

  // TODO - sockets.on('connection', ...) - map to a session id based on socket.handshake.headers
  sockets && sockets.on('connection', function (socket) {
    // NOTE: do not use set here ever, the `Cookies` api is meant to get a req, res
    // but we are just using it for a cookie parser
    var cookies = new Cookies(socket.handshake)
      , sid = cookies.get('sid');

    if(sid) {
      // index sockets against their session id
      socketIndex[sid] = socket;
      socketQueue.emit(sid, socket);
    }
  });

  Store.apply(this, arguments);
}
util.inherits(SessionStore, Store);
exports.SessionStore = SessionStore;

SessionStore.prototype.createUniqueIdentifier = function() {
  return uuid.create(128);
};

/**
* Create a new `Session` based on an optional `sid` (session id).
*
* @param {String} sid
* @param {Function} callback(err, session)
*/

SessionStore.prototype.createSession = function(sid, fn) {
  var socketIndex = this.socketIndex
    , store = this;

  if(typeof sid == 'function') {
    fn = sid;
    sid = undefined;
  }
  if(sid) {
    this.find({id: sid}, function(err, s) {
      if(err) return fn(err);
      if(!s) {
        store.insert({id: sid}, function(err, s) {
          if(err) console.error(err);
        });
      }
      var sess = sessionIndex[sid] || new Session(s, store, socketIndex, store.sockets);
      sessionIndex[sid] = sess;
      // index sessions by user
      if(s && s.uid) {
        userSessionIndex[s.uid] = sess;
      }
      fn(err, sess);
    });
  } else {
    sid = this.createUniqueIdentifier();
    var sess = sessionIndex[sid] = new Session({id: sid}, this, socketIndex, store.sockets);
    fn(null, sess);
    this.insert({id: sid}, function(err, s) {
      if(err) console.error(err);
    });
  }
};

/**
* An in memory representation of a client or user connection that can be saved to disk.
* Data will be passed around via a `Context` to resources.
* 
* Example:
* 
*    var session = new Session({id: 'my-sid', new SessionStore('sessions', db)});
*
*    session.set({uid: 'my-uid'}).save();
*
* @param {Object} data
* @param {Store} store
* @param {Socket} socket
*/

function Session(data, store, sockets, rawSockets) {
  this.data = data;
  if(data && data.id) this.sid = data.id;
  this.store = store;

  // create faux socket, to queue any events until
  // a real socket is available
  var socketWrapper = this.socket = {
    on: function () {
      // if we have a real socket, use it
      if(this._socket) {
        this._socket.apply(this._socket, arguments);
      } else {
        // otherwise add to bind queue
        var queue = this._bindQueue = this._bindQueue || [];
        queue.push(arguments);
      }
    },
    emit: function () {
      // if we have a real socket, use it
      if(this._socket) {
        this._socket.emit.apply(this._socket, arguments);
      } else {
        // otherwise add to bind queue
        var queue = this._emitQueue = this._bindQueue || [];
        queue.push(arguments);
      }
    },
    _socket: sockets[this.sid]
  };

  this.emitToUsers = function(collection, query, event, data) {
    collection.get(query, function(users) {
      var userSession;
      // TODO: arguments in weird order
      if(users && users.id) {
        userSession = userSessionIndex[err.id];
        console.info(userSession);
        if(userSession && userSession.socket) {
          userSession.socket.emit(event, data);
        }
        return;
      }
      users.forEach(function(u) {
        userSession = userSessionIndex[u.id];

        // emit to sessions online
        if(userSession && userSession.socket) {
          userSession.socket.emit(event, data);
        }
      });
    });
  };

  this.emitToAll = function() {
    rawSockets.emit.apply(rawSockets, arguments);
  };

  // resolve queue once a socket is ready
  store.socketQueue.once(this.sid, function (socket) {
    socketWrapper._socket = socket;
    // drain bind queue
    if(socketWrapper._bindQueue && socketWrapper._bindQueue.length) {
      socketWrapper._bindQueue.forEach(function (args) {
        socket.on.apply(socket, args);
      });
    }
    // drain emit queue
    if(socketWrapper._emitQueue && socketWrapper._emitQueue.length) {
      socketWrapper._emitQueue.forEach(function (args) {
        socket.emit.apply(socket, args);
      });
    }
  });
}

/**
* Set properties on the in memory representation of a session.
*
* @param {Object} changes
* @return {Session} this for chaining
*/

Session.prototype.set = function(object) {
  var session = this
    , data = session.data || (session.data = {});


  Object.keys(object).forEach(function(key) {
    data[key] = object[key];
  });
  return this;
};

/**
* Save the in memory representation of a session to its store.
*
* @param {Function} callback(err, data)
* @return {Session} this for chaining
*/

Session.prototype.save = function(fn) {
  var session = this
    , data = this.data
    , query = {id: data.id};

  session.remove(function (err) {
    if(err) return fn(err);
    session.store.insert(data, function (err, res) {
      fn(err, res);
    });
  });
  return this;
};

/**
* Reset the session using the data in its store. 
*
* @param {Function} callback(err, data)
* @return {Session} this for chaining
*/

Session.prototype.fetch = function(fn) {
  var session = this;
  this.store.first({id: this.data.id}, function (err, data) {
    session.set(data);
    fn(err, data);
  });
  return this;
};

/**
* Remove the session.
*
* @param {Function} callback(err, data)
* @return {Session} this for chaining
*/

Session.prototype.remove = function(fn) {
  var session = this;
  debug('Removing %s', this.data.id);

  delete sessionIndex[this.data.id];
  delete userSessionIndex[this.data.uid]; // TODO: Don't delete all of a user's sessions
  delete session.store.socketIndex[this.data.id];

  this.store.remove({id: this.data.id}, fn);

  return this;
};