@scandipwa/magento-scripts 2.0.3 → 2.0.4

package/lib/config/get-magento-version-config.js

@@ -1,82 +1,89 @@
-const { allVersions, defaultConfiguration } = require('./versions');
-const getInstalledMagentoVersion = require('../util/get-installed-magento-version');
-const sleep = require('../util/sleep');
-const scandipwaMagentoVersionMapping = require('./scandipwa-versions');
+const { allVersions, defaultConfiguration } = require('./versions')
+const getInstalledMagentoVersion = require('../util/get-installed-magento-version')
+const sleep = require('../util/sleep')
+const scandipwaMagentoVersionMapping = require('./scandipwa-versions')
 
-const longestMagentoName = allVersions.map(({ name }) => name).reduce((acc, val) => (val.length > acc ? val.length : acc), 0);
+const longestMagentoName = allVersions
+    .map(({ name }) => name)
+    .reduce((acc, val) => (val.length > acc ? val.length : acc), 0)
 
 const getMagentoVersionMessage = (version) => {
-    const pureMagentoVersion = version.name.replace(/-p[0-9]+$/i, '');
+    const pureMagentoVersion = version.name.replace(/-p[0-9]+$/i, '')
     if (scandipwaMagentoVersionMapping[pureMagentoVersion]) {
-        const padding = longestMagentoName - version.name.length;
-        return `${ version.name }${ ' '.repeat(padding) } (Supported ScandiPWA version: ${ scandipwaMagentoVersionMapping[pureMagentoVersion] })`;
+        const padding = longestMagentoName - version.name.length
+        return `${version.name}${' '.repeat(
+            padding
+        )} (Supported ScandiPWA version: ${
+            scandipwaMagentoVersionMapping[pureMagentoVersion]
+        })`
     }
 
-    return version.name;
-};
+    return version.name
+}
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../typings/context').ListrContext>}
+ * @returns {import('listr2').ListrTask<import('../../typings/context').ListrContext>}
  */
 const getMagentoVersion = () => ({
     // title: 'Loading Magento version',
     task: async (ctx, task) => {
-        const { throwMagentoVersionMissing = false, projectPath = process.cwd() } = ctx;
-        let { magentoVersion } = ctx;
+        const {
+            throwMagentoVersionMissing = false,
+            projectPath = process.cwd()
+        } = ctx
+        let { magentoVersion } = ctx
 
         if (!magentoVersion) {
-            task.title = 'Loading Magento version';
+            task.title = 'Loading Magento version'
             try {
-                magentoVersion = await getInstalledMagentoVersion(projectPath);
+                magentoVersion = await getInstalledMagentoVersion(projectPath)
             } catch (e) {
                 if (throwMagentoVersionMissing) {
-                    throw e;
+                    throw e
                 }
                 if (allVersions.length === 1) {
-                    const { magentoVersion: defaultMagentoVersion } = defaultConfiguration;
-                    magentoVersion = defaultMagentoVersion;
+                    const { magentoVersion: defaultMagentoVersion } =
+                        defaultConfiguration
+                    magentoVersion = defaultMagentoVersion
                 } else {
-                    let promptSkipper = false;
+                    let promptSkipper = false
                     const timer = async () => {
                         for (let i = 5 * 60; i !== 0; i--) {
-                            // eslint-disable-next-line no-await-in-loop
-                            await sleep(1000);
+                            await sleep(1000)
                             if (promptSkipper) {
-                                return null;
+                                return null
                             }
-                            task.title = `Checking app config (${i} sec left...)`;
+                            task.title = `Checking app config (${i} sec left...)`
                         }
-                        task.cancelPrompt();
-                        return defaultConfiguration.magento;
-                    };
+                        task.cancelPrompt()
+                        return defaultConfiguration.magento
+                    }
 
                     magentoVersion = await Promise.race([
                         task.prompt({
                             type: 'Select',
                             message: 'Choose Magento Version',
                             name: 'magentoVersion',
-                            choices: allVersions.map((version) => (
-                                {
-                                    name: version.name,
-                                    message: getMagentoVersionMessage(version)
-                                }
-                            )),
+                            choices: allVersions.map((version) => ({
+                                name: version.name,
+                                message: getMagentoVersionMessage(version)
+                            })),
                             initial: defaultConfiguration.name,
                             scroll: true,
                             limit: 7,
                             footer: `(use arrow keys to select other magento versions, in total we support ${allVersions.length} versions)`
                         }),
                         timer()
-                    ]);
+                    ])
 
-                    promptSkipper = true;
+                    promptSkipper = true
                 }
             }
-            task.title = `Using Magento ${magentoVersion}`;
+            task.title = `Using Magento ${magentoVersion}`
         }
 
