connect-memcached 1.0.0 → 3.0.0

package/Readme.md

@@ -4,10 +4,16 @@ Memcached session store, using [node-memcached](http://github.com/3rd-Eden/node-
 
 ## Installation
 
-via npm:
+npm:
 
-```bash
-$ npm install connect-memcached
+```shell
+npm install connect-memcached express-session
+```
+
+yarn:
+
+```shell
+yarn add connect-memcached express-session
 ```
 
 ## Example
@@ -15,12 +21,9 @@ $ npm install connect-memcached
 ```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",
@@ -30,7 +33,7 @@ app.use(
     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
+      secret: "Xj8$kLp2@Qa9#Zt5!" // Optionally use transparent encryption for memcached session data (must meet complexity requirements)
     })
   })
 );
@@ -44,21 +47,53 @@ app.get("/", function(req, res) {
   res.send("Viewed <strong>" + req.session.views + "</strong> times.");
 });
 
-http.createServer(app).listen(9341, function() {
+app.listen(9341, function() {
   console.log("Listening on %d", this.address().port);
 });
 ```
 
 ## Options
 
-- `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.
+- `hosts` (Optional) Memcached servers locations, can be string, array or hash. Default is `127.0.0.1:11211`.
+- `prefix` (Optional) Prefix for each memcached key, in case you are sharing your memcached servers with something generating its own keys.
+- `ttl` (Optional) Default TTL parameter for the session data (in seconds).
+- `secret` (Optional) Secret used to encrypt/decrypt session contents. Setting it enables data encryption, which is handled by [kruptein](https://github.com/jas-/kruptein) module.
+- `algorithm` (Optional) Cipher algorithm from `crypto.getCiphers()`. Default is `aes-256-gcm`.
+- `hashing` (Optional) Hash algorithm from `crypto.getHashes()`. Default is `sha512`.
+- ... Rest of given options will be passed directly to the [node-memcached](http://github.com/3rd-Eden/node-memcached) and [kruptein](https://github.com/jas-/kruptein) constructors, see their appropriate docs for extra configurability.
+
+## Upgrading to v3.x.x
+
+v3.0.0 introduces two breaking changes:
+
+### 1. Node.js version requirement
+
+**Breaking change:** v3.0.0 requires Node.js >= 14.0.0. Support for Node.js versions 4-12 has been dropped.
+
+If you're running an older Node.js version, please upgrade to Node.js 14 or later before upgrading to v3.x.x.
+
+### 2. Stronger secret requirements for encryption
+
+**Breaking change:** The `kruptein` dependency has been updated to enforce stricter password complexity requirements for the `secret` option. If you use encryption (set the `secret` option), your secret must now meet these requirements:
+
+- Minimum length: 8 characters
+- Minimum 2 uppercase letters
+- Minimum 2 lowercase letters
+- Minimum 2 numbers
+- Minimum 2 special characters (`!@#$%^&*()_+-=[]{};':"\\|,.<>/?`)
+
+**IMPORTANT:** Check if your current secret meets these requirements:
+
+- **If your secret already meets the requirements:** You can upgrade safely with no additional action needed.
+- **If your secret does NOT meet the requirements:** You MUST flush all encrypted session data from memcached before upgrading AND update your secret to meet the new requirements. All existing encrypted session data will become inaccessible with the new secret.
+
+Sessions without encryption (no `secret` option) are not affected.
+
+## Upgrading to v2.x.x
+
+When upgrading from pre v2 and using data encryption please flush all the session entries from memcached before rolling the update.
 
-For details see [node-memcached](http://github.com/3rd-Eden/node-memcached).
+Sessions without data encryption are not affected.
 
 ## Upgrading from v0.x.x -> v1.x.x
 

package/docker-compose.yml

@@ -0,0 +1,104 @@
+services:
+  memcached:
+    image: memcached:1.6-alpine
+    ports:
+      - "11211:11211"
+    command: memcached -m 64
+
+  test-node-14:
+    image: node:14-alpine
+    depends_on:
+      - memcached
+    working_dir: /app
+    volumes:
+      - .:/app
+    environment:
+      - NODE_ENV=test
+      - MEMCACHED_HOST=memcached:11211
+      - NPM_CONFIG_FUND=false
+      - NPM_CONFIG_UPDATE_NOTIFIER=false
+    command: sh -c "npm install && npm test"
+
+  test-node-16:
+    image: node:16-alpine
+    depends_on:
+      - memcached
+    working_dir: /app
+    volumes:
+      - .:/app
+    environment:
+      - NODE_ENV=test
+      - MEMCACHED_HOST=memcached:11211
+      - NPM_CONFIG_FUND=false
+      - NPM_CONFIG_UPDATE_NOTIFIER=false
+    command: sh -c "npm install && npm test"
+
+  test-node-18:
+    image: node:18-alpine
+    depends_on:
+      - memcached
+    working_dir: /app
+    volumes:
+      - .:/app
+    environment:
+      - NODE_ENV=test
+      - MEMCACHED_HOST=memcached:11211
+      - NPM_CONFIG_FUND=false
+      - NPM_CONFIG_UPDATE_NOTIFIER=false
+    command: sh -c "npm install && npm test"
+
+  test-node-20:
+    image: node:20-alpine
+    depends_on:
+      - memcached
+    working_dir: /app
+    volumes:
+      - .:/app
+    environment:
+      - NODE_ENV=test
+      - MEMCACHED_HOST=memcached:11211
+      - NPM_CONFIG_FUND=false
+      - NPM_CONFIG_UPDATE_NOTIFIER=false
+    command: sh -c "npm install && npm test"
+
+  test-node-22:
+    image: node:22-alpine
+    depends_on:
+      - memcached
+    working_dir: /app
+    volumes:
+      - .:/app
+    environment:
+      - NODE_ENV=test
+      - MEMCACHED_HOST=memcached:11211
+      - NPM_CONFIG_FUND=false
+      - NPM_CONFIG_UPDATE_NOTIFIER=false
+    command: sh -c "npm install && npm test"
+
+  test-node-24:
+    image: node:24-alpine
+    depends_on:
+      - memcached
+    working_dir: /app
+    volumes:
+      - .:/app
+    environment:
+      - NODE_ENV=test
+      - MEMCACHED_HOST=memcached:11211
+      - NPM_CONFIG_FUND=false
+      - NPM_CONFIG_UPDATE_NOTIFIER=false
+    command: sh -c "npm install && npm test"
+
+  test-node-25:
+    image: node:25-alpine
+    depends_on:
+      - memcached
+    working_dir: /app
+    volumes:
+      - .:/app
+    environment:
+      - NODE_ENV=test
+      - MEMCACHED_HOST=memcached:11211
+      - NPM_CONFIG_FUND=false
+      - NPM_CONFIG_UPDATE_NOTIFIER=false
+    command: sh -c "npm install && npm test"

package/flake.lock

@@ -0,0 +1,61 @@
+{
+  "nodes": {
+    "flake-utils": {
+      "inputs": {
+        "systems": "systems"
+      },
+      "locked": {
+        "lastModified": 1731533236,
+        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1765779637,
+        "narHash": "sha256-KJ2wa/BLSrTqDjbfyNx70ov/HdgNBCBBSQP3BIzKnv4=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "1306659b587dc277866c7b69eb97e5f07864d8c4",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "flake-utils": "flake-utils",
+        "nixpkgs": "nixpkgs"
+      }
+    },
+    "systems": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

package/flake.nix

@@ -0,0 +1,39 @@
+{
+  description = "Memcached session store for Connect";
+
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+    flake-utils.url = "github:numtide/flake-utils";
+  };
+
+  outputs = { self, nixpkgs, flake-utils }:
+    flake-utils.lib.eachDefaultSystem (system:
+      let
+        pkgs = nixpkgs.legacyPackages.${system};
+      in
+      {
+        devShells.default = pkgs.mkShell {
+          packages = with pkgs; [
+            nodejs
+            nodePackages.npm
+            memcached
+          ];
+
+          shellHook = ''
+            echo "connect-memcached development environment"
+            echo "Node: $(node --version)"
+            echo "npm: $(npm --version)"
+            echo ""
+
+            # Install dependencies if node_modules doesn't exist
+            if [ ! -d "node_modules" ]; then
+              echo "Installing npm dependencies..."
+              npm install
+            fi
+
+            echo "Ready! Run 'npm test' to run tests"
+          '';
+        };
+      }
+    );
+}

package/index.js

@@ -1,2 +1 @@
-
-module.exports = require('./lib/connect-memcached');
+module.exports = require('./lib/connect-memcached');

package/lib/connect-memcached.js

@@ -2,8 +2,6 @@
  * connect-memcached
  * MIT Licensed
  */
-const bufferFrom = require('buffer-from');
-
 var Memcached = require("memcached");
 var oneDay = 86400;
 
@@ -39,16 +37,17 @@ module.exports = function(session) {
       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);
     }
 
+    if (options.secret) { 
+      options.algorithm = options.algorithm || 'aes-256-gcm';
+      options.hashing = options.hashing || 'sha512';
+      this.kruptein = require("kruptein")(options);
+      this.secret = options.secret;
+    }
+
     this.client = options.client;
   }
 
@@ -72,7 +71,8 @@ module.exports = function(session) {
    * @api public
    */
   MemcachedStore.prototype.get = function(sid, fn) {
-    (secret = this.secret), (self = this), (sid = this.getKey(sid));
+    var self = this, sid = this.getKey(sid),
+        parseable_string;
 
     this.client.get(sid, function(err, data) {
       if (err) {
@@ -82,13 +82,20 @@ module.exports = function(session) {
         if (!data) {
           return fn();
         }
-        if (secret) {
-          parseable_string = decryptData.call(self, data.toString());
+
+        if (self.secret) {
+          self.kruptein.get(self.secret, data, function(err, ct) {
+            if (err) {
+              return fn(err, {});
+            }
+
+            parseable_string = JSON.parse(ct);
+          });
         } else {
-          parseable_string = data.toString();
+          parseable_string = data;
         }
 
-        fn(null, JSON.parse(parseable_string));
+	fn(null, parseable_string);
       } catch (e) {
         fn(e);
       }
@@ -110,16 +117,16 @@ module.exports = function(session) {
       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
-      );
+
+      if (this.secret) {
+        this.kruptein.set(this.secret, sess, function(err, ct) {
+          if (err) {
+            return fn(err);
+          }
+
+          sess = ct;
+        });
+      }
 
       this.client.set(sid, sess, ttl, ensureCallback(fn));
     } catch (err) {
@@ -172,70 +179,5 @@ module.exports = function(session) {
     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,6 +1,6 @@
 {
   "name": "connect-memcached",
-  "version": "1.0.0",
+  "version": "3.0.0",
   "description": "Memcached session store for Connect",
   "keywords": [
     "memcached",
@@ -15,11 +15,26 @@
     "url": "https://github.com/balor/connect-memcached"
   },
   "dependencies": {
-    "buffer-from": "1.1.0",
+    "kruptein": "3.1.x",
     "memcached": "2.2.x"
   },
+  "devDependencies": {
+    "express": "^4.17.3",
+    "express-session": "^1.17.2",
+    "jest": "^27.5.1",
+    "supertest": "^6.2.2"
+  },
+  "scripts": {
+    "test": "NODE_ENV=test jest --testTimeout=10000"
+  },
+  "jest": {
+    "testEnvironment": "node",
+    "coveragePathIgnorePatterns": [
+      "/node_modules/"
+    ]
+  },
   "engines": {
-    "node": ">= 0.10.0"
+    "node": ">= 14.0.0"
   },
   "license": "MIT",
   "directories": {

package/test/services/memcached_basic.js

@@ -0,0 +1,40 @@
+const express = require("express"),
+  session = require("express-session"),
+  app = express(),
+  MemcachedStore = require("../../lib/connect-memcached")(session);
+
+const memcachedStore = new MemcachedStore({
+  hosts: [process.env.MEMCACHED_HOST || "127.0.0.1:11211"],
+  prefix: "testapp_",
+});
+
+app.use(
+  session({
+    secret: "TestSecret",
+    key: "test",
+    proxy: "true",
+    resave: false,
+    saveUninitialized: false,
+    store: memcachedStore,
+  })
+);
+
+app.get("/", function (req, res) {
+  if (req.session.views) {
+    ++req.session.views;
+  } else {
+    req.session.views = 1;
+  }
+  res.json({ pageviews: req.session.views });
+});
+
+if (process.env.NODE_ENV !== "test") {
+  app.listen(9341, function () {
+    console.log("Listening on %d", this.address().port);
+  });
+}
+
+module.exports = {
+  app: app,
+  memcachedStore: memcachedStore,
+};

package/test/services/memcached_crypt.js

@@ -0,0 +1,41 @@
+const express = require("express"),
+  session = require("express-session"),
+  app = express(),
+  MemcachedStore = require("../../lib/connect-memcached")(session);
+
+const memcachedStore = new MemcachedStore({
+  hosts: [process.env.MEMCACHED_HOST || "127.0.0.1:11211"],
+  secret: "Hello There Stranger2025!?",
+  prefix: "testapp_encrypt_",
+});
+
+app.use(
+  session({
+    secret: "TestEncryptSecret",
+    key: "test_encrypt",
+    proxy: "true",
+    resave: false,
+    saveUninitialized: false,
+    store: memcachedStore,
+  })
+);
+
+app.get("/", function (req, res) {
+  if (req.session.views) {
+    ++req.session.views;
+  } else {
+    req.session.views = 1;
+  }
+  res.json({ pageviews: req.session.views });
+});
+
+if (process.env.NODE_ENV !== "test") {
+  app.listen(9341, function () {
+    console.log("Listening on %d", this.address().port);
+  });
+}
+
+module.exports = {
+  app: app,
+  memcachedStore: memcachedStore,
+};

package/test/services/memcached_preexisting_crypt_connection.js

@@ -0,0 +1,44 @@
+const express = require("express"),
+  session = require("express-session"),
+  app = express(),
+  Memcached = require("memcached"),
+  MemcachedStore = require("../../lib/connect-memcached")(session);
+
+const memcachedClient = new Memcached(process.env.MEMCACHED_HOST || "127.0.0.1:11211");
+
+const memcachedStore = new MemcachedStore({
+  client: memcachedClient,
+  prefix: "testapp_encrypt_",
+  secret: "Hello There Stranger2025!?",
+});
+
+app.use(
+  session({
+    secret: "TestEncryptSecret",
+    key: "test_encrypt",
+    proxy: "true",
+    resave: false,
+    saveUninitialized: false,
+    store: memcachedStore,
+  })
+);
+
+app.get("/", function (req, res) {
+  if (req.session.views) {
+    ++req.session.views;
+  } else {
+    req.session.views = 1;
+  }
+  res.json({ pageviews: req.session.views });
+});
+
+if (process.env.NODE_ENV !== "test") {
+  app.listen(9341, function () {
+    console.log("Listening on %d", this.address().port);
+  });
+}
+
+module.exports = {
+  app: app,
+  memcachedStore: memcachedStore,
+};

package/test/test.js

@@ -0,0 +1,63 @@
+const supertest = require("supertest");
+
+
+describe("Plain memcached session store", () => {
+  const { app, memcachedStore } = require("./services/memcached_basic.js");
+  const serverAgent = supertest.agent(app);
+
+  it("GET / should increment views value at each request", async () => {
+    let lastPageView = 0;
+    for (var i = 1; i < 50; i++) {
+      const res = await serverAgent.get("/");
+      expect(res.status).toEqual(200);
+      expect(res.type).toEqual(expect.stringContaining("json"));
+      expect(res.body.pageviews).toBeGreaterThan(lastPageView);
+      lastPageView = res.body.pageviews;
+    }
+  });
+
+  afterAll(() => {
+    memcachedStore.client.end();
+  });
+});
+
+describe("Encrypted memcached session store", () => {
+  const { app, memcachedStore } = require("./services/memcached_crypt.js");
+  const serverAgent = supertest.agent(app);
+
+  it("GET / should increment views value at each request", async () => {
+    let lastPageView = 0;
+    for (var i = 1; i < 50; i++) {
+      const res = await serverAgent.get("/");
+      expect(res.status).toEqual(200);
+      expect(res.type).toEqual(expect.stringContaining("json"));
+      expect(res.body.pageviews).toBeGreaterThan(lastPageView);
+      lastPageView = res.body.pageviews;
+    }
+  });
+
+  afterAll(() => {
+    memcachedStore.client.end();
+  });
+});
+
+describe("Encrypted session store using preexising memcached client", () => {
+  const { app, memcachedStore } = require("./services/memcached_preexisting_crypt_connection.js");
+  const serverAgent = supertest.agent(app);
+
+  it("GET / should increment views value at each request", async () => {
+    let lastPageView = 0;
+    for (var i = 1; i < 50; i++) {
+      const res = await serverAgent.get("/");
+      expect(res.status).toEqual(200);
+      expect(res.type).toEqual(expect.stringContaining("json"));
+      expect(res.body.pageviews).toBeGreaterThan(lastPageView);
+      expect(memcachedStore.kruptein.crypto).toBe(require("crypto"));
+      lastPageView = res.body.pageviews;
+    }
+  });
+
+  afterAll(() => {
+    memcachedStore.client.end();
+  });
+});

package/test-all.sh

@@ -0,0 +1,39 @@
+#!/bin/bash
+
+set -e
+
+echo "Starting memcached..."
+docker-compose up -d memcached
+sleep 2
+
+NODE_VERSIONS=(14 16 18 20 22 24 25)
+FAILED=()
+
+for version in "${NODE_VERSIONS[@]}"; do
+  echo ""
+  echo "========================================="
+  echo "Testing with Node $version"
+  echo "========================================="
+
+  if docker-compose run --rm test-node-$version; then
+    echo "✓ Node $version: PASSED"
+  else
+    echo "✗ Node $version: FAILED"
+    FAILED+=($version)
+  fi
+done
+
+echo ""
+echo "========================================="
+echo "Test Summary"
+echo "========================================="
+
+if [ ${#FAILED[@]} -eq 0 ]; then
+  echo "✓ All Node versions passed!"
+  docker-compose down
+  exit 0
+else
+  echo "✗ Failed Node versions: ${FAILED[*]}"
+  docker-compose down
+  exit 1
+fi

package/.npmignore

@@ -1,2 +0,0 @@
-.idea
-node_modules

package/tests/test.js

@@ -1,34 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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);
-});