@scandipwa/magento-scripts 2.0.3 → 2.0.4

package/lib/tasks/file-system/create-phpstorm-config/database-config.js

@@ -1,80 +1,90 @@
 /* eslint-disable no-param-reassign */
-const path = require('path');
-const { baseConfig } = require('../../../config');
-const { loadXmlFile, buildXmlFile } = require('../../../config/xml-parser');
-const UnknownError = require('../../../errors/unknown-error');
-const { connectionStringParser, connectionStringBuilder } = require('../../../util/connection-string');
-const pathExists = require('../../../util/path-exists');
-const setConfigFile = require('../../../util/set-config');
+const path = require('path')
+const { baseConfig } = require('../../../config')
+const { loadXmlFile, buildXmlFile } = require('../../../config/xml-parser')
+const UnknownError = require('../../../errors/unknown-error')
+const {
+    connectionStringParser,
+    connectionStringBuilder
+} = require('../../../util/connection-string')
+const pathExists = require('../../../util/path-exists')
+const setConfigFile = require('../../../util/set-config')
 
 const databaseConfiguration = {
     driver: 'mysql',
     dataSourceManagerName: 'mysql 8.0',
     dataSourcesLocal: {
         path: path.join(process.cwd(), '.idea', 'dataSources.local.xml'),
-        templatePath: path.join(baseConfig.templateDir, 'dataSources.local.template.xml')
+        templatePath: path.join(
+            baseConfig.templateDir,
+            'dataSources.local.template.xml'
+        )
     },
     dataSources: {
         path: path.join(process.cwd(), '.idea', 'dataSources.xml'),
-        templatePath: path.join(baseConfig.templateDir, 'dataSources.template.xml')
+        templatePath: path.join(
+            baseConfig.templateDir,
+            'dataSources.template.xml'
+        )
     }
-};
+}
 
 /**
  * Get link to data-source field, create fields if necessary
  *
- * @param {Object} data
- * @param {Object} defaultData Default data structure that will be used if original data is missing
+ * @param {*} data
+ * @param {*} defaultData Default data structure that will be used if original data is missing
  */
 const getToDataSource = (data, defaultData) => {
     if (!data.project) {
-        data.project = defaultData.project;
+        data.project = defaultData.project
     }
 
     if (!data.project.component) {
-        data.project.component = defaultData.project.component;
+        data.project.component = defaultData.project.component
     }
 
     if (!data.project.component['data-source']) {
-        data.project.component['data-source'] = defaultData.project.component['data-source'];
+        data.project.component['data-source'] =
+            defaultData.project.component['data-source']
     }
 
-    return data.project.component['data-source'];
-};
+    return data.project.component['data-source']
+}
 // const mariadbVersion = await ctx.databaseConnection.query('SHOW VARIABLES LIKE "%version%";');
 /**
- * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
  */
 const setupDataSourceLocalConfig = () => ({
     title: 'Set up datasource local configuration',
     task: async (ctx, task) => {
         if (await pathExists(databaseConfiguration.dataSourcesLocal.path)) {
-            let hasChanges = false;
-            const dataSourcesLocalData = await loadXmlFile(databaseConfiguration.dataSourcesLocal.path);
-            const dataSource = getToDataSource(
-                dataSourcesLocalData,
-                {
-                    project: {
-                        '@_version': '4',
-                        component: {
-                            '@_name': 'dataSourceStorageLocal',
-                            '@_created-in': 'PS-212.5284.49',
-                            'data-source': {
-                                '@_uuid': 'a2eadb3c-6fc9-4d85-b5f4-d8114906ce2f'
-                            }
+            let hasChanges = false
+            const dataSourcesLocalData = await loadXmlFile(
+                databaseConfiguration.dataSourcesLocal.path
+            )
+            const dataSource = getToDataSource(dataSourcesLocalData, {
+                project: {
+                    '@_version': '4',
+                    component: {
+                        '@_name': 'dataSourceStorageLocal',
+                        '@_created-in': 'PS-212.5284.49',
+                        'data-source': {
+                            '@_uuid': 'a2eadb3c-6fc9-4d85-b5f4-d8114906ce2f'
                         }
                     }
                 }
-            );
+            })
 
             if (!dataSource['@_name']) {
-                hasChanges = true;
-                dataSource['@_name'] = databaseConfiguration.dataSourceManagerName;
+                hasChanges = true
+                dataSource['@_name'] =
+                    databaseConfiguration.dataSourceManagerName
             }
 
             if (!dataSource['@_uuid']) {
-                hasChanges = true;
-                dataSource['@_uuid'] = 'a2eadb3c-6fc9-4d85-b5f4-d8114906ce2f';
+                hasChanges = true
+                dataSource['@_uuid'] = 'a2eadb3c-6fc9-4d85-b5f4-d8114906ce2f'
             }
 
             const defaultDatabaseInfoConfig = {
@@ -85,119 +95,134 @@ const setupDataSourceLocalConfig = () => ({
                 '@_driver-version': '',
                 '@_dbms': 'MYSQL',
                 '@_exact-version': '0'
-            };
+            }
             const isDatabaseInfoChangeNeeded = dataSource['database-info']
-                ? Object.entries(defaultDatabaseInfoConfig)
-                    .some(([key]) => !(key in dataSource['database-info']))
-                : true;
+                ? Object.entries(defaultDatabaseInfoConfig).some(
+                      ([key]) => !(key in dataSource['database-info'])
+                  )
+                : true
 
             if (isDatabaseInfoChangeNeeded) {
-                hasChanges = true;
+                hasChanges = true
                 if (!dataSource['database-info']) {
-                    dataSource['database-info'] = defaultDatabaseInfoConfig;
+                    dataSource['database-info'] = defaultDatabaseInfoConfig
                 } else {
-                    Object.entries(defaultDatabaseInfoConfig).forEach(([key, value]) => {
-                        if (!(key in dataSource['database-info'])) {
-                            dataSource['database-info'][key] = value;
+                    Object.entries(defaultDatabaseInfoConfig).forEach(
+                        ([key, value]) => {
+                            if (!(key in dataSource['database-info'])) {
+                                dataSource['database-info'][key] = value
+                            }
+                            // ^^^ only set missing properties, only ones should be in place
                         }
-                        // ^^^ only set missing properties, only ones should be in place
-                    });
+                    )
                 }
             }
 
             const dataSourceDefaultData = {
                 'secret-storage': 'master_key',
                 'user-name': 'magento'
-            };
+            }
 
             const isDataSourceDataChangeNeeded = dataSource
-                ? Object.entries(dataSourceDefaultData)
-                    .some(([key, value]) => dataSource[key] !== value)
-                : true;
+                ? Object.entries(dataSourceDefaultData).some(
+                      ([key, value]) => dataSource[key] !== value
+                  )
+                : true
 
             if (isDataSourceDataChangeNeeded) {
-                hasChanges = true;
-                Object.entries(dataSourceDefaultData).forEach(([key, value]) => {
-                    dataSource[key] = value;
-                });
+                hasChanges = true
+                Object.entries(dataSourceDefaultData).forEach(
+                    ([key, value]) => {
+                        dataSource[key] = value
+                    }
+                )
             }
 
             if (dataSource && dataSource['schema-mapping'] === undefined) {
-                hasChanges = true;
-                dataSource['schema-mapping'] = '';
+                hasChanges = true
+                dataSource['schema-mapping'] = ''
             }
 
             if (hasChanges) {
-                await buildXmlFile(databaseConfiguration.dataSourcesLocal.path, dataSourcesLocalData);
+                await buildXmlFile(
+                    databaseConfiguration.dataSourcesLocal.path,
+                    dataSourcesLocalData
+                )
             } else {
-                task.skip();
+                task.skip()
             }
         } else {
             try {
                 await setConfigFile({
                     configPathname: databaseConfiguration.dataSourcesLocal.path,
-                    template: databaseConfiguration.dataSourcesLocal.templatePath,
+                    template:
+                        databaseConfiguration.dataSourcesLocal.templatePath,
                     overwrite: true,
                     templateArgs: {
                         databaseConfiguration
                     }
-                });
+                })
             } catch (e) {
-                throw new UnknownError(`Unexpected error accrued during dataSources.local.xml config creation\n\n${e}`);
+                throw new UnknownError(
+                    `Unexpected error accrued during dataSources.local.xml config creation\n\n${e}`
+                )
             }
         }
     }
-});
+})
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
  */
 const setupDataSourceConfig = () => ({
     task: async (ctx, task) => {
         if (await pathExists(databaseConfiguration.dataSources.path)) {
-            let hasChanges = false;
-            const dataSourcesData = await loadXmlFile(databaseConfiguration.dataSources.path);
-            const dataSource = getToDataSource(
-                dataSourcesData,
-                {
-                    project: {
-                        '@_version': '4',
-                        component: {
-                            '@_name': 'DataSourceManagerImpl',
-                            '@_format': 'xml',
-                            '@_multifile-model': true,
-                            'data-source': {
-                                '@_source': 'LOCAL',
-                                '@_uuid': 'a2eadb3c-6fc9-4d85-b5f4-d8114906ce2f'
-                            }
+            let hasChanges = false
+            const dataSourcesData = await loadXmlFile(
+                databaseConfiguration.dataSources.path
+            )
+            const dataSource = getToDataSource(dataSourcesData, {
+                project: {
+                    '@_version': '4',
+                    component: {
+                        '@_name': 'DataSourceManagerImpl',
+                        '@_format': 'xml',
+                        '@_multifile-model': true,
+                        'data-source': {
+                            '@_source': 'LOCAL',
+                            '@_uuid': 'a2eadb3c-6fc9-4d85-b5f4-d8114906ce2f'
                         }
                     }
                 }
-            );
+            })
 
             if (dataSource['jdbc-url']) {
-                const parsedJDBC = dataSource['jdbc-url'].match(/jdbc:(\S+)/i);
+                const parsedJDBC = dataSource['jdbc-url'].match(/jdbc:(\S+)/i)
                 if (parsedJDBC && parsedJDBC.length > 0) {
-                    const url = parsedJDBC[1];
-                    const parsedJDBCUrl = connectionStringParser(url);
+                    const url = parsedJDBC[1]
+                    const parsedJDBCUrl = connectionStringParser(url)
 
                     if (/\S+:undefined/.test(parsedJDBCUrl.host)) {
-                        hasChanges = true;
-                        parsedJDBCUrl.host = parsedJDBCUrl.host.split(':').shift();
+                        hasChanges = true
+                        parsedJDBCUrl.host = parsedJDBCUrl.host
+                            .split(':')
+                            .shift()
                     }
 
                     if (parsedJDBCUrl.port !== `${ctx.ports.mariadb}`) {
-                        hasChanges = true;
-                        parsedJDBCUrl.port = `${ctx.ports.mariadb}`;
+                        hasChanges = true
+                        parsedJDBCUrl.port = `${ctx.ports.mariadb}`
 
-                        dataSource['jdbc-url'] = `jdbc:${connectionStringBuilder(parsedJDBCUrl)}`;
+                        dataSource[
+                            'jdbc-url'
+                        ] = `jdbc:${connectionStringBuilder(parsedJDBCUrl)}`
                     }
                 }
             }
 
             if (dataSource['@_uuid'] === undefined) {
-                hasChanges = true;
-                dataSource['@_uuid'] = 'a2eadb3c-6fc9-4d85-b5f4-d8114906ce2f';
+                hasChanges = true
+                dataSource['@_uuid'] = 'a2eadb3c-6fc9-4d85-b5f4-d8114906ce2f'
             }
 
             const expectedDataSourceData = {
@@ -208,30 +233,37 @@ const setupDataSourceConfig = () => ({
                 'jdbc-url': `jdbc:mysql://localhost:${ctx.ports.mariadb}/magento`,
                 'working-dir': '$ProjectFileDir$',
                 '@_source': 'LOCAL'
-            };
+            }
 
             const isDataSourceNeedChanges = dataSource
-                ? Object.entries(expectedDataSourceData)
-                    .some(([key]) => !(key in dataSource))
-                : true;
+                ? Object.entries(expectedDataSourceData).some(
+                      ([key]) => !(key in dataSource)
+                  )
+                : true
 
             if (isDataSourceNeedChanges) {
-                hasChanges = true;
+                hasChanges = true
                 if (!dataSource) {
-                    dataSourcesData.project.component['data-source'] = expectedDataSourceData;
+                    dataSourcesData.project.component['data-source'] =
+                        expectedDataSourceData
                 } else {
-                    Object.entries(expectedDataSourceData).forEach(([key, value]) => {
-                        if (!(key in dataSource)) {
-                            dataSource[key] = value;
+                    Object.entries(expectedDataSourceData).forEach(
+                        ([key, value]) => {
+                            if (!(key in dataSource)) {
+                                dataSource[key] = value
+                            }
                         }
-                    });
+                    )
                 }
             }
 
             if (hasChanges) {
-                await buildXmlFile(databaseConfiguration.dataSources.path, dataSourcesData);
+                await buildXmlFile(
+                    databaseConfiguration.dataSources.path,
+                    dataSourcesData
+                )
             } else {
-                task.skip();
+                task.skip()
             }
         } else {
             try {
@@ -243,23 +275,23 @@ const setupDataSourceConfig = () => ({
                         databaseConfiguration,
                         jdbcUrl: `jdbc:mysql://localhost:${ctx.ports.mariadb}/magento`
                     }
-                });
+                })
             } catch (e) {
-                throw new UnknownError(`Unexpected error accrued during dataSources.xml config creation\n\n${e}`);
+                throw new UnknownError(
+                    `Unexpected error accrued during dataSources.xml config creation\n\n${e}`
+                )
             }
         }
     }
-});
+})
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
  */
 const setupDatabaseConfig = () => ({
     title: 'Set up database configuration',
-    task: (ctx, task) => task.newListr([
-        setupDataSourceLocalConfig(),
-        setupDataSourceConfig()
-    ])
-});
+    task: (ctx, task) =>
+        task.newListr([setupDataSourceLocalConfig(), setupDataSourceConfig()])
+})
 
