How to use the connect function in connect

const Endpoints = {};

WebApp.connectHandlers.use(bodyParser.json({
  limit: "500kb", // Override default request size
  // Attach the raw body which is necessary for doing verifications for some webhooks
  verify(req, res, buf) {
    req.rawBody = buf;
  },
  extended: true
}));

// Handler for adding middleware before an endpoint (Endpoints.middleWare
// is just for legacy reasons). Also serves as a namespace for middleware
// packages to declare their middleware functions.
Endpoints.middleWare = connect();
Endpoints.Middleware = Endpoints.middleWare;
WebApp.connectHandlers.use(Endpoints.Middleware);

// List of all defined JSON API Endpoints
Endpoints.routes = [];

// Save reference to router for later
let connectRouter;

// Register as a middleware
WebApp.connectHandlers.use(Meteor.bindEnvironment(connectRoute((router) => {
  connectRouter = router;
})));

/**
 * @method writeJsonToBody

constructor(nuxt) {
    this.nuxt = nuxt
    this.options = nuxt.options

    // Will be set by createRenderer
    this.bundleRenderer = null
    this.metaRenderer = null

    // Will be available on dev
    this.webpackDevMiddleware = null
    this.webpackHotMiddleware = null

    // Create new connect instance
    this.app = connect()

    // Renderer runtime resources
    this.resources = {
      clientManifest: null,
      serverBundle: null,
      ssrTemplate: null,
      spaTemplate: null,
      errorTemplate: parseTemplate('Nuxt.js Internal Server Error')
    }
  }

constructor(nuxt) {
    this.nuxt = nuxt
    this.options = nuxt.options
    this.globals = determineGlobals(nuxt.options.globalName, nuxt.options.globals)

    // Will be set by createRenderer
    this.bundleRenderer = null
    this.metaRenderer = null

    // Will be available on dev
    this.webpackDevMiddleware = null
    this.webpackHotMiddleware = null

    // Create new connect instance
    this.app = connect()

    // Renderer runtime resources
    this.resources = {
      clientManifest: null,
      serverBundle: null,
      ssrTemplate: null,
      spaTemplate: null,
      errorTemplate: parseTemplate('Nuxt.js Internal Server Error')
    }
  }

async function startExpoProdServer() {
  console.log(`Starting Expo prod server`);
  const packagerPort = 3030;
  const projectRoot = path.join(path.resolve('.'), '.expo', 'all');
  startExpoServer(projectRoot, packagerPort);

  const app = connect();
  app
    .use(function(req, res, next) {
      req.path = req.url.split('?')[0];
      console.log("req:", req.url);
      next();
    })
    .use(compression())
    .use(debugMiddleware)
    .use(function(req, res, next) {
      var platform = url.parse(req.url, true).query.platform;
      if (platform) {
        const filePath = path.join(settings.frontendBuildDir, platform, req.path);
        if (fs.existsSync(filePath)) {
          res.writeHead(200, {"Content-Type": mime.lookup(filePath)});
          fs.createReadStream(filePath)
            .pipe(res);

if (assets.length > 1) {
          assetsMap[`${bundle}.js.map`] = `${bundleJs}.map`;
        }
      });
      if (settings.webpackDll) {
        assetsMap['vendor.js'] = vendorHashesJson.name;
      }
      fs.writeFileSync(path.join(dir, 'assets.json'), JSON.stringify(assetsMap));
    }
    if (frontendFirstStart) {
      frontendFirstStart = false;
      openFrontend(config, platform);
    }
  });

  const app = connect();

  const serverInstance = http.createServer(app);

  let wsProxy, ms, inspectorProxy;

  if (platform !== 'web') {
    mime.define({ 'application/javascript': ['bundle'] });
    mime.define({ 'application/json': ['assets'] });

    inspectorProxy = new InspectorProxy();
    const args = {port: config.
      devServer.port, projectRoots: [path.resolve('.')]};
    app
      .use(loadRawBodyMiddleware)
      .use(function(req, res, next) {
        req.path = req.url.split('?')[0];

import connect from 'connect';
import Tooltip from 'components/shared/help-tooltip.component.js';

const mapMethodsToState = (state) => ({
  checkTooltip: state.app.tooltipCheck,
});

export default connect(Tooltip, mapMethodsToState);

return _.values(state.tool.nodesDict)
        .filter(
          node => node.hasFlows === true &&
          node.isAggregated !== true &&
          node.isUnknown !== true
        );
    }
  }
});

const mapViewCallbacksToActions = () => ({
  onNodeSelected: node => searchNode(parseInt(node.id, 10)),
});


export default connect(Search, mapMethodsToState, mapViewCallbacksToActions);

constructor (App: React.ComponentType, options: RogueOptions = {}) {
    this.app = connect() 
    this.middlewares = [rogueMiddleware(App, options)]
    this.initialized = false
  }

import connect from 'connect';
import NavComponent from 'components/shared/nav.component';

const mapViewCallbacksToActions = () => ({
  onLinkClick: ({ page, query }) => ({ type: page, payload: { query } })
});

export default connect(NavComponent, null, mapViewCallbacksToActions);

loadNodes: {
    _comparedValue: state => state.tool.nodesDict,
    _returnedValue: state => _.values(state.tool.nodesDict)
      .filter(node =>
        node.hasFlows === true &&
        node.isAggregated !== true &&
        node.isUnknown !== true)
  }
});

const mapViewCallbacksToActions = () => ({
  onNodeSelected: node => searchNode(parseInt(node.id, 10))
});


export default connect(Search, mapMethodsToState, mapViewCallbacksToActions);