-        ctx.magentoVersion = magentoVersion;
+        ctx.magentoVersion = magentoVersion
     }
-});
+})
 
-module.exports = getMagentoVersion;
+module.exports = getMagentoVersion

package/lib/config/get-port-config.js

@@ -1,86 +1,72 @@
-const fs = require('fs');
-const path = require('path');
-const { baseConfig } = require('.');
-const KnownError = require('../errors/known-error');
-const pathExists = require('../util/path-exists');
-const {
-    getPort,
-    getPortsConfig,
-    defaultPorts
-} = require('./port-config');
+const fs = require('fs')
+const path = require('path')
+const { baseConfig } = require('.')
+const KnownError = require('../errors/known-error')
+const pathExists = require('../util/path-exists')
+const { getPort, getPortsConfig, defaultPorts } = require('./port-config')
 
-const portConfigPath = path.join(baseConfig.cacheDir, 'port-config.json');
+const portConfigPath = path.join(baseConfig.cacheDir, 'port-config.json')
 
 /**
  * Get available ports on the system
- * @type {() => import('listr2').ListrTask<import('../../typings/context').ListrContext>}
+ * @returns {import('listr2').ListrTask<import('../../typings/context').ListrContext>}
  */
 const getAvailablePorts = () => ({
     title: 'Getting available ports',
     task: async (ctx) => {
-        let ports = { ...defaultPorts };
+        let ports = { ...defaultPorts }
 
         if (await pathExists(portConfigPath)) {
             ports = JSON.parse(
-                await fs.promises.readFile(
-                    portConfigPath,
-                    'utf-8'
-                )
-            );
+                await fs.promises.readFile(portConfigPath, 'utf-8')
+            )
             if (!ports.sslTerminator) {
-                ports.sslTerminator = ports.app;
-                ports.app = defaultPorts.app;
+                ports.sslTerminator = ports.app
+                ports.app = defaultPorts.app
             }
         }
         const {
-            systemConfiguration: {
-                useNonOverlappingPorts
-            }
-        } = ctx;
+            systemConfiguration: { useNonOverlappingPorts }
+        } = ctx
         const availablePorts = await getPortsConfig(ports, {
             useNonOverlappingPorts
-        });
+        })
 
         if (ctx.port) {
-            const isPortAvailable = (await getPort(ctx.port)) === ctx.port;
+            const isPortAvailable = (await getPort(ctx.port)) === ctx.port
             if (!isPortAvailable) {
-                throw new KnownError(`Port ${ctx.port} is not available`);
+                throw new KnownError(`Port ${ctx.port} is not available`)
             } else {
-                availablePorts.sslTerminator = ctx.port;
+                availablePorts.sslTerminator = ctx.port
             }
         }
 
-        // eslint-disable-next-line no-param-reassign
-        ctx.ports = availablePorts;
+        ctx.ports = availablePorts
     }
