@oroinc/oro-webpack-config-builder 5.1.0-alpha8 → 5.1.0-lts001

package/validation/assets-validator.js

@@ -0,0 +1,104 @@
+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 fullBasePath = path.resolve(input);
+                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) && !fs.existsSync(fullBasePath)) {
+                    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/configs-file-writer.js

@@ -12,7 +12,7 @@ class ConfigsFileWriter {
     /**
      * Write app-modules.js file and return file path
      *
-     * @param {Array} configs List of configurable modules
+     * @param {Object} configs List of configurable modules
      * @param {string} output Output file path
      * @returns {string} JS file path of an output file
      */

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

@@ -19,9 +19,9 @@ class DynamicImportsFileWriter {
     write(dynamicImports, output) {
         const buildPath = path.join(output, 'dynamic-imports.js');
         let content = Object.entries(dynamicImports).map(([chunkName, moduleNames]) => {
-            return moduleNames.map(moduleName =>
-                `'${moduleName}': function() { return import(/* webpackChunkName: "${chunkName}" */ '${moduleName}') }`
-            );
+            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`;
         const filepath = path.resolve(this._publicPath + buildPath);

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`;