-module.exports = setupDatabaseConfig;
+module.exports = setupDatabaseConfig

package/lib/tasks/file-system/create-phpstorm-config/eslint-config.js

@@ -1,13 +1,18 @@
-const path = require('path');
-const { loadXmlFile, buildXmlFile } = require('../../../config/xml-parser');
-const pathExists = require('../../../util/path-exists');
-const { valueKey, nameKey } = require('./keys');
-const { getCSAThemes } = require('../../../util/CSA-theme');
-const { formatPathForPHPStormConfig } = require('./xml-utils');
-
-const ESLINT_COMPONENT_NAME = 'EslintConfiguration';
-
-const pathToESLintConfig = path.join(process.cwd(), '.idea', 'jsLinters', 'eslint.xml');
+const path = require('path')
+const { loadXmlFile, buildXmlFile } = require('../../../config/xml-parser')
+const pathExists = require('../../../util/path-exists')
+const { valueKey, nameKey } = require('./keys')
+const { getCSAThemes } = require('../../../util/CSA-theme')
+const { formatPathForPHPStormConfig } = require('./xml-utils')
+
+const ESLINT_COMPONENT_NAME = 'EslintConfiguration'
+
+const pathToESLintConfig = path.join(
+    process.cwd(),
+    '.idea',
+    'jsLinters',
+    'eslint.xml'
+)
 
 const defaultESLintComponentConfiguration = {
     [nameKey]: ESLINT_COMPONENT_NAME,
@@ -15,7 +20,7 @@ const defaultESLintComponentConfiguration = {
         [nameKey]: 'fix-on-save',
         [valueKey]: 'true'
     }
-};
+}
 
 const esLintDefaultConfigurationData = {
     '?xml': {
@@ -26,91 +31,110 @@ const esLintDefaultConfigurationData = {
         '@_version': '4',
         component: defaultESLintComponentConfiguration
     }
-};
+}
 
 const setupESlintConfig = async (esLintConfigurationData) => {
-    let hasChanges = false;
-    const themes = await getCSAThemes();
+    let hasChanges = false
+    const themes = await getCSAThemes()
 
     if (themes.length > 0) {
-        const theme = themes[0];
+        const theme = themes[0]
         if (await pathExists(theme.themePath)) {
             if (esLintConfigurationData['work-dir-pattern'] === undefined) {
-                hasChanges = true;
+                hasChanges = true
                 esLintConfigurationData['work-dir-pattern'] = {
                     [valueKey]: formatPathForPHPStormConfig(theme.themePath)
-                };
+                }
             }
-            const packageJsonPath = path.join(process.cwd(), theme.themePath, 'package.json');
+            const packageJsonPath = path.join(
+                process.cwd(),
+                theme.themePath,
+                'package.json'
+            )
             if (await pathExists(packageJsonPath)) {
-                if (esLintConfigurationData['custom-configuration-file'] === undefined) {
-                    hasChanges = true;
+                if (
+                    esLintConfigurationData['custom-configuration-file'] ===
+                    undefined
+                ) {
+                    hasChanges = true
                     esLintConfigurationData['custom-configuration-file'] = {
                         '@_used': 'true',
                         '@_path': formatPathForPHPStormConfig(packageJsonPath)
-                    };
+                    }
                 }
             }
         }
     }
 
