Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
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,
};
}