@oroinc/oro-webpack-config-builder 5.1.0-alpha33 → 5.1.0-alpha34

package/error-handler.js

@@ -0,0 +1,95 @@
+const BaseError = require('./validation/errors/base-error');
+const {isVerboseMode} = require('./utils');
+const {red, yellow, green, bgRed} = require('colorette');
+
+const emptyLine = length => new Array(length).fill(' ').join('');
+const multiline = (color, msg) => {
+    msg = ` ${msg}`;
+    msg = msg + emptyLine(120 - msg.length);
+
+    return `\n${color(emptyLine(msg.length))}\n${color(msg)}\n${color(emptyLine(msg.length))}`;
+};
+
+class ErrorHandler {
+    constructor() {
+        this.failedThemes = [];
+
+        process.on('beforeExit', code => {
+            this.onProcess();
+        });
+    }
+
+    /**
+     * Show a message about failed themes
+     */
+    onProcess() {
+        if (this.failedThemes.length) {
+            let msg = '[ERROR] Assets build';
+
+            if (this.failedThemes.length === 1) {
+                msg = `${msg} for "${this.failedThemes[0]}" theme failed.`;
+            } else {
+                msg = `${msg} for "${this.failedThemes.join(', ')}" themes failed.`;
+            }
+            console.error(multiline(bgRed, msg));
+            process.exit(1);
+        }
+    }
+
+    /**
+     * Executes when the Webpack Compiler will complete a compilation
+     * In case of empty Webpack Config this method will not run
+     *
+     * @param {Object} stats
+     */
+    onBuildComplete(stats) {
+        const failed = stats?.compilation?.errors.length !== 0;
+
+        if (failed) {
+            console.error(multiline(bgRed, '[ERROR] Assets build failed.'));
+            process.exit(1);
+        }
+    }
+
+    /**
+     * @param {Array|string} errors
+     * @param {string} [failedTheme]
+     */
+    displayError(errors, failedTheme) {
+        if (typeof failedTheme === 'string') {
+            this.failedThemes.push(failedTheme);
+        }
+
+        if (typeof errors === 'string') {
+            errors = [errors];
+        }
+
+        const errorMessage = errors.map(err => {
+            const highlightPrefix = str => {
+                const prefix = str.substring(0, str.search(':'));
+                return red(prefix) + str.substring(str.search(':'));
+            };
+
+            if (err instanceof BaseError) {
+                err.message = `${err.message}\n${green(err.extra)}`;
+            }
+
+            let msg = err.message;
+
+            if (isVerboseMode()) {
+                msg = highlightPrefix(err.stack);
+            } else {
+                const command = yellow('php bin/console oro:assets:build --env=dev --verbose');
+                const info = `${green(`Run the command ${command} to see more information`)}`;
+
+                msg = highlightPrefix(`${err.name}: ${msg}\n${info}`);
+            }
+
+            return `${msg}\n`;
+        });
+
+        console.error(errorMessage.join('\n'));
+    }
+}
+
+module.exports = ErrorHandler;

package/modules-config/layout-modules-config-loader.js