-    return hasChanges;
-};
+    return hasChanges
+}
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
+ * @returns {import('listr2').ListrTask<import('../../../../typings/context').ListrContext>}
  */
 const setupESLintConfigTask = () => ({
     title: 'Set up ESLint configuration',
     task: async (ctx, task) => {
         if (await pathExists(pathToESLintConfig)) {
-            let hasChanges = false;
-            const esLintConfigurationData = await loadXmlFile(pathToESLintConfig);
+            let hasChanges = false
+            const esLintConfigurationData = await loadXmlFile(
+                pathToESLintConfig
+            )
 
             if (!esLintConfigurationData.project) {
                 esLintConfigurationData.project = {
                     ...esLintDefaultConfigurationData.project
-                };
+                }
             }
 
             if (!esLintConfigurationData['?xml']) {
                 esLintConfigurationData['?xml'] = {
                     ...esLintDefaultConfigurationData['?xml']
-                };
+                }
             }
 
-            if (esLintConfigurationData.project.component && !Array.isArray(esLintConfigurationData.project.component)) {
-                hasChanges = true;
-                esLintConfigurationData.project.component = [esLintConfigurationData.project.component];
+            if (
+                esLintConfigurationData.project.component &&
+                !Array.isArray(esLintConfigurationData.project.component)
+            ) {
+                hasChanges = true
+                esLintConfigurationData.project.component = [
+                    esLintConfigurationData.project.component
+                ]
             }
 
-            const esLintConfigurationComponent = esLintConfigurationData.project.component.find(
-                (config) => config[nameKey] === ESLINT_COMPONENT_NAME
-            );
+            const esLintConfigurationComponent =
+                esLintConfigurationData.project.component.find(
+                    (config) => config[nameKey] === ESLINT_COMPONENT_NAME
+                )
 
             if (!esLintConfigurationComponent) {
-                hasChanges = true;
-                esLintConfigurationData.project.component.push(defaultESLintComponentConfiguration);
+                hasChanges = true
+                esLintConfigurationData.project.component.push(
+                    defaultESLintComponentConfiguration
+                )
             }
 
-            const hasThemeEslintChanges = await setupESlintConfig(esLintConfigurationComponent);
+            const hasThemeEslintChanges = await setupESlintConfig(
+                esLintConfigurationComponent
+            )
             if (hasThemeEslintChanges) {
-                hasChanges = hasThemeEslintChanges;
+                hasChanges = hasThemeEslintChanges
             }
 
             if (hasChanges) {
-                await buildXmlFile(pathToESLintConfig, esLintConfigurationData);
+                await buildXmlFile(pathToESLintConfig, esLintConfigurationData)
             } else {
-                task.skip();
+                task.skip()
             }
 
-            return;
+            return
         }
 
-        await setupESlintConfig(esLintDefaultConfigurationData);
+        await setupESlintConfig(esLintDefaultConfigurationData)
 
-        await buildXmlFile(pathToESLintConfig, esLintDefaultConfigurationData);
+        await buildXmlFile(pathToESLintConfig, esLintDefaultConfigurationData)
     }
-});
+})
 
-module.exports = setupESLintConfigTask;
+module.exports = setupESLintConfigTask