-});
+})
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../typings/context').ListrContext>}
+ * @returns {import('listr2').ListrTask<import('../../typings/context').ListrContext>}
  */
 const getCachedPorts = () => ({
     title: 'Getting cached ports',
     task: async (ctx) => {
-        let ports;
+        let ports
 
         if (await pathExists(portConfigPath)) {
             ports = JSON.parse(
-                await fs.promises.readFile(
-                    portConfigPath,
-                    'utf-8'
-                )
-            );
-            ctx.cachedPorts = { ...ports };
+                await fs.promises.readFile(portConfigPath, 'utf-8')
+            )
+            ctx.cachedPorts = { ...ports }
         } else {
-            ports = { ...defaultPorts };
+            ports = { ...defaultPorts }
         }
 
-        // eslint-disable-next-line no-param-reassign
-        ctx.ports = ports;
+        ctx.ports = ports
     }
-});
+})
 
 module.exports = {
     getAvailablePorts,
     getCachedPorts
-};
+}

package/lib/config/get-project-configuration.js

@@ -1,22 +1,22 @@
-const { getProjectConfig } = require('./config');
-const { getConfigFromMagentoVersion } = require('./index');
+const { getProjectConfig } = require('./config')
+const { getConfigFromMagentoVersion } = require('./index')
 
 /**
- * @type {() => import('listr2').ListrTask<import('../../typings/context').ListrContext>}
+ * @returns {import('listr2').ListrTask<import('../../typings/context').ListrContext>}
  */
 const getProjectConfiguration = () => ({
     title: 'Getting project configuration',
     task: async (ctx) => {
-        const { magentoVersion } = ctx;
+        const { magentoVersion } = ctx
 
         if (typeof ctx.debug !== 'boolean') {
-            ctx.debug = getProjectConfig().debug;
+            ctx.debug = getProjectConfig().debug
         }
 
         ctx.config = await getConfigFromMagentoVersion(ctx, {
             magentoVersion
-        });
+        })
     }
-});
+})
 
-module.exports = getProjectConfiguration;
+module.exports = getProjectConfiguration

package/lib/config/index.js

@@ -1,18 +1,15 @@
-const path = require('path');
-const getDockerConfig = require('./docker');
-const {
-    getConfigurations,
-    defaultConfiguration
-} = require('./versions');
-const getPhpConfig = require('./php-config');
-const { getMagentoConfig } = require('./magento-config');
-const resolveConfigurationWithOverrides = require('../util/resolve-configuration-with-overrides');
-const { getPrefix, folderName } = require('../util/prefix');
-const UnknownError = require('../errors/unknown-error');
-const { getProjectConfig } = require('./config');
+const path = require('path')
+const getDockerConfig = require('./docker')
+const { getConfigurations, defaultConfiguration } = require('./versions')
+const getPhpConfig = require('./php-config')
+const { getMagentoConfig } = require('./magento-config')
+const resolveConfigurationWithOverrides = require('../util/resolve-configuration-with-overrides')
+const { getPrefix, folderName } = require('../util/prefix')
+const UnknownError = require('../errors/unknown-error')
+const { getProjectConfig } = require('./config')
 
-const platforms = ['linux', 'darwin'];
-const darwinMinimalVersion = '10.5';
+const platforms = ['linux', 'darwin']
+const darwinMinimalVersion = '10.5'
 
 /**
  * @returns {import('../../typings/context').ListrContext['config']['baseConfig']}
@@ -22,55 +19,67 @@ const getBaseConfig = (projectPath = process.cwd(), prefix = folderName) => ({
     magentoDir: projectPath,
     containerMagentoDir: projectPath,
     templateDir: path.join(__dirname, 'templates'),
-    cacheDir: path.join(projectPath, 'node_modules', '.create-magento-app-cache')
-});
+    cacheDir: path.join(
+        projectPath,
+        'node_modules',
+        '.create-magento-app-cache'
+    )
+})
 
-const baseConfig = getBaseConfig();
+const baseConfig = getBaseConfig()
 
 const magento = {
     binPath: path.join(baseConfig.magentoDir, 'bin', 'magento'),
-    containerBinPath: path.join(baseConfig.containerMagentoDir, 'bin', 'magento')
-};
+    containerBinPath: path.join(
+        baseConfig.containerMagentoDir,
+        'bin',
+        'magento'
+    )
+}
 
 module.exports = {
     /**
-     * @param {import('../../typings/context')} ctx
+     * @param {import('../../typings/context').ListrContext} ctx
      * @param {Object} param1
-     * @param {String} [param1.magentoVersion]
+     * @param {String} param1.magentoVersion
      * @param {String} [param1.projectPath]
      * @param {String} [param1.prefix]
      */
