@scandipwa/magento-scripts 1.14.1-alpha.0 → 1.14.1-alpha.11

package/lib/tasks/theme/symlink-theme.js

@@ -1,24 +1,40 @@
+const path = require('path');
+const UnknownError = require('../../errors/unknown-error');
+const getJsonfileData = require('../../util/get-jsonfile-data');
 const runComposerCommand = require('../../util/run-composer');
 
 /**
  * @type {(theme: import('../../../typings/theme').Theme) => import('listr2').ListrTask<import('../../../typings/context').ListrContext>}
  */
-const symlinkTheme = ({ absoluteThemePath }) => ({
+const symlinkTheme = (theme) => ({
     title: 'Setting symbolic link for theme in composer.json',
-    task: async ({ magentoVersion, verbose = false }, task) => {
+    task: async (ctx, task) => {
+        const { magentoVersion, verbose = false } = ctx;
+        const composerJsonData = await getJsonfileData(path.join(process.cwd(), 'composer.json'));
+        const repositories = Array.isArray(composerJsonData.repositories)
+            ? composerJsonData.repositories.reduce((acc, repo, index) => ({ ...acc, [`${index}`]: repo }), {})
+            : composerJsonData.repositories;
+
+        if (Object.values(repositories).some((value) => value.url === theme.themePath)) {
+            task.skip();
+            return;
+        }
+
         try {
-            await runComposerCommand(`config repo.scandipwa path ${absoluteThemePath}`, {
+            await runComposerCommand(`config repo.scandipwa path ${theme.absoluteThemePath}`, {
                 magentoVersion,
                 callback: !verbose ? undefined : (t) => {
                     task.output = t;
                 }
             });
         } catch (e) {
-            throw new Error(
+            throw new UnknownError(
                 `Unexpected error while configuring theme symbolic link.
                 See ERROR log above.\n\n${e}`
             );
         }
+
+        ctx.isSetupUpgradeNeeded = true;
     }
 });
 

package/lib/util/analytics.js

@@ -0,0 +1,337 @@
+const os = require('os');
+const { request } = require('smol-request');
+const logger = require('@scandipwa/scandipwa-dev-utils/logger');
+const generateUUID = require('@tilework/mosaic-dev-utils/uuid');
+const { getSystemConfigSync } = require('../config/system-config');
+const { getExternalIpAddress } = require('./ip');
+const pkg = require('../../package.json');
+
+const GA_TRACKING_ID = process.env.GA_TRACKING_ID || 'UA-127741417-8';
+const UNKNOWN = 'unknown';
+
+const anonymizeError = (text) => text.replace(new RegExp(`${os.homedir()}`, 'gi'), '/home/magento-scripts-user');
+
+/**
+ * Google Analytics Parameters
+ * @typedef {Object} GAParameters
+ * @property {String} version
+ * @property {String} trackingID
+ * @property {String} [dataSource]
+ * @property {Object} [user]
+ * @property {String} [user.clientID]
+ * @property {String} [user.userID]
+ * @property {Object} [session]
+ * @property {String} [session.sessionControl]
+ * @property {String} [session.ipOverride]
+ * @property {String} [session.userAgentOverride]
+ * @property {Object} [systemInfo]
+ * @property {String} [systemInfo.userLanguage]
+ * @property {Object} [contentInformation]
+ * @property {String} [contentInformation.documentLocationUrl]
+ * @property {String} [contentInformation.documentPath]
+ * @property {String} [contentInformation.documentHostName]
+ * @property {Object} [timing]
+ * @property {String} [timing.userTimingCategory]
+ * @property {String} [timing.userTimingVariableName]
+ * @property {String} [timing.userTimingTime]
+ * @property {String} [timing.userTimingLabel]
+ * @property {Object} [hit]
+ * @property {String} [hit.type]
+ * @property {Object} [exception]
+ * @property {String} [exception.description]
+ * @property {Boolean} [exception.fatal]
+ * @property {Object} [event]
+ * @property {String} event.category
+ * @property {String} event.action
+ * @property {String} [event.label]
+ * @property {String} [event.value]
+ * @property {Object} [app]
+ * @property {String} [app.name]
+ * @property {String} [app.id]
+ * @property {String} [app.version]
+ * @property {String} [app.installedID]
+ * @property {Record<string, string>} [customDimension]
+ */
+
+/**
+ * @type {GAParameters}
+ */
+const gaParametersMapping = {
+    version: 'v',
+    trackingID: 'tid',
+    user: {
+        clientID: 'cid',
+        userID: 'uid'
+    },
+    session: {
+        sessionControl: 'sc',
+        ipOverride: 'uip',
+        userAgentOverride: 'ua'
+    },
+    systemInfo: {
+        userLanguage: 'ul'
+    },
+    contentInformation: {
+        documentLocationUrl: 'dl',
+        documentPath: 'dp',
+        documentHostName: 'dh'
+    },
+    timing: {
+        userTimingCategory: 'utc',
+        userTimingVariableName: 'utv',
+        userTimingTime: 'utt',
+        userTimingLabel: 'utl'
+    },
+    hit: {
+        type: 't'
+    },
+    exception: {
+        description: 'exd',
+        fatal: 'exf'
+    },
+    event: {
+        category: 'ec',
+        action: 'ea',
+        label: 'el',
+        value: 'ev'
+    },
+    app: {
+        name: 'an',
+        id: 'aid',
+        version: 'av',
+        installedID: 'aiid'
+    },
+    customDimension: Array.from({ length: 200 }, (_, i) => i + 1).reduce((acc, val) => ({
+        ...acc,
+        [`customDimension${val}`]: `cd${val}`
+    }), {})
+};
+
+const getAppData = () => ({
+    name: pkg.name,
+    version: pkg.version
+});
+
+/**
+ * @param {GAParameters} parameters
+ */
+const collectAnalyticsParameters = (parameters) => {
+    const parsedParameters = {};
+
+    for (const [firstLevelKey, firstLevelValue] of Object.entries(gaParametersMapping)) {
+        if (typeof firstLevelValue === 'object' && firstLevelValue !== null) {
+            for (const [secondLevelKey, secondLevelValue] of Object.entries(firstLevelValue)) {
+                if (parameters[firstLevelKey] && parameters[firstLevelKey][secondLevelKey]) {
+                    parsedParameters[secondLevelValue] = parameters[firstLevelKey][secondLevelKey];
+                }
+            }
+        } else if (parameters[firstLevelKey]) {
+            parsedParameters[firstLevelValue] = parameters[firstLevelKey];
+        }
+    }
+
+    return parsedParameters;
+};
+
+class Analytics {
+    constructor() {
+        this.isGaDisabled = this.getIsGaDisabled();
+        this.gaTrackingId = GA_TRACKING_ID;
+        this.clientIdentifier = UNKNOWN;
+        this.currentUrl = UNKNOWN;
+        this.lang = UNKNOWN;
+
+        try {
+            this.setClientIdentifier(
+                generateUUID()
+            );
+        } catch (e) {
+            this.setClientIdentifier(
+                Date.now()
+            );
+        }
+    }
+
+    setLang(lang) {
+        this.lang = lang;
+    }
+
+    setCurrentUrl(currentUrl) {
+        this.currentUrl = currentUrl;
+    }
+
+    setClientIdentifier(id) {
+        this.clientIdentifier = id;
+    }
+
+    setGaTrackingId(id) {
+        this.gaTrackingId = id;
+    }
+
+    getIsGaDisabled() {
+        const { analytics } = getSystemConfigSync({ validate: false });
+
+        return !analytics;
+    }
+
+    /**
+     * @param {GAParameters} data
+     */
+    async _collect(data) {
+        if (this.isGaDisabled) {
+            // skip GA
+            return;
+        }
+
+        /**
+         * @type {GAParameters}
+         */
+        const analyticsParameters = {
+            ...data,
+            version: '1',
+            trackingID: this.gaTrackingId,
+            user: {
+                clientID: this.clientIdentifier
+            },
+            app: getAppData()
+        };
+
+        try {
+            analyticsParameters.systemInfo = {
+                ipOverride: await getExternalIpAddress()
+            };
+        } catch (e) {
+            console.log(e);
+            // Do nothing
+        }
+
+        if (this.lang !== UNKNOWN) {
+            // get system language here
+            analyticsParameters.systemInfo = {
+                userLanguage: this.lang
+            };
+        }
+
+        if (this.currentUrl !== UNKNOWN) {
+            const {
+                hostname,
+                pathname
+            } = new URL(this.currentUrl);
+
+            analyticsParameters.contentInformation = {
+                documentLocationUrl: this.currentUrl,
+                documentPath: pathname,
+                documentHostName: hostname
+            };
+        }
+
+        const params = new URLSearchParams(collectAnalyticsParameters(analyticsParameters)).toString();
+
+        try {
+            if (!process.env.GA_DEBUG) {
+                await request(
+                    `https://www.google-analytics.com/collect?${ params }`,
+                    {
+                        headers: { 'User-Agent': 'Google-Cloud-Functions' },
+                        responseType: 'headers'
+                    }
+                );
+
+                return;
+            }
+
+            const { data: jsonResponse } = await request(
+                `https://www.google-analytics.com/debug/collect?${ params }`,
+                {
+                    headers: { 'User-Agent': 'Google-Cloud-Functions' },
+                    responseType: 'json'
+                }
+            );
+
+            logger.log(analyticsParameters);
+            logger.log(JSON.stringify(jsonResponse, null, 2));
+
+        // eslint-disable-next-line no-empty
+        } catch (e) {
+            console.log('Failed to report telemetry data');
+        }
+    }
+
+    trackError(error, isFatal = true) {
+        // return; // nothing
+        return this._collect({
+            hit: {
+                type: 'exception'
+            },
+            exception: {
+                description: anonymizeError(typeof error === 'string' ? error : error.message),
+                fatal: isFatal
+            }
+        });
+        // return this._collect({
+        //     t: 'exception',
+        //     exd: anonymizeError(typeof error === 'string' ? error : error.message),
+        //     exf: isFatal
+        // });
+    }
+
+    trackTiming(label, time, category = UNKNOWN) {
+        return this._collect({
+            hit: {
+                type: 'timing'
+            },
+            timing: {
+                userTimingCategory: category,
+                userTimingVariableName: label,
+                userTimingLabel: this.currentUrl,
+                userTimingTime: Math.round(time)
+            }
+        });
+        // return this._collect({
+        //     t: 'timing',
+        //     utc: category,
+        //     utv: label,
+        //     utl: this.currentUrl,
+        //     utt: Math.round(time)
+        // });
+    }
+
+    trackPageView() {
+        return this._collect({
+            hit: {
+                type: 'pageview'
+            }
+        });
+    }
+
+    trackEvent(action, label, value, category = UNKNOWN) {
+        return this._collect({
+            hit: {
+                type: 'event'
+            },
+            event: {
+                category,
+                action,
+                label,
+                value
+            }
+        });
+        // return this._collect({
+        //     t: 'event',
+        //     ec: category,
+        //     ea: action,
+        //     el: label,
+        //     ev: value
+        // });
+    }
+
+    printAboutAnalytics() {
+        if (!this.isGaDisabled) {
+            logger.log('We collect analytics data to make our products more stable and reliable!');
+            logger.log('If you want to know more go here https://docs.scandipwa.com/about/data-analytics');
+            logger.logN();
+        }
+    }
+}
+
+module.exports = new Analytics();

package/lib/util/config-file-validator.js

@@ -1,12 +1,13 @@
 const Joi = require('joi');
 const semver = require('semver');
+const KnownError = require('../errors/known-error');
 const pathExistsSync = require('./path-exists-sync');
 
 const fileExistsValidator = (value) => {
     const fileExists = pathExistsSync(value);
 
     if (!fileExists) {
-        throw new Error(`File "${value}" does not exists!`);
+        throw new KnownError(`File "${value}" does not exists!`);
     }
 
     return undefined;
@@ -72,6 +73,15 @@ const nginxConfigurationSchema = Joi.object({
     configTemplate: Joi.string().optional().custom(fileExistsValidator)
 });
 
+/**
+ * @type {Joi.ObjectSchema<import('../../typings').NginxConfiguration>}
+ */
+const varnishConfigurationSchema = Joi.object({
+    enabled: Joi.boolean().optional(),
+    version: Joi.string().optional(),
+    configTemplate: Joi.string().optional().custom(fileExistsValidator)
+});
+
 /**
  * @type {Joi.ObjectSchema<import('../../typings').ServiceWithVersion>}
  */
@@ -101,7 +111,9 @@ const configurationSchema = Joi.object({
     mysql: serviceConfigurationSchema.optional(),
     elasticsearch: serviceConfigurationSchema.optional(),
     redis: serviceConfigurationSchema.optional(),
-    composer: composerConfigurationSchema.optional()
+    composer: composerConfigurationSchema.optional(),
+    varnish: varnishConfigurationSchema.optional(),
+    sslTerminator: nginxConfigurationSchema.optional()
 });
 
 /**

package/lib/util/config-php-json.js

@@ -0,0 +1,20 @@
+const path = require('path');
+const UnknownError = require('../errors/unknown-error');
+const runPhpCode = require('./run-php');
+
+const configPhpToJson = async (projectPath = process.cwd(), { magentoVersion }) => {
+    const { code, result } = await runPhpCode(`-r "echo json_encode(require '${path.join(projectPath, 'app', 'etc', 'config.php')}');"`, {
+        magentoVersion
+    });
+
+    if (code !== 0) {
+        throw new UnknownError(`Received non-zero code during converting app/etc/config.php to json:\n\n${result}`);
+    }
+    try {
+        return JSON.parse(result);
+    } catch (e) {
+        throw new UnknownError(`Ooops! Something went wrong when trying to parse app/etc/config.php file!\n\n${e}\n\nFile result: ${result}`);
+    }
+};
+
+module.exports = configPhpToJson;

package/lib/util/env-php-json.js

@@ -1,4 +1,5 @@
 const path = require('path');
+const UnknownError = require('../errors/unknown-error');
 const runPhpCode = require('./run-php');
 
 const envPhpToJson = async (projectPath = process.cwd(), { magentoVersion }) => {
@@ -7,12 +8,12 @@ const envPhpToJson = async (projectPath = process.cwd(), { magentoVersion }) =>
     });
 
     if (code !== 0) {
-        throw new Error(result);
+        throw new UnknownError(`Received non-zero code during converting app/etc/env.php to json:\n\n${result}`);
     }
     try {
         return JSON.parse(result);
     } catch (e) {
-        throw new Error(`Ooops! Something went wrong when trying to parse app/etc/env.php file!\n\n${e}\n\nFile result: ${result}`);
+        throw new UnknownError(`Ooops! Something went wrong when trying to parse app/etc/env.php file!\n\n${e}\n\nFile result: ${result}`);
     }
 };
 

package/lib/util/get-installed-magento-version.js

@@ -1,5 +1,6 @@
 const fs = require('fs');
 const path = require('path');
+const KnownError = require('../errors/known-error');
 const pathExists = require('./path-exists');
 
 const getComposerData = async (composerPath) => {
@@ -16,7 +17,7 @@ const getInstalledMagentoVersion = async (projectPath = process.cwd()) => {
     const composerData = await getComposerData(path.join(projectPath, 'composer.json'));
 
     if (!composerData) {
-        throw new Error('composer.json not found');
+        throw new KnownError('composer.json not found');
     }
     const magentoDependency = [
         'magento/product-community-edition',
@@ -24,7 +25,7 @@ const getInstalledMagentoVersion = async (projectPath = process.cwd()) => {
     ].find((magentoEdition) => composerData.require[magentoEdition]);
 
     if (!magentoDependency) {
-        throw new Error('No Magento dependency found in composer.json');
+        throw new KnownError('No Magento dependency found in composer.json');
     }
 
     return composerData.require[magentoDependency].replace(/\^/i, '');

package/lib/util/get-jsonfile-data.js

@@ -1,4 +1,5 @@
 const fs = require('fs');
+const UnknownError = require('../errors/unknown-error');
 const pathExists = require('./path-exists');
 
 const getJsonfileData = async (filePath) => {
@@ -11,7 +12,7 @@ const getJsonfileData = async (filePath) => {
     try {
         return JSON.parse(await fs.promises.readFile(filePath, 'utf-8'));
     } catch (e) {
-        throw new Error(`Ooops! Something went wrong when trying to json parse ${filePath} file!\n\n${e}`);
+        throw new UnknownError(`Ooops! Something went wrong when trying to json parse ${filePath} file!\n\n${e}`);
     }
 };
 

package/lib/util/install-dependencies-task.js

@@ -3,6 +3,7 @@ const logger = require('@scandipwa/scandipwa-dev-utils/logger');
 const sleep = require('./sleep');
 const { execCommandTask } = require('./exec-async-command');
 const dependenciesForPlatforms = require('../config/dependencies-for-platforms');
+const KnownError = require('../errors/known-error');
 
 /**
  * Install dependencies
@@ -56,15 +57,14 @@ const installDependenciesTask = (options) => ({
         promptSkipper = true;
 
         if (installAnswer === 'timeout') {
-            throw new Error(`Timeout!
+            throw new KnownError(`Timeout!
 
 To install missing ${ dependenciesWordFormatter } manually, run the following command: ${ installCommand }`);
         }
 
         if (installAnswer === 'not-install') {
-            throw new Error(`Okay, skipping ${ dependenciesWordFormatter } installation for now.
-
-To install missing ${ dependenciesWordFormatter } manually, run the following command: ${ installCommand }`);
+            task.skip(`User chose to skip installation of ${ dependenciesWordFormatter }`);
+            return;
         }
 
         if (installAnswer === 'install') {

package/lib/util/instance-metadata.js

@@ -7,7 +7,8 @@ const WEB_ADMIN_CREDENTIALS_TITLE = 'Panel credentials';
 
 const mapDataStyle = ({ title, text }) => ({
     title,
-    text: logger.style.link(text)
+    text: logger.style.link(text),
+    link: text
 });
 
 /**
@@ -38,7 +39,7 @@ const getInstanceMetadata = (ctx) => {
     if (isNgrok) {
         frontend.push({
             title: WEB_LOCAL_LOCATION_TITLE,
-            text: `${ssl.enabled ? 'https' : 'http'}://localhost${ssl.enabled || ports.app === 80 ? '' : `:${ports.app}`}/`
+            text: `${ssl.enabled ? 'https' : 'http'}://localhost${ssl.enabled || ports.sslTerminator === 80 ? '' : `:${ports.sslTerminator}`}/`
         });
         frontend.push({
             title: WEB_LOCATION_TITLE,
@@ -47,7 +48,7 @@ const getInstanceMetadata = (ctx) => {
     } else {
         frontend.push({
             title: WEB_LOCATION_TITLE,
-            text: `${ssl.enabled ? 'https' : 'http'}://${host}${ssl.enabled || ports.app === 80 ? '' : `:${ports.app}`}/`
+            text: `${ssl.enabled ? 'https' : 'http'}://${host}${ssl.enabled || ports.sslTerminator === 80 ? '' : `:${ports.sslTerminator}`}/`
         });
     }
 
@@ -70,5 +71,11 @@ const getInstanceMetadata = (ctx) => {
 };
 
 module.exports = {
-    getInstanceMetadata
+    getInstanceMetadata,
+    constants: {
+        WEB_LOCAL_LOCATION_TITLE,
+        WEB_LOCATION_TITLE,
+        WEB_ADMIN_LOCATION_TITLE,
+        WEB_ADMIN_CREDENTIALS_TITLE
+    }
 };

package/lib/util/ip.js

@@ -1,8 +1,52 @@
+const { request } = require('smol-request');
+
 const ipRegex = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
 
 const isIpAddress = (text) => ipRegex.test(text);
 
+const externalIpProviders = [
+    'http://api.ipify.org/',
+    'http://icanhazip.com/',
+    'http://ifconfig.io/ip',
+    'http://ip.appspot.com/',
+    'http://ident.me/',
+    'http://whatismyip.akamai.com/',
+    'http://tnx.nl/ip',
+    'http://myip.dnsomatic.com/',
+    'http://ipecho.net/plain',
+    'http://diagnostic.opendns.com/myip',
+    'http://trackip.net/ip'
+];
+
+/**
+ * Get an external IP address
+ * @returns {Promise<string>}
+ */
+const getExternalIpAddress = async () => {
+    let ip;
+
+    for (const ipProvider of externalIpProviders) {
+        try {
+            const response = await request(ipProvider, {
+                responseType: 'text'
+            });
+
+            ip = response.data;
+            break;
+        } catch (e) {
+            //
+        }
+    }
+
+    if (!ip) {
+        throw new Error('External IP address is not available!');
+    }
+
+    return ip;
+};
+
 module.exports = {
     ipRegex,
-    isIpAddress
+    isIpAddress,
+    getExternalIpAddress
 };

package/lib/util/is-running-root.js

@@ -0,0 +1,3 @@
+const isRunningRoot = () => process.getuid() === 0; // UID 0 is always root
+
+module.exports = isRunningRoot;

package/lib/util/magento-task.js

@@ -1,17 +1,28 @@
 const runMagentoCommand = require('./run-magento');
 
 /**
- * @type {(command: string) => import('listr2').ListrTask<import('../../typings/context').ListrContext>}
+ * @param {String} command
+ * @param {Object} [options]
+ * @param {(e: Error) => void} [options.onError]
+ * @returns {import('listr2').ListrTask<import('../../typings/context').ListrContext>}
  */
-const magentoTask = (command) => ({
+const magentoTask = (command, options = {}) => ({
     title: `Running command 'magento ${command}'`,
-    task: ({ magentoVersion, verbose }, task) => runMagentoCommand(command, {
-        callback: !verbose ? undefined : (t) => {
-            task.output = t;
-        },
-        magentoVersion,
-        throwNonZeroCode: true
-    }),
+    task: async ({ magentoVersion, verbose }, task) => {
+        try {
+            await runMagentoCommand(command, {
+                callback: !verbose ? undefined : (t) => {
+                    task.output = t;
+                },
+                magentoVersion,
+                throwNonZeroCode: true
+            });
+        } catch (e) {
+            if (options.onError) {
+                options.onError(e);
+            }
+        }
+    },
     options: {
         bottomBar: 10
     }

package/lib/util/match-filesystem.js

@@ -13,7 +13,8 @@ const matchFilesystem = async (cwd, structure) => {
             .every((value) => value === true);
 
         return ok;
-    } if (typeof structure === 'object') {
+    }
+    if (typeof structure === 'object') {
         const ok = (await Promise.all(Object.entries(structure).map(([key, value]) => {
             if (typeof value === 'boolean') {
                 return pathExists(path.join(cwd, key));