feat: add "rules" concept, resolve.root name-clash detection with node_modules packages, file path existence checks (#81)

BREAKING CHANGE: validate() now takes only two arguments. The schema which could be passed as second argument can now be supplied via property `schema` on the options object which is now the second argument. The now preferred way to supply extra properties to the schema is supplying a a Joi.object via the options property `schemaExtension`, that *just contains the properties you want to add* (see README under "Customizing"). The schema used by this library **is not exported anymore**, as we now parameterize it by supplying "rules" which toggle / modify parts of the schema (Have a look at `src/index.js` to learn more).

Author: jonathanglasmeyer

.eslintignore

@@ -1,5 +1,6 @@
 node_modules/
 dist/
 test/passing-configs
+test/failing-configs
 coverage/
 .nyc_output/

.travis.yml

@@ -1,7 +1,9 @@
 sudo: false
 language: node_js
 node_js:
-  - '5'
+  - '4'
+before_install:
+  - npm i -g npm@^3.0.0
 cache:
   directories:
     - node_modules

README.md

@@ -57,27 +57,39 @@ Now run webpack. Either everything is green and the build continues or `joi` wil
 #### CLI
 For CLI usage you probably want to install the tool globally (`npm install -g webpack-validator`) first. Then just run `webpack-validator <your-config>`.
 
-#### Customizing
+### Customizing
+#### Schema
 If you need to extend the schema, for example for custom top level properties or properties added by third party plugins like `eslint-loader` (which adds a toplevel `eslint` property), do it like this:
 
 ```js
 const validate = require('webpack-validator')
-const schema = require('webpack-validator').schema
+const Joi = require('webpack-validator').Joi
 
-// joi is installed as dependency of this package and will be available in node_modules
-// if you use npm 3. Otherwise install it explicitly.
-const Joi = require('joi')
-
-const yourSchema = schema.concat(Joi.object({
+// This joi schema will be `Joi.concat`-ed with the internal schema
+const yourSchemaExtension = Joi.object({
   // this would just allow the property and doesn't perform any additional validation
   eslint: Joi.any()
-}))
+})
 
 const config = { /* ... your webpack config */ }
 
-// Override default config by supplying your config as second parameter.
-module.exports = validate(config, yourSchema)
+module.exports = validate(config, { schemaExtension: yourSchemaExtension })
+```
+
+#### Rules
+Some validations do more than just validating your data shape, they check for best practices and do "more" which you might want to opt out of / in to. This is an overview of the available rules (we just started with this, this list will grow :)):
+- **no-root-files-node-modules-nameclash** (default: true): this checks that files/folders that are found in directories specified via webpacks `resolve.root` option do not nameclash with `node_modules` packages. This prevents nasty path resolving bugs (for a motivating example, have a look at [this redux issue](https://github.com/reactjs/redux/issues/1681)).
+
+You opt in/out of rules by using the `rules` option:
 ```
+module.exports = validate(config, {
+  rules: {
+    'no-root-files-node-modules-nameclash': false,
+  },
+)
+```
+
+**Note**: This is not yet implemented via cli options, the default rules will apply in that case.
 
 #### Quiet Mode
 If you want to mute console output apart from errors, set `--quiet` (`-q`) or `validate(config, yourSchema, {quiet: true})`. This is particularly useful if you are using webpack `--json` as you'll want to avoid writing additional text to the JSON output.

package.json

@@ -13,13 +13,10 @@
     "build": "babel --ignore *.test.js -d dist src",
     "check-coverage": "nyc check-coverage --statements 100 --branches 100 --functions 100 --lines 100",
     "lint": "eslint .",
-    "cover": "nyc --reporter=lcov --reporter=text --reporter=html mocha src/**/*.test.js",
+    "cover": "cross-env NODE_ENV=test nyc --reporter=lcov --reporter=text --reporter=html mocha \"src/**/*.test.js\"",
     "report-coverage": "cat ./coverage/lcov.info | node_modules/.bin/codecov",
-    "test": "mocha \"src/**/*.test.js\"",
+    "test": "cross-env NODE_ENV=test mocha \"src/**/*.test.js\"",
     "watch:test": "npm run test -- -w",
-    "release": "npm run build && with-package git commit -am pkg.version && with-package git tag pkg.version && git push && npm publish && git push --tags",
-    "release:beta": "npm run release && npm run tag:beta",
-    "tag:beta": "with-package npm dist-tag add pkg.name@pkg.version beta",
     "semantic-release": "semantic-release pre && npm publish && semantic-release post"
   },
   "repository": {
@@ -41,12 +38,16 @@
     ]
   },
   "dependencies": {
+    "basename": "0.1.2",
     "chalk": "1.1.3",
     "commander": "2.9.0",
-    "joi": "8.0.5",
+    "cross-env": "^1.0.7",
+    "find-node-modules": "^1.0.1",
+    "joi": "9.0.0-0",
     "lodash": "4.11.1",
     "npmlog": "2.0.3",
-    "yargs": "4.7.1"
+    "yargs": "4.7.1",
+    "shelljs": "0.7.0"
   },
   "devDependencies": {
     "autoprefixer": "6.3.6",

src/index.js

@@ -7,56 +7,79 @@ import devtoolSchema from './properties/devtool'
 import externalsSchema from './properties/externals'
 import nodeSchema from './properties/node'
 import pluginsSchema from './properties/plugins'
-import resolveSchema from './properties/resolve'
+import resolveSchemaFn from './properties/resolve'
 import outputSchema from './properties/output'
 import watchOptionsSchema from './properties/watchOptions'
 import devServerSchema from './properties/devServer'
 import { absolutePath } from './types'
+import _merge from 'lodash/merge'
+import sh from 'shelljs'
 
-const schema = Joi.object({
-  amd: Joi.object(),
-  bail: Joi.boolean(),
-  cache: Joi.boolean(),
-  context: contextSchema,
-  debug: Joi.boolean(),
-  devServer: devServerSchema,
-  devtool: devtoolSchema,
-  entry: entrySchema,
-  externals: externalsSchema,
-  loader: Joi.any(), // ?
-  module: moduleSchema,
-  node: nodeSchema,
-  output: outputSchema,
-  plugins: pluginsSchema,
-  profile: Joi.boolean(),
-  recordsInputPath: absolutePath,
-  recordsOutputPath: absolutePath,
-  recordsPath: absolutePath,
-  resolve: resolveSchema,
-  resolveLoader: resolveSchema.concat(Joi.object({
-    moduleTemplates: Joi.array().items(Joi.string()),
-  })),
-  watchOptions: watchOptionsSchema,
-  stats: Joi.any(), // TODO
-  target: Joi.any(), // TODO
+sh.config.silent = true
 
-  // Plugins
-  postcss: Joi.any(),
-  eslint: Joi.any(),
-  tslint: Joi.any(),
-  metadata: Joi.any(),
-})//.unknown()
+const makeSchema = (schemaOptions, schemaExtension) => {
+  const resolveSchema = resolveSchemaFn(schemaOptions)
 
+  const schema = Joi.object({
+    amd: Joi.object(),
+    bail: Joi.boolean(),
+    cache: Joi.boolean(),
+    context: contextSchema,
+    debug: Joi.boolean(),
+    devServer: devServerSchema,
+    devtool: devtoolSchema,
+    entry: entrySchema,
+    externals: externalsSchema,
+    loader: Joi.any(), // ?
+    module: moduleSchema,
+    node: nodeSchema,
+    output: outputSchema,
+    plugins: pluginsSchema,
+    profile: Joi.boolean(),
+    recordsInputPath: absolutePath,
+    recordsOutputPath: absolutePath,
+    recordsPath: absolutePath,
+    resolve: resolveSchema,
+    resolveLoader: resolveSchema.concat(Joi.object({
+      moduleTemplates: Joi.array().items(Joi.string()),
+    })),
+    watchOptions: watchOptionsSchema,
+    stats: Joi.any(), // TODO
+    target: Joi.any(), // TODO
+
+    // Plugins
+    postcss: Joi.any(),
+    eslint: Joi.any(),
+    tslint: Joi.any(),
+    metadata: Joi.any(),
+  })
+  return schemaExtension ? schema.concat(schemaExtension) : schema
+}
+
+const defaultSchemaOptions = {
+  rules: {
+    'no-root-files-node-modules-nameclash': true,
+  },
+}
 
 // Easier consumability for require (default use case for non-transpiled webpack configs)
-module.exports = function validate(config, schema_ = schema, options = {}) {
+module.exports = function validate(config, options = {}) {
   const {
     // Don't return the config object and throw on error, but just return the validation result
     returnValidation, // bool
     quiet, // bool
+    schema: overrideSchema, // Don't take internal schema, but override with this one
+    schemaExtension, // Internal schema will be `Joi.concat`-ted with this schema if supplied
+    rules,
   } = options
 
-  const validationResult = Joi.validate(config, schema_, { abortEarly: false })
+  const schemaOptions = _merge(defaultSchemaOptions, { rules })
+
+  const schema = overrideSchema || makeSchema(schemaOptions, schemaExtension)
+
+  const validationResult = Joi.validate(config, schema, { abortEarly: false })
+  validationResult.schemaOptions = schemaOptions // Mainly for having sth to assert on right now
+
   if (returnValidation) return validationResult
 
   if (validationResult.error) {
@@ -70,4 +93,5 @@ module.exports = function validate(config, schema_ = schema, options = {}) {
 
   return config
 }
-module.exports.schema = schema
+
+module.exports.Joi = Joi

src/index.test.js

@@ -1,6 +1,7 @@
 import sinon from 'sinon'
 import configs from '../test/passing-configs'
-import validate from './'
+import failingConfigs from '../test/failing-configs'
+import validate, { Joi } from './'
 
 describe('.', () => {
   let sandbox
@@ -33,20 +34,19 @@ describe('.', () => {
     })
   })
 
-  it('for an invalid config the joi validation result is printed to console.error and ' +
-     'the process exits with exit code 1', () => {
-    const invalidConfig = { resolvee: 'bar' }
-    validate(invalidConfig)
-
-    // The error message should have been printed
-    assert(consoleErrorStub.callCount === 1)
+  failingConfigs.forEach(({ config, name }) => {
+    it(`throws for ${name}`, () => {
+      validate(config)
+      // The error message should have been printed
+      assert(consoleErrorStub.callCount === 1)
 
-    // process.exit should have been called
-    assert(processExitStub.callCount === 1)
+      // process.exit should have been called
+      assert(processExitStub.callCount === 1)
+    })
   })
 
   it('should allow console output to be muted', () => {
-    validate({}, {}, { quiet: true })
+    validate({}, { quiet: true })
 
     // The success message should not have been printed
     assert(consoleInfoStub.callCount === 0)
@@ -58,4 +58,38 @@ describe('.', () => {
     // process.exit should not have been called
     assert(processExitStub.callCount === 0)
   })
+
+  const fooSchema = Joi.object({ foo: Joi.string() })
+
+  it('should allow the schema to be extended', () => {
+    const result1 = validate({ foo: 'bar' }, { returnValidation: true })
+    const result2 = validate({ foo: 'bar' }, {
+      returnValidation: true,
+      schemaExtension: fooSchema,
+    })
+    assert(result1.error)
+    assert(!result2.error)
+  })
+
+  it('should allow the schema to be overridden', () => {
+    const result = validate({ foo: 'bar' }, {
+      schema: fooSchema,
+      returnValidation: true,
+    })
+    assert(!result.error)
+  })
+
+  it('should allow overriding rules', () => {
+    const result = validate({ foo: 'bar' }, {
+      rules: {
+        foo: true,
+        'no-root-files-node-modules-nameclash': false,
+      },
+      returnValidation: true,
+    })
+    assert(result.schemaOptions.rules.foo)
+    assert(result.schemaOptions.rules['no-root-files-node-modules-nameclash'] === false)
+    // Will be merged with default rules, so length def greater then 1
+    assert(Object.keys(result.schemaOptions.rules).length > 1)
+  })
 })

src/properties/context/index.test.js

@@ -3,13 +3,13 @@ import { allValid, allInvalid } from '../../../test/utils'
 
 const validModuleConfigs = [
   // #0
-  '/home/jwerner/foo/entry.js', // Absolute
+  { input: 'exists' }, // Absolute
 ]
 
 const invalidModuleConfigs = [
   // #0
   // Relative
-  { input: './entry.js', error: { message: '"value" must be an absolute path' } },
+  { input: './entry.js', error: { type: 'path.absolute' } },
 
   // #1
   { input: 1, error: { message: '"value" must be a string' } },