-    async getConfigFromMagentoVersion(ctx, {
-        magentoVersion,
-        projectPath = process.cwd(),
-        prefix = folderName
-    }) {
-        const newBaseConfig = getBaseConfig(projectPath, prefix);
-        const configurations = getConfigurations(newBaseConfig);
+    async getConfigFromMagentoVersion(
+        ctx,
+        { magentoVersion, projectPath = process.cwd(), prefix = folderName }
+    ) {
+        const newBaseConfig = getBaseConfig(projectPath, prefix)
+        const configurations = getConfigurations(newBaseConfig)
         if (!configurations[magentoVersion]) {
-            throw new UnknownError(`No config found for magento version ${magentoVersion}`);
+            throw new UnknownError(
+                `No config found for magento version ${magentoVersion}`
+            )
         }
-        const projectConfig = getProjectConfig();
+        const projectConfig = getProjectConfig()
 
-        const {
-            overridenConfiguration,
-            userConfiguration
-        } = await resolveConfigurationWithOverrides(
-            configurations[magentoVersion],
-            newBaseConfig,
-            projectPath
-        );
+        const { overridenConfiguration, userConfiguration } =
+            await resolveConfigurationWithOverrides(
+                configurations[magentoVersion],
+                projectPath
+            )
 
         return {
             php: getPhpConfig(overridenConfiguration, newBaseConfig),
-            docker: await getDockerConfig(ctx, overridenConfiguration, newBaseConfig),
-            magentoConfiguration: getMagentoConfig(overridenConfiguration.magento),
+            docker: await getDockerConfig(
+                ctx,
+                overridenConfiguration,
+                newBaseConfig
+            ),
+            magentoConfiguration: getMagentoConfig(
+                overridenConfiguration.magento
+            ),
             baseConfig: newBaseConfig,
             overridenConfiguration,
             userConfiguration,
             nonOverridenConfiguration: configurations[magentoVersion],
             projectConfig
-        };
+        }
     },
     baseConfig,
     getBaseConfig,
@@ -78,4 +87,4 @@ module.exports = {
     platforms,
     darwinMinimalVersion,
     defaultConfiguration
-};
+}

package/lib/config/magento/required-php-extensions/index.js

@@ -1,29 +1,43 @@
-const magento23RequiredPHPExtensions = require('./magento-2.3');
-const magento24RequiredPHPExtensions = require('./magento-2.4');
+const magento23RequiredPHPExtensions = require('./magento-2.3')
+const magento24RequiredPHPExtensions = require('./magento-2.4')
 
-const { phpExtensionInstallationInstructions } = require('../../services/php/extensions');
+const {
+    phpExtensionInstallationInstructions
+} = require('../../services/php/extensions')
 
 /**
  * @param {string[]} requiredPHPExtensions
  * @returns {Record<string, import('../../../../typings/index').PHPExtensionInstallationInstruction>}
  */
