feat(startup): validate config on startup

closes #26
- add `startup` checks to ghost-cli

Author: acburdine

lib/commands/config/advanced.js

@@ -1,6 +1,7 @@
 'use strict';
 // Advanced options for the config command
 const portfinder = require('portfinder');
+const toString = require('lodash/toString');
 const includes = require('lodash/includes');
 const validator = require('validator');
 const url = require('url');
@@ -39,6 +40,8 @@ module.exports = [{
     description: 'Port ghost should listen on',
     configPath: 'server.port',
     validate: value => {
+        value = toString(value);
+
         if (!validator.isInt(value, {allow_leading_zeros: false})) {
             return 'Port must be an integer.';
         }

lib/commands/doctor/checks/startup.js

@@ -0,0 +1,45 @@
+'use strict';
+const path = require('path');
+const get = require('lodash/get');
+const filter = require('lodash/filter');
+const Promise   = require('bluebird');
+
+const errors = require('../../../errors');
+const Config = require('../../../utils/config');
+const advancedOptions = require('../../config/advanced');
+
+module.exports = [{
+    title: 'Validating config',
+    task: (ctx) => {
+        let config = Config.exists(path.join(process.cwd(), `config.${ctx.environment}.json`));
+
+        if (config === false) {
+            return Promise.reject(new errors.ConfigError({
+                environment: ctx.environment,
+                message: 'Config file is not valid JSON'
+            }));
+        }
+
+        let configValidations = filter(advancedOptions, cfg => cfg.validate);
+
+        return Promise.each(configValidations, (configItem) => {
+            let key = configItem.configPath || configItem.name
+            let value = get(config, key);
+
+            if (!value) {
+                return;
+            }
+
+            return Promise.resolve(configItem.validate(value)).then((validated) => {
+                if (validated !== true) {
+                    return Promise.reject(new errors.ConfigError({
+                        configKey: key,
+                        configValue: value,
+                        message: validated,
+                        environment: ctx.environment
+                    }));
+                }
+            });
+        });
+    }
+}];

lib/commands/start.js

@@ -2,9 +2,11 @@
 const fs = require('fs');
 const path = require('path');
 const KnexMigrator = require('knex-migrator');
+const Listr = require('listr');
 
 const Config = require('../utils/config');
 const errors = require('../errors');
+const startupChecks = require('./doctor/checks/startup');
 const checkValidInstall = require('../utils/check-valid-install');
 
 function register(config, environment) {
@@ -25,6 +27,7 @@ module.exports.execute = function execute(options) {
     checkValidInstall('start');
 
     options = options || {};
+    let config, cliConfig;
 
     // If we are starting in production mode but a development config exists and a production config doesn't,
     // we want to start in development mode anyways.
@@ -35,47 +38,49 @@ module.exports.execute = function execute(options) {
         process.env.NODE_ENV = this.environment = 'development';
     }
 
-    let config = Config.load(this.environment);
-    let cliConfig = Config.load('.ghost-cli');
+    return new Listr(startupChecks, {renderer: this.renderer}).run(this).then(() => {
+        config = Config.load(this.environment);
+        cliConfig = Config.load('.ghost-cli');
 
-    if (cliConfig.has('running')) {
-        return Promise.reject(new Error('Ghost is already running.'));
-    }
+        if (cliConfig.has('running')) {
+            return Promise.reject(new Error('Ghost is already running.'));
+        }
 
-    this.service.setConfig(config);
+        this.service.setConfig(config);
 
-    process.env.paths__contentPath = path.join(process.cwd(), 'content');
+        process.env.paths__contentPath = path.join(process.cwd(), 'content');
 
-    let knexMigrator = new KnexMigrator({
-        knexMigratorFilePath: path.join(process.cwd(), 'current')
-    });
-
-    return knexMigrator.isDatabaseOK().catch((error) => {
-        if (error.code === 'DB_NOT_INITIALISED' ||
-            error.code === 'MIGRATION_TABLE_IS_MISSING') {
-            return knexMigrator.init();
-        } else if (error.code === 'DB_NEEDS_MIGRATION') {
-            return knexMigrator.migrate();
-        }
-
-        if (error.code === 'ENOTFOUND') {
-            // Database not found
-            error = new errors.ConfigError({
-                configKey: 'database.connection.host',
-                configValue: config.get('database.connection.host'),
-                message: 'Invalid database host',
-                environment: this.environment
-            });
-        } else if (error.code === 'ER_ACCESS_DENIED_ERROR') {
-            error = new errors.ConfigError({
-                configKey: 'database.connection.user',
-                configValue: config.get('database.connection.user'),
-                message: 'Invalid database username or password',
-                environment: this.environment
-            });
-        }
+        let knexMigrator = new KnexMigrator({
+            knexMigratorFilePath: path.join(process.cwd(), 'current')
+        });
 
-        return Promise.reject(error);
+        return knexMigrator.isDatabaseOK().catch((error) => {
+            if (error.code === 'DB_NOT_INITIALISED' ||
+                error.code === 'MIGRATION_TABLE_IS_MISSING') {
+                return knexMigrator.init();
+            } else if (error.code === 'DB_NEEDS_MIGRATION') {
+                return knexMigrator.migrate();
+            }
+
+            if (error.code === 'ENOTFOUND') {
+                // Database not found
+                error = new errors.ConfigError({
+                    configKey: 'database.connection.host',
+                    configValue: config.get('database.connection.host'),
+                    message: 'Invalid database host',
+                    environment: this.environment
+                });
+            } else if (error.code === 'ER_ACCESS_DENIED_ERROR') {
+                error = new errors.ConfigError({
+                    configKey: 'database.connection.user',
+                    configValue: config.get('database.connection.user'),
+                    message: 'Invalid database username or password',
+                    environment: this.environment
+                });
+            }
+
+            return Promise.reject(error);
+        });
     }).then(() => {
         let start = () => Promise.resolve(this.service.process.start(process.cwd(), this.environment)).then(() => {
             register(config, this.environment);

lib/errors.js

@@ -111,11 +111,16 @@ class ConfigError extends CliError {
     }
 
     toString() {
-        return chalk.red(`Error detected in the ${this.options.environment} configuration.\n\n`) +
-            `${chalk.gray('Message:')} ${this.options.message}\n` +
-            `${chalk.gray('Configuration Key:')} ${this.options.configKey}\n` +
-            `${chalk.gray('Current Value:')} ${this.options.configValue}\n\n` +
-            chalk.blue(`Run \`${chalk.underline('ghost config ${this.options.configKey} <new value>')}\` to fix it.\n`);
+        let initial = chalk.red(`Error detected in the ${this.options.environment} configuration.\n\n`) +
+            `${chalk.gray('Message:')} ${this.options.message}\n`;
+
+        if (this.options.configKey) {
+            initial += `${chalk.gray('Configuration Key:')} ${this.options.configKey}\n` +
+                `${chalk.gray('Current Value:')} ${this.options.configValue}\n\n` +
+                chalk.blue(`Run \`${chalk.underline(`ghost config ${this.options.configKey} <new value>`)}\` to fix it.\n`);
+        }
+
+        return initial;
     }
 }