Extracting webpack utils to their own file (#147)

packages/neutrino/bin/neutrino

@@ -71,6 +71,11 @@ const normalizeOptions = (args) => {
   });
 };
 
+process.on('unhandledRejection', (err) => {
+  console.error(err);
+  process.exit(1);
+});
+
 const cmd = args.inspect ? 'inspect' : args._[0];
 const middleware = foldMiddleware(args);
 const options = normalizeOptions(args);

packages/neutrino/src/build.js

@@ -1,10 +1,10 @@
 const Future = require('fluture');
-const { webpackCompile, validateWebpackConfig } = require('./utils');
+const { compile, validate } = require('./webpack');
 
 // build :: Object config -> Future (Array Error) Function
 const build = config => Future
   .of(config)
-  .chain(validateWebpackConfig)
+  .chain(validate)
-  .chain(webpackCompile);
+  .chain(compile);
 
 module.exports = build;

packages/neutrino/src/devServer.js

@@ -1,19 +1,11 @@
 const merge = require('deepmerge');
-const DevServer = require('webpack-dev-server');
 const Future = require('fluture');
-const { createWebpackCompiler, validateWebpackConfig } = require('./utils');
+const { serve, validate } = require('./webpack');
 
-// devServer :: Object config -> Future () Function
+// server :: Object config -> Future () Function
 const devServer = config => Future
   .of(merge({ devServer: { host: 'localhost', port: 5000, noInfo: true } }, config))
-  .chain(validateWebpackConfig)
+  .chain(validate)
-  .chain(createWebpackCompiler)
+  .chain(serve);
-  .chain(compiler => Future((reject, resolve) => {
-    const { devServer } = compiler.options;
-    const { host, port } = devServer;
-    const server = new DevServer(compiler, devServer);
-
-    server.listen(port, host, () => resolve(compiler));
-  }));
 
 module.exports = devServer;

packages/neutrino/src/utils.js

@@ -3,7 +3,6 @@ const { cond, curry, defaultTo, identity, map, memoize, of, partialRight, pipe,
 const { List } = require('immutable-ext');
 const { isAbsolute, join } = require('path');
 const optional = require('optional');
-const webpack = require('webpack');
 
 // any :: List -> Future a b
 const any = reduce(Future.or, Future.reject('empty list'));
@@ -48,53 +47,14 @@ const toArray = cond([
   [T, of]
 ]);
 
-// webpackErrors :: (Error|Array Error err -> Object stats) -> Array Error
-const webpackErrors = (err, stats) => (err ? toArray(err) : stats.toJson().errors);
-
-// createWebpackCompiler :: Object config -> Future Error Object
-const createWebpackCompiler = config => Future.of(config).map(webpack);
-
-// createWebpackValidator :: Object config -> Future Error Object
-const createWebpackValidator = config => Future.of(config).map(webpack.validate);
-
-// createWebpackWatcher :: Object config -> Future Error Object
-const createWebpackWatcher = config => createWebpackCompiler(config)
-  .chain(compiler => Future((reject, resolve) => {
-    compiler.watch(compiler.options.watchOptions || {}, (err, stats) => {
-      const errors = webpackErrors(err, stats);
-
-      errors.length ? reject(errors) : resolve(compiler);
-    });
-  }));
-
-// validateWebpackConfig :: Object config -> Future Error Object
-const validateWebpackConfig = config => createWebpackValidator(config)
-  .chain(errors => (errors.length ?
-    Future.reject([new webpack.WebpackOptionsValidationError(errors)]) :
-    Future.of(config)));
-
-// webpackCompile :: Object config -> Future Error Object
-const webpackCompile = config => createWebpackCompiler(config)
-  .chain(compiler => Future((reject, resolve) => compiler.run((err, stats) => {
-    const errors = webpackErrors(err, stats);
-
-    errors.length ? reject(errors) : resolve(stats);
-  })));
-
 module.exports = {
   any,
   createPaths,
-  createWebpackCompiler,
-  createWebpackValidator,
-  createWebpackWatcher,
   getNodeEnv,
   getPackageJson,
   normalizePath,
   requireSafe,
   resolveAny,
   resolveSafe,
-  toArray,
+  toArray
-  validateWebpackConfig,
-  webpackCompile,
-  webpackErrors
 };

packages/neutrino/src/watch.js

@@ -1,10 +1,10 @@
 const Future = require('fluture');
-const { createWebpackWatcher, validateWebpackConfig } = require('./utils');
+const { watcher, validate } = require('./webpack');
 
 // watch :: Object config -> Future (Array Error) ()
 const watch = config => Future
   .of(config)
-  .chain(validateWebpackConfig)
+  .chain(validate)
-  .chain(createWebpackWatcher);
+  .chain(watcher);
 
 module.exports = watch;

packages/neutrino/src/webpack.js

@@ -0,0 +1,74 @@
+const Future = require('fluture');
+const { assoc, construct, isEmpty, pathOr, pipe } = require('ramda');
+const webpack = require('webpack');
+const DevServer = construct(require('webpack-dev-server'));
+const { toArray } = require('./utils');
+
+// errors :: (Error|Array Error err -> Object stats) -> Array Error
+const getErrors = (err, stats) => (err ? toArray(err) : stats.toJson().errors);
+
+// compiler :: Object config -> Future Error Object
+const compiler = pipe(Future.of, Future.ap(Future.of(webpack)));
+
+// compile :: Object config -> Future Error Object
+const compile = pipe(
+  compiler,
+  Future.chain(compiler => Future((reject, resolve) => {
+    compiler.run((err, stats) => {
+      const errors = getErrors(err, stats);
+
+      isEmpty(errors) ? resolve(stats) : reject(errors);
+    });
+  }))
+);
+
+// devServer :: Object config -> Future Error Object
+const devServer = pipe(
+  compiler,
+  Future.map(compiler => assoc('compiler', compiler, new DevServer(compiler, compiler.options.devServer)))
+);
+
+// serve :: Object config -> Future Error Object
+const serve = pipe(
+  devServer,
+  Future.chain(server => Future((reject, resolve) => {
+    const { compiler } = server;
+    const { host, port } = compiler.options.devServer;
+
+    server.listen(port, host, () => resolve(compiler));
+  }))
+);
+
+// validator :: Object config -> Future Error Object
+const validator = pipe(Future.of, Future.ap(Future.of(webpack.validate)));
+
+// validate :: Object config -> Future Error Object
+const validate = config => validator(config)
+  .chain(errors => (isEmpty(errors) ?
+    Future.of(config) :
+    Future.reject([new webpack.WebpackOptionsValidationError(errors)])));
+
+// watch :: Object config -> Future Error Object
+const watcher = pipe(
+  compiler,
+  Future.chain(compiler => Future((reject, resolve) => {
+    const watchOptions = pathOr({}, ['options', 'watchOptions'], compiler);
+
+    compiler.watch(watchOptions, (err, stats) => {
+      const errors = getErrors(err, stats);
+
+      isEmpty(errors) ? resolve(compiler) : reject(errors);
+    });
+  }))
+);
+
+module.exports = {
+  getErrors,
+  compiler,
+  compile,
+  devServer,
+  serve,
+  validator,
+  validate,
+  watcher
+};