-const mapMagentoRequiredExtensionsToInstructions = (requiredPHPExtensions) => requiredPHPExtensions.map((extensionName) => {
-    if (phpExtensionInstallationInstructions[extensionName]) {
-        return phpExtensionInstallationInstructions[extensionName];
-    }
+const mapMagentoRequiredExtensionsToInstructions = (requiredPHPExtensions) =>
+    requiredPHPExtensions
+        .map((extensionName) => {
+            if (phpExtensionInstallationInstructions[extensionName]) {
+                return phpExtensionInstallationInstructions[extensionName]
+            }
 
-    for (const [extensionName, extensionData] of Object.entries(phpExtensionInstallationInstructions)) {
-        if (extensionData.alternativeName && extensionData.alternativeName.includes(extensionName)) {
-            return extensionData;
-        }
-    }
+            for (const [extensionName, extensionData] of Object.entries(
+                phpExtensionInstallationInstructions
+            )) {
+                if (
+                    extensionData.alternativeName &&
+                    extensionData.alternativeName.includes(extensionName)
+                ) {
+                    return extensionData
+                }
+            }
 
-    return {
-        name: extensionName
-    };
-}).reduce((acc, val) => ({ ...acc, [val.name]: val }), {});
+            return {
+                name: extensionName
+            }
+        })
+        .reduce((acc, val) => ({ ...acc, [val.name]: val }), {})
 
 module.exports = {
-    magento23PHPExtensionList: mapMagentoRequiredExtensionsToInstructions(magento23RequiredPHPExtensions),
-    magento24PHPExtensionList: mapMagentoRequiredExtensionsToInstructions(magento24RequiredPHPExtensions)
-};
+    magento23PHPExtensionList: mapMagentoRequiredExtensionsToInstructions(
+        magento23RequiredPHPExtensions
+    ),
+    magento24PHPExtensionList: mapMagentoRequiredExtensionsToInstructions(
+        magento24RequiredPHPExtensions
+    )
+}

package/lib/config/magento/required-php-extensions/magento-2.3.js

@@ -14,6 +14,6 @@ const magento23RequiredPHPExtensions = [
     'soap',
     'xsl',
     'zip'
-];
+]
 
-module.exports = magento23RequiredPHPExtensions;
+module.exports = magento23RequiredPHPExtensions

package/lib/config/magento/required-php-extensions/magento-2.4.js

@@ -24,6 +24,6 @@ const magento24RequiredPHPExtensions = [
     'zip',
     'libxml',
     'openssl'
-];
+]
 
-module.exports = magento24RequiredPHPExtensions;
+module.exports = magento24RequiredPHPExtensions

package/lib/config/magento-config.js

@@ -1,4 +1,4 @@
-const { deepmerge } = require('../util/deepmerge');
+const { deepmerge } = require('../util/deepmerge')
 
 /**
  * @type {import('../../typings/index').CMAConfiguration['magento']}
@@ -12,16 +12,16 @@ const defaultMagentoConfig = {
     adminuri: 'admin',
     mode: 'developer',
     edition: 'community'
-};
+}
 
 /**
  *
  * @param {import('../../typings/index').CMAConfiguration['magento']} magento
  * @returns {import('../../typings/index').CMAConfiguration['magento']}
  */
-const getMagentoConfig = (magento) => deepmerge(defaultMagentoConfig, magento);
+const getMagentoConfig = (magento) => deepmerge(defaultMagentoConfig, magento)
 
 module.exports = {
     defaultMagentoConfig,
     getMagentoConfig
-};
+}

package/lib/config/php-config.js

@@ -1,13 +1,15 @@
-const path = require('path');
+const path = require('path')
 
 /**
  * @param {import('../../typings/context').ListrContext['config']['overridenConfiguration']} overridenConfiguration
  * @param {import('../../typings/context').ListrContext['config']['baseConfig']} baseConfig
  */
 module.exports = (overridenConfiguration, baseConfig) => {
-    const { configuration: { php } } = overridenConfiguration;
+    const {
+        configuration: { php }
+    } = overridenConfiguration
 
-    const { cacheDir } = baseConfig;
+    const { cacheDir } = baseConfig
 
     const phpConfiguration = {
         iniPath: path.join(cacheDir, 'php.ini'),
@@ -17,7 +19,7 @@ module.exports = (overridenConfiguration, baseConfig) => {
         fpmTemplatePath: php.fpmConfigTemplate,
         fpmConfPath: path.join(cacheDir, 'php-fpm.conf'),
         extensions: php.extensions
-    };
+    }
 
-    return phpConfiguration;
-};
+    return phpConfiguration
+}