How to use the next function in next

import express from 'express';
import next from 'next';

const dev = process.env.NODE_ENV !== 'production';

const port = process.env.PORT || 8000;
const ROOT_URL = dev ? `http://localhost:${port}` : 'https://builderbook.org';

const app = next({ dev });
const handle = app.getRequestHandler();

// Nextjs's server prepared
app.prepare().then(() => {
  const server = express();

  server.get('*', (req, res) => handle(req, res));

  // starting express server
  server.listen(port, (err) => {
    if (err) throw err;
    console.log(`> Ready on ${ROOT_URL}`); // eslint-disable-line no-console
  });
});

import nextApp from 'next';
import express, { Request, Response, NextFunction } from 'express';
import { parse } from "url";
import { join } from "path";
import get from "lodash.get";
import { ApolloServer } from "apollo-server-express";
import helmet from "helmet";
import resolvers from "./schema/resolvers";
import typeDefs from "./schema/typeDefs";
import config from "./config";
import httpRedirect from "./lib/http-redirect";
import rootStaticFiles from "../config/root-static-files.json";

const { IS_PROD, PORT } = config;

const nextServer = nextApp({ dev: !IS_PROD });

const handle = nextServer.getRequestHandler();
nextServer.prepare().then(() => {
  const server = express();
  server.enable('trust proxy');
  server.use(helmet());
  if (IS_PROD) {
    // compression should be setup in reverse proxy
    // server.use(compression());
    server.use(httpRedirect());
  }

  server.get('/*', (req: Request, res: Response, next: NextFunction) => {

    if (req.headers && req.headers.host && req.headers.host.match && req.headers.host.match(/^www/) !== null) {
      res.redirect(`https://${req.headers.host.replace(/^www\./, '')}${req.url}`);

import './env';

import express from 'express';
import helmet from 'helmet';
import * as mobxReact from 'mobx-react';
import next from 'next';
import * as path from 'path';

import { getUser } from '../lib/api/public';
import routesWithSlug from './routesWithSlug';

import { IS_DEV, PORT_APP, URL_API, URL_APP } from '../lib/consts';

mobxReact.useStaticRendering(true);

const app = next({ dev: IS_DEV });
const handle = app.getRequestHandler();

app.prepare().then(() => {
  const server = express();

  // give all Nextjs's request to Nextjs before anything else
  server.get('/_next/*', (req, res) => {
    handle(req, res);
  });

  server.get('/static/*', (req, res) => {
    handle(req, res);
  });

  server.use(helmet());
  server.use(express.json());

/* eslint-disable no-console */
import express from 'express'
import next from 'next'
// eslint-disable-next-line node/no-deprecated-api
// import { parse } from 'url'

import { resolve } from '~drupal/modules/pages/lib/resolver'

const { NODE_ENV, PORT = 3000 } = process.env

const dev = NODE_ENV !== 'production'
const app = next({ dev })
const handle = app.getRequestHandler()

const initializeServer = () => {
  const server = express()

  // Drupal based route resolver.
  server.get('*', async (req, res, next) => {
    // @TODO: static routing should have precedence over Drupal's.
    // const isNextRoute = app.router.match(req, res, parse(req.url, true))
    const isNextRoute = false

    if (!isNextRoute) {
      try {
        const route = await resolve({ location: req, ctx: { res } })

        if (route) return app.render(req, res, '/drupal', { route })

import accepts from 'accepts';
import cookieParser from 'cookie-parser';
import cloudflareIps from 'cloudflare-ip/ips.json';

import routes from './routes';
import { loggerMiddleware, logger } from './logger';
import { getLocaleDataScript, getMessages, languages } from './intl';

const server = express();

server.set('trust proxy', ['loopback', 'linklocal', 'uniquelocal'].concat(cloudflareIps));

const env = process.env.NODE_ENV;
const dev = env === 'development' || env === 'docker';

const app = next({ dev, dir: path.dirname(__dirname) });
server.next = app;

const port = process.env.PORT;

app.prepare().then(() => {
  server.use(loggerMiddleware.logger);

  server.use(cookieParser());

  server.use((req, res, next) => {
    const accept = accepts(req);

    if (req.query.language && languages.includes(req.query.language)) {
      // Detect language as query string in the URL
      req.language = req.query.language;
    } else if (req.cookies.language && languages.includes(req.cookies.language)) {

getObjectsMetadata,
} from '../lib/s3';
import { fetchOrgMembership } from '../lib/github';

const {
  PORT,
  SESSION_SECRET,
  GITHUB_CLIENT_ID,
  GITHUB_CLIENT_SECRET,
} = process.env;

const sessionSecret = SESSION_SECRET || crypto.randomBytes(64).toString('hex');

const port = parseInt(PORT, 10) || 3000;

const nextApp = next({
  dir: path.dirname(__dirname),
  dev: process.env.NODE_ENV !== 'production',
});

const cookieOptions = {
  path: '/',
  httpOnly: true,
  secure: false,
};

const handler = routes.getRequestHandler(nextApp);

nextApp.prepare().then(() => {
  const server = express();
  const upload = multer();

import Router from 'koa-router'
import api from './api'
import { getSitemap } from '../controllers'
import next from 'next'
import isBot from '../middleware/isBot'
import postService from '../service/postService'

const app = next({ dev: process.env.NODE_ENV !== 'production' })
app.prepare()

const router = new Router()

router.use('/api', api.routes(), api.allowedMethods())
router.get('/sitemap.xml', getSitemap)
router.get('/post/:name', isBot(), async ctx => {
  const { res } = ctx

  const getIdByName = async (name: string): Promise => {
    const posts = await postService.getPostList()
    for (const post of posts) {
      if (post.name === name) {
        return post.id
      }
    }

constructor ({ dir = '.', dev = true }) {
    this.app = next({ dev })
    this.dev = dev
    this.handle = this.app.getRequestHandler()
  }

async function main() {
  const app = next({
    conf,
    dev,
    dir: path.resolve(__dirname, './'),
  })

  await app.prepare()

  const server = asyncify(express())

  server.use(bodyParser.json())
  server.use(bodyParser.urlencoded({ extended: true }))
  server.use(cookieParser())

  server.use(session({
    secret: '602f0a56-136b-524b-9871-d0450ef60b48',
    resave: true,

export async function createServerAsync(
  projectRoot: string,
  {
    app: possibleApp,
    handleRequest: possiblyHandleRequest,
  }: {
    app?: NextApp;
    handleRequest?: (req: IncomingMessage, res: ServerResponse) => Promise | void;
  }
): Promise {
  const app = possibleApp || next({ dev: process.env.NODE_ENV !== 'production' });
  const handle = app.getRequestHandler();

  await app.prepare();

  const server = createServer(async (req: IncomingMessage, res: ServerResponse) => {
    if (possiblyHandleRequest && (await possiblyHandleRequest(req, res))) {
      return;
    }
    handleRequest({ projectRoot, app, handle }, req, res);
  });
  return {
    server,
    app,
    handle,
  };
}