connect-memcached 0.0.3 → 1.0.0

package/.npmignore

@@ -1,4 +1,2 @@
-support
-test
-examples
-*.sock
+.idea
+node_modules

package/LICENSE

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2011-2014 Michał Thoma <michal@balor.pl>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/Readme.md

@@ -1,71 +1,81 @@
-
 # connect-memcached
 
-  Memcached session store, using [node-memcached](http://github.com/3rd-Eden/node-memcached) for communication with cache server.
+Memcached session store, using [node-memcached](http://github.com/3rd-Eden/node-memcached) for communication with cache server.
 
 ## Installation
 
-  via npm:
+via npm:
 
-      $ npm install connect-memcached
+```bash
+$ npm install connect-memcached
+```
 
 ## Example
 
-      /**
-      * Module dependencies.
-      */
-
-      var express = require('express');
-
-      // pass the express to the connect memcached module
-      // allowing it to inherit from express.session.Store
-      var MemcachedStore = require('connect-memcached')(express);
-
-      var app = express.createServer();
+```javascript
+var express = require("express"),
+  session = require("express-session"),
+  cookieParser = require("cookie-parser"),
+  http = require("http"),
+  app = express(),
+  MemcachedStore = require("connect-memcached")(session);
+
+app.use(cookieParser());
+app.use(
+  session({
+    secret: "CatOnKeyboard",
+    key: "test",
+    proxy: "true",
+    resave: false,
+    saveUninitialized: false,
+    store: new MemcachedStore({
+      hosts: ["127.0.0.1:11211"],
+      secret: "123, easy as ABC. ABC, easy as 123" // Optionally use transparent encryption for memcache session data
+    })
+  })
+);
+
+app.get("/", function(req, res) {
+  if (req.session.views) {
+    ++req.session.views;
+  } else {
+    req.session.views = 1;
+  }
+  res.send("Viewed <strong>" + req.session.views + "</strong> times.");
+});
+
+http.createServer(app).listen(9341, function() {
+  console.log("Listening on %d", this.address().port);
+});
+```
 
-      app.use(express.favicon());
-
-      // request logging
-      app.use(express.logger());
+## Options
 
-      // required to parse the session cookie
-      app.use(express.cookieParser());
+- `hosts` Memcached servers locations, can be string, array, hash.
+- `prefix` An optional prefix for each memcache key, in case you are sharing your memcached servers with something generating its own keys.
+- `ttl` An optional parameter used for setting the default TTL (in seconds)
+- `secret` An optional secret can be used to encrypt/decrypt session contents.
+- `algorithm` An optional algorithm parameter may be used, but must be valid based on returned `crypto.getCiphers()`. The current default is `aes-256-ctr` and was chosen based on the following [information](http://www.daemonology.net/blog/2009-06-11-cryptographic-right-answers.html)
+- ... Rest of given option will be passed directly to the node-memcached constructor.
 
-      // Populates:
-      // - req.session
-      // - req.sessionStore
-      // - req.sessionID (or req.session.id)
+For details see [node-memcached](http://github.com/3rd-Eden/node-memcached).
 
-      app.use(express.session({ 
-        secret: 'CatOnTheKeyboard', 
-        store: new MemcachedStore 
-      }));
+## Upgrading from v0.x.x -> v1.x.x
 
-      app.get('/', function(req, res){
-        if (req.session.views) {
-          ++req.session.views;
-        } else {
-          req.session.views = 1;
-        }
-        res.send('Viewed <strong>' + req.session.views + '</strong> times.');
-      });
+If You're upgrading from the pre v1.0.0 version of this library and use encryption for session data be sure to **remove all session entries created with previous version**. 
 
-      app.listen(3000);
-      console.log('Express app started on port 3000');
+Upgrading library without taking appropriate action will result in `SyntaxError` exceptions during JSON parsing of decoded entries. 
 
-## Options
+Sessions without encryption are not affected.
 
-    - `hosts` Memcached servers locations, can by string, array, hash.
-    - ...     Rest of given option will be passed directly to the node-memcached constructor.
+## Contributors
 
-  For details see [node-memcached](http://github.com/3rd-Eden/node-memcached).
+Big thanks for the contributors! See the actual list [here](https://github.com/balor/connect-memcached/graphs/contributors)!
 
-## License 
+## License
 
 (The MIT License)
 
-Copyright (c) 2011 Michał Thoma &lt;michal@balor.pl&gt;
-
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
 'Software'), to deal in the Software without restriction, including

package/lib/connect-memcached.js

@@ -1,46 +1,27 @@
-
 /*!
  * connect-memcached
- * Copyright(c) 2012 Michał Thoma <michal@balor.pl>
  * MIT Licensed
  */
+const bufferFrom = require('buffer-from');
 
-/**
- * Library version.
- */
-
-exports.version = '0.0.3';
-
-
-/**
- * Module dependencies.
- */
-
-var Memcached = require('memcached');
-
-/**
- * One day in seconds.
- */
-
+var Memcached = require("memcached");
 var oneDay = 86400;
 
-
+function ensureCallback(fn) {
+  return function() {
+    fn && fn.apply(null, arguments);
+  };
+}
 
 /**
  * Return the `MemcachedStore` extending `connect`'s session Store.
- * 
- * @param {object} connect
+ *
+ * @param {object} session
  * @return {Function}
  * @api public
  */
-
-module.exports = function(connect){
-
-  /**
-   * Connect's Store.
-   */
-
-  var Store = connect.session.Store;
+module.exports = function(session) {
+  var Store = session.Store;
 
   /**
    * Initialize MemcachedStore with the given `options`.
@@ -48,47 +29,70 @@ module.exports = function(connect){
    * @param {Object} options
    * @api public
    */
-
   function MemcachedStore(options) {
     options = options || {};
     Store.call(this, options);
-    if (!options.hosts) {
-        options.hosts = '127.0.0.1:11211';
+
+    this.prefix = options.prefix || "";
+    this.ttl = options.ttl;
+    if (!options.client) {
+      if (!options.hosts) {
+        options.hosts = "127.0.0.1:11211";
+      }
+      if (options.secret) {
+        (this.crypto = require("crypto")), (this.secret = options.secret);
+      }
+      if (options.algorithm) {
+        this.algorithm = options.algorithm;
+      }
+
+      options.client = new Memcached(options.hosts, options);
     }
-    this.client = new Memcached(options.hosts, options);
-    console.log("MemcachedStore initialized for servers: " + options.hosts);
 
-    this.client.on("issue", function(issue) {
-        console.log("MemcachedStore::Issue @ " + issue.server + ": " + 
-            issue.messages + ", " + issue.retries  + " attempts left");
-    });
-  };
+    this.client = options.client;
+  }
+
+  MemcachedStore.prototype.__proto__ = Store.prototype;
 
   /**
-   * Inherit from `Store`.
+   * Translates the given `sid` into a memcached key, optionally with prefix.
+   *
+   * @param {String} sid
+   * @api private
    */
-
-  MemcachedStore.prototype.__proto__ = Store.prototype;
+  MemcachedStore.prototype.getKey = function getKey(sid) {
+    return this.prefix + sid;
+  };
 
   /**
    * Attempt to fetch session by the given `sid`.
-   * 
+   *
    * @param {String} sid
    * @param {Function} fn
    * @api public
    */
-
   MemcachedStore.prototype.get = function(sid, fn) {
-      this.client.get(sid, function(err, data) {
-          try {
-              if (!data) {
-                 return fn();
-              }
-              fn(null, JSON.parse(data.toString()));
-          } catch (err) {
-              fn(err);
-          } 
-      });
+    (secret = this.secret), (self = this), (sid = this.getKey(sid));
+
+    this.client.get(sid, function(err, data) {
+      if (err) {
+        return fn(err, {});
+      }
+      try {
+        if (!data) {
+          return fn();
+        }
+        if (secret) {
+          parseable_string = decryptData.call(self, data.toString());
+        } else {
+          parseable_string = data.toString();
+        }
+
+        fn(null, JSON.parse(parseable_string));
+      } catch (e) {
+        fn(e);
+      }
+    });
   };
 
   /**
@@ -99,30 +103,40 @@ module.exports = function(connect){
    * @param {Function} fn
    * @api public
    */
-
   MemcachedStore.prototype.set = function(sid, sess, fn) {
-      try {
-          var maxAge = sess.cookie.maxAge
-          var ttl = 'number' == typeof maxAge ? maxAge / 1000 | 0 : oneDay
-          var sess = JSON.stringify(sess);
-
-          this.client.set(sid, sess, ttl, function() {
-              fn && fn.apply(this, arguments);
-          });
-      } catch (err) {
-          fn && fn(err);
-      } 
+    sid = this.getKey(sid);
+
+    try {
+      var maxAge = sess.cookie.maxAge;
+      var ttl =
+        this.ttl || ("number" == typeof maxAge ? (maxAge / 1000) | 0 : oneDay);
+      var sess = JSON.stringify(
+        this.secret
+          ? encryptData.call(
+              this,
+              JSON.stringify(sess),
+              this.secret,
+              this.algorithm
+            )
+          : sess
+      );
+
+      this.client.set(sid, sess, ttl, ensureCallback(fn));
+    } catch (err) {
+      fn && fn(err);
+    }
   };
 
   /**
    * Destroy the session associated with the given `sid`.
-   * 
+   *
    * @param {String} sid
+   * @param {Function} fn
    * @api public
    */
-
   MemcachedStore.prototype.destroy = function(sid, fn) {
-        this.client.del(sid, fn);
+    sid = this.getKey(sid);
+    this.client.del(sid, ensureCallback(fn));
   };
 
   /**
@@ -131,21 +145,97 @@ module.exports = function(connect){
    * @param {Function} fn
    * @api public
    */
-
   MemcachedStore.prototype.length = function(fn) {
-        this.client.items(fn);
+    this.client.items(ensureCallback(fn));
   };
 
   /**
    * Clear all sessions.
-   * 
+   *
    * @param {Function} fn
    * @api public
-   */ 
-
+   */
   MemcachedStore.prototype.clear = function(fn) {
-        this.client.flush(fn);
+    this.client.flush(ensureCallback(fn));
   };
 
+  /**
+   * Refresh the time-to-live for the session with the given `sid`.
+   *
+   * @param {String} sid
+   * @param {Session} sess
+   * @param {Function} fn
+   * @api public
+   */
+
+  MemcachedStore.prototype.touch = function(sid, sess, fn) {
+    this.set(sid, sess, fn);
+  };
+
+  function encryptData(plaintext) {
+    var pt = encrypt.call(this, this.secret, plaintext, this.algo),
+      hmac = digest.call(this, this.secret, pt);
+
+    return {
+      ct: pt,
+      mac: hmac
+    };
+  }
+
+  function decryptData(ciphertext) {
+    ciphertext = JSON.parse(ciphertext);
+
+    var hmac = digest.call(this, this.secret, ciphertext.ct);
+
+    if (hmac != ciphertext.mac) {
+      throw "Encrypted session was tampered with!";
+    }
+
+    return decrypt.call(this, this.secret, ciphertext.ct, this.algo);
+  }
+
+  function digest(key, obj) {
+    var hmac = this.crypto.createHmac("sha512", key);
+    hmac.setEncoding("hex");
+    hmac.write(obj);
+    hmac.end();
+    return hmac.read();
+  }
+
+  function encrypt(key, pt, algo) {
+    algo = algo || "aes-256-ctr";
+    pt = Buffer.isBuffer(pt) ? pt : new bufferFrom(pt);
+    var iv = this.crypto.randomBytes(16);
+    var hashedKey = this.crypto
+      .createHash("sha256")
+      .update(key)
+      .digest();
+    var cipher = this.crypto.createCipheriv(algo, hashedKey, iv),
+      ct = [];
+    ct.push(iv.toString("hex"));
+    ct.push(cipher.update(pt, "buffer", "hex"));
+    ct.push(cipher.final("hex"));
+
+    return ct.join("");
+  }
+
+  function decrypt(key, ct, algo) {
+    algo = algo || "aes-256-ctr";
+    var dataBuffer = bufferFrom(ct, "hex");
+    var iv = dataBuffer.slice(0, 16);
+    var hashedKey = this.crypto
+      .createHash("sha256")
+      .update(key)
+      .digest();
+
+    var cipher = this.crypto.createDecipheriv(algo, hashedKey, iv),
+      pt = [];
+
+    pt.push(cipher.update(dataBuffer.slice(16), "hex", "utf8"));
+    pt.push(cipher.final("utf8"));
+
+    return pt.join("");
+  }
+
   return MemcachedStore;
 };

package/package.json

@@ -1,16 +1,28 @@
 {
-    "name": "connect-memcached"
-  , "version": "0.0.3"
-  , "description": "Memcached session store for Connect"
-  , "keywords": ["memcached", "connection", "session", "store", "cache"]
-  , "author": "Michał Thoma <michal@balor.pl>"
-  , "repository": {
+  "name": "connect-memcached",
+  "version": "1.0.0",
+  "description": "Memcached session store for Connect",
+  "keywords": [
+    "memcached",
+    "connection",
+    "session",
+    "store",
+    "cache"
+  ],
+  "author": "Michał Thoma <me@balor.pl>",
+  "repository": {
     "type": "git",
     "url": "https://github.com/balor/connect-memcached"
+  },
+  "dependencies": {
+    "buffer-from": "1.1.0",
+    "memcached": "2.2.x"
+  },
+  "engines": {
+    "node": ">= 0.10.0"
+  },
+  "license": "MIT",
+  "directories": {
+    "lib": "./lib"
   }
-  , "dependencies": { "memcached": ">= 0.0.1" }
-  , "devDependencies": { "connect": ">= 1.4.x" }
-  , "main": "index"
-  , "engines": { "node": ">=0.4.7" }
-  , "directories": { "lib": "./lib" }
 }

package/tests/test.js

@@ -0,0 +1,34 @@
+var express = require("express"),
+  session = require("express-session"),
+  cookieParser = require("cookie-parser"),
+  http = require("http"),
+  app = express(),
+  MemcachedStore = require("../lib/connect-memcached")(session);
+
+app.use(cookieParser());
+app.use(
+  session({
+    secret: "TestSecret",
+    key: "test",
+    proxy: "true",
+    resave: false,
+    saveUninitialized: false,
+    store: new MemcachedStore({
+      hosts: ["127.0.0.1:11211"],
+      prefix: "testapp_"
+    })
+  })
+);
+
+app.get("/", function(req, res) {
+  if (req.session.views) {
+    ++req.session.views;
+  } else {
+    req.session.views = 1;
+  }
+  res.send("Viewed <strong>" + req.session.views + "</strong> times.");
+});
+
+http.createServer(app).listen(9341, function() {
+  console.log("Listening on %d", this.address().port);
+});

package/tests/test_encrypt.js

@@ -0,0 +1,35 @@
+var express = require("express"),
+  session = require("express-session"),
+  cookieParser = require("cookie-parser"),
+  http = require("http"),
+  app = express(),
+  MemcachedStore = require("../lib/connect-memcached")(session);
+
+app.use(cookieParser());
+app.use(
+  session({
+    secret: "TestEncryptSecret",
+    key: "test_encrypt",
+    proxy: "true",
+    resave: false,
+    saveUninitialized: false,
+    store: new MemcachedStore({
+      hosts: ["127.0.0.1:11211"],
+      secret: "Hello there stranger!",
+      prefix: "testapp_encrypt_"
+    })
+  })
+);
+
+app.get("/", function(req, res) {
+  if (req.session.views) {
+    ++req.session.views;
+  } else {
+    req.session.views = 1;
+  }
+  res.send("Viewed <strong>" + req.session.views + "</strong> times.");
+});
+
+http.createServer(app).listen(9341, function() {
+  console.log("Listening on %d", this.address().port);
+});

package/History.md

@@ -1,14 +0,0 @@
-0.0.3 / 2012-03-06
-==================
-
-  * Rewritten the module due to npm 1.x changes (we now need to pass connect to the function connect-memcached exports in order to extend connect.session.Store:
-
-0.0.2 / 2010-01-03
-==================
-
-  * Created basic version that actually works
-
-0.0.1 / 2010-01-03
-==================
-
-  * Initial release

package/Makefile

@@ -1,2 +0,0 @@
-doc.json: lib/connect-memcached.js
-	dox < $< > $@

package/doc.json

@@ -1,333 +0,0 @@
-[
-  {
-    "tags": [],
-    "description": {
-      "full": "<p>connect-memcached<br />Copyright(c) 2012 Michał Thoma <a href=\"&#109;&#x61;&#x69;l&#116;o:&#x6D;&#105;&#x63;&#104;&#97;&#108;&#64;&#x62;&#97;&#108;&#111;&#114;&#x2E;&#112;&#x6C;\">&#x6D;&#105;&#x63;&#104;&#97;&#108;&#64;&#x62;&#97;&#108;&#111;&#114;&#x2E;&#112;&#x6C;</a><br />MIT Licensed</p>",
-      "summary": "<p>connect-memcached<br />Copyright(c) 2012 Michał Thoma <a href=\"&#109;&#97;&#x69;l&#116;&#x6F;:&#x6D;&#105;&#99;&#104;&#x61;&#x6C;&#x40;&#98;&#97;&#108;&#111;&#x72;&#46;&#x70;&#x6C;\">&#x6D;&#105;&#99;&#104;&#x61;&#x6C;&#x40;&#98;&#97;&#108;&#111;&#x72;&#46;&#x70;&#x6C;</a><br />MIT Licensed</p>",
-      "body": ""
-    },
-    "ignore": true
-  },
-  {
-    "tags": [],
-    "description": {
-      "full": "<p>Library version.</p>",
-      "summary": "<p>Library version.</p>",
-      "body": ""
-    },
-    "ignore": false,
-    "code": "exports.version = '0.0.3';",
-    "ctx": {
-      "type": "property",
-      "receiver": "exports",
-      "name": "version",
-      "value": "'0.0.3'",
-      "string": "exports.version"
-    }
-  },
-  {
-    "tags": [],
-    "description": {
-      "full": "<p>Module dependencies.</p>",
-      "summary": "<p>Module dependencies.</p>",
-      "body": ""
-    },
-    "ignore": false,
-    "code": "var Memcached = require('memcached');",
-    "ctx": {
-      "type": "declaration",
-      "name": "Memcached",
-      "value": "require('memcached')",
-      "string": "Memcached"
-    }
-  },
-  {
-    "tags": [],
-    "description": {
-      "full": "<p>One day in seconds.</p>",
-      "summary": "<p>One day in seconds.</p>",
-      "body": ""
-    },
-    "ignore": false,
-    "code": "var oneDay = 86400;",
-    "ctx": {
-      "type": "declaration",
-      "name": "oneDay",
-      "value": "86400",
-      "string": "oneDay"
-    }
-  },
-  {
-    "tags": [
-      {
-        "type": "param",
-        "types": [
-          "object"
-        ],
-        "name": "connect",
-        "description": ""
-      },
-      {
-        "type": "return",
-        "types": [
-          "Function"
-        ],
-        "description": ""
-      },
-      {
-        "type": "api",
-        "visibility": "public"
-      }
-    ],
-    "description": {
-      "full": "<p>Return the <code>MemcachedStore</code> extending <code>connect</code>'s session Store.</p>",
-      "summary": "<p>Return the <code>MemcachedStore</code> extending <code>connect</code>'s session Store.</p>",
-      "body": ""
-    },
-    "isPrivate": false,
-    "ignore": false,
-    "code": "module.exports = function(connect){",
-    "ctx": {
-      "type": "method",
-      "receiver": "module",
-      "name": "exports",
-      "string": "module.exports()"
-    }
-  },
-  {
-    "tags": [],
-    "description": {
-      "full": "<p>Connect's Store.</p>",
-      "summary": "<p>Connect's Store.</p>",
-      "body": ""
-    },
-    "ignore": false,
-    "code": "var Store = connect.session.Store;",
-    "ctx": {
-      "type": "declaration",
-      "name": "Store",
-      "value": "connect.session.Store",
-      "string": "Store"
-    }
-  },
-  {
-    "tags": [
-      {
-        "type": "param",
-        "types": [
-          "Object"
-        ],
-        "name": "options",
-        "description": ""
-      },
-      {
-        "type": "api",
-        "visibility": "public"
-      }
-    ],
-    "description": {
-      "full": "<p>Initialize MemcachedStore with the given <code>options</code>.</p>",
-      "summary": "<p>Initialize MemcachedStore with the given <code>options</code>.</p>",
-      "body": ""
-    },
-    "isPrivate": false,
-    "ignore": false,
-    "code": "function MemcachedStore(options) {\n    options = options || {};\n    Store.call(this, options);\n    if (!options.hosts) {\n        options.hosts = '127.0.0.1:11211';\n    }\n    this.client = new Memcached(options.hosts, options);\n    console.log(\"MemcachedStore initialized for servers: \" + options.hosts);\n\n    this.client.on(\"issue\", function(issue) {\n        console.log(\"MemcachedStore::Issue @ \" + issue.server + \": \" + \n            issue.messages + \", \" + issue.retries  + \" attempts left\");\n    });\n  };",
-    "ctx": {
-      "type": "function",
-      "name": "MemcachedStore",
-      "string": "MemcachedStore()"
-    }
-  },
-  {
-    "tags": [],
-    "description": {
-      "full": "<p>Inherit from <code>Store</code>.</p>",
-      "summary": "<p>Inherit from <code>Store</code>.</p>",
-      "body": ""
-    },
-    "ignore": false,
-    "code": "MemcachedStore.prototype.__proto__ = Store.prototype;",
-    "ctx": {
-      "type": "property",
-      "constructor": "MemcachedStore",
-      "name": "__proto__",
-      "value": "Store.prototype",
-      "string": "MemcachedStore.prototype__proto__"
-    }
-  },
-  {
-    "tags": [
-      {
-        "type": "param",
-        "types": [
-          "String"
-        ],
-        "name": "sid",
-        "description": ""
-      },
-      {
-        "type": "param",
-        "types": [
-          "Function"
-        ],
-        "name": "fn",
-        "description": ""
-      },
-      {
-        "type": "api",
-        "visibility": "public"
-      }
-    ],
-    "description": {
-      "full": "<p>Attempt to fetch session by the given <code>sid</code>.</p>",
-      "summary": "<p>Attempt to fetch session by the given <code>sid</code>.</p>",
-      "body": ""
-    },
-    "isPrivate": false,
-    "ignore": false,
-    "code": "MemcachedStore.prototype.get = function(sid, fn) {\n      this.client.get(sid, function(err, data) {\n          try {\n              if (!data) {\n                 return fn();\n              }\n              fn(null, JSON.parse(data.toString()));\n          } catch (err) {\n              fn(err);\n          } \n      });\n  };",
-    "ctx": {
-      "type": "method",
-      "constructor": "MemcachedStore",
-      "name": "get",
-      "string": "MemcachedStore.prototype.get()"
-    }
-  },
-  {
-    "tags": [
-      {
-        "type": "param",
-        "types": [
-          "String"
-        ],
-        "name": "sid",
-        "description": ""
-      },
-      {
-        "type": "param",
-        "types": [
-          "Session"
-        ],
-        "name": "sess",
-        "description": ""
-      },
-      {
-        "type": "param",
-        "types": [
-          "Function"
-        ],
-        "name": "fn",
-        "description": ""
-      },
-      {
-        "type": "api",
-        "visibility": "public"
-      }
-    ],
-    "description": {
-      "full": "<p>Commit the given <code>sess</code> object associated with the given <code>sid</code>.</p>",
-      "summary": "<p>Commit the given <code>sess</code> object associated with the given <code>sid</code>.</p>",
-      "body": ""
-    },
-    "isPrivate": false,
-    "ignore": false,
-    "code": "MemcachedStore.prototype.set = function(sid, sess, fn) {\n      try {\n          var maxAge = sess.cookie.maxAge\n          var ttl = 'number' == typeof maxAge ? maxAge / 1000 | 0 : oneDay\n          var sess = JSON.stringify(sess);\n\n          this.client.set(sid, sess, ttl, function() {\n              fn && fn.apply(this, arguments);\n          });\n      } catch (err) {\n          fn && fn(err);\n      } \n  };",
-    "ctx": {
-      "type": "method",
-      "constructor": "MemcachedStore",
-      "name": "set",
-      "string": "MemcachedStore.prototype.set()"
-    }
-  },
-  {
-    "tags": [
-      {
-        "type": "param",
-        "types": [
-          "String"
-        ],
-        "name": "sid",
-        "description": ""
-      },
-      {
-        "type": "api",
-        "visibility": "public"
-      }
-    ],
-    "description": {
-      "full": "<p>Destroy the session associated with the given <code>sid</code>.</p>",
-      "summary": "<p>Destroy the session associated with the given <code>sid</code>.</p>",
-      "body": ""
-    },
-    "isPrivate": false,
-    "ignore": false,
-    "code": "MemcachedStore.prototype.destroy = function(sid, fn) {\n        this.client.del(sid, fn);\n  };",
-    "ctx": {
-      "type": "method",
-      "constructor": "MemcachedStore",
-      "name": "destroy",
-      "string": "MemcachedStore.prototype.destroy()"
-    }
-  },
-  {
-    "tags": [
-      {
-        "type": "param",
-        "types": [
-          "Function"
-        ],
-        "name": "fn",
-        "description": ""
-      },
-      {
-        "type": "api",
-        "visibility": "public"
-      }
-    ],
-    "description": {
-      "full": "<p>Fetch number of sessions.</p>",
-      "summary": "<p>Fetch number of sessions.</p>",
-      "body": ""
-    },
-    "isPrivate": false,
-    "ignore": false,
-    "code": "MemcachedStore.prototype.length = function(fn) {\n        this.client.items(fn);\n  };",
-    "ctx": {
-      "type": "method",
-      "constructor": "MemcachedStore",
-      "name": "length",
-      "string": "MemcachedStore.prototype.length()"
-    }
-  },
-  {
-    "tags": [
-      {
-        "type": "param",
-        "types": [
-          "Function"
-        ],
-        "name": "fn",
-        "description": ""
-      },
-      {
-        "type": "api",
-        "visibility": "public"
-      }
-    ],
-    "description": {
-      "full": "<p>Clear all sessions.</p>",
-      "summary": "<p>Clear all sessions.</p>",
-      "body": ""
-    },
-    "isPrivate": false,
-    "ignore": false,
-    "code": "MemcachedStore.prototype.clear = function(fn) {\n        this.client.flush(fn);\n  };\n\n  return MemcachedStore;\n};",
-    "ctx": {
-      "type": "method",
-      "constructor": "MemcachedStore",
-      "name": "clear",
-      "string": "MemcachedStore.prototype.clear()"
-    }
-  }
-]

package/lib/_connect-memcached.js

@@ -1,133 +0,0 @@
-
-/*!
- * connect-memcached
- * Copyright(c) 2011 Michał Thoma <michal@balor.pl>
- * MIT Licensed
- */
-
-/**
- * Library version.
- */
-
-exports.version = '0.0.3';
-
-
-/**
- * Module dependencies.
- */
-
-var Store = require('connect').session.Store;
-var Memcached = require('memcached');
-
-/**
- * One day in seconds.
- */
-
-var oneDay = 86400;
-
-
-
-/**
- * Initialize MemcachedStore with the given `options`.
- * 
- * @param {Object} options
- * @api public
- */
-
-var MemcachedStore = module.exports = function MemcachedStore(options) {
-    options = options || {};
-    Store.call(this, options);
-    if (!options.hosts) {
-        options.hosts = '127.0.0.1:11211';
-    }
-    this.client = new Memcached(options.hosts, options);
-    console.log("MemcachedStore initialized for servers: " + options.hosts);
-
-    this.client.on("issue", function(issue) {
-        console.log("MemcachedStore::Issue @ " + issue.server + ": " + 
-            issue.messages + ", " + issue.retries  + " attempts left");
-    });
-};
-
-/**
- * Inherit from `Store`.
- */
-
-MemcachedStore.prototype.__proto__ = Store.prototype;
-
-/**
- * Attempt to fetch session by the given `sid`.
- * 
- * @param {String} sid
- * @param {Function} fn
- * @api public
- */
-
-MemcachedStore.prototype.get = function(sid, fn) {
-    this.client.get(sid, function(err, data) {
-        try {
-            if (!data) {
-               return fn();
-            }
-            fn(null, JSON.parse(data.toString()));
-        } catch (err) {
-            fn(err);
-        } 
-    });
-};
-
-/**
- * Commit the given `sess` object associated with the given `sid`.
- *
- * @param {String} sid
- * @param {Session} sess
- * @param {Function} fn
- * @api public
- */
-
-MemcachedStore.prototype.set = function(sid, sess, fn) {
-    try {
-        var maxAge = sess.cookie.maxAge
-        var ttl = 'number' == typeof maxAge ? maxAge / 1000 | 0 : oneDay
-        var sess = JSON.stringify(sess);
-
-        this.client.set(sid, sess, ttl, function() {
-            fn && fn.apply(this, arguments);
-        });
-    } catch (err) {
-        fn && fn(err);
-    } 
-};
-
-/**
- * Destroy the session associated with the given `sid`.
- * 
- * @param {String} sid
- * @api public
- */
-
-MemcachedStore.prototype.destroy = function(sid, fn) {
-      this.client.del(sid, fn);
-};
-
-/**
- * Fetch number of sessions.
- *
- * @param {Function} fn
- * @api public
- */
-
-MemcachedStore.prototype.length = function(fn) {
-      this.client.items(fn);
-};
-
-/**
- * Clear all sessions.
- * 
- * @param {Function} fn
- * @api public
- */ 
-
-MemcachedStore.prototype.clear = function(fn) {
-      this.client.flush(fn);
-};