module.exports = function (app) {
if (app.env !== 'development') {
return;
}
/* eslint-disable global-require */
const webpack = require('webpack');
const webpackMiddleware = require('koa-webpack-dev-middleware');
const config = require('../assets/webpack.config');
/* eslint-enable global-require */
app.use(webpackMiddleware(webpack(config), {
publicPath: '/script/',
stats: {
colors: true
}
}));
};
export default function (compiler, options) {
const webpackDevMiddlewareOptions = {
...options,
quiet: true,
noInfo: true,
stats: {
colors: true,
chunks: false,
chunkModules: false,
},
hot: true,
lazy: false,
historyApiFallback: true,
contentBase: `http://${SERVER_HOST}:${WEBPACK_DEV_SERVER_PORT}`,
headers: { 'Access-Control-Allow-Origin': '*' },
}
return convert(koaWebpackDevMiddleware(compiler, webpackDevMiddlewareOptions))
}
export default function (compiler, options) {
const webpackDevMiddlewareOptions = {
...options,
quiet: QUIET_MODE,
noInfo: QUIET_MODE,
stats: {
colors: true,
chunks: false,
chunkModules: false
},
hot: true,
lazy: false,
historyApiFallback: true,
contentBase: 'http://localhost:3001',
headers: { 'Access-Control-Allow-Origin': '*' }
}
return convert(koaWebpackDevMiddleware(compiler, webpackDevMiddlewareOptions))
}
export default (app) => {
if (app.env !== 'development') {
console.warn('webpack请在开发环境下使用');
return;
}
const compiler = webpack(webpackConfig);
app.use(webpackMiddleware(compiler, {
publicPath: webpackConfig.output.publicPath,
noInfo: false,
stats: {
colors: true,
hash: true,
cached: true,
chunkModules: false,
cachedAssets: true,
}
}));
app.use(webpackHotMiddleware(compiler));
};
const koa = require('koa')
const webpackDevMiddleware = require('koa-webpack-dev-middleware')
const webpack = require('webpack')
const config = require('./webpack.config.babel')
const app = koa()
app.use(webpackDevMiddleware(webpack(config), { noInfo: true, stats: { colors: true } }))
module.exports = app
'use strict';
require('dotenv').config({silent: true});
const path = require('path');
const koa = require('koa');
const serve = require('koa-static');
const webpack = require('webpack');
const webpackMiddleware = require('koa-webpack-dev-middleware');
const webpackConfig = require('./webpack.config.js');
const port = process.env.PORT || 3000;
const app = koa();
if (process.env.NODE_ENV === 'production') {
app.use(serve(path.join(__dirname, 'dist')));
} else {
app.use(serve(path.join(__dirname, 'app')));
app.use(webpackMiddleware(webpack(webpackConfig), {
stats: {
colors: true
}
}));
}
app.use(serve(path.join(__dirname, 'app/public')));
app.listen(port);
'use strict'
const webpack = require('webpack')
const devMiddleware = require('koa-webpack-dev-middleware')
const hotMiddleware = require('koa-webpack-hot-middleware')
const config = require('../../webpack.config.js')
const compiler = webpack(config)
module.exports = {
devMiddleware: devMiddleware(compiler, {
historyApiFallback: true,
noInfo: true,
hot: true,
inline: true
}),
hotMiddleware: hotMiddleware(compiler)
}
});
// logger
app.use(function*(next) {
console.log(this.method.info, this.url);
yield next;
});
// use routes
routes(router, app, staticDir);
app.use(router.routes());
if (debug) {
let webpackDevMiddleware = require('koa-webpack-dev-middleware');
let webpack = require('webpack');
let webpackConf = require('../config/webpack-dev');
app.use(webpackDevMiddleware(webpack(webpackConf), webpackConf.devServer));
}
// handle static files
app.use(serve(staticDir, {
maxage: 0
}));
app = http.createServer(app.callback());
app.listen(pkg.localServer.port, 'localhost', () => {
let url = util.format('http://%s:%d', 'localhost', pkg.localServer.port);
console.log('Listening at %s', url);
open(url);
});
const compiler = webpack(webpackConfig)
const app = Koa()
require('koa-ejs')(app, {
root: __dirname,
layout: false,
viewExt: 'html',
cache: false
})
app.use(logger())
app.use(require('koa-static')(path.join(__dirname, './static')))
app.use(function * (next) {
fallback(this, null, function () {})
yield next
})
app.use(devMiddleware(compiler, {
publicPath: webpackConfig.output.publicPath,
stats: {
colors: true,
chunks: false
}
}))
app.use(hotMiddleware(compiler))
app.listen(3001, function () {
console.log('Listening on 3001...')
})
module.exports = app
var webpack = require('webpack')
var webpackMiddleware = require('koa-webpack-dev-middleware')
var sassMiddleware = require('koa-sass-middleware')
var path = require('path')
var wpConfig = require('./webpack.dev.conf')
var config = require('../../config.json')
var app = koa()
var compiler = webpack(wpConfig)
app.use(webpackMiddleware(compiler, {
noInfo: false,
quiet: false,
lazy: false,
watchOptions: {
aggregateTimeout: 300
},
publicPath: wpConfig.output.publicPath,
stats: {
colors: true
}
}))
var hotMiddleware = require('webpack-hot-middleware')(compiler);
app.use(function*(next) {
yield hotMiddleware.bind(null, this.req, this.res)
yield next
})
// use sass middleware
app.use(sassMiddleware({
src: path.join(__dirname, '../static'),
const app = koa()
const compiler = webpack(webpackConfig)
debug('Booting up server...')
/**
* Webpack Middleware Configuarations
*/
app.use(webpackDevMiddleware(compiler, {
publicPath: webpackConfig.output.publicPath,
quiet: false,
noInfo: false,
hot: true,
inline: true,
lazy: false,
historyApiFallback: true,
headers: {'Access-Control-Allow-Origin': '*'},
stats: {
chunks: false,
chunkModules: false,
colors: true,
},
}))
/**
* Webpack Hot Middleware Configuarations
*/
app.use(webpackHotMiddleware(compiler))
/**
* Server port listining
app.use(convert(bodyParser()))
app.use(convert(historyApiFallback({
verbose: false,
})))
if (process.env.NODE_ENV !== 'production') {
const webpack = require('webpack')
const WebpackDevMiddleware = require('koa-webpack-dev-middleware')
const webpackDevelopmentConfig = require('../webpack.development')
app.use(convert(WebpackDevMiddleware(webpack(webpackDevelopmentConfig), {
stats: {
colors: true,
cached: false,
chunks: false,
hash: false,
version: false,
warnings: false,
children: false,
assets: false,
},
})))
} else {
const serve = require('koa-static')
app.use(serve(path.join(__dirname, '../dist')))
}
app.use(convert(jwt({
secret: process.env.JWT_SECRET
}).unless({
path: [
'/v1/signup',
const Koa = require('koa');
const path = require('path');
const http = require('http');
const webpackDevMiddleware = require('koa-webpack-dev-middleware');
const webpack = require('webpack');
const app = new Koa();
console.log(Date.now(), `Child ${process.pid} is running`);
const httpServer = http.createServer(app.callback()).listen(8080);
console.log(Date.now(), 'http listening on port 8080!');
const compiler = webpack(require('../webpack.config'));
app.use(
webpackDevMiddleware(compiler, {
publicPath: '/', // Same as `output.publicPath` in most cases.
watchOptions: {
aggregateTimeout: 300,
poll: true
}
})
);
app.use(require('koa-static')(path.join(__dirname, '../public')));
console.log('[SERVER] env: ', env);
if (process.env.NODE_ENV === 'development') {
const webpack = require('webpack');
const compiler = webpack(config);
const webpackDevMiddleware = require('koa-webpack-dev-middleware');
const webpackHotMiddleware = require('koa-webpack-hot-middleware');
app.use(webpackDevMiddleware(compiler, {
noInfo: false,
publicPath: config.output.publicPath,
stats: {
colors: true,
hash: false,
timings: true,
assets: true,
chunks: true,
chunkModules: false,
modules: false,
children: true,
profile: false
}
}));
app.use(webpackHotMiddleware(compiler, {
log: console.log,
path: '/__webpack_hmr',
heartbeat: 5 * 1000
}));
}
import koaConvert from 'koa-convert';
import config from './config';
import routers from './routers';
const app = new Koa();
routers(app);
app.use(koaConvert(koaStatic(path.join(__dirname, 'public'))));
var webpackDevMiddleware = require("koa-webpack-dev-middleware");
var webpack = require("webpack");
var compiler = webpack({
entry: './src/app.js',
output: {
path: 'public'
}
});
app.use(webpackDevMiddleware(webpack({
entry: './src/app.js',
output: {
path: 'public'
}
}), {
// options
}));
app.listen(config.port, () => {
console.log(`Server running at: ${config.port}.`);
});
if (isProd) {
app.use(staticCache('public', {
gzip: true,
maxAge: isProd ? 365 * 24 * 60 * 60 : 0,
}));
} else {
const webpack = require('webpack');
const webpackDevMiddleware = require('koa-webpack-dev-middleware');
const webpackHotMiddleware = require('koa-webpack-hot-middleware');
const config = require('../webpack.config.babel.js').default;
const compiler = webpack(config);
app.use(webpackDevMiddleware(compiler, {
hot: true,
noInfo: true,
stats: {
children: false,
chunks: false,
},
watchOptions: {
poll: 1000,
},
}));
app.use(webpackHotMiddleware(compiler));
}
app.use(renderer('html'));
app.listen(port, host);
const path = require('path');
const promisify = require('util').promisify;
const readFile = promisify(fs.readFile);
const webpack = require('webpack'); // webpack模块
const config = require('./webpack.config.js');
//加载webpack 热加载服务器模块
const webpackDevMiddleware = require('koa-webpack-dev-middleware');
const webpackHotMiddleware = require('koa-webpack-hot-middleware');
const compiler = webpack(config);
app.use(webpackDevMiddleware(compiler, {
noInfo: true,
hot: true,
publicPath: '/',
stats: {
colors: true
}
}));
app.use(webpackHotMiddleware(compiler));
// app.use(router.routes())
app.listen(3000, () => {
console.log('app listen at 3000')
});
import webpackDevMiddleware from 'koa-webpack-dev-middleware';
import webpackHotMiddleware from 'koa-webpack-hot-middleware';
import webpack from 'webpack';
let config;
if (process.env.NODE_ENV !== 'production') {
config = require('./webpack.config.dev');
} else {
config = require('./webpack.config.prod');
}
const compiler = webpack(config);
app.use(convert(webpackDevMiddleware(compiler, {
noInfo: true,
publicPath: config.output.publicPath
})));
if (process.env.NODE_ENV !== 'production') {
app.use(convert(webpackHotMiddleware(compiler)));
}
// Serve Static Files
// --------------------------------------------------
import path from 'path';
import serve from 'koa-static';
app.use(convert(serve(path.resolve('client'))));
// Routing
app.use(async (ctx, next) => {
if ('/favicon.ico' === ctx.path) {
await send(ctx, './favicon.png');
return;
}
await next();
});
if (!config.isProduction) {
const compile = webpack(devConfig);
app.use(devMiddleware(compile, {
compress: true,
hot: true,
inline: true,
quiet: true,
https: true,
progress: true,
publicPath: devConfig.output.publicPath,
}));
app.use(hotMiddleware(compile));
} else {
const files = {};
app.use(staticCache(path.join(__dirname, 'dist'), {}, files));
}
app.use(async (ctx, next) => {
if (!config.isProduction) {
webpackIsomorphicTools.refresh();
}
console.log(this.method.info, this.url)
yield next
})
// use routes
routes(router, app, staticDir)
app.use(router.routes())
if(dev) {
let webpackDevMiddleware = require('koa-webpack-dev-middleware')
let webpack = require('webpack')
let webpackConf = require('../configs/webpack-dev.config')
let compiler = webpack(webpackConf)
// 为使用Koa做服务器配置koa-webpack-dev-middleware
app.use(webpackDevMiddleware(compiler, webpackConf.devServer))
// 为实现HMR配置webpack-hot-middleware
let hotMiddleware = require("webpack-hot-middleware")(compiler);
// Koa对webpack-hot-middleware做适配
app.use(function* (next) {
yield hotMiddleware.bind(null, this.req, this.res);
yield next;
})
}
// handle static files
app.use(serve(staticDir, {
maxage: 0
}))
use(() => {
return webpackMiddleware(compiler, devServerConfig);
});
// test.save(function(err, data) {
// if (err) return console.error(err)
// console.log(data);
// })
// add for h5.js test
// var convert = require('koa-convert');
// var historyApiFallback = require('koa-connect-history-api-fallback');
var config = require('./webpack.config');
var compiler = webpack(config);
app.use(staticRes(path.resolve(__dirname,'../public')));
app.use(webpackDevMiddleware(compiler, {
publicPath: config.output.publicPath,
stats: {colors: true}
})
);
app.use(webpackHotMiddleware(compiler, {
log: console.log
})
);
app.listen(8081, () => {
console.log('Server is now running at : 8081.')
});
const webpack = require("webpack");
const webpackConfig = require("./webpack.config.js");
const webpackDevMiddleware = require("koa-webpack-dev-middleware");
const webpackHotMiddleware = require("koa-webpack-hot-middleware");
const React = require("react");
const ReactServer = require("react-dom/server");
const Util = require("./components/Util");
const Container = React.createFactory(require("./components/Container"));
// 静态资源访问以及构建
if( process.env.NODE_ENV == "development" ){
var compiler = webpack( webpackConfig );
app.use(webpackDevMiddleware(compiler, {
noInfo : true,
publicPath : webpackConfig.output.publicPath,
}));
app.use(webpackHotMiddleware( compiler ));
}
// 计算X-Response-Time
app.use(function *(next){
let start = new Date();
yield next;
let end = new Date();
console.log("X-Response-Time %s", (end - start) + "ms");
this.set("X-Response-Time", (end - start) + "ms");
init: async (config) => {
params = config;
const app = new Koa();
const sessions = sessionManager.getSessions();
const sessionMaxAge = 1000 * 60 * 60 * 24 * 7;
const sessionName = "apiio";
const staticPaths = [
path.join(__dirname, "..", "..", "node_modules", "semantic-ui-css"),
path.join(__dirname, "..", "..", "www", "pages", "default", "static")
];
// Setup application
app.use(compress());
app.use(bodyParser({ enableTypes: [ "json", "form", "text" ] }));
app.use(conditional());
app.use(etag());
app.use(range);
// Configure error handling
app.use(async (ctx, next) => {
try {
await next();
} catch (error) {
console.error(error);
ctx.status = error.status || 500;
ctx.type = "json";
ctx.body = JSON.stringify({
result: "fail",
error: error.message || error,
status: ctx.status
}, null, 2);
}
});
// Configure sessions
app.use(async (ctx, next) => {
let sessionId = false;
try {
sessionId = ctx.cookies.get(sessionName);
} catch (e) {
}
if (!sessionId || !sessions[sessionId]) {
sessionId = uuid.v4();
sessions[sessionId] = {
_id: sessionId
};
}
ctx.session = sessions[sessionId];
ctx.session._expires = ctx.session._expires || new Date(Date.now() + sessionMaxAge);
ctx.cookies.set(sessionName, sessionId, { maxAge: sessionMaxAge });
await next();
});
for (const staticPath of staticPaths) {
app.use(serve(staticPath));
}
app.use(async (ctx, next) => {
if (ctx.path !== "/") {
return next();
}
ctx.type = "text/html; charset=utf-8";
ctx.body = fs.createReadStream(path.join(__dirname, "..", "..", "www", "index.html"));
});
const mediaRoutes = media.routes();
for (const mroute of mediaRoutes) {
app.use(route[mroute.method.toLowerCase()](mroute.route, mroute.handler));
}
log.info(`Webpack is running in ${config.production ? "production" : "development"} mode`);
const webpackCfg = await buildWebpackCfg({
dev: !config.production,
configuration: {}
});
const webpackMiddlewareConf = webpackMiddleware(webpack(webpackCfg), {
stats: {
colors: true
}
});
app.use(webpackMiddlewareConf);
app.use(route.get("*", async (ctx) => {
ctx.type = "text/html; charset=utf-8";
ctx.body = fs.createReadStream(path.join(__dirname, "..", "..", "www", "index.html"));
}));
// app.use(route.get("*", async (ctx) => await send(ctx, "/index.html", { root: path.join(__dirname, "..", "..", "www") })));
server = app.listen(params.port);
enableDestroy(server);
// Socket.io if we have defined API
await api.start(server, { sessionName: sessionName, sessionMaxAge: sessionMaxAge }, sessions);
log.info(`Now listening for http request on port ${params.port}`);
},
import webpack from 'webpack'
import c2k from 'koa-connect'
import webpackDevMiddleware from 'koa-webpack-dev-middleware'
import webpackHotMiddleware from 'webpack-hot-middleware'
import webpackConfig from '../../webpack.config'
const compiler = webpack(webpackConfig)
export default process.env.NODE_ENV === 'development' ? [
webpackDevMiddleware(compiler, {
noInfo: false,
publicPath: '/layout/js/',
quiet: true,
stats: {
chunk: false,
chunkModules: false,
version: false,
colors: true,
hash: false
}
}),
c2k(webpackHotMiddleware(compiler, {
log: console.log,
path: '/__webpack_hmr'
}))
] : false
process.env.NODE_ENV = 'development'
import Koa from 'koa'
import webpack from 'webpack'
import convert from 'koa-convert'
import devMiddleware from 'koa-webpack-dev-middleware'
import hotMiddleware from 'koa-webpack-hot-middleware'
import config from './dev.config'
const app = new Koa()
const compiler = webpack(config.webpack)
app.use(convert(devMiddleware(compiler, config.server.options)))
app.use(convert(hotMiddleware(compiler)))
app.listen(config.server.port, '0.0.0.0', () => {
console.log(`webpack-dev-server listening on port ${config.server.port} 🚀`)
})
const {renderToStream} = createRenderer()
import vm from '../client/main'
import assets from '../build/webpack-assets'
const app = new Koa()
if (process.env.NODE_ENV === 'development') {
const webpack = require('webpack')
const webpackConfig = require('../scripts/webpack.client.dev')
const compiler = webpack(webpackConfig)
const devMiddleware = require('koa-webpack-dev-middleware')
const hotMiddleware = require('koa-webpack-hot-middleware')
app.use(convert(devMiddleware(compiler, {
publicPath: webpackConfig.output.publicPath,
stats: {
colors: true,
modules: false,
children: false,
chunks: false,
chunkModules: false
}
})))
app.use(convert(hotMiddleware(compiler)))
} else {
// use nginx to serve static files in real
app.use(convert(serve({rootDir: path.join(process.cwd(), 'build'), rootPath: '/static'})))
}
app.use(function (ctx) {
ctx.type = 'text/html; charset=utf-8'
const title = 'Vue Isomorphic Starter'
const stream = CombinedStream.create()
ctx.body = { message: err.message }
ctx.status = err.status || 500
}
})
// This rewrites all routes requests to the root /index.html file
// (ignoring file requests). If you want to implement isomorphic
// rendering, you'll want to remove this middleware.
app.use(convert(historyApiFallback({
verbose: false
})))
const compiler = webpack(webpackConfig);
app.use(convert(WebpackDevMiddleware(compiler, {
hot: true,
noInfo: true,
publicPath: webpackConfig.output.publicPath,
historyApiFallback: true
})))
app.use(convert(WebpackHotMiddleware(compiler, {
log: console.log,
path: '/__webpack_hmr',
heartbeat: 10 * 1000
})))
app.use(serve(__dirname + '/../public'))
app.use(convert(jwt({
secret: process.env.JWT_SECRET
}).unless({
path: [
'/login',
const Koa = require('koa');
const serve = require('koa-static');
const config = require('../config');
const app = new Koa();
app.use(serve('static'));
app.use(serve('dist'));
if (process.env.NODE_ENV != 'PRODUCTION') {
const webpack = require('webpack');
const webpackConfig = require('../webpack.config.js');
const bundler = webpack(webpackConfig);
const webpackDevMiddleware = require('koa-webpack-dev-middleware');
const webpackHotMiddleware = require('koa-webpack-hot-middleware');
app.use(webpackDevMiddleware(bundler));
app.use(webpackHotMiddleware(bundler));
}
app.listen(process.env.port || config.get('app:port'), () => console.log(`app server started on port ${config.get('app:port')}`));
const serverConfig = {
contentBase: `http://${host}:${port}`,
quiet: false,
noInfo: false,
hot: true,
inline: true,
lazy: false,
publicPath: webpackConfig.output.publicPath,
headers: {'Access-Control-Allow-Origin': '*'},
stats: {
colors: true,
chunks: false
},
historyApiFallback: true
}
const app = new Koa()
const compiler = webpack(webpackConfig)
const devMiddleware = devMiddlewareFactory(compiler, serverConfig)
const hotMiddleware = hotMiddlewareFactory(compiler)
app.use(convert(devMiddleware))
app.use(convert(hotMiddleware))
app.listen(port, (err) => {
if (err) {
return logger.error(err)
}
logger.appStarted(port)
})