@@ -8,13 +8,17 @@ class LayoutModulesConfigLoader extends ModulesConfigLoader {
      */
     loadConfig(theme, filePath) {
         let themeConfig = super.loadConfig(theme, path.join('Resources/views/layouts/', theme, filePath));
+
         // recursive process parent theme
         const {parent: parentTheme} = this.themes[theme];
         if (typeof parentTheme === 'string') {
+            const processedFiles = this.processedFiles;
             const parentThemeConfig = this.loadConfig(parentTheme, filePath);
+
             themeConfig = merge(parentThemeConfig, themeConfig);
+            // processedFiles from parent theme is added to processedFiles of current theme
+            this._processedFiles = [...processedFiles, ...this.processedFiles];
         }
-
         return themeConfig;
     }
 
@@ -40,7 +44,7 @@ class LayoutModulesConfigLoader extends ModulesConfigLoader {
      * @return {string[]}
      */
     extraJSBuildNames(theme) {
-        const {extra_js_builds:  extraJSBuilds = []} = this._themes[theme] || {}
+        const {extra_js_builds: extraJSBuilds = []} = this._themes[theme] || {};
         return [...extraJSBuilds.map(suffix => `${theme}-${suffix}`)];
     }
 
@@ -66,7 +70,7 @@ class LayoutModulesConfigLoader extends ModulesConfigLoader {
         const result = [];
         if (marches) {
             const [, theme, suffix] = marches;
-            const {extra_js_builds:  extraJSBuilds = []} = this._themes[theme] || {}
+            const {extra_js_builds: extraJSBuilds = []} = this._themes[theme] || {};
             if (extraJSBuilds.includes(suffix)) {
                 result.push(marches[1], marches[2]);
             } else {

package/modules-config/modules-config-loader.js

@@ -2,6 +2,7 @@ const path = require('path');
 const fs = require('fs');
 const merge = require('deepmerge');
 const yaml = require('js-yaml');
+const validation = require('../validation');
 
 // merge only unique items
 const arrayMerge = (target, source) => target.concat(source.filter(item => !target.includes(item)));
@@ -28,6 +29,13 @@ class ModulesConfigLoader {
         return this.themeNames;
     }
 
+    /**
+     * @returns {Array}
+     */
+    get processedFiles() {
+        return [...this._processedFiles];
+    }
+
     /**
      * @param {Array} bundles Array of ordered symfony bundle paths
      * @param {string} themesLocation Path inside the bundle, where to find the theme
@@ -36,6 +44,7 @@ class ModulesConfigLoader {
     constructor(bundles, themesLocation, themeInfoFileName) {
         this._bundles = bundles;
         this._themes = this._getThemes(themesLocation, themeInfoFileName);
+        this._processedFiles = [];
     }
 
     /**
@@ -76,6 +85,8 @@ class ModulesConfigLoader {
     loadConfig(theme, filePath) {
         let configs = {};
         const filePaths = [].concat(filePath);
+
+        this._processedFiles = [];
         this._bundles.forEach(bundle => {
             let absolutePath;
 
@@ -88,10 +99,16 @@ class ModulesConfigLoader {
             }
 
             if (absolutePath) {
-                const doc = yaml.load(fs.readFileSync(absolutePath, 'utf8'));
+                const rawDoc = fs.readFileSync(absolutePath, 'utf8');
+                const doc = yaml.load(rawDoc);
+
+                this._processedFiles.push(absolutePath);
+
+                validation.checkSchema(absolutePath, doc, theme);
                 configs = merge(configs, doc);
             }
         });
+
         return configs;
     }
 }

package/oro-webpack-config.js

@@ -3,6 +3,7 @@ const printf = require('printf');
 const AppConfigLoader = require('./app-config-loader');
 const AppModulesFileWriter = require('./writer/app-modules-file-writer');
 const CleanupStatsPlugin = require('./plugin/stats/cleanup-stats-plugin');
+const AfterWebpackLogsPlugin = require('./plugin/logs/after-webpack-logs-plugin');
 const ConfigsFileWriter = require('./writer/configs-file-writer');
 const EntryPointFileWriter = require('./writer/scss-entry-point-file-writer');
 const LayoutModulesConfigLoader = require('./modules-config/layout-modules-config-loader');
@@ -23,33 +24,44 @@ const resolve = require('enhanced-resolve');
 const {merge: webpackMerge} = require('webpack-merge');
 const BundleAnalyzerPlugin = require('webpack-bundle-analyzer').BundleAnalyzerPlugin;
 const RtlCssWebpackPlugin = require('rtlcss-webpack-plugin');
-const {red: colorRed} = require('colorette');
+const validation = require('./validation');
+const EventEmitter = require('events');
+const ErrorHandler = require('./error-handler');
+
 require('resolve-url-loader');
 
 class ConfigBuilder {
     constructor() {
-        this._publicPath = 'public/';
-        this._adminTheme = 'admin.oro';
         this._enableLayoutThemes = false;
         this._defaultLayoutThemes = null;
-        this._versionFormat = '%s?v=%s';
-        this._babelConfig = {
+        this.emitter = new EventEmitter();
+        this.errorHandler = new ErrorHandler();
+        this.addListeners();
+        this.setPublicPath('public/');
+        this.setAdminTheme('admin.oro');
+        this.setVersionFormat('%s?v=%s');
+        this.setBabelConfig({
             sourceType: 'unambiguous',
             presets: [
                 [
                     '@babel/preset-env', {
-                    useBuiltIns: 'usage',
-                    corejs: {
-                        version: 3,
-                        proposals: true
+                        useBuiltIns: 'usage',
+                        corejs: {
+                            version: 3,
+                            proposals: true
+                        }
                     }
-                }
                 ]
             ],
             plugins: [
                 '@babel/plugin-transform-runtime'
             ]
-        };
+        });
+    }
+
+    addListeners() {
+        this.emitter.on('publicPath:updated', path => validation.setPublicPath(path));
+        this.emitter.on('build:complete', stats => this.errorHandler.onBuildComplete(stats));
     }
 
     /**
@@ -59,6 +71,7 @@ class ConfigBuilder {
      */
     setPublicPath(publicPath) {
         this._publicPath = publicPath;
+        this.emitter.emit('publicPath:updated', publicPath);
         return this;
     }
 
@@ -80,6 +93,7 @@ class ConfigBuilder {
      */
     setVersionFormat(versionFormat) {
         this._versionFormat = versionFormat;
+        this.emitter.emit('versionFormat:updated', versionFormat);
         return this;
     }
 
@@ -96,6 +110,7 @@ class ConfigBuilder {
         }
 
         this._adminTheme = adminTheme;
+        this.emitter.emit('adminTheme:updated', adminTheme);
         return this;
     }
 
@@ -105,8 +120,10 @@ class ConfigBuilder {
     enableLayoutThemes(themes) {
         if (themes) {
             this._defaultLayoutThemes = themes;
+            this.emitter.emit('defaultLayoutThemes:updated', themes);
         }
         this._enableLayoutThemes = true;
+        this.emitter.emit('enableLayoutThemes:updated', true);
         return this;
     }
 
@@ -117,6 +134,7 @@ class ConfigBuilder {
      */
     setBabelConfig(babelConfig) {
         this._babelConfig = babelConfig;
+        this.emitter.emit('babelConfig:updated', babelConfig);
         return this;
     }
 
@@ -132,19 +150,30 @@ class ConfigBuilder {
             try {
                 commonConfig = this._getCommonWebpackConfig(args, env);
             } catch (e) {
-                console.error(colorRed(`Error: ${e.message}`));
+                this.errorHandler.displayError(e);
                 process.exit(1);
             }
 
             const webpackConfigs = [];
             const requestedBuildNames = env.theme ? env.theme.split(',') : [];
             const buildNames = this._getBuildNames(requestedBuildNames);
+
+            const buildErrors = [];
+            validation.jsmodulesValidator.emitter.on('error', error => buildErrors.push(error));
+            validation.assetsValidation.emitter.on('error', error => buildErrors.push(error));
             buildNames.forEach(buildName => {
                 let buildConfig;
+                // flush all collected errors from previews builds
+                buildErrors.splice(0, buildErrors.length);
+
                 try {
                     buildConfig = this._getThemeWebpackConfig(buildName, args, env);
-                } catch (e) {
-                    console.error(colorRed(`Error: ${e.message}`));
+                } catch (error) {
+                    buildErrors.push(error);
+                }
+
+                if (buildErrors.length) {
+                    this.errorHandler.displayError(buildErrors, buildName);
                     return;
                 }
 
@@ -331,7 +360,10 @@ class ConfigBuilder {
                 }),
                 new webpack.optimize.MinChunkSizePlugin({
                     minChunkSize: 30000 // Minimum number of characters
-                })
+                }),
+                new AfterWebpackLogsPlugin(
+                    stats => this.emitter.emit('build:complete', stats)
+                )
             ]
         };
 
@@ -403,6 +435,11 @@ class ConfigBuilder {
             buildPublicPath = '/build/admin/';
             const jsModulesConfig = this._themeConfigFactory.loadConfig(buildName,
                 ['Resources/config/oro/jsmodules.yml', 'Resources/config/jsmodules.yml']);
+            validation.jsmodulesValidator.checkFullSchema(
+                jsModulesConfig,
+                this._themeConfigFactory?._configLoader.processedFiles,
+                buildName
+            );
             jsBuildConfig = this._themeConfigFactory.create(buildPublicPath, jsModulesConfig);
         } else if (this._layoutModulesConfigLoader.isExtraJSBuild(buildName)) {
             const [theme, suffix] = this._layoutModulesConfigLoader.splitBuildName(buildName);
@@ -412,11 +449,21 @@ class ConfigBuilder {
             const baseConfig = this._layoutThemeConfigFactory.loadConfig(theme, 'config/jsmodules.yml');
             const extraConfig = this._layoutThemeConfigFactory.loadConfig(theme, `config/jsmodules-${suffix}.yml`);
             const jsModulesConfig = this._layoutThemeConfigFactory.extendConfig(baseConfig, extraConfig);
+            validation.jsmodulesValidator.checkFullSchema(
+                jsModulesConfig,
+                this._layoutThemeConfigFactory?._configLoader.processedFiles,
+                buildName
+            );
             jsBuildConfig = this._layoutThemeConfigFactory.create(buildPublicPath, jsModulesConfig);
         } else {
             themeDefinition = this._layoutModulesConfigLoader.themes[buildName];
             buildPublicPath = `/build/${buildName}/`;
             const jsModulesConfig = this._layoutThemeConfigFactory.loadConfig(buildName, 'config/jsmodules.yml');
+            validation.jsmodulesValidator.checkFullSchema(
+                jsModulesConfig,
+                this._layoutThemeConfigFactory?._configLoader.processedFiles,
+                buildName
+            );
             jsBuildConfig = this._layoutThemeConfigFactory.create(buildPublicPath, jsModulesConfig);
         }
         const {rtl_support: rtlSupport = false} = themeDefinition;
@@ -481,7 +528,7 @@ class ConfigBuilder {
                     ...prepareModulesShim(resolver, jsBuildConfig.shim)
                 ]
             }
-        }
+        };
     }
 
     _initialize(args, env) {
@@ -520,7 +567,7 @@ class ConfigBuilder {
     }
 
     _getVersionedPath(name, assetVersion) {
-        if(!assetVersion) {
+        if (!assetVersion) {
             return name;
         }
         return printf(this._versionFormat, name, assetVersion);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oroinc/oro-webpack-config-builder",
-  "version": "5.1.0-alpha33",
+  "version": "5.1.0-alpha34",
   "author": "Oro, Inc (https://www.oroinc.com)",
   "license": "MIT",
   "description": "An integration of OroPlatform based applications with the Webpack.",
@@ -34,6 +34,7 @@
     "rtlcss-webpack-plugin": "~4.0.6",
     "sass": "~1.50.0",
     "sass-loader": "~12.6.0",
+    "schema-utils": "^4.0.0",
     "style-loader": "~3.3.1",
     "terser": "~5.12.1",
     "text-loader": "0.0.1",

package/plugin/logs/after-webpack-logs-plugin.js

@@ -0,0 +1,25 @@
+const {once} = require('underscore');
+
+class AfterWebpackLogsPlugin {
+    /**
+     * @param {function} afterLogsCb
+     */
+    constructor(afterLogsCb) {
+        if (typeof afterLogsCb !== 'function') {
+            throw new Error('The "afterLogsCb" arg should be a function');
+        }
+        this._afterLogsCb = once(afterLogsCb);
+    }
+
+    apply(compiler) {
+        compiler.hooks.done.tap('AfterWebpackLogsPlugin', stats => {
+            const compilerStats = stats;
+            stats.compilation.hooks.statsPrinter.tap('AfterWebpackLogsPlugin', stats => {
+                // Making logs to be after all webpack logs in the console
+                setImmediate(() => this._afterLogsCb(compilerStats));
+            });
+        });
+    }
+}
+
+module.exports = AfterWebpackLogsPlugin;

package/style/style-loader.js

@@ -1,7 +1,9 @@
 const path = require('path');
 const wildcard = require('wildcard');
 const _ = require('underscore');
-const messages = require('../messages')
+const {isProdMode} = require('../utils');
+const {assetsValidation} = require('../validation');
+const StylesError = require('../validation/errors/styles-error');
 
 /**
  * @typedef ThemeGroupConfig
@@ -30,17 +32,19 @@ class StyleLoader {
     getThemeEntryPoints(theme, buildPath) {
         const {themeConfig, settings = {}} = this._fetchThemeConfig(theme);
 
+        assetsValidation.checkFullSchema(themeConfig, this._configLoader.processedFiles, theme);
+
         const entryPoints = {};
         const writingOptions = {};
         for (const [group, config] of Object.entries(themeConfig)) {
             let {inputs, entries = [], output, auto_rtl_inputs: rtlMasks = []} = config;
 
-            if (output === void 0) {
-                throw new Error(messages.assetsMissedOutput(group, theme));
+            if (isProdMode() && output === void 0) {
+                throw new StylesError('output', group, theme);
             }
 
-            if (inputs === void 0) {
-                throw new Error(messages.assetsMissedInput(group, theme));
+            if (isProdMode() && inputs === void 0) {
+                throw new StylesError('inputs', group, theme);
             }
 
             inputs = this._overrideInputs(inputs);
@@ -89,7 +93,7 @@ class StyleLoader {
                 const oldInputIndex = mappedInputs.findIndex(item => item === oldInput);
 
                 if (oldInputIndex === -1) {
-                    // old input does not exists any more
+                    // old input does not exist anymore
                     mappedInputs.push(newInput);
                 } else if (newInput) {
                     // replace input
@@ -120,11 +124,11 @@ class StyleLoader {
         inputs.forEach(input => {
             if (input.indexOf('/settings/primary-settings') > 0) {
                 primarySettingsInputs.push(input);
-            } else if (input.indexOf('/settings/') > 0)  {
+            } else if (input.indexOf('/settings/') > 0) {
                 settingsInputs.push(input);
-            } else  if (input.indexOf('/variables/primary-variables') > 0) {
+            } else if (input.indexOf('/variables/primary-variables') > 0) {
                 primaryVariablesInputs.push(input);
-            } else if (input.indexOf('/variables/') > 0)  {
+            } else if (input.indexOf('/variables/') > 0) {
                 variablesInputs.push(input);
             } else {
                 restInputs.push(input);

package/theme-config-factory.js

@@ -1,4 +1,4 @@
-const messages = require('./messages');
+const JSModulesExtraModulesError = require('./validation/errors/jsmodules-extra-modules-error');
 
 class ThemeConfigFactory {
     /**
@@ -19,11 +19,7 @@ class ThemeConfigFactory {
      * @return {Object} Merged Configs loaded from all the bundles Yaml files matched by filePath
      */
     loadConfig(theme, configFilepath) {
-        try {
-            return this._configLoader.loadConfig(theme, configFilepath)
-        } catch (e) {
-            throw new Error(messages.jsModulesError(theme));
-        }
+        return this._configLoader.loadConfig(theme, configFilepath);
     }
 
     extendConfig(baseConfig, extraConfig) {
@@ -31,7 +27,7 @@ class ThemeConfigFactory {
             aliases = {},
             configs,
             map = {},
-            shim = {},
+            shim = {}
         } = baseConfig;
 
         const {
@@ -43,7 +39,7 @@ class ThemeConfigFactory {
 
         const beyondKeys = Object.keys(rest);
         if (beyondKeys.length) {
-            throw new Error( messages.jsExtraModulesError(beyondKeys));
+            throw new JSModulesExtraModulesError(beyondKeys);
         }
 
         return {
@@ -69,7 +65,7 @@ class ThemeConfigFactory {
             shim = {},
             configs,
             aliases = {},
-            ['app-modules']: appModules,
+            ['app-modules']: appModules = [],
             ['dynamic-imports']: dynamicImports
         } = jsModulesConfig;
 

package/utils.js

@@ -0,0 +1,30 @@
+let prodMode;
+let verboseMode;
+
+module.exports = {
+    isVerboseMode() {
+        if (verboseMode === void 0) {
+            verboseMode = process.argv.filter(arg => {
+                // Depending on how the command was run (-v, -vv, -vvv, --verbose) -
+                // arguments can be present in different formats: stats=normal, stats=detailed, stats=verbose, verbose
+                return arg.search(/^verbose|(^stats=(normal|detailed|verbose))/) !== -1;
+            }).length > 0;
+        }
+
+        return verboseMode;
+    },
+    isProdMode() {
+        if (prodMode !== void 0) {
+            return prodMode;
+        }
+
+        process.argv.forEach(arg => {
+            if (prodMode) {
+                return;
+            }
+            prodMode = ['--mode=production', '--env=prod'].some(item => item === arg);
+        });
+
+        return prodMode;
+    }
+};

package/validation/assets-validator.js

@@ -0,0 +1,103 @@
+const {isProdMode} = require('../utils');
+const fs = require('fs');
+const path = require('path');
+const schema = require('./schemas/assets-schema');
+const fullSchema = require('./schemas/assets-schema-full');
+const schemaValidator = require('./schema-validator');
+const EventEmitter = require('events');
+const emitter = new EventEmitter();
+const AssetsSchemaError = require('./errors/assets-schema-error');
+const AssetsInputFileError = require('./errors/assets-input-file-error');
+
+module.exports = Object.assign({}, schemaValidator, {
+    emitter,
+
+    /**
+     * @param {string} filePath
+     * @param {Object} doc
+     * @param {string} theme
+     * @returns {boolean|undefined}
+     */
+    checkSchema(filePath, doc, theme) {
+        if (isProdMode()) {
+            return;
+        }
+        const result = this.validateSchema(schema, doc);
+
+        if (!result.valid) {
+            const error = new AssetsSchemaError(result.formattedError, [filePath], theme);
+
+            this.emitter.emit('error', error);
+        }
+
+        return result.valid;
+    },
+
+    /**
+     * @param {Object} doc
+     * @param {Array} files
+     * @param {string} theme
+     * @returns {boolean|undefined}
+     */
+    checkFullSchema(doc, files = [], theme) {
+        if (isProdMode()) {
+            return;
+        }
+        const result = this.validateSchema(fullSchema, doc);
+
+        if (!result.valid) {
+            const error = new AssetsSchemaError(result.formattedError, files, theme);
+
+            this.emitter.emit('error', error);
+        }
+
+        return result.valid;
+    },
+
+    /**
+     * @param {string} filePath
+     * @param {Object} doc
+     * @param {string} theme
+     * @returns {boolean|undefined}
+     */
+    checkInputsExist(filePath, doc, theme) {
+        if (isProdMode()) {
+            return;
+        }
+
+        let valid = true;
+        for (const [, props] of Object.entries(doc)) {
+            if (!Array.isArray(props.inputs)) {
+                continue;
+            }
+
+            const files = [];
+            props.inputs.forEach(input => {
+                if (typeof input === 'object') {
+                    const newPath = Object.values(input)[0];
+
+                    if (newPath === '~') {
+                        return;
+                    }
+                    input = newPath;
+                }
+
+                const fullPath = path.resolve(this._publicPath + input);
+                // skip the path to global node modules,
+                // e.g. '~bootstrap/scss/bootstrap'
+                if (!input.startsWith('~') && !fs.existsSync(fullPath)) {
+                    files.push(input);
+                }
+            });
+            if (files.length) {
+                valid = false;
+                files.forEach(notExistFile => {
+                    const error = new AssetsInputFileError(notExistFile, filePath);
+
+                    this.emitter.emit('error', error);
+                });
+            }
+        }
+        return valid;
+    }
+});

package/validation/errors/assets-input-file-error.js

@@ -0,0 +1,24 @@
+const BaseError = require('./base-error');
+
+class AssetsInputFileError extends BaseError {
+    /**
+     * @example
+     *  Invalid styles config: input file does not exist /scss/test.scss
+     *  at /config/assets.yml
+     *  Please, find more information in the documentation https://doc.oroinc.com/...
+     *
+     * @param {string} notExistFile
+     * @param {string} path
+     */
+    constructor(notExistFile, path) {
+        const msg = `input file does not exist: ${notExistFile}\nat ${path}:1`;
+
+        super(msg);
+
+        this.name = 'Invalid styles config';
+        this.docLink =
+            'https://doc.oroinc.com/backend/bundles/platform/AssetBundle/#load-scss-or-css-files-from-the-bundle';
+    }
+}
+
+module.exports = AssetsInputFileError;

package/validation/errors/assets-schema-error.js

@@ -0,0 +1,40 @@
+const BaseError = require('./base-error');
+
+class AssetsSchemaError extends BaseError {
+    /**
+     * @example
+     *  Invalid styles config: the "assets.yml" in the "default" theme file does not match the API schema.
+     *  styles.inputs[0] should be: string | object
+     *  at /config/assets.yml
+     *  Please, find more information in the documentation https://doc.oroinc.com/...
+     *
+     * @example
+     * Invalid styles config: the "assets.yml" file the "default" theme does not match the API schema.
+     * styles misses the property 'output'.
+     * List of processed files for the "default" theme:
+     *     /default/config/assets.yml
+     *     /default/config/assets.yml
+     *  Please, find more information in the documentation https://doc.oroinc.com/...
+     *
+     * @param {string} reason
+     * @param {Array} files
+     * @param {string} theme
+     */
+    constructor(reason, files, theme) {
+        let msg = `the "assets.yml" file in the "${theme}" theme does not match the API schema.\n${reason}`;
+
+        const filesListMsg = BaseError.generateFilesListMsg(files, theme);
+
+        if (filesListMsg.length) {
+            msg = `${msg}\n${filesListMsg}`;
+        }
+
+        super(msg);
+
+        this.name = 'Invalid styles config';
+        this.docLink =
+            'https://doc.oroinc.com/backend/bundles/platform/AssetBundle/#load-scss-or-css-files-from-the-bundle';
+    }
+}
+
+module.exports = AssetsSchemaError;

package/validation/errors/base-error.js

@@ -0,0 +1,37 @@
+const {isVerboseMode} = require('../../utils');
+
+class BaseError extends Error {
+    /**
+     * Prepares documentation phrase
+     * @returns {string}
+     */
+    get extra() {
+        return this.docLink ? `Please, find more information in the documentation ${this.docLink}` : '';
+    }
+
+    /**
+     * Creates an instance of BaseError
+     * @param {string} message error message
+     */
+    constructor(message) {
+        super(message);
+    }
+
+    /**
+     * Creates a part of message about processed files
+     * @param {Array} files
+     * @param {string} theme
+     * @returns {string}
+     */
+    static generateFilesListMsg(files, theme) {
+        if (files.length === 1) {
+            return `at ${files[0]}:1`;
+        } else if (isVerboseMode()) {
+            return `List of processed files for the "${theme}" theme:\n    ${files.join('\n    ')}`;
+        }
+
+        return '';
+    }
+}
+
+module.exports = BaseError;

package/validation/errors/jsmodules-extra-modules-error.js

@@ -0,0 +1,22 @@
+const BaseError = require('./base-error');
+
+class JsmodulesExtraModulesError extends BaseError {
+    /**
+     * @example
+     * Failed assembly JS: sections ["shim"] are not allowed in extra js build definition.
+     * Please, find more information in the documentation https://doc.oroinc.com/...
+     *
+     * @param {Array} parts
+     */
+    constructor(parts) {
+        const msg = `sections ["${parts.join('", "')}"] are not allowed in extra js build definition.`;
+
+        super(msg);
+
+        this.name = 'Failed assembly JS';
+        this.docLink =
+            'https://doc.oroinc.com/master/frontend/storefront/how-to/how-to-create-extra-js-build-for-landing-page';
+    }
+}
+
+module.exports = JsmodulesExtraModulesError;

package/validation/errors/jsmodules-schema-error.js

@@ -0,0 +1,40 @@
+const BaseError = require('./base-error');
+
+class JSModulesSchemaError extends BaseError {
+    /**
+     * @example
+     * Invalid JS config: the "jsmodules.yml" files in the "default" theme do not match the API schema.
+     * has an unknown property 'rest'.
+     * at default/config/jsmodules.yml
+     * Please, find more information in the documentation https://doc.oroinc.com/...
+     *
+     * @example
+     * Invalid JS config: the "jsmodules.yml" files in the "default" theme do not match the API schema.
+     * misses the property 'entry'.
+     * List of processed files for the "default" theme:
+     *     /default/config/jsmodules.yml
+     *     /default/config/jsmodules.yml
+     * Please, find more information in the documentation https://doc.oroinc.com/...
+     *
+     * @param {string} reason
+     * @param {Array} files
+     * @param {string} theme
+     */
+    constructor(reason, files, theme) {
+        let msg = `the "jsmodules.yml" files in the "${theme}" theme do not match the API schema.\n${reason}`;
+
+        const filesListMsg = BaseError.generateFilesListMsg(files, theme);
+
+        if (filesListMsg.length) {
+            msg = `${msg}\n${filesListMsg}`;
+        }
+
+        super(msg);
+
+        this.name = 'Invalid JS config';
+        this.docLink =
+            'https://doc.oroinc.com/backend/bundles/platform/AssetBundle/#create-jsmodules-yml-configuration';
+    }
+}
+
+module.exports = JSModulesSchemaError;

package/validation/errors/styles-error.js

@@ -0,0 +1,24 @@
+const BaseError = require('./base-error');
+
+class StylesError extends BaseError {
+    /**
+     * @example
+     * Failed assembly styles: the "output" for "styles" entry point in "default" theme is not defined.
+     * Please, find more information in the documentation https://doc.oroinc.com/...
+     *
+     * @param {string} key
+     * @param {string} group
+     * @param {string} theme
+     */
+    constructor(key, group, theme) {
+        const msg = `the "${key}" for "${group}" entry point in "${theme}" theme is not defined.`;
+
+        super(msg);
+
+        this.name = 'Failed assembly styles';
+        this.docLink =
+            'https://doc.oroinc.com/backend/bundles/platform/AssetBundle/#load-scss-or-css-files-from-the-bundle';
+    }
+}
+
+module.exports = StylesError;

package/validation/index.js

@@ -0,0 +1,36 @@
+const assetsValidation = require('./assets-validator');
+const jsmodulesValidator = require('./jsmodules-validator');
+
+const isJSModulesPath = path => /jsmodules([-a-zA-Z\d]*)\.yml$/.test(path);
+const isAssetsPath = path => /assets\.yml$/.test(path);
+
+module.exports = {
+    assetsValidation,
+    jsmodulesValidator,
+
+    /**
+     * set public path for all validators
+     * {string} path
+     */
+    setPublicPath(path) {
+        [assetsValidation, jsmodulesValidator].forEach(validator => validator.setPublicPath(path));
+    },
+
+    /**
+     * Run appropriate validator
+     * {string} filePath
+     * {Object} doc
+     * {string} theme
+     */
+    checkSchema(filePath, doc, theme) {
+        if (isJSModulesPath(filePath)) {
+            jsmodulesValidator.checkSchema(filePath, doc, theme);
+        } else if (isAssetsPath(filePath)) {
+            const validSchema = assetsValidation.checkSchema(filePath, doc, theme);
+
+            if (validSchema) {
+                assetsValidation.checkInputsExist(filePath, doc, theme);
+            }
+        }
+    }
+};

package/validation/jsmodules-validator.js

@@ -0,0 +1,53 @@
+const schema = require('./schemas/jsmodules-schema');
+const fullSchema = require('./schemas/jsmodules-schema-full');
+const schemaValidator = require('./schema-validator');
+const {isProdMode} = require('../utils');
+const EventEmitter = require('events');
+const emitter = new EventEmitter();
+const JSModulesSchemaError = require('./errors/jsmodules-schema-error');
+
+module.exports = Object.assign({}, schemaValidator, {
+    emitter,
+
+    /**
+     * @param {string} filePath
+     * @param {Object} doc
+     * @param {string} theme
+     * @returns {boolean|undefined}
+     */
+    checkSchema(filePath, doc, theme) {
+        if (isProdMode()) {
+            return;
+        }
+        const result = this.validateSchema(schema, doc);
+
+        if (!result.valid) {
+            const error = new JSModulesSchemaError(result.formattedError, [filePath], theme);
+
+            this.emitter.emit('error', error);
+        }
+
+        return result.valid;
+    },
+
+    /**
+     * @param {Object} doc
+     * @param {Array} files
+     * @param {string} theme
+     * @returns {boolean|undefined}
+     */
+    checkFullSchema(doc, files = [], theme) {
+        if (isProdMode()) {
+            return;
+        }
+        const result = this.validateSchema(fullSchema, doc);
+
+        if (!result.valid) {
+            const error = new JSModulesSchemaError(result.formattedError, files, theme);
+
+            this.emitter.emit('error', error);
+        }
+
+        return result.valid;
+    }
+});

package/validation/schema-validator.js

@@ -0,0 +1,62 @@
+const {validate} = require('schema-utils');
+
+module.exports = {
+    /**
+     * Symfony public directory path related to application root folder
+     * {string}
+     */
+    _publicPath: 'public/',
+
+    setPublicPath(path) {
+        this._publicPath = path;
+    },
+
+    /**
+     * Validates data according to the schema
+     * @param {Object} scheme
+     * @param {Object} data
+     * @param {Object} [options]
+     * @returns {Object}
+     */
+    validateSchema(scheme, data, options) {
+        const result = {
+            valid: true
+        };
+
+        try {
+            const baseDataPath = 'configuration';
+            const basePathReg = /^configuration\./;
+            validate(scheme, data, {
+                baseDataPath,
+                ...options || {},
+                postFormatter(formattedError, error) {
+                    if (result.formattedError === void 0) {
+                        result.formattedError = [];
+                    }
+                    result.error = error;
+
+                    if (
+                        Array.isArray(error.params.type) ||
+                        error.params.missingProperty
+                    ) {
+                        // remove an excess line break
+                        formattedError = formattedError.replace(/\n/g, ' ');
+                    }
+
+                    formattedError = formattedError.replace(basePathReg, '');
+                    result.formattedError.push(formattedError.trim());
+                    return formattedError;
+                }
+            });
+        } catch (e) {
+            result.valid = false;
+            result.errorMessage = e.message;
+        }
+
+        if (result.formattedError) {
+            result.formattedError = result.formattedError.join('\n');
+        }
+
+        return result;
+    }
+};

package/validation/schemas/assets-schema-full.js

@@ -0,0 +1,22 @@
+/**
+ * Schema to validate assets.yml files
+ *
+ * @description
+ * Full scheme complements "assets-schema" one.
+ * It should have only rules which are not defined in "assets-schema" schema due to avoid duplicates in error messages
+ */
+module.exports = {
+    type: 'object',
+    patternProperties: {
+        '.*': {
+            type: 'object',
+            properties: {
+                inputs: {
+                    description: 'The "inputs" property is an array of files to load.',
+                    minItems: 1
+                }
+            },
+            required: ['inputs', 'output']
+        }
+    }
+};

package/validation/schemas/assets-schema.js

@@ -0,0 +1,32 @@
+/**
+ * Schema to validate assets.yml files
+ */
+module.exports = {
+    type: 'object',
+    patternProperties: {
+        '.*': {
+            type: 'object',
+            properties: {
+                inputs: {
+                    description: 'The "inputs" property is an array of files to load.',
+                    type: 'array',
+                    items: {
+                        type: ['string', 'object']
+                    }
+                },
+                output: {
+                    description: 'Output file path inside "public/" directory for the entry point',
+                    type: 'string'
+                },
+                auto_rtl_inputs: {
+                    description: 'List of wildcard file masks for inputs that has to be processed with RTL plugin.',
+                    type: 'array',
+                    items: {
+                        type: 'string'
+                    }
+                }
+            },
+            additionalProperties: false
+        }
+    }
+};

package/validation/schemas/jsmodules-schema-full.js

@@ -0,0 +1,11 @@
+/**
+ * Schema to validate jsmodules.yml files
+ *
+ * @description
+ * Full scheme complements "jsmodules-schema" one.
+ * It should have only rules which are not defined in "jsmodules-schema" schema due to avoid duplicates in error messages
+ */
+module.exports = {
+    type: 'object',
+    required: ['entry']
+};

package/validation/schemas/jsmodules-schema.js

@@ -0,0 +1,76 @@
+/**
+ * Schema to validate jsmodules.yml files
+ */
+module.exports = {
+    type: 'object',
+    properties: {
+        'entry': {
+            description: 'Webpack entry points configuration.',
+            type: 'object',
+            patternProperties: {
+                '.*': {
+                    type: 'array',
+                    items: {
+                        type: 'string'
+                    }
+                }
+            }
+        },
+        'shim': {
+            description: 'Configure a webpack shimming feature',
+            type: 'object',
+            patternProperties: {
+                '.*': {
+                    type: 'object'
+                }
+            }
+        },
+        'map': {
+            description: 'The map option allows to substitute a module with the given ID with a different module.',
+            type: 'object',
+            patternProperties: {
+                '.*': {
+                    type: 'object'
+                }
+            }
+        },
+        'app-modules': {
+            description: 'Introduces a list of modules that should be initialized before application is launched.',
+            type: 'array',
+            items: {
+                type: 'string'
+            }
+        },
+        'dynamic-imports': {
+            description: 'Gives possibility to import a module with the name that is determined at runtime.',
+            type: 'object',
+            patternProperties: {
+                '.*': {
+                    type: 'array',
+                    items: {
+                        type: 'string'
+                    }
+                }
+            }
+        },
+        'configs': {
+            description: 'Runtime configuration for a the module.',
+            type: 'object',
+            patternProperties: {
+                '.*': {
+                    type: 'object'
+                }
+            }
+        },
+        'aliases': {
+            description: 'An alias is an alternative name.',
+            type: 'object',
+            patternProperties: {
+                '.*': {
+                    type: 'string'
+                }
+            }
+        }
+    },
+    additionalProperties: false
+};

package/writer/dynamic-imports-file-writer.js

@@ -19,8 +19,8 @@ class DynamicImportsFileWriter {
     write(dynamicImports, output) {
         const buildPath = path.join(output, 'dynamic-imports.js');
         let content = Object.entries(dynamicImports).map(([chunkName, moduleNames]) => {
-            const notation = chunkName === 'commons' ?
-                '/* webpackMode: "eager" */' : `/* webpackChunkName: "${chunkName}" */`;
+            const notation = chunkName === 'commons'
+                ? '/* webpackMode: "eager" */' : `/* webpackChunkName: "${chunkName}" */`;
             return moduleNames.map(moduleName =>`'${moduleName}': () => import(${notation}'${moduleName}')`);
         });
         content = `module.exports = {\n  ${content.flat().join(',\n  ')}\n};\n`;

package/writer/scss-entry-point-file-writer.js

@@ -25,7 +25,7 @@ class SCSSEntryPointFileWriter {
             input = input.replace(/\.[^/.]+$/, '');
             // don't add the base path to global node modules,
             // e.g. '~bootstrap/scss/bootstrap'
-            const basePath = input.startsWith('~') ? '': baseInputPath;
+            const basePath = input.startsWith('~') ? '' : baseInputPath;
             let importModule = `@import "${basePath}${input}";\n`;
             if (ignoreRTL) {
                 importModule = `/*rtl:begin:ignore*/\n${importModule}/*rtl:end:ignore*/\n`;

package/messages.js

@@ -1,29 +0,0 @@
-const doc = "Please, find more information in the documentation ";
-const CSSError = "Failed assembly styles.\n";
-const CSSDoc = "https://doc.oroinc.com/backend/bundles/platform/AssetBundle/#load-scss-or-css-files-from-the-bundle";
-const JSError = `Failed assembly JS.\n`;
-const JSDoc = "https://doc.oroinc.com/backend/bundles/platform/AssetBundle/#create-jsmodules-yml-configuration";
-const JSExtraBuildDoc = "https://doc.oroinc.com/master/frontend/storefront/how-to/how-to-create-extra-js-build-for-landing-page";
-
-module.exports = {
-    assetsMissedOutput(group, theme) {
-        const error = `The "output" for "${group}" entry point in "${theme}" theme is not defined.\n`;
-
-        return `${CSSError}${error}${doc}${CSSDoc}`;
-    },
-    assetsMissedInput(group, theme) {
-        const error = `The "output" for "${group}" entry point in "${theme}" theme is not defined.\n`;
-
-        return `${CSSError}${error}${doc}${CSSDoc}`
-    },
-    jsModulesError(theme) {
-        const error = `Failed assembly JS for the "${theme}" theme.\n`;
-
-        return `${error}${doc}${JSDoc}`
-    },
-    jsExtraModulesError(parts) {
-        const error = `Sections ["${parts.join('", "')}"] are not allowed in extra js build definition\n`;
-
-        return `${JSError}${error}${doc}${JSExtraBuildDoc}`;
-    }
-};