How to use the connect.json function in connect

var app = connect();
app.use(connect.limit(config.maxRequestSize));

app.use(rt({headerName: 'X-ReadTime'}));
app.use('/public', connect.static(PUBLIC_DIR));
app.use(function (req, res, next) {
  res.req = req;
  next();
});

//parse http get params
app.use(connect.query());

//parse http post body
app.use(connect.urlencoded());
app.use(connect.json({
  strict: true
}));

// //parse cookie
// app.use(connect.cookieParser());

// //session
// app.use(connect.session({
//   key: config.sessionCookie,
//   secret: config.sessionSecret,
//   cookie: { path: '/', httpOnly: true},
// }));

//handle csrf, do not open it when 
// if (process.env.NODE_ENV !== 'test') {
//   app.use(connect.csrf());  

var render = require('connect-render');
var urlrouter = require('urlrouter');
// var session = require('../common/session');
var routes = require('./routes');
var logger = require('./common/logger');
var config = require('./config');
// var auth = require('./middleware/auth');

var app = connect();

app.use(function (req, res, next) {
  res.req = req;
  next();
});
app.use(connect.query());
app.use(connect.json({
  strict: true, // json body must use strict mode.
}));
app.use(connect.urlencoded());
app.use(connect.cookieParser());
app.use('/assets', connect.static(path.join(__dirname, 'assets')));
// app.use(connect.csrf());
app.use(render({
  root: path.join(__dirname, 'views'),
  layout: false,
  viewExt: '.html',
  cache: false,
  helpers: {
    version: config.version,
    config: config,
    // _csrf: function (req, res) {
    //   return req.csrfToken() || '';

options = options || {};

  var personaOpts = {};
  Object.keys(defaultOptions).forEach(function(key) {
    if (typeof options[key] === typeof defaultOptions[key]) {
      personaOpts[key] = options[key];
    } else {
      personaOpts[key] = defaultOptions[key];
    }
  });

  var verify = browseridVerify({
    url: personaOpts.verifierURI
  });

  app.post(personaOpts.verifyPath, connect.json(), connect.urlencoded(), personaOpts.middleware, function(req, res) {
    // If the body can't be parsed then we can't get the assertion
    if (!req.body) {
      personaOpts.verifyResponse("Server-side exception", req, res);
      return;
    }

    verify(req.body.assertion, personaOpts.audience, function(err, email, response) {
      if (err) {
        if (err instanceof Error) {
          err = err.message;
        }
        return personaOpts.verifyResponse(err, req, res);
      }

      if (response && response.status !== "okay") {
        return personaOpts.verifyResponse(response.reason, req, res, email);

var Globals = require('./Globals');
var Util = require('./Util');
var VsConfig = require('./VsConfig');

var Url = require('url');
var querystring = require('querystring');

var extend = require('extend');
var runnerMiddleware = require('karma/lib/middleware/runner');
var runnerMiddlewareCreate = runnerMiddleware.create;
var helper = require('karma/lib/helper');
var constant = require('karma/lib/constants');
var json = require('connect').json();

function removeQueryString(url) {
    var parsedUrl = Url.parse(url);
    parsedUrl.search = undefined;
    parsedUrl.query = undefined;
    return Url.format(parsedUrl);
}

function getQuery(url) {
    var parsedUrl = Url.parse(url);
    return querystring.parse(parsedUrl.query);
}

function create(emitter, fileList, capturedBrowsers, reporter, executor, /* config.hostname */ hostname, /* config.port */ port, /* config.urlRoot */ urlRoot, config) {
    var logger = require('karma/lib/logger');
    var log = Util.createLogger(logger);

var connect = require('connect')
var argv = require('optimist').argv

var seneca = require('../..')

var si = seneca()
si.use('echo', {inject: {bar: 2}, delay: argv.delay || 0})
si.use('transport')

var app = connect()
app.use(connect.json())
app.use(si.export('web'))
app.listen(10171)

exports.setup = function(app) {
  app.get('/subscribed',
          session.provider,
          getUserSubscriptions);
  app.post('/subscribed',
           connect.json(),
           session.provider,
           changeUserSubscriptions);
  app.get('/:channel/subscribers/:node',
          session.provider,
          getNodeSubscriptions);
  app.post('/:channel/subscribers/:node',
          api.bodyReader,
          session.provider,
          changeNodeSubscriptions);
  app.get('/:channel/subscribers/:node/approve',
          session.provider,
          getPendingNodeSubscriptions);
  app.post('/:channel/subscribers/:node/approve',
          api.bodyReader,
          session.provider,
          approveNodeSubscriptions);

number = valNum;
      telCarrier.lookup(number, function (err, info) {
        if (info) {
          result.push(info);
        }
        next();
      });
    }).then(function () {
      cb(result);
    });
  }

  server = connect.createServer()
    .use(connect.compress())
    .use(connect.static(path.join(__dirname, 'public')))
    .use(connect.json())
    .use(function (request, response, next) {
        if (response.send) {
          next();
          return;
        }

        response.send = function (data) {
          response.setHeader('Content-Type', 'application/json');
          response.write(JSON.stringify(data, null, '  '));
          response.end();
        };
        next();
      })
    .use('/analytics', function (request, response, next) {
        if (!request.method.match(/POST/i) || !Object.keys(request.body).length) { 
          next();

import Globals = require('./Globals');
import Util = require('./Util');
import VsConfig = require('./VsConfig');
import http = require('http');
import Url = require('url');
import querystring = require('querystring');
import util = require('util');
import path = require('path');
import _ = require('lodash');
var extend = require('extend');
var runnerMiddleware = require('karma/lib/middleware/runner');
var runnerMiddlewareCreate = runnerMiddleware.create;
var helper = require('karma/lib/helper');
var constant = require('karma/lib/constants');
var json = require('connect').json();

interface IQueryString {
    outputFile?: string;
    vsConfig?: string;
}

function removeQueryString(url: string): string {
    var parsedUrl = Url.parse(url);
    parsedUrl.search = undefined;
    parsedUrl.query = undefined;
    return Url.format(parsedUrl);
}

function getQuery(url: string): IQueryString {
    var parsedUrl = Url.parse(url);
    return querystring.parse(parsedUrl.query);

exports.setup = function(app) {
  app.post('/login',
           connect.json(),
           login);
};

require('jaydata');

require('./client/context.js');

var connect = require('connect');
var app = require('connect')();

app.use(connect.multipart());
app.use(connect.urlencoded());
app.use(connect.json());
app.use(connect.bodyParser());
app.use(connect.query());

app.use("/", connect.static("./client"));

ISODate = function(date){
    return new Date(date);
};

app.use('/db', function(req, res){
    if (req.method === 'GET'){
        test.context = new test.Context({ name: 'mongoDB', databaseName: 'x' });
        test.context.onReady(function(db){
            var callback = function(result){
                res.write(JSON.stringify(result));
                res.end();