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

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